NCR Desarrollo

Crear Api REST con Spring Boot

En este apartado veremos como crear una Api REST con Spring Boot. Estaremos utilizando como base de datos MySQL y los programas SpringToolSuite4 y WorkBench

Para crear un proyecto vamos a File luego en new y luego en Spring Starter Project y luego en la ventana que nos aparece colocamos el Name el Group y el Package el resto de campos se dejan como están y luego le damos en Next. En la sesion de dependencias utilizamos las de Spring Web, MySQL Driver, Spring Data JPA, Spring Boot DevTools

Vamos a utilizar el patrón de MVC. Para esto empezamos creando la estructura del proyecto, por lo tanto nos dirigimos a src/main/java y luego damos clic derecho en el paquete principal -> new -> Package y colocamos el nombre del paquete

Creamos 4 paquetes que los llamaremos así: empty, repository, service, controller

Creamos la conexión con la base de datos MySQL, para eso nos dirigimos a src/main/resources y luego abrimos el archivo application.properties y copiamos y modificamos las siguiente lineas de código según sea necesario

#en esta primera linea pasamos los datos de la conexion como la url
#que este caso es localhost y el puerto 3306
#y luego el nombre de la base de datos
spring.datasource.url=jdbc:mysql://localhost:3306/bd_curso_springboot?useSSL=false&serverTimezone=America/Bogota
#colocamos el usuario de la bd
spring.datasource.username=root 
#colocamos la conraseña de la bd
spring.datasource.password=1234
#colocamos el drive de mysql ya que nos conecatmos con mysql
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.show-sql=true
#con esta linea hacemos que se creen las tablas 
#cada vez que ejecutamos la aplicacion.
#podemos cambiar el create-drop 
spring.jpa.hibernate.ddl-auto=create-drop
#indicamos que esta en debug
logging.level.org.hibernate.SQL=debug

Ahora lo que hacemos es crear el modelo; para eso nos ubicamos en el paquete empty luego damos clic derecho luego en new --> Class y colocamos el nombre de la clase que en este caso va a ser User

En la clase User realizamos las siguientes anotaciones:

@Entity //Para que lo tome como una entidad @Table(name = "users") //para que se cree la tabla en la base de datos

(pra generear los getter y setter en el IDE de springboot lo hacemos de la siguiente manera:

Damos clic derecho luego en Source --> Generate Getters and Setters)

 

Así quedaría el código

package com.ncrdesarrollo.cursospringboot.empty;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity //Para que lo tome como una entidad
@Table(name = "users") //para que se cree la tabla en la base de datos
public class User implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = -9017550965540550456L;

	@Id //para indicar que este es la llave primaria
	@GeneratedValue(strategy = GenerationType.IDENTITY) //para generar el valor automaticamente
	private Long id;
	
	@Column(length = 50)//para definir el tamaño y demas propiedades que va tener la columna
	private String name; //nombre de la columna en la tabla de la bd
	
	private String surname;
	
	@Column(nullable=false, length=50, unique= true)
	private String email;
	
	private Boolean enabled;

	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 String getSurname() {
		return surname;
	}

	public void setSurname(String surname) {
		this.surname = surname;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Boolean getEnabled() {
		return enabled;
	}

	public void setEnabled(Boolean enabled) {
		this.enabled = enabled;
	}
		
}

 

Ahora en el paquete repository creamos una clase de tipo interfaz. Para esto damos clic derecho sobre el paquete luego en new y luego en Interface y se le coloca el nombre; en este caso lo llamamos UserRepository

package com.ncrdesarrollo.cursospringboot.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.ncrdesarrollo.cursospringboot.empty.User;

@Repository 
public interface UserRepository extends JpaRepository<User, Long>{
	//extendemos de JpaRepository ya que nos permite usar los atributos de paginación 

}

 

Ahora en el paquete de service creamos una clase de tipo interface la cual llamaremos UserService

package com.ncrdesarrollo.cursospringboot.service;

import java.util.Optional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import com.ncrdesarrollo.cursospringboot.empty.User;

public interface UserService {
	
	//para llamar la lista
	public Iterable<User> findAll();
	
	//para llamar la lista con paginación
	public Page<User> findAll(Pageable pageable);
	
	//para buscar por id
	public Optional<User> findById(Long id);
	
	//para guardar
	public User save(User user);
	
	//para eliminar
	public void deleteById(Long id);
	 
}

 

Ahora en el paquete de service creamos una clase que la llamaremos UserServiceImpl y implementamos la interfaz de UserService

package com.ncrdesarrollo.cursospringboot.service;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ncrdesarrollo.cursospringboot.empty.User;
import com.ncrdesarrollo.cursospringboot.repository.UserRepository;

@Service
public class UserServiceImpl implements UserService{
	
	@Autowired //para inyectar el UserRepository
	private UserRepository userRepository;

	@Override
	@Transactional(readOnly = true)//indicamos que es de lectura
	public Iterable<User> findAll() {
		
		return userRepository.findAll();
	}

	@Override
	@Transactional(readOnly = true)
	public Page<User> findAll(Pageable pageable) {
		return userRepository.findAll(pageable);
	}

	@Override
	@Transactional(readOnly = true)
	public Optional<User> findById(Long id) {
		return userRepository.findById(id);
	}

	@Override
	@Transactional
	public User save(User user) {
		return userRepository.save(user);
	}

	@Override
	@Transactional
	public void deleteById(Long id) {
		userRepository.deleteById(id);
		
	}

}

 

Ahora en el paquete controller creamos una clase que la llamaremos UserController y creamos todos los metodos necesarios para el funcionamiento de la api

package com.ncrdesarrollo.cursospringboot.controller;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.ncrdesarrollo.cursospringboot.empty.User;
import com.ncrdesarrollo.cursospringboot.service.UserService;

@RestController //indicamos que es el controller
@RequestMapping("/api/users")//aqui colocamos la dirección de la api
public class UserController {
	
	@Autowired //inyectamos el UserService
	private UserService userService;
	
	//create the new user
	@PostMapping
	public ResponseEntity<?> create (@RequestBody User user){
		return ResponseEntity.status(HttpStatus.CREATED).body(userService.save(user));
	}
	
	//read the user
	@GetMapping("/{id}")
	public ResponseEntity<?> read (@PathVariable(value="id") Long userId){
		Optional<User> oUser = userService.findById(userId);
		
		//validamos si existe el id que llega
		if(!oUser.isPresent()) {
			return ResponseEntity.notFound().build();
		}
		
		return ResponseEntity.ok(oUser);
		
		
	}
	
	//edit user
	@PutMapping("/{id}")
	public ResponseEntity<?> update (@RequestBody User userDetails, @PathVariable(value="id") Long userId){
		Optional<User> user = userService.findById(userId);
		
		if(!user.isPresent()) {
			return ResponseEntity.notFound().build();
		}
		
		user.get().setName(userDetails.getName());
		user.get().setSurname(userDetails.getSurname());
		user.get().setEmail(userDetails.getEmail());
		user.get().setEnabled(userDetails.getEnabled());
		
		return ResponseEntity.status(HttpStatus.CREATED).body(userService.save(user.get()));
		
	}
	
	//delete user
	@DeleteMapping("/{id}")
	public ResponseEntity<?> delete (@PathVariable(value="id") Long userId){
		if(!userService.findById(userId).isPresent()) {
			return ResponseEntity.notFound().build();
		}
		
		userService.deleteById(userId);
		return ResponseEntity.ok().build();
	}
	
	//read all user
	@GetMapping
	public List<User> readAll(){
		List<User> users = StreamSupport
				.stream(userService.findAll().spliterator(), false)
				.collect(Collectors.toList());
		
		return users;
		
		
	}

}

Para ejecutar la aplicación damos clic derecho en

Ahora probamos la api utilizando la extensión Postman de google chrome

Para agregar un registro debemos seleccionar POST y en la url escribimos localhost:8080/api/users (api/users es la direccion que colocamos en el UserController)

En el body colocamos los datos en formato Json

{
	"name": "Pepito",
	"surname": "Perez",
	"email": "pepito@gmail.com",
	"enabled": true
	
}

Si todo sale bién nos debe devolver el estatus 201 Created

 

Para editar seleccionamos PUT escribimos la dirección y le pasamos el id

Ejemplo: localhost:8080/api/users/1

En el body le pasamos los datos en formato Json

{
	"name": "Pepito editado",
	"surname": "Perez editado",
	"email": "pepitoeditado@gmail.com",
	"enabled": false
	
}

Para listar seleccionamos GET y escribimos la url localhost:8080/api/users

Para eliminar seleccionamos DELETE y le pasamos el id

Ejemplo: localhost:8080/api/users/2