Module java.xml.ws

# Package javax.xml.ws.spi.http

Provides HTTP SPI that is used for portable deployment of JAX-WS web services in containers(for e.g.

See: Description

Class Summary
HttpContext: HttpContext represents a mapping between the root URI path of a web service to a `HttpHandler` which is invoked to handle requests destined for that path on the associated container.
HttpExchange: This class encapsulates a HTTP request received and a response to be generated in one exchange.
HttpHandler: A handler which is invoked to process HTTP requests.

## Package javax.xml.ws.spi.http Description

Provides HTTP SPI that is used for portable deployment of JAX-WS web services in containers(for e.g. servlet containers). This SPI is not for end developers but provides a way for the container developers to deploy JAX-WS services portably.

The portable deployment is done as below:

1. Container creates `Endpoint` objects for an application. The necessary information to create Endpoint objects may be got from web service deployment descriptor files.
2. Container needs to create `HttpContext` objects for the deployment. For example, a HttpContext could be created using servlet configuration(for e.g url-pattern) for the web service in servlet container case.
3. Then publishes all the endpoints using `Endpoint.publish(HttpContext)`. During publish(), JAX-WS runtime registers a `HttpHandler` callback to handle incoming requests or `HttpExchange` objects. The HttpExchange object encapsulates a HTTP request and a response.

      Container                               JAX-WS runtime
      ---------                               --------------
      1. Creates Invoker1, ... InvokerN
      2. Provider.createEndpoint(...)     --> 3. creates Endpoint1
         configures Endpoint1
         ...
      4. Provider.createEndpoint(...)     --> 5. creates EndpointN
         configures EndpointN
      6. Creates ApplicationContext
      7. creates HttpContext1, ... HttpContextN
      8. Endpoint1.publish(HttpContext1)  --> 9. creates HttpHandler1
                                              HttpContext1.setHandler(HttpHandler1)
         ...
     10. EndpointN.publish(HttpContextN)  --> 11. creates HttpHandlerN
                                             HttpContextN.setHandler(HttpHandlerN)

The request processing is done as below(for every request):

      Container                               JAX-WS runtime
      ---------                               --------------
      1. Creates a HttpExchange
      2. Gets handler from HttpContext
      3. HttpHandler.handle(HttpExchange) --> 4. reads request from HttpExchange
                                          <-- 5. Calls Invoker
      6. Invokes the actual instance
                                              7. Writes the response to HttpExchange

The portable undeployment is done as below:

      Container
      ---------
      1. @preDestroy on instances
      2. Endpoint1.stop()
      ...
      3. EndpointN.stop()

Since:
  1.7, JAX-WS 2.2