Exemplo de Spring RestTemplate

Spring RestTemplate oferece uma maneira conveniente de testar serviços web RESTful.

Spring RestTemplate

• A classe Spring RestTemplate faz parte do spring-web, introduzida na versão 3 do Spring.
• Podemos usar o RestTemplate para testar serviços web RESTful baseados em HTTP, mas não oferece suporte ao protocolo HTTPS.
• A classe RestTemplate fornece métodos sobrecarregados para diferentes métodos HTTP, como GET, POST, PUT, DELETE, etc.

Exemplo de Spring RestTemplate

Vamos dar uma olhada em um exemplo de Spring RestTemplate, onde testaremos os serviços da web REST criados no artigo sobre o Spring Data JPA. A tabela abaixo ilustra as URIs suportadas por este serviço web REST. .tg {border-collapse:collapse;border-spacing:0;border-color:#999;} .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#999;color:#444;background-color:#F7FDFA;} .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:#999;color:#fff;background-color:#26ADE4;} .tg .tg-baqh{text-align:center;vertical-align:top} .tg .tg-yw4l{vertical-align:top}

Vamos começar criando nosso projeto de cliente Rest para testar esses serviços web. A imagem abaixo mostra nosso projeto final de exemplo Spring RestTemplate.

Dependências do Maven para o Spring RestTemplate

Precisamos das dependências spring-core e spring-context para o framework Spring. Em seguida, precisamos do artefato spring-web que contém a classe RestTemplate. Também precisamos do jackson-mapper-asl para suporte JSON do Spring através da API do Jackson.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.journaldev.spring</groupId>
	<artifactId>SpringRestTemplate</artifactId>
	<version>1.0-SNAPSHOT</version>
	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
		<spring.web>3.0.2.RELEASE</spring.web>
		<serializer.version>2.8.1</serializer.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.9.4</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.web}</version>
		</dependency>
	</dependencies>
</project>

Classe de Configuração do Spring

Devemos definir um bean do Spring para a classe RestTemplate, isso é feito na classe AppConfig.

package com.journaldev.spring.config;

import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

@Configuration
@ComponentScan("com.journaldev.spring")
public class AppConfig {

	@Bean
	RestTemplate restTemplate() {
		RestTemplate restTemplate = new RestTemplate();
		MappingJacksonHttpMessageConverter converter = new MappingJacksonHttpMessageConverter();
		converter.setObjectMapper(new ObjectMapper());
		restTemplate.getMessageConverters().add(converter);
		return restTemplate;
	}
}

Note que RestTamplate usa MessageConverter e precisamos definir essa propriedade no bean RestTemplate. Em nosso exemplo, estamos usando o MappingJacksonHttpMessageConverter para obter dados no formato JSON.

Classe de Modelo

Uma vez que estamos tentando converter JSON retornado pelo nosso serviço web para um objeto Java usando o Jackson Mapper, precisamos criar a classe de modelo para isso. Note que esta classe de modelo será muito semelhante à classe de modelo usada no serviço web, exceto que aqui não precisamos de anotações JPA.

package com.journaldev.spring.model;

public class Person {

	private Long id;

	private Integer age;

	private String firstName;

	private String lastName;

	public Person() {
	}

	public Long getId() {
		return id;
	}

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

	public Integer getAge() {
		return age;
	}

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

	public String getFirstName() {
		return firstName;
	}

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

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "Person{" + "id=" + id + ", age=" + age + ", firstName='" + firstName + '\'' + ", lastName='" + lastName
				+ '\'' + '}';
	}
}

Classe Cliente Spring RestTemplate

A etapa final é criar as classes de cliente que utilizarão o bean RestTemplate definido acima.

package com.journaldev.spring.config;

import java.util.List;

import org.springframework.http.HttpStatus;

import com.journaldev.spring.model.Person;

public interface PersonClient {
	List<Person> getAllPerson();

	Person getById(Long id);

	HttpStatus addPerson(Person person);

	void updatePerson(Person person);

	void deletePerson(Long id);
}

package com.journaldev.spring.config;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import com.journaldev.spring.model.Person;

@Service
public class PersonClientImpl implements PersonClient {

	@Autowired
	RestTemplate restTemplate;

	final String ROOT_URI = "https://localhost:8080/springData/person";

	public List<Person> getAllPerson() {
		ResponseEntity<Person[]> response = restTemplate.getForEntity(ROOT_URI, Person[].class);
		return Arrays.asList(response.getBody());

	}

	public Person getById(Long id) {
		ResponseEntity<Person> response = restTemplate.getForEntity(ROOT_URI + "/"+id, Person.class);
		return response.getBody();
	}

	public HttpStatus addPerson(Person person) {
		ResponseEntity<HttpStatus> response = restTemplate.postForEntity(ROOT_URI, person, HttpStatus.class);
		return response.getBody();
	}

	public void updatePerson(Person person) {
		restTemplate.put(ROOT_URI, person);
	}

	public void deletePerson(Long id) {
		restTemplate.delete(ROOT_URI + id);

	}
}

O código é autoexplicativo, estamos chamando os métodos RestTemplate com base no URI e no método HTTP, e passando o objeto de requisição apropriado, se necessário.

Classe de Teste Spring RestTemplate

É hora de testar nosso projeto de exemplo Spring RestTemplate, a classe abaixo mostra como usar os métodos RestTemplate no estilo Spring.

package com.journaldev.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.http.HttpStatus;

import com.journaldev.spring.config.AppConfig;
import com.journaldev.spring.config.PersonClient;
import com.journaldev.spring.model.Person;

public class Main {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

		PersonClient client = applicationContext.getBean(PersonClient.class);

		System.out.println("Getting list of all people:");

		for (Person p : client.getAllPerson()) {
			System.out.println(p);
		}

		System.out.println("\nGetting person with ID 2");

		Person personById = client.getById(2L);

		System.out.println(personById);

		System.out.println("Adding a Person");
		Person p = new Person();
		p.setAge(50);
		p.setFirstName("David");
		p.setLastName("Blain");
		HttpStatus status = client.addPerson(p);
		System.out.println("Add Person Response = " + status);

		applicationContext.close();
	}
}

Ao executar o programa acima na minha configuração local, obtenho a seguinte saída.

Getting list of all people:
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Person{id=1, age=30, firstName='Vlad', lastName='Mateo'}

Getting person with ID 2
Person{id=2, age=30, firstName='Oksi', lastName=' Bahatskaya'}
Adding a Person
Add Person Response = 201

A imagem abaixo mostra os dados da tabela do banco de dados do serviço web antes e depois da execução do programa acima. Como você pode ver, a saída do programa corresponde aos dados de exemplo da tabela. Isso é tudo para o exemplo do Spring RestTemplate, você pode baixar o projeto no link abaixo.

Baixar Projeto Exemplo do Spring RestTemplate

Referência: Documento da API