Hola comunidad Vikinga. Ahora voy a mostrar como crear un Api REST usando Java y todo el poder de Spring Boot.
para esta demo vamos hacer un CRUD usando MySQL como base de datos y usando el paradigma de programación First Code. sin mas pasamos a tirar código.
pueden usar https://start.spring.io/ para crear la plantilla o directamente en VS Code se puede hacer, solo hay que instalara las extenciones Spring Boot Extension , Extension Pack for Java, además para este demo tengo la instalación de apache-maven-3.8.4 y Java jdk-11.0.14.
una vez abierta la plantilla hay que ir a configurar la conexion a la base de datos.
spring.datasource.url=jdbc:mysql://localhost:3306/springboot spring.datasource.username=root spring.datasource.password=mario spring.jpa.hibernate.ddl-auto=update como vamos a ocupar el paradigma first code vamos ocupar ddl-auto en update, para que cada cambio en el modelo se vea reflejado en la base de datos.
spring.jpa.hibernate.ddl-auto=update
En el archivo pom.xml tenemos que asegurarnos que tengamos las dependencias de spring boot y conector a MySQL
<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.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> </dependencies>
en la estructura de este demo vamos a tener 4 carpetas principalmente
como inicio en la carpeta models vamos a tener el conjunto de entidades con sus atributos la cual va a tener una relación con la base de datos, ya que estas entidades pasaran a ser tablas en la BD.
para este ejemplo vamos a tener una entidad llamada UserModel, se van a usar anotaciones para especificar diversas propiedades
package com.example.demo.models;
import javax.persistence.Entity;
import javax.persistence.*;
@Entity
@Table (name = "user") // para que el nombre de la tabla en BD no sea UserModel y pase a //nombrase user
public class UserModel {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(unique = true,nullable = false)
private Long id;
private String name;
private String email;
private int age;
public Long getId() {
return id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setId(Long id) {
this.id = id;
}
}
en la carpeta de repositories vamos a tener toda la magia de Spring Boot, es la encargada de hacer el CRUD y tener conexión con la BD.
la parte importante de la magia y todo el poder es
CrudRepository<UserModel, Long>
package com.example.demo.repositories; import java.util.ArrayList; import com.example.demo.models.UserModel; import org.springframework.data.repository.CrudRepository; import org.springframework.stereotype.Repository; @Repository public interface UserRepository extends CrudRepository<UserModel, Long> { public abstract ArrayList<UserModel> findByName(String name); // podemos agregar mas // métodos personalizados } en la carpeta de services vamos a tener todas las operaciones básicas del CRUD además de búsquedas. vemos que el servicio interactúa con el repositorio, la magia de esta parte es la siguiente ya que se encarga de instanciar la clase para todos los métodos.
@Autowired UserRepository userRepository;
la magia de spring boot son los siguientes métodos,. ya que tan solo con hacer esto, spring boot se encarga de hacer todo, ya no hay que hacer las típicas consultas, SP, etc.
userRepository.findAll();
userRepository.save(user);
userRepository.findById(id);
userRepository.findByName(name);
package com.example.demo.services; import java.util.ArrayList; import java.util.Optional; import com.example.demo.models.UserModel; import com.example.demo.repositories.UserRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class UserService { @Autowired UserRepository userRepository; public ArrayList<UserModel> getUsers() { return (ArrayList<UserModel>) userRepository.findAll(); } public UserModel saveUser(UserModel user) { return userRepository.save(user); } public Optional<UserModel> getUserById(Long id) { return userRepository.findById(id); } public ArrayList<UserModel> getUsersByName(String name) { return userRepository.findByName(name); } public boolean deleteUser(Long id) { try { userRepository.deleteById(id); return true; } catch (Exception error) { return false; } } } y finalmente en la carpeta de controllers vamos a exponer los métodos para que se puedan consumir. vemos que se tienen que usar las anotaciones para poder establecer las rutas y la forma como va a operar.
@RestController @RequestMapping("/user")
@GetMapping
@PostMapping()
@DeleteMapping(path = "/{id}")
package com.example.demo.controllers;
import com.example.demo.services.UserService;
import java.util.ArrayList;
import java.util.Optional;
import com.example.demo.models.UserModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
UserService userService;
@GetMapping()
public ArrayList<UserModel> getUsers() {
return userService.getUsers();
}
@PostMapping()
public UserModel saveUser(@RequestBody UserModel user) {
return userService.saveUser(user);
}
@GetMapping(path = "/{id}")
public Optional<UserModel> getUserById(@PathVariable("id") Long id) {
return userService.getUserById(id);
}
@GetMapping("/query")
public ArrayList<UserModel> getUsersByName(@RequestParam("name") String name) {
return userService.getUsersByName(name);
}
@DeleteMapping(path = "/{id}")
public String deleteUserById(@PathVariable("id") Long id) {
boolean ok = userService.deleteUser(id);
if (ok) {
return "Delete user by id" + id;
} else {
return "Error Delete user by id" + id;
}
}
}
para probar lo hecho, uso Postman para validar. les dejo unas imagenes para pronta referencia de como consultar, guardar, borrar.
espero que le sea de gran utilidad. si tienen dudas favor de hacérmelas llegar.
finalmente les comparto el código
saludos.