Cícero Ednilson

Blog sobre Desenvolvimento de Softwares

Home » Criando um Web Service Rest com Spring Boot, JdbcTemplate e Oracle.

Criando um Web Service Rest com Spring Boot, JdbcTemplate e Oracle.

Nesse tutorial vamos aprender como criar um serviço Rest usando o Spring Boot e JdbcTemplate.

Introdução.

Os Web Services Rest(Representational State Transfer) vem sendo muito usado para a realização de comunicação entre diferentes sistemas, essa arquitetura de Web Service não é nova, ela já existe a um bom tempo, mas de alguns anos para cá ela vem sendo mais usada devido a interação com as aplicações Mobile, mas não se limita apenas a essa plataforma, um Web Service Rest pode ser acessado por qualquer aplicação que tenha suporte a HTTP/HTTPS, vamos ver nesse tutorial como criar um Web Service Rest com o Spring Boot, também vamos usar esse framework para realizarmos à persistência de dados através do JdbcTemplate.

Criando os objetos no banco de dados Oracle.

Primeiro vamos criar a Sequence que vamos usar para gerar a chave da nossa tabela, para isso vamos executar o comando abaixo.

Atenção: Aqui estou usando um usuário com o nome de cicero, você deve usar um usuário da sua Base de Dados.

1
2
3
4
5
6
--CRIANDO A SEQUENCE
CREATE SEQUENCE cicero.seq_id_usuario
MINVALUE 1  
MAXVALUE 9999999999
START WITH 1       
INCREMENT BY 1;

Agora vamos criar a tabela que vamos manipular através do nosso Web Service Rest, para isso execute o comando abaixo.

1
2
3
4
5
6
7
8
--CRIANDO A TABELA
CREATE TABLE cicero.tb_usuario(
    id_usuario INT NOT NULL PRIMARY KEY,  
    ds_login   VARCHAR(20),
    ds_senha   VARCHAR(20),
    fl_ativo   NUMBER(1)
 
);

Agora vamos criar uma Trigger para inserir a chave na nossa tabela automaticamente quando inserirmos um novo registro, para isso execute o comando abaixo.

1
2
3
4
5
6
7
8
9
--CRIANDO A TRIGGER QUE VAI INSERIR A CHAVE DA NOSSA TABELA NA EXECUÇÃO DO INSERT
CREATE OR REPLACE TRIGGER cicero.tr_insert_id_usuario
                  BEFORE INSERT ON tb_usuario FOR EACH ROW       
BEGIN
 
SELECT seq_id_usuario.NEXTVAL
INTO :NEW.id_usuario
FROM DUAL;
END;

Criando o Projeto.

Para criarmos o nosso projeto vamos acessar o site http://start.spring.io/, depois vamos selecionar os itens como mostra a imagem abaixo.

Generate a: Maven Project.
with Spring Boot:1.4.2.
Group:br.com.ciceroednilson.
Artifact:BlogRest.
Dependencies:Web.

Criando o projeto

Depois que realizar o Download basta descompactar o projeto.

Importando o Projeto Maven no Eclipse.

Agora vamos pegar o projeto que criamos e vamos importar no Eclipse, para isso vamos acessar o menu File -> Import…

Na tela que foi aberta vamos selecionar Maven -> Existing Maven Projects e clicar em Next como mostra a imagem abaixo.

Agora vamos selecionar a pasta do nosso projeto e depois clicar em Finish como mostra a imagem abaixo.

E então podemos ver o nosso projeto no Eclipse.

Iniciando o desenvolvimento do Web Service Rest.

Vamos agora abri o arquivo pom.xml e vamos deixar ele com o código abaixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 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">
	<modelVersion>4.0.0</modelVersion>
 
	<groupId>br.com.ciceroednilson</groupId>
	<artifactId>BlogRest</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
 
	<name>BlogRest</name>
	<description>Demo project for Spring Boot</description>
 
	<parent>
	   <groupId>org.springframework.boot</groupId>
	   <artifactId>spring-boot-starter-parent</artifactId>
	   <version>1.4.2.RELEASE</version>
	   <relativePath/> <!-- lookup parent from repository -->
	</parent>
 
	<properties>
	   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
           <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	   <java.version>1.8</java.version>
	</properties>
 
	<repositories>
	   <repository>
	     <id>repositorio-oracle-jdbc</id>
	     <name>oracle-jdbc</name>
	     <url>https://maven.atlassian.com/3rdparty/</url>
	   </repository>
  	</repositories>
 
	<dependencies>			
	   <dependency>
	      <groupId>org.springframework.boot</groupId>
	      <artifactId>spring-boot-starter-web</artifactId>
	   </dependency>
 
	   <dependency>
	      <groupId>org.springframework.boot</groupId>
	      <artifactId>spring-boot-starter-test</artifactId>
	      <scope>test</scope>
	   </dependency>
 
	   <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-jdbc</artifactId>
           </dependency>
 
           <dependency>
	      <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-jdbc</artifactId>
	   </dependency>
 
	   <dependency>
	      <groupId>com.oracle</groupId>
              <artifactId>ojdbc6</artifactId>
	      <version>12.1.0.1-atlassian-hosted</version>
	   </dependency>
 
	</dependencies>
 
	<build>
	  <plugins>
	    <plugin>
	      <groupId>org.springframework.boot</groupId>
	      <artifactId>spring-boot-maven-plugin</artifactId>
	    </plugin>
	  </plugins>
	</build>
 
</project>

Agora vamos abrir o arquivo application.properties e vamos definir uma porta para execução do nosso servidor e as informações para acesso ao banco de dados, quando colocamos as informações de banco de dados seguindo os parâmetros determinados pelo Spring ela já faz todo o gerenciamento de acesso ao banco para nós, assim não precisamos se preocupar em abrir e fechar as conexões.

1
2
3
4
5
6
7
8
#PORTA ONDE VAI SER EXECUTADO O NOSSO TOMCAT
server.port = 8090
 
#INFORMAÇÕES PARA CONEXÃO COM O BANCO DE DADOS ORACLE XE
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:xe
spring.datasource.username=cicero
spring.datasource.password=123456
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver

Abaixo o nosso arquivo application.properties com as alterações realizadas.

Agora vamos criar um pacote com o nome de br.com.ciceroednilson.model, e vamos adicionar um classe com o nome de UsuarioModel, essa classe vamos usar para persistência no banco de dados e usar para request e response de algumas operações do nosso serviço, abaixo o código de como deve fica nossa classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package br.com.ciceroednilson.model;
 
 
public class UsuarioModel {
 
	private Integer codigo;
	private String login;
	private String senha;
	private Integer ativo;
 
	public Integer getCodigo() {
		return codigo;
	}
	public void setCodigo(Integer codigo) {
		this.codigo = codigo;
	}
	public String getLogin() {
		return login;
	}
	public void setLogin(String login) {
		this.login = login;
	}
	public String getSenha() {
		return senha;
	}
	public void setSenha(String senha) {
		this.senha = senha;
	}
	public Integer getAtivo() {
		return ativo;
	}
	public void setAtivo(Integer ativo) {
		this.ativo = ativo;
	}
 
}

Ainda no pacote br.com.ciceroednilson.model vamos criar uma classe com o nome de ResultadoModel, essa classe vamos usar para retornar se a nossa operação foi executada com sucesso ou se teve algum erro, vamos usar nas operações de insert, update e delete, abaixo o código de como deve ficar a nossa classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package br.com.ciceroednilson.model;
 
public class ResultadoModel {
 
	private int codigo;
	private String mensagem;
 
	public ResultadoModel(){
 
	}
 
	public ResultadoModel(int codigo, String mensagem) {
		super();
		this.codigo = codigo;
		this.mensagem = mensagem;
	}
 
	public int getCodigo() {
		return codigo;
	}
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}
	public String getMensagem() {
		return mensagem;
	}
	public void setMensagem(String mensagem) {
		this.mensagem = mensagem;
	}
}

Agora vamos criar um pacote com o nome de br.com.ciceroednilson.repository e nesse pacote vamos adicionar uma classe com o nome de QuerysRepository, essa classe vai conter as as querys que vamos usar para persistir as nossas informações no banco de dados, vamos deixar a nossa classe com o código abaixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package br.com.ciceroednilson.repository;
 
public class QuerysRepository {
 
	/*INSERIR UM NOVO USUÁRIO*/
	public static final String INSERIR_USUARIO = "INSERT INTO cicero.tb_usuario(ds_login,ds_senha,fl_ativo) VALUES(?,?,?)";
 
	/*CONSULTAR TODOS USUÁRIOS*/
	public static final String CONSULTAR_USUARIOS = "SELECT id_usuario codigo, ds_login login, ds_senha senha, fl_ativo ativo FROM cicero.tb_usuario";
 
	/*SELECIONAR UM USUÁRIO PELO CÓDIGO*/
	public static final String SELECIONAR_USUARIO = "SELECT id_usuario codigo, ds_login login, ds_senha senha, fl_ativo ativo FROM cicero.tb_usuario WHERE id_usuario = :id_usuario";
 
	/*EXCLUIR UM USUÁRIO PELO CÓDIGO*/
	public static final String EXCLUIR_USUARIO =" DELETE cicero.tb_usuario WHERE id_usuario = :id_usuario";
 
	/*ATUALIZAR INFORMAÇÕES DO USUÁRIO PELO CÓDIGO*/
	public static final String ATUALIZAR_USUARIO = "UPDATE cicero.tb_usuario SET ds_login = ?,ds_senha=?, fl_ativo=? WHERE id_usuario=? ";
 
 
}

Ainda no pacote br.com.ciceroednilson.repository vamos adicionar uma classe com o nome de UsuarioRepository, essa classe vai ter os métodos que vão persistir as nossas informações no banco de dados atráves das querys criadas na classe QuerysRepository, o código da nossa classe deve ficar como mostra abaixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package br.com.ciceroednilson.repository;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
 
import br.com.ciceroednilson.model.ResultadoModel;
import br.com.ciceroednilson.model.UsuarioModel;
 
/**
 * CLASSE RESPONSÁVEL POR PERSISTIR AS INFORMAÇÕES DE USUÁRIO NO BANCO DE DADOS
 * @author cicero
 *
 */
@Repository
public class UsuarioRepository {
 
	@Autowired
	private JdbcTemplate jdbcTemplate;
 
	/**
	 * ESSE MÉTODO CADASTRA UM NOVO USUÁRIO NO BANCO DE DADOS	
	 * @param usuario
	 * @return
	 */
	public ResultadoModel cadastrar(UsuarioModel usuario){
 
		try {
 
			jdbcTemplate.update(QuerysRepository.INSERIR_USUARIO, usuario.getLogin(),usuario.getSenha(),usuario.getAtivo());
 
		} catch (Exception e) {
 
			return new ResultadoModel(0,"Erro ao cadastrar o registro! detalhe:" + e.getMessage());	
		}
 
		return new ResultadoModel(1,"Registro cadastrado com sucesso!");
	}
 
	/**
	 * ESSE MÉTODO RETORNAR TODOS OS USUÁRIOS CADASTRADOS
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public List<UsuarioModel> usuarios(){
 
		return jdbcTemplate.query(QuerysRepository.CONSULTAR_USUARIOS, new BeanPropertyRowMapper(UsuarioModel.class));
 
	}
 
	/**
	 * ESSE MÉTODO RETORNA UM USUÁRIO CADASTRADO PELO CÓDIGO
	 * @param codigo
	 * @return
	 */
	public UsuarioModel usuario(int codigo){
 
		return jdbcTemplate.queryForObject(QuerysRepository.SELECIONAR_USUARIO, new BeanPropertyRowMapper<UsuarioModel>(UsuarioModel.class),codigo);
 
	}
 
	/**
	 * ATUALIZA AS INFORMAÇÕES DO USUÁRIO
	 * @param usuario
	 * @return
	 */
	public ResultadoModel atualizarUsuario(UsuarioModel usuario){
 
		try {
 
			jdbcTemplate.update(QuerysRepository.ATUALIZAR_USUARIO, 
					usuario.getLogin(), 
					usuario.getSenha(), 
					usuario.getAtivo(), 
					usuario.getCodigo());
 
		} catch (Exception e) {
 
			return new ResultadoModel(0,"Erro ao atualizar o registro! detalhe:" + e.getMessage());	
		}
 
		return new ResultadoModel(1,"Registro atualizado com sucesso!");
	}
 
	/**
	 * EXCLUI UM USUÁRIO DA BASE PELO CÓDIGO INFORMADO
	 * @param codigo
	 * @return
	 */
	public ResultadoModel excluirUsuario(int codigo){
 
		try {
 
			jdbcTemplate.update(QuerysRepository.EXCLUIR_USUARIO, codigo);
 
		} catch (Exception e) {
 
			return new ResultadoModel(0,"Erro ao excluir o registro! detalhe:" + e.getMessage());	
		}
 
		return new ResultadoModel(1,"Registro excluido com sucesso!");
	}
 
 
 
}

Agora vamos criar um pacote com o nome de br.com.ciceroednilson.service, e vamos adicionar uma classe com o nome de Service, essa classe vamos usar para expor o nosso métodos via http, devemos deixar nossa classe com o código abaixo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
package br.com.ciceroednilson.service;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
 
import br.com.ciceroednilson.model.ResultadoModel;
import br.com.ciceroednilson.model.UsuarioModel;
import br.com.ciceroednilson.repository.UsuarioRepository;
 
/**
 * CLASSE RESPONSÁVEL POR DISPONIBILIZAR OS NOSSO MÉTODOS VIA HTTP COMO SERVIÇO REST
 * @author cicero
 *
 */
@RestController
@RequestMapping("/service")
public class Service {
 
	/*INJEÇÃO DE DEPÊNDENCIA*/
	@Autowired
	private UsuarioRepository usuarioRepository;
 
 
	/**
	 * ESSE MÉTODO CADASTRA UM NOVO USUÁRIO COMO MOSTRA O EXEMPLO ABAIXO.
	 * 
	 * EXEMPLO:
	 * 
	 * 	URL: http://localhost:8090/service/usuario
	 * 
	 *  REQUEST JSON:
	 *  			{
	 *  				"login":"cicero",
	 *  				"senha":"123456",
	 *  				"ativo":0
	 *  			}
	 *  
	 *  
	 *  RESPONSE JSON:
	 *  			{
	 *  				"codigo": 1,
	 *  				"mensagem": "Registro cadastrado com sucesso!"
	 *  			}
	 *  
	 *  
	 * 
	 * */
	@RequestMapping(value="/usuario", 
			method = RequestMethod.POST, 
			consumes=MediaType.APPLICATION_JSON_VALUE, 
			produces=MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody ResultadoModel cadastrar(@RequestBody UsuarioModel usuario){
 
		return this.usuarioRepository.cadastrar(usuario);
	}
 
 
	/**
	 * ATUALIZA UM USUÁRIO COMO MOSTRA O EXEMPLO ABAIXO.
	 * 
	 * EXEMPLO: 
	 * 	 
	 * 	 URL: http://localhost:8090/service/usuario
	 * 	 
	 *   REQUEST JSON:   
	 *				{
	 *					"codigo": 1,
	 *					"login": "cicero",
	 *					"senha": "1234",
	 *					"ativo": 1
	 *				}
	 *      
	 *      
	 *   RESPONSE JSON:
	 *				{
	 *					"codigo": 1,
	 *					"mensagem": "Registro atualizado com sucesso!"
	 *				}
	 *         
	 *         
	 *         
	 *         
	 * 
	 * @param usuario
	 * @return
	 */
	@RequestMapping(value="/usuario", 
			method = RequestMethod.PUT, 
			consumes=MediaType.APPLICATION_JSON_VALUE, 
			produces=MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody ResultadoModel atualizar(@RequestBody UsuarioModel usuario){
 
		return this.usuarioRepository.atualizarUsuario(usuario);
	}
 
 
	/**
	 * CONSULTA TODOS OS USUÁRIOS CADASTRADOS COMO MOSTRA O EXEMPLO ABAIXO
	 * 
	 * EXEMPLO:
	 * 	 URL:http://localhost:8090/service/usuario
	 * 
	 *   RESPONSE JSON:
	 *				[
	 *					{
	 *					  "codigo": 16,
	 *					  "login": "cicero1",
	 *					  "senha": "1234561",
	 *					  "ativo": 0
	 *					  },
	 *					  {
	 *					  "codigo": 14,
	 *					  "login": "cicero2",
	 *					  "senha": "123456",
	 *					  "ativo": 1
	 *					  }
	 *				]   	
	 *   
	 *   
	 * 
	 * @return
	 */
	@RequestMapping(value="/usuario", 
			method = RequestMethod.GET,  
			produces=MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody List<UsuarioModel> consultar(){
 
		return this.usuarioRepository.usuarios();
 
	}
 
	/**
	 * SELECIONA UM USUÁRIO PELO CÓDIGO COMO MOSTRA O EXEMPLO ABAIXO
	 * 
	 * EXEMPLO:
	 *   
	 *   URL REQUEST:http://localhost:8090/service/usuario/15
	 *   
	 *   
	 *   RESPONSE JSON:
	 *   		{
	 *   			"codigo": 1,
	 *   			"login": "cicero",
	 *   			"senha": "1234561",
	 *   			"ativo": 0
	 *   		}
	 *   		
	 * 
	 * @param codigo
	 * @return
	 */
	@RequestMapping(value="/usuario/{codigo}", 
			method = RequestMethod.GET,  
			produces=MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody UsuarioModel selecionar(@PathVariable("codigo") Integer codigo){
 
		return this.usuarioRepository.usuario(codigo);
	}
 
	/**
	 * EXCLUI UM USUÁRIO PELO CÓDIGO COMO MOSTRA O EXEMPLO ABAIXO;
	 * 
	 * EXEMPLO:
	 * 	
	 * 	URL REQUEST:http://localhost:8090/service/usuario/16
	 * 
	 * 	RESPONSE JSON:
	 * 				{
	 * 					"codigo": 1,
	 * 					"mensagem": "Registro excluido com sucesso!"
	 * 				}
	 * 
	 * @param codigo
	 * @return
	 */
	@RequestMapping(value="/usuario/{codigo}", 
			method = RequestMethod.DELETE,  
			produces=MediaType.APPLICATION_JSON_VALUE)
	public @ResponseBody ResultadoModel delete(@PathVariable("codigo") Integer codigo){
 
		return this.usuarioRepository.excluirUsuario(codigo);
	}
}

Podemos ver na nossa classe que acabamos de criar que todos os métodos tem a mesma URI(Identificador Uniforme de Recurso (URI) – Uniform Resource Identifier) no value do @RequestMapping, pois vamos controlar a chamada de cada método através dos verbos GET, POST, PUT e DELETE, e assim seguimos as boas práticas para desenvolvimento de serviços Rest, abaixo um exemplo de como vai ficar a chamada dos métodos do nosso serviço.

1
2
3
4
5
http://localhost:porta/service/usuario   -> PUT    - execução para atualização.
http://localhost:porta/service/usuario/1 -> GET    - consulta um registro pela chave.
http://localhost:porta/service/usuario   -> GET    - consulta todos os registros.
http://localhost:porta/service/usuario   -> POST   - cadastra um novo registro.
http://localhost:porta/service/usuario/1 -> DELETE - exclui um registro pela chave.

Bom o nosso serviço Rest está pronto, vamos testar ele através do Soap UI que é uma ferramenta para teste de Web Services, primeiro vamos deixar o nosso serviço em executação, para isso vamos clicar com o botão direito sobre a classe BlogRestApplication e vamos até Run As -> Java Application como mostra a imagem abaixo.

Nossa aplicação vai ser executada no Tomcat que já vem embutido no Spring Boot, podemos ver o log de inicialização no console do Eclipse.

Testando o serviço Rest com SoapUI.

Com o Soap UI aberto vamos clicar na opção Rest.

Na tela que foi aberta vamos adicionar o caminho do nosso serviço como mostra a imagem abaixo, depois basta clicar em OK.

E então vamos executar nosso método que cadastra um novo registro, basta deixar o verbo como POST e adicionar a request abaixo.

1
2
3
4
5
{
	"login":"cicero20",
	"senha":"123456",
	"ativo":0
}

Veja como deve ficar o SoapUI com a operação de cadastro.

Para executar o método que realiza a atualização do registro devemos mudar o verbo apenas para PUT e mandar executar.

14

Para executar o método que realiza a exclusão do registro vamos mudar o verbo para DELETE e vamos colocar na URL o código do registro que precisamos excluir, depois basta mandar executar.

Para consultar um registro pelo código basta mudar o verbo para GET e passar um código na URL.

Para consultar todos os registros cadastrados devemos deixar o verbo como GET e não passar nenhuma informação na URL como mostra a imagem abaixo.

É isso ai amigos, nesse tutorial aprendemos como criar um serviço Rest usando Spring Boot, você pode pegar o código fonte desse tutorial aqui.

Até o próximo tutorial.

Comentários

Name of author

Name: ciceroednilson@gmail.com

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *