Rest With Spring 

Web Service

Software System designed to support interportable machine to machine interaction over a network

3 Keys

  • Designed for machine-to-machine (or application to application ) interaction
  • Should be interoperable - Not platform dependent.
  • Should allow communication over a network.

Service Definition

  • Request/Response Format
  • Request Structure
  • Response Structure
  • Endpoint

 

Web Services Groups 

  • Soap Based
  • Rest Styled

SOAP and REST are not really comparable

SOAP

  • SOAP defines a specific way of building web services
  • SOAP uses XML for request excahange format.
  • SOAP defines following XML Response/Request structure

SOAP (Cont.)

  • Format
    • SOAP XML Request
    • SOAP XML Response
  • Transport
    • SOAP over MQ
    • SOAP over HTTP  
  • Service Definition
    • WSDL (Web Service Definition Language)
      • Endpoint
      • All Operations
      • Request Structure
      • Response Structure

 

REST (Representational State Transfer )

  • Makes the best use of HTTP
    • HTTP Methods (GET, PUT, POST...)
    • HTTP Status Codes (200, 404 ...)
  • When you create a resource in rest you define operations on it using the methods provided by HTTP i.e POST, GET etc
  • In REST you think in terms of resource which are in your application which you want to make available to other platforms.
  • REST does not care how you represent your resource (URI) i.e XML, JSON, HTML.
  • Transportation through HTTP.
  • Service Definition: No standard. WADL, Swagger etc. Its is optional to provide service definition

Best Practices for REST

  • Resource in the URI should be noun
  • For different operations use verbs defined by HTTP i.e POST, GET, PUT and DELETE
  • Response of API
    • Success 2**
    • Client Error 4**
    • Server Error 5**
  • Some common Reponse Status
    • 200 Success
    • 404 Resource not found
    • 400 Bad Request
    • 201 Created 
    • 401 Unauthorized
    • 500 Server Error
  • Use plurals e.g /users or /users/1

Sample Application

 

 

git@github.com:pulkitpushkarna/rest-with-spring.git

build.gradle

buildscript {
	ext {
		springBootVersion = '2.0.3.RELEASE'
	}
	repositories {
		mavenCentral()
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
	}
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'


repositories {
	mavenCentral()
}


dependencies {
	compile('org.springframework.boot:spring-boot-starter-web')
	compile('org.springframework.boot:spring-boot-starter-data-jpa')
	runtime('mysql:mysql-connector-java')
	testCompile('org.springframework.boot:spring-boot-starter-test')
}

SpringRestApplication

package com.spring.rest.springrest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
@EnableJpaRepositories(basePackages = "com.spring.rest.springrest.repositories")
@EntityScan(basePackages = {"com.spring.rest.springrest.entities"})
public class SpringRestApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringRestApplication.class, args);
	}
}

application.properties

spring.datasource.url=jdbc:mysql://localhost/rest_with_spring
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.hibernate.ddl-auto=create

Creating action to get user by Id and save User

package com.spring.rest.springrest.controllers;


import com.spring.rest.springrest.entities.User;
import com.spring.rest.springrest.services.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    UserService userService;

    @GetMapping("/")
    String helloWorld(){
        return "Hello World";
    }

    @GetMapping("/users")
    List<User> getUsers(){
        return userService.getAllUsers();
    }

    @GetMapping("/users/{id}")
    User getUserById(@PathVariable Long id){
        return userService.getUserById(id);
    }

    @PostMapping("/users")
    User saveUser( @RequestBody User user){
        userService.saveUser(user);
        return user;
    }
}

package com.spring.rest.springrest.services;

import com.spring.rest.springrest.entities.User;
import com.spring.rest.springrest.repositories.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {

    @Autowired
    UserRepository userRepository;

    public List<User> getAllUsers(){
        return (List<User>)userRepository.findAll();
    }

    public User getUserById(Long id){
        Optional<User> optional=userRepository.findById(id);
        return optional.isPresent() ? optional.get(): null;
    }

    public void saveUser(User user){
        userRepository.save(user);
    }
}

Add methods to retrieve user by Id and save user in user service

Enhancing post method to return the correct status code

@PostMapping("/users")
    ResponseEntity<User> saveUser(@RequestBody User user){
        userService.saveUser(user);

        URI uri=ServletUriComponentsBuilder
                .fromCurrentRequest()
                .path("{id}").buildAndExpand(user.getId()).toUri();

        return ResponseEntity.created(uri).build();
    }

Getting user with non existing Id

@GetMapping("/users/{id}")
    User getUserById(@PathVariable Long id){
        User user=userService.getUserById(id);
        if(user==null){
            throw new UserNotFoundException("User not found!!");
        }
        return userService.getUserById(id);
    }
package com.spring.rest.springrest.exceptions;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)
public class UserNotFoundException extends RuntimeException {

   public UserNotFoundException(String message){
        super(message);
    }
}

Generic Exception Handling for all resources

package com.spring.rest.springrest.exceptions;

import java.util.Date;

public class ExceptionResponse {

    private Date timestamp;
    private String message;
    private String details;

    public ExceptionResponse(Date timestamp, String message, String details) {
        this.timestamp = timestamp;
        this.message = message;
        this.details = details;
    }

    public Date getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Date timestamp) {
        this.timestamp = timestamp;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }
}

package com.spring.rest.springrest.exceptions;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import java.util.Date;

@ControllerAdvice
@RestController
public class CustomResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(Exception.class)
    public final ResponseEntity<Object> handleAllException(Exception ex, WebRequest request)  {
      ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),ex.getMessage(),request.getDescription(false));
      return new ResponseEntity(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(UserNotFoundException.class)
    public final ResponseEntity<Object> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
        ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),ex.getMessage(),request.getDescription(false));
        return new ResponseEntity(exceptionResponse, HttpStatus.NOT_FOUND);
    }
}

Deleting the user

@DeleteMapping("/users/{id}")
    void deleteUser(@PathVariable Long id){
        User user=userService.getUserById(id);

        if(user==null) {
            throw new UserNotFoundException("User not found");
        }
        userService.deleteUser(user);

    }
//UserService.java

public void deleteUser(User user){
        userRepository.delete(user);
    }

Validating the Bean

package com.spring.rest.springrest.entities;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.validation.constraints.Size;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Size(min = 2,message = "Name should have at least 2 characters")
    private String name;

    private Integer age;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@PostMapping("/users")
    ResponseEntity<User> saveUser(@Valid @RequestBody User user){
        userService.saveUser(user);

        URI uri=ServletUriComponentsBuilder
                .fromCurrentRequest()
                .path("{id}").buildAndExpand(user.getId()).toUri();

        return ResponseEntity.created(uri).build();
    }
package com.spring.rest.springrest.exceptions;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@ControllerAdvice
@RestController
public class CustomResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @Autowired
    MessageSource messageSource;

    @ExceptionHandler(Exception.class)
    public final ResponseEntity<Object> handleAllException(Exception ex, WebRequest request)  {
      ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),ex.getMessage(),request.getDescription(false));
      return new ResponseEntity(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    @ExceptionHandler(UserNotFoundException.class)
    public final ResponseEntity<Object> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
        ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),ex.getMessage(),request.getDescription(false));
        return new ResponseEntity(exceptionResponse, HttpStatus.NOT_FOUND);
    }

    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(
            MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
        List<String> errorMessageList=ex.getBindingResult().getAllErrors().stream().filter(e->e instanceof FieldError).map((e)->{

            FieldError fieldError = (FieldError) e;
            return   messageSource.getMessage(fieldError, null);
        }).collect(Collectors.toList());

        ExceptionResponse exceptionResponse = new ExceptionResponse(new Date(),"Validation Failed....",errorMessageList.toString());
        return new ResponseEntity(exceptionResponse, HttpStatus.BAD_REQUEST);
    }
}

Exercise 1

  • Create an Entity Student with fields:
    • Name
    • Standard
    • age
    • city
    • percentage
  • Generate the bootstrap data for Student
  • Create Student Controller and introduce following actions in it:
    • Get employee List
    • Get Single Employee
    • Create Employee
    • Delete Employee
    • Update Employee

 

Exercise 1 (Cont.)

  • For Post Request send resource URI once the Student is created.
  • Create an UnChecked Exception StudentNotFound and Throw it in case of POST, PUT and DELETE if you don't find the User.
  • Create your customise response with timestamp, message and details and return your customise response on error
  • Validate the Student bean and show the relevant error messages in error response

Internationalization

Create 2 files in resources directory

messages.properties

good.morning.message=Good Morning

messages_fr.properties

good.morning.message=Bonjour
@GetMapping("/")
    String helloWorld(@RequestHeader(name = "Accept-Language",required = false)Locale locale){
        System.out.println("hello world");
        System.out.println(locale.getLanguage());
        return messageSource.getMessage("good.morning.message",null,locale);
    }

Accept-Language will be passed in header with language code

@Bean
   public ResourceBundleMessageSource messageSource() {
       ResourceBundleMessageSource source = new ResourceBundleMessageSource();
       source.setBasenames("i18n/messages");
       source.setUseCodeAsDefaultMessage(true);
       return source;
   }

Need to Configure this bean if you are not getting ResourceBudleMessageSource

More efficient way of introducing i18n

spring.mvc.locale=en
spring.mvc.locale-resolver=accept_header

application.properties

 @GetMapping("/")
    String helloWorld(){
        return messageSource.getMessage("good.morning.message",null,LocaleContextHolder.getLocale());
    }

Content Negotiaition

If you try to hit user API with Accept header value application/xml. You will get 406 Not Acceptable. In order to provide support for xml include the following dependency in build.gradle

compile ('com.fasterxml.jackson.dataformat:jackson-dataformat-xml')

For Post request you need to set the Accept:application/xml. Following will be the data format

<item>
        
        <name>Sunny</name>
        <age>46</age>
    </item>

Static Filtering 

If you want to filter some field from your object you can do it by using @JsonIgnore at the top of the field.

 

@JsonIgnoreProperties(value={"field1","field2"}) annotation is placed at the top of the class to ignore the fields in the reponse.

 

@Entity
@JsonIgnoreProperties(value = {"age"})
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Size(min = 2,message = "Name should have at least 2 characters")
    private String name;

    //@JsonIgnore
    private Integer age;

   //Getters and Setters
}

Dynamic Filtering 

package com.spring.rest.springrest.entities;

import com.fasterxml.jackson.annotation.JsonFilter;

@JsonFilter("myFilter")
public class Employee {

    private String name;
    private Integer age;
    private Integer salary;

    public Employee(String name, Integer age, Integer salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSalary() {
        return salary;
    }

    public void setSalary(Integer salary) {
        this.salary = salary;
    }
}

package com.spring.rest.springrest.controllers;

import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.spring.rest.springrest.entities.Employee;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

@RestController
public class EmployeeController {

    @GetMapping("/employee")
    MappingJacksonValue getEmployee(){
        Employee employee=new Employee("name1",23,23000);
        SimpleBeanPropertyFilter simpleBeanPropertyFilter=
                SimpleBeanPropertyFilter.filterOutAllExcept("name","salary");

        FilterProvider filterProvider=new SimpleFilterProvider()
                .addFilter("myFilter",simpleBeanPropertyFilter);

        MappingJacksonValue mappingJacksonValue= new MappingJacksonValue(employee);
        mappingJacksonValue.setFilters(filterProvider);
        return mappingJacksonValue;
    }

    @GetMapping("/employee-list")
    MappingJacksonValue getEmployeeList(){

        List<Employee> employeeList= Arrays.asList(new Employee("name1",23,23000),
                new Employee("name2",24,24000),
                new Employee("name3",25,25000));

        SimpleBeanPropertyFilter simpleBeanPropertyFilter=
                SimpleBeanPropertyFilter.filterOutAllExcept("name","age");

        FilterProvider filterProvider=new SimpleFilterProvider()
                .addFilter("myFilter",simpleBeanPropertyFilter);

        MappingJacksonValue mappingJacksonValue= new MappingJacksonValue(employeeList);
        mappingJacksonValue.setFilters(filterProvider);
        return mappingJacksonValue;

    }


}

Versioning

package com.spring.rest.springrest.versioning;

public class PersonV1 {

    private String name;

    public PersonV1(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.spring.rest.springrest.versioning;

public class PersonV2 {

    private Name name;

    public PersonV2(Name name) {
        this.name = name;
    }

    public Name getName() {
        return name;
    }

    public void setName(Name name) {
        this.name = name;
    }
}

package com.spring.rest.springrest.versioning;

public class Name {

    private String firstName;
    private String secondName;

    public Name(String firstName, String secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getSecondName() {
        return secondName;
    }

    public void setSecondName(String secondName) {
        this.secondName = secondName;
    }
}

package com.spring.rest.springrest.versioning;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class PersonController {

    //URI Versioning

    @GetMapping("/person/V1")
    PersonV1 getPersonV1() {
        return new PersonV1("Peter Parker");
    }

    @GetMapping("/person/V2")
    PersonV2 getPersonV2() {
        return new PersonV2(new Name("Peter","Parker"));
    }

    //Parameter Versioning
    // /person/param?version=1
    @GetMapping(value = "/person/param",params = "version=1")
    PersonV1 getPersonParam1() {
        return new PersonV1("Peter Parker");
    }

    @GetMapping(value = "/person/param",params = "version=2")
    PersonV2 getPersonParam2() {
        return new PersonV2(new Name("Peter","Parker"));
    }


    //Header Versioning
    //API-VERSION 1 header required with request
    @GetMapping(value = "/person/header",headers = "API-VERSION=1")
    PersonV1 getPersonHeader1() {
        return new PersonV1("Peter Parker");
    }

    @GetMapping(value = "/person/header",headers = "API-VERSION=2")
    PersonV2 getPersonHeader2() {
        return new PersonV2(new Name("Peter","Parker"));
    }

    //Mime Type/Content Negotiation/Accept Header Versioning
    //Accept application/app-v1+json header required with request
    @GetMapping(value = "/person/produces",produces = "application/app-v1+json")
    PersonV1 getPersonProducer1() {
        return new PersonV1("Peter Parker");
    }

    @GetMapping(value = "/person/produces",produces = "application/app-v2+json")
    PersonV2 getPersonProducer2() {
        return new PersonV2(new Name("Peter","Parker"));
    }

}

Exercise 2

  • Perform i18n in your application for message "Have a nice day" for 2 languages English and German.
  • Provide the support for both JSON and XML in your Application.
  • Perform Static and Dynamic Filtering on Student entity.
  • Create 2 versions for Get Students API in one version we will return the percentage and in other we will not return the percentage. Perform following Versioning:
    • URI versioning
    • Parameter Versioning 
    • Header Versioning
    • Accept Header Versioning

Consuming API with REST Template

 @GetMapping("/post")
    public String getPost(){
        RestTemplate restTemplate = new RestTemplate();
        String url="https://jsonplaceholder.typicode.com/posts/1";
        ResponseEntity<String> response = restTemplate.getForEntity(url,String.class);
        System.out.println(response.getStatusCode().toString());
        System.out.println(response.getHeaders().toString());
        return response.getBody();
    }

Getting the Data in String Format

Getting and parsing the data to an Object

@GetMapping("/postObject")
    public Post getPostObject(){
        RestTemplate restTemplate = new RestTemplate();
        String url="https://jsonplaceholder.typicode.com/posts/1";
        ResponseEntity<Post> response = restTemplate.getForEntity(url,Post.class);
        System.out.println(response.getStatusCode().toString());
        System.out.println(response.getHeaders().toString());
        return response.getBody();
    }

Getting the List of Objects

 @GetMapping("/postList")
    public List<Post> getPostList(){
        RestTemplate restTemplate = new RestTemplate();
        String url="https://jsonplaceholder.typicode.com/posts";
        ResponseEntity<List<Post>> response = restTemplate
                .exchange(url, HttpMethod.GET, null,
                new ParameterizedTypeReference<List<Post>>(){});
        return response.getBody();
    }

Create Post

@PostMapping("/createPost")
    public ResponseEntity<Post> createPost(){
        String url="https://jsonplaceholder.typicode.com/posts";
        RestTemplate restTemplate= new RestTemplate();
        HttpHeaders httpHeaders= new HttpHeaders();
        httpHeaders.add("Content-type","application/json; charset=UTF-8");
        HttpEntity<Post> request=new HttpEntity<>(new Post(10000L,10000L,"title1","description1"),httpHeaders);
        Post post=restTemplate.postForObject(url,request,Post.class);
        System.out.println(post);
        return new ResponseEntity<Post>(post, HttpStatus.CREATED);
    }

Updating the POST

@PutMapping("/updatePost")
    public ResponseEntity<Post> updatePost(){
        String url="https://jsonplaceholder.typicode.com/posts/1";
        RestTemplate restTemplate= new RestTemplate();
        HttpHeaders httpHeaders= new HttpHeaders();
        httpHeaders.add("Content-type","application/json; charset=UTF-8");
        HttpEntity<Post> request=new HttpEntity<>(new Post(1L,100L,"title1","description1"),httpHeaders);
        return restTemplate.exchange(url,HttpMethod.PUT,request,Post.class);
    }

Deleting the POST

@DeleteMapping("/deletePost")
    public void deletePost(){
        String url="https://jsonplaceholder.typicode.com/posts/1";
        RestTemplate restTemplate= new RestTemplate();
        HttpHeaders httpHeaders= new HttpHeaders();
        httpHeaders.add("Content-type","application/json; charset=UTF-8");
        HttpEntity<Post> request=new HttpEntity<>(httpHeaders);
         restTemplate.exchange(url,HttpMethod.DELETE,request,Post.class);
    }

Exercise 3

  • Use RestTemplate to interact API's outside your application. Use Employee resource on http://dummy.restapiexample.com/. Try out all the API's of Employee

Rest Assured for API Testing

        testCompile('io.rest-assured:rest-assured:3.1.0')
	testCompile('com.jayway.restassured:rest-assured:2.3.3')
	testCompile 'org.hamcrest:hamcrest-all:1.3'

Gradle Dependencies for rest assured

For Testing with Rest Assured we will use following API's:

https://jsonplaceholder.typicode.com/

package com.spring.rest.springrest;


import com.jayway.restassured.RestAssured;
import com.jayway.restassured.response.Header;

import static org.hamcrest.Matchers.*;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringRestApplicationTests {


    @Test
    public  void canary(){
        Assert.assertEquals(1,1);
    }

    @Test
    public void testingGoogle(){
        RestAssured.given().get("https://www.google.com/").then().statusCode(200);
    }

   
}

Canary Test 

    String uri="https://jsonplaceholder.typicode.com/posts/{id}";

  

    @Test
    public void validPostTest() {
	 RestAssured.given().pathParam("id",1)
               .get(uri).then()
               .statusCode(200).log().all();
    }

    @Test
    public void invalidPostTest() {
        RestAssured.given().pathParam("id",1000)
                .get(uri).then()
                .statusCode(404).log().all();
    }

Simple Test for Get 

More Tests for GET

        @BeforeClass
        public static void init(){
            RestAssured.baseURI="https://jsonplaceholder.typicode.com";
            RestAssured.basePath="/posts/{id}";
        }

        @Test
	public void postUserIdValueMatchingTest(){
        RestAssured.given().pathParam("id",1)
                .get().then()
                .body("userId", equalTo(1))
                .log().all();;
	}

    @Test
    public void invalidPostTest() {
        RestAssured.given().pathParam("id",1000)
                .get().then()
                .statusCode(404).log().all();
    }

Matching Values

@Test
	public void postUserIdValueMatchingTest(){
        RestAssured.given().pathParam("id",1)
                .get(uri).then()
                .body("userId", equalTo(1))
                .log().all();;
	}

    @Test
    public void postUserIdAndTitleValueMatchingTest(){
        RestAssured.given().pathParam("id",1)
                .get(uri).then()
                .body("userId", equalTo(1))
                .body("title",equalTo("sunt aut facere repellat provident occaecati excepturi optio reprehenderit"))
                .log().all();;
    }
@Test
    public void postCreationTest(){
        Map<String,String> map = new HashMap<>();
        map.put("userId","1");
        map.put("title","title1");
        map.put("body","body1");

        RestAssured.given().header(new Header("Content-type","application/json; charset=UTF-8"))
                .body(map)
                .when().post("https://jsonplaceholder.typicode.com/posts").then()
                .statusCode(201).log().all();

    }

Test for Post

Test for Put

@Test
    public void postUpdationTest(){
        Map<String,String> map = new HashMap<>();
        map.put("id","1");
        map.put("userId","1");
        map.put("title","title1");
        map.put("body","body1");
        RestAssured.given().pathParam("id",1).header(new Header("Content-type","application/json; charset=UTF-8"))
                .body(map)
                .when().put(uri).then()
                .statusCode(200).log().all();
    }

Test for Delete

  @Test
    public void postDeletionTest(){
        RestAssured.given().pathParam("id",1).header(new Header("Content-type","application/json; charset=UTF-8"))
                .when().delete(uri).then()
                .statusCode(200).log().all();
    }
package com.spring.rest.springrest;


import com.jayway.restassured.RestAssured;
import com.jayway.restassured.response.Header;

import static org.hamcrest.Matchers.*;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringRestApplicationTests {


    @Test
    public  void canary(){
        Assert.assertEquals(1,1);
    }

    @Test
    public void testingGoogle(){
        RestAssured.given().get("https://www.google.com/").then().statusCode(200);
    }

    String uri="https://jsonplaceholder.typicode.com/posts/{id}";

    @BeforeClass
    public static void init(){
        RestAssured.baseURI="https://jsonplaceholder.typicode.com";
        RestAssured.basePath="/posts/{id}";
    }

	@Test
	public void validPostTest() {
		RestAssured.given().pathParam("id",1)
                .get(uri).then()
                .statusCode(200).log().all();
	}

    @Test
    public void invalidPostTest() {
        RestAssured.given().pathParam("id",1000)
                .get(uri).then()
                .statusCode(404).log().all();
    }


	@Test
	public void postUserIdValueMatchingTest(){
        RestAssured.given().pathParam("id",1)
                .get(uri).then()
                .body("userId", equalTo(1))
                .log().all();;
	}

    @Test
    public void postUserIdAndTitleValueMatchingTest(){
        RestAssured.given().pathParam("id",1)
                .get(uri).then()
                .body("userId", equalTo(1))
                .body("title",equalTo("sunt aut facere repellat provident occaecati excepturi optio reprehenderit"))
                .log().all();;
    }

    @Test
    public void postCreationTest(){
        Map<String,String> map = new HashMap<>();
        map.put("userId","1");
        map.put("title","title1");
        map.put("body","body1");

        RestAssured.given().header(new Header("Content-type","application/json; charset=UTF-8"))
                .body(map)
                .when().post("https://jsonplaceholder.typicode.com/posts").then()
                .statusCode(201).log().all();

    }

    @Test
    public void postUpdationTest(){
        Map<String,String> map = new HashMap<>();
        map.put("id","1");
        map.put("userId","1");
        map.put("title","title1");
        map.put("body","body1");
        RestAssured.given().pathParam("id",1).header(new Header("Content-type","application/json; charset=UTF-8"))
                .body(map)
                .when().put(uri).then()
                .statusCode(200).log().all();
    }

    @Test
    public void postDeletionTest(){
        RestAssured.given().pathParam("id",1).header(new Header("Content-type","application/json; charset=UTF-8"))
                .when().delete(uri).then()
                .statusCode(200).log().all();
    }

}

Following file will reside under test java

Exercise 4

  • Use Rest Assured to test all API's on http://dummy.restapiexample.com/

 OAuth2 with Spring Security

  • OAuth2 is a standard for authorization.
  • A high level goal of OAuth is allowing a Resource Owner to give access to a third party in a limited way, without giving away the password.

Roles and Actors in OAuth

  • The Resource Owner (the user) is capable of granting access to a Resource.

 

  • The Resource Server (the API) is the host of the protected Resources.

 

  • The Authorization Server is capable of issuing Access Tokens to the Client.

 

  • The Client (the front end app) is capable of making requests on behalf of the Resource Owner.

Getting Start with OAuth config in Spring Security

build.gradle

apply plugin: 'java'
apply plugin: org.springframework.boot.gradle.plugin.SpringBootPlugin

buildscript {
    ext {
        springBootVersion = "1.4.0.RELEASE"
        propdepsPluginVersion = "0.0.7"
    }
    repositories {
        jcenter()
        maven { url 'http://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion")
        classpath("org.springframework.build.gradle:propdeps-plugin:$propdepsPluginVersion")
    }
}


repositories {
    mavenCentral()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    compile("org.springframework.boot:spring-boot-starter-security")
    compile("org.springframework.security.oauth:spring-security-oauth2")
    compile("org.springframework.security:spring-security-jwt")
}

Authorization Server

package com.spring_security.oauth.config;

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {

    @Autowired
    AuthenticationManager authenticationManager;

    public AuthorizationServerConfiguration() {
        super();
    }

    @Bean
    public TokenStore tokenStore() {
        return new InMemoryTokenStore();
    }


    @Override
    public void configure(final AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints.tokenStore(tokenStore())
                .authenticationManager(authenticationManager);
    }

    @Override
    public void configure(final ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("live-test")
                .secret("abcde")
                .authorizedGrantTypes("password")
                .scopes("app")
                .accessTokenValiditySeconds(30);

    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer authorizationServerSecurityConfigurer) throws Exception {
        authorizationServerSecurityConfigurer.allowFormAuthenticationForClients();
    }
}

Resource Server

package com.spring_security.oauth.config;

@Configuration
@EnableResourceServer
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true)
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {

    @Autowired
    UserDetailsService userDetailsService;

    public ResourceServerConfiguration() {
        super();
    }

    @Bean
    public AuthenticationProvider authenticationProvider() {
        final DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
        authenticationProvider.setUserDetailsService(userDetailsService);
        return authenticationProvider;
    }

    @Autowired
    public void configureGlobal(final AuthenticationManagerBuilder authenticationManagerBuilder) {
        authenticationManagerBuilder.authenticationProvider(authenticationProvider());
    }

    @Override
    public void configure(final HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                .csrf().disable();
    }
}

GrantAuthorityImpl

package com.spring_security.oauth.model;

import org.springframework.security.core.GrantedAuthority;

public class GrantAuthorityImpl implements GrantedAuthority {

    String authority;

    @Override
    public String getAuthority() {
        return authority;
    }
}

User Entity

import java.util.List;

public class User implements UserDetails {

    private String username;
    private String password;
    List<GrantAuthorityImpl> grantAuthorities;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public List<GrantAuthorityImpl> getAuthorities() {
        return grantAuthorities;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", grantAuthorities=" + grantAuthorities +
                '}';
    }
}

UserDetailService

package com.spring_security.oauth.service;

import com.spring_security.oauth.model.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class AppUserDetailsService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        UserDetails userDetails = new User(username, "pass");
        return userDetails;
    }
}

Introduce Controller action

package com.spring_security.oauth;

import javax.annotation.security.RolesAllowed;

@Controller
@SpringBootApplication
@RolesAllowed("ROLE_ANONYMOUS")
public class OauthApplication {

	@RequestMapping("/")
	@ResponseBody
	String home() {
		return "Hello World!";
	}

	public static void main(String[] args) {
		SpringApplication.run(OauthApplication.class, args);
	}
}

Post Request for Authentication

Request:

http://localhost:8080/oauth/token <Post Request>

grant_type : password

client_id : live-test

username : user

password : pass

client_secret : abcde

 

Response:

{
  "access_token": "fc132af8-e5ad-4318-8f29-b3cf95b51161",
  "token_type": "bearer",
  "expires_in": 29,
  "scope": "app"
}

Now lets hit the controller action

 

Request:

localhost:8080/

 <Header > Authorization bearer <access-token>

 

JWT token

A simple high level structure of JWT Token is:

headers.payloads.signature

Configuration changes for JWT Token in Authorization Server

 @Bean
    JwtAccessTokenConverter accessTokenConverter(){
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        jwtAccessTokenConverter.setSigningKey("1234");
        return jwtAccessTokenConverter;
    }

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(accessTokenConverter());
    }

@Override
    public void configure(final AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints.tokenStore(tokenStore())
                .authenticationManager(authenticationManager)
                .accessTokenConverter(accessTokenConverter());
    }

Configuration changes in Authorization Server for Refresh Token

    @Autowired
    UserDetailsService userDetailsService;

    @Bean
    @Primary
    DefaultTokenServices tokenServices(){
        DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
        defaultTokenServices.setTokenStore(tokenStore());
        defaultTokenServices.setSupportRefreshToken(true);
        return defaultTokenServices;
    }

    @Override
    public void configure(final ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("live-test")
                .secret("abcde")
                .authorizedGrantTypes("password","refresh_token")
                .refreshTokenValiditySeconds(30 * 24 * 3600)
                .scopes("app")
                .accessTokenValiditySeconds(30);

    }

     @Override
    public void configure(final AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints.tokenStore(tokenStore())
                .userDetailsService(userDetailsService)
                .authenticationManager(authenticationManager);
    }

Refresh Token

Request:

http://localhost:8080/oauth/token

grant_type : refresh_token

refresh_token: <refresh_token>

client_id:<client_id>

client_secret:<client_secret>

 

Response:

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MjQyMzk4MzUsInVzZXJfbmFtZSI6InVzZXIiLCJqdGkiOiI4MWJkNjQ3Ny02NmY3LTRjNWUtODdkOS1lZmE2NjdlMzhmZDAiLCJjbGllbnRfaWQiOiJsaXZlLXRlc3QiLCJzY29wZSI6WyJhcHAiXX0.lNu44yo3HgJ2EkTcRHKj4mu9Rq6Nhi9IMXT_SM1PIxk",
  "token_type": "bearer",
  "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MjQyNjk1MDQsInVzZXJfbmFtZSI6InVzZXIiLCJqdGkiOiI2NTk5NTdiMC04NzM4LTRjNjktYTk5My01Y2Q5YzQ1NTg3NzMiLCJjbGllbnRfaWQiOiJsaXZlLXRlc3QiLCJzY29wZSI6WyJhcHAiXSwiYXRpIjoiODFiZDY0NzctNjZmNy00YzVlLTg3ZDktZWZhNjY3ZTM4ZmQwIn0.Vx2dKyTympi6VTBnGid4uW5yGavcsRvwD5ezy1b3M8I",
  "expires_in": 29,
  "scope": "app",
  "jti": "81bd6477-66f7-4c5e-87d9-efa667e38fd0"
}

Gradle project with oauth dependencies

git@github.com:pulkitpushkarna/spring-oauth-boiler-plate-code.git

Exercise 5

Create a Spring Boot Application and Implement OAuth in it.

Rest With Spring

By Pulkit Pushkarna

Made with Slides.com

Rest With Spring

  • 1,283

More from Pulkit Pushkarna