La transferencia de estado representacional (REST) es un estilo de arquitectura de software que define un conjunto de restricciones que se utilizarán para crear servicios web. Los servicios web que se ajustan al estilo arquitectónico REST, denominados servicios web RESTful , proporcionan interoperabilidad entre sistemas informáticos en Internet. Los servicios web RESTful permiten a los sistemas solicitantes acceder y manipular representaciones textuales de recursos web mediante el uso de un conjunto uniforme y predefinido de operaciones sin estado. Otros tipos de servicios web, como los servicios web SOAP , exponen sus propios conjuntos arbitrarios de operaciones.
En este artículo, entenderemos cómo crear una API de descanso usando Spring Boot .
Spring es ampliamente utilizado para crear aplicaciones escalables. Para aplicaciones web, Spring proporciona Spring MVC, que es un módulo de Spring ampliamente utilizado que se utiliza para crear aplicaciones web escalables. Pero la principal desventaja de los proyectos Spring es que la configuración requiere mucho tiempo y puede ser un poco abrumadora para los nuevos desarrolladores. La solución a esto es Spring Boot . Spring Boot está construido en la parte superior del resorte y contiene todas las características del resorte. En este artículo, crearemos una API REST para agregar empleados a la lista de empleados y obtener la lista de empleados. Para hacer esto, primero tenemos que crear un proyecto Spring Boot simple en cualquiera de los IDE y seguir los pasos:
- Inicialmente, necesitamos definir la entidad del empleado. Por lo tanto, se define la siguiente clase de empleado:
package
com.example.demo;
// Creating an entity Employee
public
class
Employee {
public
Employee() {}
// Parameterized Constructor
// to assign the values
// to the properties of
// the entity
public
Employee(
Integer id, String firstName,
String lastName, String email)
{
super
();
this
.id = id;
this
.firstName = firstName;
this
.lastName = lastName;
this
.email = email;
}
private
Integer id;
private
String firstName;
private
String lastName;
private
String email;
// Overriding the toString method
// to find all the values
@Override
public
String toString()
{
return
"Employee [id="
+ id +
", firstName="
+ firstName +
", lastName="
+ lastName +
", email="
+ email +
"]"
;
}
// Getters and setters of
// the properties
public
Integer getId()
{
return
id;
}
public
void
setId(Integer id)
{
this
.id = id;
}
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;
}
public
String getEmail()
{
return
email;
}
public
void
setEmail(String email)
{
this
.email = email;
}
}
- Ahora, necesitamos crear una clase de almacenamiento que almacene la lista de todos los empleados:
package
com.example.demo;
import
java.util.ArrayList;
import
java.util.List;
// Class to store the list of
// all the employees in an
// Array List
public
class
Employees {
private
List<Employee> employeeList;
// Method to return the list
// of employees
public
List<Employee> getEmployeeList()
{
if
(employeeList ==
null
) {
employeeList
=
new
ArrayList<>();
}
return
employeeList;
}
public
void
setEmployeeList(
List<Employee> employeeList)
{
this
.employeeList
= employeeList;
}
}
- Hasta ahora, hemos definido la entidad empleado y creado una clase de almacenamiento. Ahora, necesitamos acceder a los empleados. Entonces, creamos una clase desde donde crearemos un objeto de la clase de almacenamiento para almacenar los empleados:
package
com.example.demo;
import
org.springframework
.stereotype
.Repository;
// Importing the employees class to
// use the defined properties
// in this class
import
com.example.demo.Employees;
@Repository
// Class to create a list
// of employees
public
class
EmployeeDAO {
private
static
Employees list
=
new
Employees();
// This static block is executed
// before executing the main
// block
static
{
// Creating a few employees
// and adding them to the list
list.getEmployeeList().add(
new
Employee(
1
,
"Prem"
,
"Tiwari"
,
"chapradreams@gmail.com"
));
list.getEmployeeList().add(
new
Employee(
2
,
"Vikash"
,
"Kumar"
,
"abc@gmail.com"
));
list.getEmployeeList().add(
new
Employee(
3
,
"Ritesh"
,
"Ojha"
,
"asdjf@gmail.com"
));
}
// Method to return the list
public
Employees getAllEmployees()
{
return
list;
}
// Method to add an employee
// to the employees list
public
void
addEmployee(Employee employee)
{
list.getEmployeeList()
.add(employee);
}
}
- Finalmente, necesitamos crear una clase de controlador que sea la implementación real de la API REST. De acuerdo con las reglas REST, cada nueva entrada en la base de datos debe llamarse mediante el método POST y todas las requests de la base de datos deben llamarse mediante el método GET. Los mismos métodos se implementan en el siguiente código:
package
com.example.demo;
import
java.net.URI;
import
org.springframework.beans
.factory.annotation.Autowired;
import
org.springframework.http
.ResponseEntity;
import
org.springframework.web.bind
.annotation.GetMapping;
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.RestController;
import
org.springframework.web.servlet
.support.ServletUriComponentsBuilder;
// Import the above-defined classes
// to use the properties of those
// classes
import
com.example.demo.Employees;
import
com.example.demo.EmployeeDAO;
import
com.example.demo.Employee;
// Creating the REST controller
@RestController
@RequestMapping
(path =
"/employees"
)
public
class
EmployeeController {
@Autowired
private
EmployeeDAO employeeDao;
// Implementing a GET method
// to get the list of all
// the employees
@GetMapping
(
path =
"/"
,
produces =
"application/json"
)
public
Employees getEmployees()
{
return
employeeDao
.getAllEmployees();
}
// Create a POST method
// to add an employee
// to the list
@PostMapping
(
path =
"/"
,
consumes =
"application/json"
,
produces =
"application/json"
)
public
ResponseEntity<Object> addEmployee(
@RequestBody
Employee employee)
{
// Creating an ID of an employee
// from the number of employees
Integer id
= employeeDao
.getAllEmployees()
.getEmployeeList()
.size()
+
1
;
employee.setId(id);
employeeDao
.addEmployee(employee);
URI location
= ServletUriComponentsBuilder
.fromCurrentRequest()
.path(
"/{id}"
)
.buildAndExpand(
employee.getId())
.toUri();
return
ResponseEntity
.created(location)
.build();
}
}
- Después de implementar todas las clases en el proyecto, ejecute el proyecto como la aplicación Spring Boot. Una vez que el servidor comienza a funcionar, podemos enviar las requests a través del navegador o cartero. Podemos acceder a la aplicación en ejecución ingresando a la siguiente URL:
http://localhost:8080/employees/
Salida: La siguiente es la salida generada al ejecutar el proyecto anterior:
- Cuando se realiza una solicitud GET:
- Cuando se realiza una solicitud POST:
- Nuevamente presionando la solicitud GET después de realizar la solicitud POST:
Publicación traducida automáticamente
Artículo escrito por prem_tiwari y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA