Tải bản đầy đủ

Building+a+ REST API spring

Building a
REST API with




Building a REST API with

TABLE OF CONTENTS
1: BOOTSTRAP A WEB APPLICATION WITH SPRING 4
2: BUILD A REST API WITH SPRING 4 AND JAVA CONFIG
3: SPRING SECURITY FOR A REST API
4: SPRING SECURITY BASIC AUTHENTICATION
5: SPRING SECURITY DIGEST AUTHENTICATION
6: BASIC AND DIGEST AUTHENTICATION FOR A REST SERVICE
WITH SPRING SECURITY



7: HTTP MESSAGE CONVERTERS WITH THE SPRING FRAMEWORK
8: REST API DISCOVERABILITY AND HATEOAS

9: HATEOAS FOR A SPRING REST SERVICE
10: ETAGS FOR REST WITH SPRING
11: REST PAGINATION IN SPRING
12: ERROR HANDLING FOR REST WITH SPRING
13: VERSIONING A REST API
14: TESTING REST WITH MULTIPLE MIME TYPESA
Page 2 / 113




Building a REST API with

1: BOOTSTRAP A WEB APPLICATION WITH SPRING 4
1. Overview.............. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������� 11
2. The Maven pom.xml

���������������������������������������������������������������������������������������������������������������������������������������������������� 11

2.1. The cglib dependency before Spring 3.2

������������������������������������������������������������������������������������������������������ 12

2.2. The cglib dependency in Spring 3.2 and beyond
3. The Java based Web Configuration

��������������������������������������������������������������������������������������� 13

��������������������������������������������������������������������������������������������������������������������� 13

3.1. The web.xml... ������������������������������������������������������������������������������������������������������������������������������������������������������������������������� 15
4. Conclusion........ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������� 16

2: BUILD A REST API WITH SPRING 4 AND JAVA
CONFIG
1. Overview.............. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������� 18
2. Understanding REST in Spring ������������������������������������������������������������������������������������������������������������������������������������ 18
3. The Java Configuration

��������������������������������������������������������������������������������������������������������������������������������������������������� 19



4. Testing the Spring Context

������������������������������������������������������������������������������������������������������������������������������������ 19

5. The Controller... �������������������������������������������������������������������������������������������������������������������������������������������������������������������������20
6. Mapping the HTTP response codes
6.1. Unmapped Requests

��������������������������������������������������������������������������������������������������������������������� 21

��������������������������������������������������������������������������������������������������������������������������������������������������� 21

6.2. Valid, Mapped Requests���������������������������������������������������������������������������������������������������������������������������������������������������22
6.3. Client Error..... �������������������������������������������������������������������������������������������������������������������������������������������������������������������������22
6.4. Using @ExceptionHandler

������������������������������������������������������������������������������������������������������������������������������������22

Page 3 / 113




Building a REST API with

7. Additional Maven dependencies ��������������������������������������������������������������������������������������������������������������������������������23
8. Conclusion........ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������24

3: SPRING SECURITY FOR A REST API
1. Overview.............. ���������������������������������������������������������������������������������������������������������������������������������������������������������������������26
2. Spring Security in the web.xml ��������������������������������������������������������������������������������������������������������������������������������26
3. The Security Configuration

�������������������������������������������������������������������������������������������������������������������������������� 27

3.2. The Entry Point ��������������������������������������������������������������������������������������������������������������������������������������������������������������28
3.3. The Login Form for REST

��������������������������������������������������������������������������������������������������������������������������������29

3.4. Authentication should return 200 instead of 301

�����������������������������������������������������������������������������������29

3.5. Failed Authentication should return 401 instead of 302
3.6. The Authentication Manager and Provider
3.7 Finally – Authentication against the running

��������������������������������������������������������������������30

���������������������������������������������������������������������������������������������������31
REST Service���������������������������������������������������������������������31

4. Maven and other trouble �����������������������������������������������������������������������������������������������������������������������������������������������32
5. Conclusion........ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������32

4: SPRING SECURITY BASIC AUTHENTICATION
1. Overview.............. ���������������������������������������������������������������������������������������������������������������������������������������������������������������������34
2. The Spring Security Configuration

�����������������������������������������������������������������������������������������������������������������34

3. Consuming The Secured Application

�����������������������������������������������������������������������������������������������������������������35

4. Further Configuration – The Entry Point�����������������������������������������������������������������������������������������������������������������36

Page 4 / 113




Building a REST API with

5. The Maven Dependencies��������������������������������������������������������������������������������������������������������������������������������������������������� 37
6. Conclusion........ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������38

5: SPRING SECURITY DIGEST AUTHENTICATION
1. Overview.............. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������40
2. The Security XML Configuration ������������������������������������������������������������������������������������������������������������������������������������40
3. Consuming the Secured Application

���������������������������������������������������������������������������������������������������������������������42

4. The Maven Dependencies���������������������������������������������������������������������������������������������������������������������������������������������������43
5. Conclusion........ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������ 44

6: BASIC AND DIGEST AUTHENTICATION FOR A
REST SERVICE WITH SPRING SECURITY
1. Overview.............. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������ 46
2. Configuration of Basic Authentication �������������������������������������������������������������������������������������������������������������������� 46
2.1. Satisfying the stateless constraint – getting rid of sessions������������������������������������������������������������������������ 47
3. Configuration of Digest Authentication ���������������������������������������������������������������������������������������������������������������������47
4. Supporting both authentication protocols in the same RESTful service
4.1. Anonymous request

�������������������������������������������������������������������������������������������������������������������������������������������������� 49

4.2. Request with authentication credentials
5. Testing both scenarios

����������������������������������������� 48

����������������������������������������������������������������������������������������������������� 49

�������������������������������������������������������������������������������������������������������������������������������������������������� 49

6. Conclusion........ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������50

Page 5 / 113




Building a REST API with

7: HTTP MESSAGE CONVERTERS WITH THE
SPRING FRAMEWORK
1. Overview.............. �����������������������������������������������������������������������������������������������������������������������������������������������������������������52
2. The Basics.......... �����������������������������������������������������������������������������������������������������������������������������������������������������������������52
2.1. Enable Web MVC ����������������������������������������������������������������������������������������������������������������������������������������������������������52
2.2. The Default Message Converters

�������������������������������������������������������������������������������������������������������������53

3. Client-Server Communication – JSON only

����������������������������������������������������������������������������������������������54

3.1. High Level Content Negotiation����������������������������������������������������������������������������������������������������������������������������54
3.2. @ResponseBody

�������������������������������������������������������������������������������������������������������������������������������������������54

3.3. @RequestBody ����������������������������������������������������������������������������������������������������������������������������������������������������������55
4. Custom Converters Configuration – adding XML Support

����������������������������������������������������������������56

5. Using Spring’s RestTemplate with Http Message Converters ����������������������������������������������������������������58
5.1. Retrieving the Resource with no Accept Header

�������������������������������������������������������������������������������58

5.2. Retrieving a Resource with application/xml Accept header ����������������������������������������������������������������58
5.3. Retrieving a Resource with application/json Accept header����������������������������������������������������������������59
5.4. Update a Resource with XML Content-Type ����������������������������������������������������������������������������������������������60
6. Conclusion........ ����������������������������������������������������������������������������������������������������������������������������������������������������������������� 61

8: REST API DISCOVERABILITY AND HATEOAS
1. Overview.............. �����������������������������������������������������������������������������������������������������������������������������������������������������������������63
2. Why make the API Discoverable ����������������������������������������������������������������������������������������������������������������������������63
3. Discoverability Scenarios (Driven by tests)

����������������������������������������������������������������������������������������������64

Page 6 / 113




Building a REST API with

3.1. Discover the valid HTTP methods

��������������������������������������������������������������������������������������������������������������������64

3.2. Discover the URI of newly created Resource �����������������������������������������������������������������������������������������������������64
3.3. Discover the URI to GET All Resources of that type

�������������������������������������������������������������������������������������� 65

4. Other potential discoverable URIs and microformats ��������������������������������������������������������������������������������������66
5. Conclusion........ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������67

9: HATEOAS FOR A SPRING REST SERVICE
1. Overview.............. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������69
2. Decouple Discoverability through events

�����������������������������������������������������������������������������������������������������69

3. Make the URI of a newly created Resource discoverable
4. Get of single Resource

������������������������������������������������������������������������ 71

��������������������������������������������������������������������������������������������������������������������������������������������������� 71

5. Discoverability at the Root

������������������������������������������������������������������������������������������������������������������������������������72

5.1. Discoverability is not about changing URIs
6. Caveats of Discoverability

������������������������������������������������������������������������������������������������������73

������������������������������������������������������������������������������������������������������������������������������������73

7. Conclusion......... �������������������������������������������������������������������������������������������������������������������������������������������������������������������������74

10: ETAGS FOR REST WITH SPRING
1. Overview.............. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������76
2. REST and ETags.�������������������������������������������������������������������������������������������������������������������������������������������������������������������������76
3. Client-Server communication with curl
4. ETag support in Spring

������������������������������������������������������������������������������������������������������77

���������������������������������������������������������������������������������������������������������������������������������������������������78

Page 7 / 113




Building a REST API with

5. Testing ETags..... �������������������������������������������������������������������������������������������������������������������������������������������������������������������������79
6. ETags are BIG.... �������������������������������������������������������������������������������������������������������������������������������������������������������������������������81
7. Conclusion......... ������������������������������������������������������������������������������������������������������������������������������������������������������������������������ 82

11: REST PAGINATION IN SPRING
1. Overview.............. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������84
2. Page as Resource vs Page as Representation �����������������������������������������������������������������������������������������������������84
3. The Controller... ������������������������������������������������������������������������������������������������������������������������������������������������������������������������ 85
4. Discoverability for REST pagination
5. Test Driving Pagination

�������������������������������������������������������������������������������������������������������������������� 85

���������������������������������������������������������������������������������������������������������������������������������������������������87

6. Test Driving Pagination Discoverability ���������������������������������������������������������������������������������������������������������������������87
7. Getting All Resources

��������������������������������������������������������������������������������������������������������������������������������������������������88

8. REST Paging with Range HTTP headers ��������������������������������������������������������������������������������������������������������������������89
9. Conclusion........ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������89

12: ERROR HANDLING FOR REST WITH SPRING
1. Overview.............. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������91
2. Solution 1 – The Controller level @ExceptionHandler ���������������������������������������������������������������������������������������91
3. Solution 2 – The HandlerExceptionResolver ����������������������������������������������������������������������������������������������������� 92
3.1. ExceptionHandlerExceptionResolver �������������������������������������������������������������������������������������������������������������������� 92
3.2. DefaultHandlerExceptionResolver

�������������������������������������������������������������������������������������������������������������������� 93

Page 8 / 113




Building a REST API with

3.3. ResponseStatusExceptionResolver �������������������������������������������������������������������������������������������������������������������� 93
3.4. SimpleMappingExceptionResolver and AnnotationMethodHandlerExceptionResolver �����������94
3.5. Custom HandlerExceptionResolver ��������������������������������������������������������������������������������������������������������������������94
4. Solution 3 – The New @ControllerAdvice (Spring 3.2 And Above)

�������������������������������������������������������� 95

5. Conclusion........ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������97

13: VERSIONING A REST API
1. The Problem....... ������������������������������������������������������������������������������������������������������������������������������������������������������������������������99
2. What is in the Contract? ��������������������������������������������������������������������������������������������������������������������������������������������������99
2.1. URIs part of the Contract?

�����������������������������������������������������������������������������������������������������������������������������������99

2.2. Media Types part of the Contract?

������������������������������������������������������������������������������������������������������������������ 100

3. High Level Options��������������������������������������������������������������������������������������������������������������������������������������������������������������� 100
4. Advantages and Disadvantages ��������������������������������������������������������������������������������������������������������������������������������� 102
5. Possible Changes to the API

��������������������������������������������������������������������������������������������������������������������������������� 103

5.1. Adding to the Representation of a Resource ��������������������������������������������������������������������������������������������������� 103
5.2. Removing or changing an existing Representation ������������������������������������������������������������������������������������ 103
5.3. Major Semantic Changes

��������������������������������������������������������������������������������������������������������������������������������� 104

6. Conclusion........ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������� 105

14: TESTING REST WITH MULTIPLE MIME TYPES
1. Overview.............. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������107

Page 9 / 113




Building a REST API with

2. Goals..................... ����������������������������������������������������������������������������������������������������������������������������������������������������������������������� 107
3. Testing Infrastructure

������������������������������������������������������������������������������������������������������������������������������������������������� 107

4. The JSON and XML Marshallers ����������������������������������������������������������������������������������������������������������������������������������109
5. Consuming the Service with both JSON and XML
6. Maven and Jenkins

������������������������������������������������������������������������������������� 110

�������������������������������������������������������������������������������������������������������������������������������������������������� 111

7. Conclusion......... ����������������������������������������������������������������������������������������������������������������������������������������������������������������������� 112

Page 10 / 113


Building a REST API with

1. Overview

1: BOOTSTRAP A WEB
APPLICATION WITH SPRING 4
1. Overview
This section illustrates how to Bootstrap a Web Application with Spring and also discusses
how to make the jump from XML to Java without having to completely migrate the entire XML
configuration.

2. The Maven pom.xml
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”
http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd”>
4.0.0
org
rest
0.0.1-SNAPSHOT
war


org.springframework
spring-webmvc
${spring.version}


commons-logging
commons-logging





rest

Page 11 / 113


Building a REST API with

2.1. The cglib dependency before Spring 3.2



org.apache.maven.plugins
maven-compiler-plugin
3.1

1.6
1.6
UTF-8





4.0.5.RELEASE



2.1. The cglib dependency before Spring 3.2
You may wonder why cglib is a dependency – it turns out there is a valid reason to include it –
the entire configuration cannot function without it. If removed, Spring will throw:

Caused by: java.lang.IllegalStateException: CGLIB is required to process @Configuration
classes. Either add CGLIB to the classpath or remove the following @Configuration bean
definitions

The reason this happens is explained by the way Spring deals with @Configuration classes.
These classes are effectively beans, and because of this they need to be aware of the Context,
and respect scope and other bean semantics. This is achieved by dynamically creating a cglib
proxy with this awareness for each @Configuration class, hence the cglib dependency.
Also, because of this, there are a few restrictions for Configuration annotated classes:
• Configuration classes should not be final
• They should have a constructor with no arguments

Page 12 / 113


Building a REST API with

2.2. The cglib dependency in Spring 3.2 and beyond

2.2. The cglib dependency in Spring 3.2 and beyond
Starting with Spring 3.2, it is no longer necessary to add cglib as an explicit dependency.
This is because Spring is in now inlining cglib – which will ensure that all class based proxying
functionality will work out of the box with Spring 3.2.
The new cglib code is placed under the Spring package: org.springframework.cglib (replacing
the original net.sf.cglib). The reason for the package change is to avoid conflicts with any cglib
versions already existing on the classpath.
Also, the new cglib 3.0 is now used, upgraded from the older 2.2 dependency (see this JIRA
issue for more details).
Finally, now that Spring 4.0 is out in the wild, changes like this one (removing the cglib
dependency) are to be expected with Java 8 just around the corner – you can watch this
Spring Jira to keep track of the Spring support, and the Java 8 Resources page to keep tabs
on the that.

3. The Java based Web Configuration
@Configuration
@ImportResource( { “classpath*:/rest_config.xml” } )
@ComponentScan( basePackages = “org.rest” )
@PropertySource({ “classpath:rest.properties”, “classpath:web.properties” })
public class AppConfig{

}

@Bean
public static PropertySourcesPlaceholderConfigurer properties() {
return new PropertySourcesPlaceholderConfigurer();
}

First, the @Configuration annotation – this is the main artifact used by the Java based Spring
configuration; it is itself meta-annotated with @Component, which makes the annotated
classes standard beans and as such, also candidates for component scanning. The main
purpose of @Configuration classes is to be sources of bean definitions for the Spring IoC
Container. For a more detailed description, see the official docs.

Page 13 / 113


Building a REST API with

3. The Java based Web Configuration

Then, @ImportResource is used to import the existing XML based Spring configuration.
This may be configuration which is still being migrated from XML to Java, or simply legacy
configuration that you wish to keep. Either way, importing it into the Container is essential
for a successful migration, allowing small steps without to much risk. The equivalent XML
annotation that is replaced is:


Moving on to @ComponentScan – this configures the component scanning directive,
effectively replacing the XML:



As of Spring 3.1, the @Configuration are excluded from classpath scanning by default – see
this JIRA issue. Before Spring 3.1 though, these classes should have been excluded explicitly:

excludeFilters = { @ComponentScan.Filter( Configuration.class ) }

The @Configuration classes should not be autodiscovered because they are already specified
and used by the Container – allowing them to be rediscovered and introduced into the Spring
context will result in the following error:

Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException:
Annotation-specified bean name ‘webConfig’ for bean class [org.rest.spring.AppConfig]
conflicts with existing, non-compatible bean definition of same name and class [org.rest.
spring.AppConfig]

And finally, using the @Bean annotation to configure the properties support –
PropertySourcesPlaceholderConfigurer is initialized in a @Bean annotated method, indicating
it will produce a Spring bean managed by the Container. This new configuration has replaced
the following XML:
location=”classpath:persistence.properties, classpath:web.properties”
ignore-unresolvable=”true”/>

Page 14 / 113


Building a REST API with

3.1. The web.xml

For a more in depth discussion on why it was necessary to manually register the
PropertySourcesPlaceholderConfigurer bean, see the Properties with Spring Tutorial.

3.1. The web.xml

http://java.sun.com/xml/ns/javaee”
xmlns:web=”http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”
http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd”
id=”rest” version=”3.0”>

contextClass

org.springframework.web.context.support.AnnotationConfigWebApplicationContext



contextConfigLocation
org.rest.spring.root


org.springframework.web.context.ContextLoaderListener


rest

org.springframework.web.servlet.DispatcherServlet


contextClass

org.springframework.web.context.support.AnnotationConfigWebApplicationContext



contextConfigLocation
org.rest.spring.rest

1


rest
/api/*






Page 15 / 113


3.1. The web.xml

Building a REST API with

First, the root context is defined and configured to use
AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext.
The newer AnnotationConfigWebApplicationContext accepts @Configuration annotated
classes as input for the Container configuration and is needed in order to set up the Java
based context.
Unlike XmlWebApplicationContext, it assumes no default configuration class locations, so
the “contextConfigLocation” init-param for the Servlet must be set. This will point to the java
package where the @Configuration classes are located; the fully qualified name(s) of the
classes are also supported.
Next, the DispatcherServlet is configured to use the same kind of context, with the only
difference that it’s loading configuration classes out of a different package.
Other than this, the web.xml doesn’t really change from a XML to a Java based configuration.

4. Conclusion
The presented approach allows for a smooth migration of
the Spring configuration from XML to Java, mixing the old
and the new. This is important for older projects, which may
have a lot of XML based configuration that cannot be
migrated all at once.
This way, in a migration, the XML beans can be ported in small increments.
In the next section on REST with Spring, I cover setting up MVC in the project,
configuration of the HTTP status codes, payload marshalling and content
negotiation.
This is an Eclipse based project, so it should be easy to import and run as it is.

Page 16 / 113


Building a REST API with


Building a REST API with

1. Overview

2: BUILD A REST API WITH
SPRING 4 AND JAVA CONFIG
1. Overview
This section shows how to set up REST in Spring – the Controller and HTTP response codes,
configuration of payload marshalling and content negotiation.

2. Understanding REST in Spring
The Spring framework supports 2 ways of creating RESTful services:


using MVC with ModelAndView



using HTTP message converters

The ModelAndView approach is older and much better documented, but also more verbose
and configuration heavy. It tries to shoehorn the REST paradigm into the old model, which
is not without problems. The Spring team understood this and provided first-class REST
support starting with Spring 3.0.
The new approach, based on HttpMessageConverter and annotations, is much more
lightweight and easy to implement. Configuration is minimal and it provides sensible defaults
for what you would expect from a RESTful service. It is however newer and a a bit on the
light side concerning documentation; what’s more, the reference doesn’t go out of it’s way
to make the distinction and the tradeoffs between the two approaches as clear as they
should be. Nevertheless, this is the way RESTful services should be build after Spring 3.0.

Page 18 / 113


Building a REST API with

3. The Java Configuration

3. The Java Configuration
@Configuration
@EnableWebMvc
public class WebConfig{
//
}

The new @EnableWebMvc annotation does a number of useful things – specifically, in
the case of REST, it detect the existence of Jackson and JAXB 2 on the classpath and
automatically creates and registers default JSON and XML converters. The functionality of
the annotation is equivalent to the XML version:



This is a shortcut, and though it may be useful in many situations, it’s not perfect.
When more complex configuration is needed, remove the annotation and extend
WebMvcConfigurationSupport directly.

4. Testing the Spring Context
Starting with Spring 3.1, we get first-class testing support for @Configuration classes:
@RunWith( SpringJUnit4ClassRunner.class )
@ContextConfiguration( classes = { ApplicationConfig.class, PersistenceConfig.class },
loader = AnnotationConfigContextLoader.class )
public class SpringTest{

}

@Test
public void whenSpringContextIsInstantiated_thenNoExceptions(){
// When
}

The Java configuration classes are simply specified with the @ContextConfiguration
annotation and the new AnnotationConfigContextLoader loads the bean definitions from the
@Configuration classes.
Page 19 / 113


Building a REST API with

5. The Controller

Notice that the WebConfig configuration class was not included in the test because it needs
to run in a Servlet context, which is not provided.

5. The Controller
The @Controller is the central artifact in the entire Web Tier of the RESTful API. For the
purpose of the following examples, the controller is modeling a simple REST resource – Foo:

@Controller
@RequestMapping( value = “/foos” )
class FooController{
@Autowired
IFooService service;
@RequestMapping( method = RequestMethod.GET )
@ResponseBody
public List< Foo > findAll(){
return service.findAll();
}
@RequestMapping( value = “/{id}”, method = RequestMethod.GET )
@ResponseBody
public Foo findOne( @PathVariable( “id” ) Long id ){
return RestPreconditions.checkFound( service.findOne( id ) );
}
@RequestMapping( method = RequestMethod.POST )
@ResponseStatus( HttpStatus.CREATED )
@ResponseBody
public Long create( @RequestBody Foo resource ){
Preconditions.checkNotNull( resource );
return service.create( resource );
}
@RequestMapping( value = “/{id}”, method = RequestMethod.PUT )
@ResponseStatus( HttpStatus.OK )
public void update( @PathVariable( “id” ) Long id, @RequestBody Foo resource ){
Preconditions.checkNotNull( resource );
RestPreconditions.checkNotNull( service.getById( resource.getId() ) );
service.update( resource );
}
@RequestMapping( value = “/{id}”, method = RequestMethod.DELETE )
@ResponseStatus( HttpStatus.OK )
public void delete( @PathVariable( “id” ) Long id ){
service.deleteById( id );
}
}
Page 20 / 113


Building a REST API with

6. Mapping the HTTP response codes

You may have noticed I’m using a very simple, guava style RestPreconditions utility:

public class RestPreconditions {
public static T checkFound(final T resource) {
if (resource == null) {
throw new MyResourceNotFoundException();
}
return resource;
}
}

The Controller implementation is non-public – this is because it doesn’t need to be. Usually
the controller is the last in the chain of dependencies – it receives HTTP requests from the
Spring front controller (the DispathcerServlet) and simply delegate them forward to a service
layer. If there is no use case where the controller has to be injected or manipulated through a
direct reference, then I prefer not to declare it as public.
The request mappings are straightforward – as with any controller, the actual value of the
mapping as well as the HTTP method are used to determine the target method for the
request. @RequestBody will bind the parameters of the method to the body of the HTTP
request, whereas @ResponseBody does the same for the response and return type. They
also ensure that the resource will be marshalled and unmarshalled using the correct HTTP
converter. Content negotiation will take place to choose which one of the active converters
will be used, based mostly on the Accept header, although other HTTP headers may be used
to determine the representation as well.

6. Mapping the HTTP response codes
The status codes of the HTTP response are one of the most important parts of the REST
service, and the subject can quickly become very complex. Getting these right can be what
makes or breaks the service.

6.1. Unmapped Requests
If Spring MVC receives a request which doesn’t have a mapping, it considers the request
not to be allowed and returns a 405 METHOD NOT ALLOWED back to the client. It is also
Page 21 / 113


Building a REST API with

6.2. Valid, Mapped Requests

good practice to include the Allow HTTP header when returning a 405 to the client, in order
to specify which operations are allowed. This is the standard behavior of Spring MVC and does
not require any additional configuration.

6.2. Valid, Mapped Requests
For any request that does have a mapping, Spring MVC considers the request valid and
responds with 200 OK if no other status code is specified otherwise. It is because of this that
controller declares different @ResponseStatus for the create, update and delete actions but
not for get, which should indeed return the default 200 OK.

6.3. Client Error
In case of a client error, custom exceptions are defined and mapped to the appropriate error
codes. Simply throwing these exceptions from any of the layers of the web tier will ensure
Spring maps the corresponding status code on the HTTP response.

@ResponseStatus( value = HttpStatus.BAD_REQUEST )
public class BadRequestException extends RuntimeException{
//
}
@ResponseStatus( value = HttpStatus.NOT_FOUND )
public class ResourceNotFoundException extends RuntimeException{
//
}

These exceptions are part of the REST API and, as such, should only be used in the appropriate
layers corresponding to REST; if for instance a DAO/DAL layer exist, it should not use the
exceptions directly. Note also that these are not checked exceptions but runtime exceptions –
in line with Spring practices and idioms.

6.4. Using @ExceptionHandler
Another option to map custom exceptions on specific status codes is to use the

@ExceptionHandler annotation in the controller. The problem with that approach is that
the annotation only applies to the controller in which it is defined, not to the entire Spring
Page 22 / 113


Building a REST API with

7. Additional Maven dependencies

Container, which means that it needs to be declared in each controller individually. This quickly
becomes cumbersome, especially in more complex applications which many controllers.
There are a few JIRA issues opened with Spring at this time to handle this and other related
limitations: SPR-8124, SPR-7278, SPR-8406.

7. Additional Maven dependencies
In addition to the spring-webmvc dependency required for the standard web application, we’ll
need to set up content marshalling and unmarshalling for the REST API:



com.fasterxml.jackson.core
jackson-databind
${jackson.version}


javax.xml.bind
jaxb-api
${jaxb-api.version}
runtime



2.4.0
2.2.11


These are the libraries used to convert the representation of the REST resource to either JSON
or XML.

Page 23 / 113


7. Additional Maven dependencies

Building a REST API with

8. Conclusion
This section covered the configuration and implementation
of a REST Service using Spring 4 and Java based
configuration, discussing HTTP response codes, basic
Content Negotiation and marshaling.
In the next sections of the series I will focus on Discoverability of the API,
advanced content negotiation and working with additional representations of a
Resource.
This is an Eclipse based project, so it should be easy to import and run as it is.

Page 24 / 113


Building a REST API with


Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay

×