As JAX-RS API is evolving, with version 2.0 released earlier this year under JSR-339 umbrella, it's becoming even more easy to create REST services using excellent Java platform.
But with great simplicity comes great responsibility: documenting all these APIs so other developers could quickly understand how to use them. Unfortunately, in this area developers are on their own: the JSR-339 doesn't help much. For sure, it would be just awesome to generate verbose and easy to follow documentation from source code, and not asking someone to write it along the development process. Sounds unreal, right? In certain extent, it really is, but help is coming in a form of Swagger.
Essentially, Swagger does a simple but very powerful thing: with a bit of additional annotations it generates the REST API descriptions (HTTP methods, path / query / form parameters, responses, HTTP error codes, ...) and even provides a simple web UI to play with REST calls to your APIs (not to mention that all this metadata is available over REST as well).
Before digging into implementation details, let's take a quick look what Swagger is from API consumer prospective. Assume you have developed a great REST service to manage people. As a good citizen, this REST service is feature-complete and provides following functionality:
- lists all people (GET)
- looks up person by e-mail (GET)
- adds new person (POST)
- updates existing person (PUT)
- and finally removes person (DELETE)
It looks quite pretty. Let's do more and call our REST service from Swagger UI, here this awesome framework really shines. The most complicated use-case is adding new person (POST) so this one will be looked closely.
As you can see on the snapshot above, every piece of REST service call is there:
- description of the service
- relative context path
- parameters (form / path / query), required or optional
- HTTP status codes: 201 CREATED and 409 CONFLICT
- ready to go Try it out! to call REST service immediately (with out-of-the box parameters validation)
To complete the demo part, let me show yet another example, where REST resource is being involved (in our case, it's a simple class Person). Swagger is able to provide its properties and meaningful description together with expected response content type(s).
Looks nice! Moving on to the next part, it's all about implementation details. Swagger supports seamless integration with JAX-RS services, with just couple of additional annotations required on top of existing ones. Firstly, every single JAX-RS service which supposed to be documented should be annotated with @Api annotation, in our case:
@Path( "/people" )
@Api( value = "/people", description = "Manage people" )
public class PeopleRestService {
// ...
}
Next, the same approach is applicable to REST service operations: every method which supposed to be documented should be annotated with @ApiOperation annotation, and optionally with @ApiResponses/@ApiResponse. If it accepts parameters, those should be annotated with @ApiParam annotation. Couple of examples here:
@Produces( { MediaType.APPLICATION_JSON } )
@GET
@ApiOperation(
value = "List all people",
notes = "List all people using paging",
response = Person.class,
responseContainer = "List"
)
public Collection< Person > getPeople(
@ApiParam( value = "Page to fetch", required = true )
@QueryParam( "page") @DefaultValue( "1" ) final int page ) {
// ...
}
And another one:
@Produces( { MediaType.APPLICATION_JSON } )
@Path( "/{email}" )
@GET
@ApiOperation(
value = "Find person by e-mail",
notes = "Find person by e-mail",
response = Person.class
)
@ApiResponses( {
@ApiResponse( code = 404, message = "Person with such e-mail doesn't exists" )
} )
public Person getPeople(
@ApiParam( value = "E-Mail address to lookup for", required = true )
@PathParam( "email" ) final String email ) {
// ...
}
REST resource classes (or model classes) require special annotations: @ApiModel and @ApiModelProperty. Here is how our Person class looks like:
@ApiModel( value = "Person", description = "Person resource representation" )
public class Person {
@ApiModelProperty( value = "Person's first name", required = true )
private String email;
@ApiModelProperty( value = "Person's e-mail address", required = true )
private String firstName;
@ApiModelProperty( value = "Person's last name", required = true )
private String lastName;
// ...
}
The last steps is to plug in Swagger into JAX-RS application. The example I have developed uses Spring Framework, Apache CXF, Swagger UI and embedded Jetty (complete project is available on Github). Integrating Swagger is a matter of adding configuration bean (swaggerConfig), one additional JAX-RS service (apiListingResourceJson) and two JAX-RS providers (resourceListingProvider and apiDeclarationProvider).
package com.example.config;
import java.util.Arrays;
import javax.ws.rs.ext.RuntimeDelegate;
import org.apache.cxf.bus.spring.SpringBus;
import org.apache.cxf.endpoint.Server;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.core.env.Environment;
import com.example.resource.Person;
import com.example.rs.JaxRsApiApplication;
import com.example.rs.PeopleRestService;
import com.example.services.PeopleService;
import com.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;
import com.wordnik.swagger.jaxrs.config.BeanConfig;
import com.wordnik.swagger.jaxrs.listing.ApiDeclarationProvider;
import com.wordnik.swagger.jaxrs.listing.ApiListingResourceJSON;
import com.wordnik.swagger.jaxrs.listing.ResourceListingProvider;
@Configuration
public class AppConfig {
public static final String SERVER_PORT = "server.port";
public static final String SERVER_HOST = "server.host";
public static final String CONTEXT_PATH = "context.path";
@Bean( destroyMethod = "shutdown" )
public SpringBus cxf() {
return new SpringBus();
}
@Bean @DependsOn( "cxf" )
public Server jaxRsServer() {
JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance().createEndpoint( jaxRsApiApplication(), JAXRSServerFactoryBean.class );
factory.setServiceBeans( Arrays.< Object >asList( peopleRestService(), apiListingResourceJson() ) );
factory.setAddress( factory.getAddress() );
factory.setProviders( Arrays.< Object >asList( jsonProvider(), resourceListingProvider(), apiDeclarationProvider() ) );
return factory.create();
}
@Bean @Autowired
public BeanConfig swaggerConfig( Environment environment ) {
final BeanConfig config = new BeanConfig();
config.setVersion( "1.0.0" );
config.setScan( true );
config.setResourcePackage( Person.class.getPackage().getName() );
config.setBasePath(
String.format( "http://%s:%s/%s%s",
environment.getProperty( SERVER_HOST ),
environment.getProperty( SERVER_PORT ),
environment.getProperty( CONTEXT_PATH ),
jaxRsServer().getEndpoint().getEndpointInfo().getAddress()
)
);
return config;
}
@Bean
public ApiDeclarationProvider apiDeclarationProvider() {
return new ApiDeclarationProvider();
}
@Bean
public ApiListingResourceJSON apiListingResourceJson() {
return new ApiListingResourceJSON();
}
@Bean
public ResourceListingProvider resourceListingProvider() {
return new ResourceListingProvider();
}
@Bean
public JaxRsApiApplication jaxRsApiApplication() {
return new JaxRsApiApplication();
}
@Bean
public PeopleRestService peopleRestService() {
return new PeopleRestService();
}
// ...
}
In order to get rid of any possible hard-coded configuration, all parameters are passed through named properties (SERVER_PORT, SERVER_HOST and CONTEXT_PATH). Swagger exposes additional REST endpoint to provide API documentation, in our case it is accessible at: http://localhost:8080/rest/api/api-docs. It is used by Swagger UI which itself is embedded into final JAR archive and served by Jetty as static web resource.
The final piece of the puzzle is to start embedded Jetty container which glues all those parts together and is encapsulated into Starter class:
package com.example;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.HandlerList;
import org.eclipse.jetty.servlet.DefaultServlet;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.util.resource.Resource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import com.example.config.AppConfig;
public class Starter {
private static final int SERVER_PORT = 8080;
private static final String CONTEXT_PATH = "rest";
public static void main( final String[] args ) throws Exception {
Resource.setDefaultUseCaches( false );
final Server server = new Server( SERVER_PORT );
System.setProperty( AppConfig.SERVER_PORT, Integer.toString( SERVER_PORT ) );
System.setProperty( AppConfig.SERVER_HOST, "localhost" );
System.setProperty( AppConfig.CONTEXT_PATH, CONTEXT_PATH );
// Configuring Apache CXF servlet and Spring listener
final ServletHolder servletHolder = new ServletHolder( new CXFServlet() );
final ServletContextHandler context = new ServletContextHandler();
context.setContextPath( "/" );
context.addServlet( servletHolder, "/" + CONTEXT_PATH + "/*" );
context.addEventListener( new ContextLoaderListener() );
context.setInitParameter( "contextClass", AnnotationConfigWebApplicationContext.class.getName() );
context.setInitParameter( "contextConfigLocation", AppConfig.class.getName() );
// Configuring Swagger as static web resource
final ServletHolder swaggerHolder = new ServletHolder( new DefaultServlet() );
final ServletContextHandler swagger = new ServletContextHandler();
swagger.setContextPath( "/swagger" );
swagger.addServlet( swaggerHolder, "/*" );
swagger.setResourceBase( new ClassPathResource( "/webapp" ).getURI().toString() );
final HandlerList handlers = new HandlerList();
handlers.addHandler( context );
handlers.addHandler( swagger );
server.setHandler( handlers );
server.start();
server.join();
}
}
Couple of comments make thing a bit more clear: our JAX-RS services will be available under /rest/* context path while Swagger UI is available under /swagger context path. The one important note concerning Resource.setDefaultUseCaches( false ): because we are serving static web content from JAR file, we have to set this property to false as workaround for this bug.
Now, let's build and run our JAX-RS application by typing:
mvn clean package java -jar target/jax-rs-2.0-swagger-0.0.1-SNAPSHOT.jar
In a second, Swagger UI should be available in your browser at: http://localhost:8080/swagger/
As a final note, there are a lot more to say about Swagger but I hope this simple example shows the way to make our REST services self-documented and easily consumable with minimal efforts. Many thanks to Wordnik team for that.
Source code is available on Github.
Posts
