Java Web Services resources (updated)

• JAXB user guide
• SOAP resources
• SOAP Webservices standards overview
• WSDL binding styles
• SOAP 1.2 enhancements
• Metro JAX-WS reference implementation
• SOAP 1.2 binding
• Dispatch Client API (CXF)
• Spring WS resources
• a public SOAP service 
• REST resources
• REST primer and API design guidelines
• HAL (Hypertext Application Language)
• traverson-hal npm REST client package 
• Swagger and Jersey
• OpenAPI code generator
• REST security related libraries 
• Data formats
• JSON
• Jersey JAXB JSON configuration 
• YAML in Y minutes
• Servers
• ServersWeblogic doc
• API 
• Apache CXF resources
• Tools
• Firefox RESTClient addon
• cURL (see URL) command line HTTP and network client
• cookies, forms, proxies 
• protocols: ssh, FTP, mail ...
• simultaneous requests
• event based actions
• encryption and authentication: SSL, OAuth, Kerberos...
• Browser Developer Tools (launch using CTRL SHIFT i)
• , network section
• Firefox: right click request: copy as curl
• SOAP UI testing tool
•  SOAP and REST testing
• Postman REST testing tool
• handcrafting SOAP
• common Java keytool commands 
• Oracle Certified Expert, Java Platform, Enterprise Edition 6 Web Services Developer Study Guide
• Alternatives
• Microservices
• GraphQL 
• Burlap: an RMI like protocol using XML over HTTP

JAX-RS 2.0 preview (updated)

Here's an overview of the most important new features in JAX-RS 2.0 (JSR339).
The JSR is currently in public review, so this is subject to change.

• Asynchronous REST web services
REST web services are based on servlets. So the new asynchronous REST support looks a lot like the new asynchronous servlet support.
The response to an asynchronous web service can be delegated to another thread.
 The webservice needs to pass the asynchronous response, to allow it to send a response.

@Path ("/rest2/async")
public class NoWaiter{
  @Asynchronous
  @GET 
  public String delegate(@Suspended AsyncResponse ctx) {
    // put context on a queue
    // for job to be picked up by a thread
    bloq.add(ctx);
    // exit immediatly
  }
}

class Handler implements Runnable{
  public void run(){
    AsyncResponse ctx bloq.take();
    // return response
    ctx.resume("response");
  }
} 

• Client API
Similar to Jersey 1 client API (some names change)

Client client = ClientFactory.newClient();
String result = client.target(“http://reasonsto.be”)
  .request("text/plain")
  .get(String.class); 

Chaining async() in the call, the client becomes asynchronous:

Future<String> result = client.target(“http://reasonsto.be”)
  .request("text/plain")
  .async()
  .get(String.class);

You can also pass a listener to the asynchronous client:

Future<String> result = client.target(“http://reasonsto.be”)
  .request("text/plain")
  .async()
  .get(new Hark()); 

class Hark implements InvocationCallback<String>
{
public void completed(String result) {…}
public void failed(InvocationException err) {…}
}

• Filters and Entity Interceptors
• Similar to Jersey 1 filters 
• @Provider annotated 
• set order using @Priority
• Filters wrap around an entire HTTP request. Mostly deal with HTTP headers, URI, method...
• interface ContainerResponsFilter (javax.ws.rs.container)
• void filter(ContainerResponseContext ctx) throws IOException
• interface ContainerRequestFilter
• void filter(ContainerRequestContext ctx) throws IOException 
• Can have an additional @PreMatching annotation to run before JAX-RS resource method is selected (default is after resource method selection)
• Throwing an exception will veto further processing of the message
• javax.ws.rs.client contains similar clientside filters. Just replace Container with Client in the above interfaces. 
• not annotated, but ClientBuilder, Client, and WebTarget all implement the Configurable interface. You can add your filter using its register(yourFilter) method.
• Entity Interceptors wrap around the HTTP body <=> java Object marshalling/unmarshalling (e.g. for supporting compression encoding)
•  interface WriterInterceptor
• void aroundWriteTo(WriterInterceptorContext ctx) throws IOException, WebApplicationException
• interface ReaderInterceptor
• Object aroundReadFrom(ReaderInterceptorContext ctx) throws IOException, WebApplicationException
• The aroundXXX  method naming indicate that these work like servlet filters:
1. do some stuff
2. ctx.proceed(): delegate to the next interceptor in the chain (of there is one)
3. do some more stuff
• Binding
• Global
•  @Provider
• Local 
• Using DynamicFeature
• Using @NameBinding
• Indicate that the usage of this resourcemethod is to be logged, using our own annotation:

@LogMe
@GET
@Produces("text/html")
public String getXml(){ 
  return "<html>...</html>"
}

• Define the annotation

@NameBinding
public @interface Logme{}

• Implement the annotation

@LogMe
public class LoggerLoggingFilter 
  implements ContainerRequestFilter, ContainerResponseFilter {
// your logging code 
}

• Dynamic
1. The filter is bound using one of the above methods, but there is an extra check to see if the filter should be applied
2. The filter must implement the DynamicBinding interface
3. The filter is applied only if the isBound() method returns true 
• JSR303 validation
• @Produces allows server to specify a mime type preference, using the qs attribute
• Form class can be used as a resource method argument to capture a map of query parameters (shorthand for UriInfo.getQueryParameters()).