diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/RestClientBuilder.java b/api/src/main/java/org/eclipse/microprofile/rest/client/RestClientBuilder.java index a28590f..1cd6066 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/RestClientBuilder.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/RestClientBuilder.java @@ -40,8 +40,8 @@ * Invoking {@link #newBuilder()} is intended to always create a new instance, not use a cached version. *

*

- * The RestClientBuilder is a {@link Configurable} class as defined by JAX-RS. This allows a user to - * register providers, implementation specific configuration. + * The RestClientBuilder is a {@link Configurable} class as defined by Jakarta RESTful Web Services. This + * allows a user to register providers, implementation specific configuration. *

*

* Implementations are expected to implement this class and provide the instance via the mechanism in @@ -123,8 +123,8 @@ default RestClientBuilder baseUri(String uri) { /** * Set the connect timeout. *

- * Like JAX-RS's jakarta.ws.rs.client.ClientBuilder's connectTimeout method, specifying a - * timeout of 0 represents infinity, and negative values are not allowed. + * Like Jakarta RESTful Web Services's jakarta.ws.rs.client.ClientBuilder's connectTimeout + * method, specifying a timeout of 0 represents infinity, and negative values are not allowed. *

*

* If the client instance is injected via CDI and the @@ -146,12 +146,12 @@ default RestClientBuilder baseUri(String uri) { /** * Set the read timeout. *

- * Like JAX-RS's jakarta.ws.rs.client.ClientBuilder's readTimeout method, specifying a - * timeout of 0 represents infinity, and negative values are not allowed. + * Like Jakarta RESTful Web Services's jakarta.ws.rs.client.ClientBuilder's readTimeout + * method, specifying a timeout of 0 represents infinity, and negative values are not allowed. *

*

- * Also like the JAX-RS Client API, if the read timeout is reached, the client interface method will throw a - * jakarta.ws.rs.ProcessingException. + * Also like the Jakarta RESTful Web Services Client API, if the read timeout is reached, the client interface + * method will throw a jakarta.ws.rs.ProcessingException. *

*

* If the client instance is injected via CDI and the diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/annotation/RegisterClientHeaders.java b/api/src/main/java/org/eclipse/microprofile/rest/client/annotation/RegisterClientHeaders.java index 3761afd..ec932d5 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/annotation/RegisterClientHeaders.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/annotation/RegisterClientHeaders.java @@ -32,7 +32,7 @@ *

* If no implementation class of the ClientHeadersFactory interface is specified in the annotation, then the * {@link DefaultClientHeadersFactoryImpl} will be used. This implementation will simply propagate headers (specified - * via MP Config property) from an inbound JAX-RS request (if applicable) to the outbound request. + * via MP Config property) from an inbound Jakarta RESTful Web Services request (if applicable) to the outbound request. *

* If a ClientHeadersFactory class specified is not found on the classpath, this should be considered a deployment * exception. diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ClientHeadersFactory.java b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ClientHeadersFactory.java index 5b2bcdd..dc409dc 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ClientHeadersFactory.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ClientHeadersFactory.java @@ -21,9 +21,9 @@ /** * This interface is intended for generating or propagating HTTP headers. It is invoked by the MP Rest Client * implementation before invoking any entity providers on the outbound processing chain. It contains a single method, - * update which takes parameters of headers passed in from the incoming JAX-RS request (if applicable, if - * not, this will be an empty map) and a read-only map of headers specified by ClientHeaderParam or - * HeaderParam annotations on the client interface. + * update which takes parameters of headers passed in from the incoming Jakarta RESTful Web Services + * request (if applicable, if not, this will be an empty map) and a read-only map of headers specified by + * ClientHeaderParam or HeaderParam annotations on the client interface. *

* This method should return a MultivaluedMap of headers to be merged with the outgoing headers. If it's desired for * {@code clientOutgoingHeaders} to be present in addition to any propagated headers, @@ -31,8 +31,9 @@ * the final set of HTTP headers that will be sent to the outbound entity provider processing chain - thus any filters, * MessageBodyWriters, interceptors, etc. could further refine the set of headers actually sent on the client request. *

- * If the ClientHeadersFactory instance is invoked while in the context of a JAX-RS request, the implementation may - * optionally support injection of fields and methods annotated with {@literal @}Context. + * If the ClientHeadersFactory instance is invoked while in the context of a Jakarta RESTful Web Services request, the + * implementation may optionally support injection of fields and methods annotated with + * {@literal @}Context. *

* If the ClientHeadersFactory instance is managed by CDI (i.e. it is annotated with * {@literal @}ApplicationScoped, etc.), the implementation must use the appropriate CDI-managed instance, @@ -47,8 +48,8 @@ public interface ClientHeadersFactory { * could further update the headers. * * @param incomingHeaders - * - the map of headers from the inbound JAX-RS request. This will be an empty map if the associated - * client interface is not part of a JAX-RS request. + * - the map of headers from the inbound Jakarta RESTful Web Services request. This will be an empty map + * if the associated client interface is not part of a Jakarta RESTful Web Services request. * @param clientOutgoingHeaders * - the read-only map of header parameters specified on the client interface. * @return a map of HTTP headers to merge with the clientOutgoingHeaders to be sent to the remote service. diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/DefaultClientHeadersFactoryImpl.java b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/DefaultClientHeadersFactoryImpl.java index f1018e7..58f4c03 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/DefaultClientHeadersFactoryImpl.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/DefaultClientHeadersFactoryImpl.java @@ -28,13 +28,13 @@ import jakarta.ws.rs.core.MultivaluedMap; /** - * This class propagates JAX-RS headers whose names are specified using the MicroProfile Config property, - * org.eclipse.microprofile.rest.client.propagateHeaders. + * This class propagates Jakarta RESTful Web Services headers whose names are specified using the MicroProfile Config + * property, org.eclipse.microprofile.rest.client.propagateHeaders. * *

* The value of this property should be a comma-separated list of HTTP header names. If the headers specified in the - * property exist in the inbound JAX-RS request, this class will propagate those headers to the outbound Rest Client - * request. + * property exist in the inbound Jakarta RESTful Web Services request, this class will propagate those headers to the + * outbound Rest Client request. * *

* Any headers present on {@code clientOutgoingHeaders} will not be returned when calling the diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ResponseExceptionMapper.java b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ResponseExceptionMapper.java index becc4f3..0f94562 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ResponseExceptionMapper.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/ext/ResponseExceptionMapper.java @@ -24,7 +24,7 @@ import jakarta.ws.rs.core.Response; /** - * Converts an JAX-RS Response object into an Exception. + * Converts an Jakarta RESTful Web Services Response object into an Exception. * */ public interface ResponseExceptionMapper { @@ -37,7 +37,7 @@ public interface ResponseExceptionMapper { * If this method reads the response body as a stream it must ensure that it resets the stream. * * @param response - * the JAX-RS response processed from the underlying client + * the Jakarta RESTful Web Services response processed from the underlying client * @return A throwable, if this mapper could convert the response. */ T toThrowable(Response response); diff --git a/api/src/main/java/org/eclipse/microprofile/rest/client/package-info.java b/api/src/main/java/org/eclipse/microprofile/rest/client/package-info.java index 2178eeb..2cc07b4 100644 --- a/api/src/main/java/org/eclipse/microprofile/rest/client/package-info.java +++ b/api/src/main/java/org/eclipse/microprofile/rest/client/package-info.java @@ -19,7 +19,7 @@ *******************************************************************************/ /** - * APIs for building a type-safe RESTful client leveraging existing JAX-RS APIs, for example: + * APIs for building a type-safe RESTful client leveraging existing Jakarta RESTful Web Services APIs, for example: * * 

  * public interface MyClientService {
diff --git a/spec/src/main/asciidoc/clientexamples.asciidoc b/spec/src/main/asciidoc/clientexamples.asciidoc
index 2e100a1..235cebc 100644
--- a/spec/src/main/asciidoc/clientexamples.asciidoc
+++ b/spec/src/main/asciidoc/clientexamples.asciidoc
@@ -140,12 +140,12 @@ public interface MyInvalidClient {
 }
 ----
 
-It is also possible to add or propagate headers en masse using a `ClientHeadersFactory`. This interface has a single method and takes two read-only `MultivaluedMap` parameters: The first map represents headers for the incoming request - if the client is executing in a JAX-RS environment then this map will contain headers from the inbound JAX-RS request. The second map represents the headers to be sent,
+It is also possible to add or propagate headers en masse using a `ClientHeadersFactory`. This interface has a single method and takes two read-only `MultivaluedMap` parameters: The first map represents headers for the incoming request - if the client is executing in a Jakarta RESTful Web Services environment then this map will contain headers from the inbound Jakarta RESTful Web Services request. The second map represents the headers to be sent,
 and it contains headers that have been specified via `@ClientHeaderParam`, `@HeaderParam`, `@BeanParam`, etc. The method should return a `MultivaluedMap` containing the "final" map of headers to be sent to the outbound processing flow. Providers such as filters, interceptors, message body writers, etc. could still modify the final map of headers prior to
 sending the HTTP request.
 
 By default, no `ClientHeadersFactory` implementation is used. To enable a `ClientHeadersFactory`, the client interface must be annotated with the `@RegisterClientHeaders` annotation. If this annotation specifies a value, the client implementation must invoke an instance of the specified `ClientHeadersFactory` implementation class. If no value is specified, then the client
-implementation must invoke the `DefaultClientHeadersFactoryImpl`. This default factory will propagate specified headers from the inbound JAX-RS request to the outbound request - these headers are specified with a comma-separated list using the following MicroProfile Config property:
+implementation must invoke the `DefaultClientHeadersFactoryImpl`. This default factory will propagate specified headers from the inbound Jakarta RESTful Web Services request to the outbound request - these headers are specified with a comma-separated list using the following MicroProfile Config property:
 
 `org.eclipse.microprofile.rest.client.propagateHeaders`
 
diff --git a/spec/src/main/asciidoc/integration.asciidoc b/spec/src/main/asciidoc/integration.asciidoc
index a476ac4..63dcedf 100644
--- a/spec/src/main/asciidoc/integration.asciidoc
+++ b/spec/src/main/asciidoc/integration.asciidoc
@@ -48,17 +48,17 @@ the default connect and read timeouts and use the timeout value specified in the
 blocking/non-interruptible operations should be less than or equal to the time specified in the annotation, allowing the MP Fault Tolerance implementation to
 interrupt the request and the throw the appropriate `TimeoutException`.
 
-=== JAX-RS
+=== Jakarta RESTful Web Services
 
-When a client interface is executed from within a JAX-RS context (resource or provider class), it is possible to propagate HTTP headers using the `DefaultClientHeadersFactoryImpl` by adding the
-`@RegisterClientHeaders` annotation to the interface with no value. To specify which headers to propagate from the inbound JAX-RS request to the outbound MP Rest Client request, users must use a
+When a client interface is executed from within a Jakarta RESTful Web Services context (resource or provider class), it is possible to propagate HTTP headers using the `DefaultClientHeadersFactoryImpl` by adding the
+`@RegisterClientHeaders` annotation to the interface with no value. To specify which headers to propagate from the inbound Jakarta RESTful Web Services request to the outbound MP Rest Client request, users must use a
 comma-separated list of headers in the following MicroProfile Config property:
 
 `org.eclipse.microprofile.rest.client.propagateHeaders`.
 
-If the client interface is used within a JAX-RS context, then the implementation may support injection of `@Context` 
-fields and methods into custom `ClientHeadersFactory` instances. The injected objects are related to the JAX-RS context
-(i.e. an injected `UriInfo` will be specific to the JAX-RS resource's URI, not the URI of the MP Rest Client interface).
+If the client interface is used within a Jakarta RESTful Web Services context, then the implementation may support injection of `@Context` 
+fields and methods into custom `ClientHeadersFactory` instances. The injected objects are related to the Jakarta RESTful Web Services context
+(i.e. an injected `UriInfo` will be specific to the Jakarta RESTful Web Services resource's URI, not the URI of the MP Rest Client interface).
 This injection is optional for the implementation, so the only portable injection mechanism of `ClientHeadersFactory`
 instances is `@Inject` when the client is managed by CDI.
 
diff --git a/spec/src/main/asciidoc/providers.asciidoc b/spec/src/main/asciidoc/providers.asciidoc
index 9c89168..1ef07eb 100644
--- a/spec/src/main/asciidoc/providers.asciidoc
+++ b/spec/src/main/asciidoc/providers.asciidoc
@@ -17,7 +17,7 @@
 [[providers]]
 == MicroProfile Rest Client Provider Registration
 
-The RestClientBuilder interface extends the `Configurable` interface from JAX-RS, allowing a user to register custom providers while its being built.  The behavior of the providers supported is defined by the JAX-RS Client API specification.  Below is a list of provider types expected to be supported by an implementation:
+The RestClientBuilder interface extends the `Configurable` interface from Jakarta RESTful Web Services, allowing a user to register custom providers while its being built.  The behavior of the providers supported is defined by the Jakarta RESTful Web Services Client API specification.  Below is a list of provider types expected to be supported by an implementation:
 
 === ClientResponseFilter
 
@@ -31,15 +31,15 @@ Both the `ClientRequestFilter` and `ClientResponseFilter` interfaces contains me
 
 === MessageBodyReader
 
-The `MessageBodyReader` interface defined by JAX-RS allows the entity to be read from the API response after invocation.
+The `MessageBodyReader` interface defined by Jakarta RESTful Web Services allows the entity to be read from the API response after invocation.
 
 === MessageBodyWriter
 
-The `MessageBodyWriter` interface defined by JAX-RS allows a request body to be written in the request for `@POST`, `@PUT` operations, as well as other HTTP methods that support bodies.
+The `MessageBodyWriter` interface defined by Jakarta RESTful Web Services allows a request body to be written in the request for `@POST`, `@PUT` operations, as well as other HTTP methods that support bodies.
 
 === ParamConverter
 
-The `ParamConverter` interface defined by JAX-RS allows a parameter in a resource method to be converted to a format to be used in a request or a response.
+The `ParamConverter` interface defined by Jakarta RESTful Web Services allows a parameter in a resource method to be converted to a format to be used in a request or a response.
 
 === ReaderInterceptor
 
@@ -55,7 +55,7 @@ The `ResponseExceptionMapper` is specific to MicroProfile Rest Client.  This map
 
 ==== How to Implement ResponseExceptionMapper
 
-The specification provides default methods for `getPriority()` and `handles(int status, MultivaluedMap headers)` methods.  Priority is meant to be derived via a `@Priority` annotation added to the `ResponseExceptionMapper` implementation.  The runtime will sort ascending, taking the one with the lowest numeric value first to check if it can handle the `Response` object based on it's status code and headers.  The usage of ascending sorting is done to be consistent with JAX-RS behavior.
+The specification provides default methods for `getPriority()` and `handles(int status, MultivaluedMap headers)` methods.  Priority is meant to be derived via a `@Priority` annotation added to the `ResponseExceptionMapper` implementation.  The runtime will sort ascending, taking the one with the lowest numeric value first to check if it can handle the `Response` object based on it's status code and headers.  The usage of ascending sorting is done to be consistent with Jakarta RESTful Web Services behavior.
 
 Likewise, the `handles` method by default will handle any response status code >= 400.  You may override this behavior if you so choose to handle other response codes (both a smaller ranger and a larger range are expected) or base the decision on the response headers.
 
@@ -166,7 +166,7 @@ Implementations may provide any number of providers registered automatically, bu
 
 === JSON-P and JSON-B Providers
 
-Implementations of the MicroProfile Rest Client should behave similar to JAX-RS implementations with regard to built-in JSON-P and JSON-B providers. Implementations must provide a built-in JSON-P entity provider. If the implementation supports JSON-B, then it must also provide a built-in JSON-B entity provider. Note that the JSON-B provider should take precedence over the JSON-P provider unless the client interface method's entity parameter or return type is a JSON-P object type (`jakarta.json.JsonObject`, `jakarta.json.JsonArray`, etc.).
+Implementations of the MicroProfile Rest Client should behave similar to Jakarta RESTful Web Services implementations with regard to built-in JSON-P and JSON-B providers. Implementations must provide a built-in JSON-P entity provider. If the implementation supports JSON-B, then it must also provide a built-in JSON-B entity provider. Note that the JSON-B provider should take precedence over the JSON-P provider unless the client interface method's entity parameter or return type is a JSON-P object type (`jakarta.json.JsonObject`, `jakarta.json.JsonArray`, etc.).
 
 When an interface is registered that contains:
 
@@ -175,7 +175,7 @@ When an interface is registered that contains:
 - a method that declares input or output of type `jakarta.json.JsonValue` or any subclass therein (JSON-P only) or
 - no `@Produces` or `@Consumes`
 
-Then a JSON-B or JSON-P `MessageBodyReader` and `MessageBodyWriter` will be registered automatically by the implementation.  This is in alignment with the JAX-RS 2.1 specification.  The provider registered will have a priority of `Integer.MAX_VALUE`, allowing a user to register a custom provider to be used instead.
+Then a JSON-B or JSON-P `MessageBodyReader` and `MessageBodyWriter` will be registered automatically by the implementation.  This is in alignment with the Jakarta RESTful Web Services specification.  The provider registered will have a priority of `Integer.MAX_VALUE`, allowing a user to register a custom provider to be used instead.
 
 Users may configure how JSON-B serializes a request entity or deserializes a response entity by registering a class or instance of `ContextResolver`. For example, the following code would enable the JSON-B provider implementation to deserialize private fields (without needing getters/setters):
 
diff --git a/spec/src/main/asciidoc/release_notes.asciidoc b/spec/src/main/asciidoc/release_notes.asciidoc
index cd47004..bd64e31 100644
--- a/spec/src/main/asciidoc/release_notes.asciidoc
+++ b/spec/src/main/asciidoc/release_notes.asciidoc
@@ -88,7 +88,7 @@ APIs now depend on Jakarta EE 8 APIs and they must be provided by the implementa
 
 Changes since 1.3:
 
-- Ensure CDI and optionally JAX-RS injection into `ClientHeadersFactory`.
+- Ensure CDI and optionally Jakarta RESTful Web Services injection into `ClientHeadersFactory`.
 - Specified `@Target` to `@RestClient` annotation.
 - Removed recursive classloader check when resolving service loader for Rest Client SPI.
 - Updated ParamConverter TCK test case to be more realistic (converting String-to-Widget rather than String-to-String).
@@ -109,7 +109,7 @@ Changes since 1.2:
 
 Changes since 1.1:
 
-- Generate headers en masse, including propagation of headers from inbound JAX-RS requests.
+- Generate headers en masse, including propagation of headers from inbound Jakarta RESTful Web Services requests.
 - New `@ClientHeaderParam` API for defining HTTP headers without modifying the client interface method signature.
 - New section documenting the <>.
 - Clarification on built-in JSON-B/JSON-P entity providers.
@@ -140,9 +140,9 @@ http://download.eclipse.org/microprofile/microprofile-rest-client-1.0/apidocs/[M
 Key features:
 
 - Built in alignment to other MicroProfile Specs - automatic registration of JSON provider, CDI support for injecting clients, fully configurable clients via MicroProfile Config
-- Can map JAX-RS `Response` objects into `Exception`s to be handled by your client code
+- Can map Jakarta RESTful Web Services `Response` objects into `Exception`s to be handled by your client code
 - Fully declarative annotation driven configuration, with supported builder patterns
-- Closely aligned to JAX-RS with configuration and behavior based on the JAX-RS `Client` object
+- Closely aligned to Jakarta RESTful Web Services with configuration and behavior based on the Jakarta RESTful Web Services `Client` object
 
 To get started, simply add this dependency to your project, assuming you have an implementation available:
 
diff --git a/spec/src/main/asciidoc/server_sent_events.asciidoc b/spec/src/main/asciidoc/server_sent_events.asciidoc
index c1b0ec0..51c7444 100644
--- a/spec/src/main/asciidoc/server_sent_events.asciidoc
+++ b/spec/src/main/asciidoc/server_sent_events.asciidoc
@@ -150,10 +150,10 @@ This allows subscribers to consume the type-safe business objects (`WeatherEvent
 needing to manually deserialize them from the `InboundSseEvent`. Depending on the execution environment, the provider
 class may not be necessary.
 
-Similar to JAX-RS, MicroProfile Rest Client implementations must use registered `MessageBodyReader` implementations to
+Similar to Jakarta RESTful Web Services, MicroProfile Rest Client implementations must use registered `MessageBodyReader` implementations to
 deserialize the data from the SSE into the business object. The SSE specification does not specify that a content type
 be sent with each SSE, so it is not always possible for Rest Client implementations to choose the correct 
-`MessageBodyReader` for the specified business object. MessageBodyReader selection is documented in the JAX-RS 
+`MessageBodyReader` for the specified business object. MessageBodyReader selection is documented in the Jakarta RESTful Web Services 
 specification. Users are advised to either use `Publisher` or create and register their own
 `MessageBodyReader` when type selection is difficult to determine. Users are always advised to use 
 `Publisher` when a server pushes different types of objects from the endpoint.
diff --git a/tck/src/main/java/org/eclipse/microprofile/rest/client/tck/ProducesConsumesTest.java b/tck/src/main/java/org/eclipse/microprofile/rest/client/tck/ProducesConsumesTest.java
index 0feff32..d2edc39 100644
--- a/tck/src/main/java/org/eclipse/microprofile/rest/client/tck/ProducesConsumesTest.java
+++ b/tck/src/main/java/org/eclipse/microprofile/rest/client/tck/ProducesConsumesTest.java
@@ -39,7 +39,8 @@
 /**
  * Tests that MP Rest Client's @Produces annotation affects the value transmitted in the
  * Accept header, and that it's @Consumes annotation affects the value transmitted in the
- * Content-Type header. Note that this is opposite of what you would expect for JAX-RS resources.
+ * Content-Type header. Note that this is opposite of what you would expect for Jakarta RESTful Web
+ * Services resources.
  */
 public class ProducesConsumesTest extends Arquillian {
     private final static Logger LOG = Logger.getLogger(ProducesConsumesTest.class.getName());