Leonard Richardson desarrolló el modelo de madurez de Richardson para calificar las API en función de su adherencia a las restricciones REST . Se considera que las API con una puntuación alta de cumplimiento de REST funcionan mejor.
Al determinar la madurez de un servicio, Richardson enfatizó tres factores principales. Incluyen:
- URI
- Métodos HTTP
- HATEOAS (Hipermedia)
URI: un identificador uniforme de recursos (URI) es una secuencia única de caracteres que utilizan las tecnologías web para identificar recursos en la web.
MÉTODOS HTTP : El Protocolo de transferencia de hipertexto (HTTP) es un protocolo que se utiliza para transferir documentos hipermedia. Los clientes HTTP envían las requests HTTP a los servidores en forma de mensajes de solicitud. HTTP define un conjunto de métodos de solicitud para especificar la acción que se llevará a cabo en un recurso determinado.
- GET: el método GET recupera una representación del recurso especificado.
- POST: una solicitud POST transmite datos al servidor.
- PUT: El método PUT reemplaza todas las representaciones existentes del recurso.
- PATCH: una solicitud de PATCH realiza cambios parciales en un recurso.
- DELETE: el método DELETE elimina el recurso especificado.
HATEOAS (Hypermedia as the Engine of Application State) se refiere a la capacidad de descubrimiento. El cliente puede interactuar con una API REST únicamente a través de las respuestas del servidor. Es un hipermedia autodocumental. Los clientes no necesitan consultar ninguna documentación para interactuar con una nueva API.
Los servicios REST se dividen en niveles de madurez según el modelo de madurez de Richardson.
- Nivel 0
- Nivel 1
- Nivel 2
- Nivel 3
NIVEL 0: POX pantano
El nivel 0 también suele denominarse POX (Plain Old XML). En el nivel 0, HTTP se usa solo como protocolo de transporte. Para los servicios de nivel de madurez cero, usamos una sola URL y un solo método HTTP. Enviamos una solicitud a la misma URI para obtener y publicar los datos. Solo se puede utilizar el método POST. por ejemplo, una empresa en particular puede tener muchos clientes o usuarios. Solo tenemos un punto final para todos los clientes. Todas las operaciones se realizan a través del método POST.
- Para obtener los datos: POST http://localhost:8080/users
- Para publicar los datos: POST http://localhost:8080/users
NIVEL 1: Recurso basado en múltiples URI y verbo único
En el nivel 1, cada recurso se asigna a un URI específico. Sin embargo, solo se usa un método HTTP (POST) para recuperar y crear datos. por ejemplo, necesitamos acceder a los empleados que trabajan en una empresa.
- Para agregar un empleado a un departamento en particular:
POST/department/<department-id>/employee - Para acceder a un empleado específico:
POST/department/<department-id>/employee/<employee-id>
NIVEL 2: múltiples verbos HTTP y recursos basados en URI
En el nivel 2, las requests se envían con el verbo HTTP correcto. Se devuelve un código de respuesta HTTP correcto para cada solicitud.
Por ejemplo: Para obtener los usuarios de la empresa, enviamos una solicitud con la URI
http://localhost:8080/users y el servidor envía la respuesta adecuada 200 OK.
NIVEL 3: ODIOS
El nivel 3 es el más alto. Combina el nivel 2 y HATEOS. Es útil en la auto-documentación. Guías de HATEOS donde se pueden encontrar nuevos recursos. Imagine un restaurante chino como una analogía. Pediste fideos, el camarero te trae el plato deseado, te explica lo que acabas de pedir y dónde puedes encontrar los demás platos disponibles. Así, podemos considerar que el plato deseado son datos JSON, mientras que el resto de platos son hipermedia.
Consideramos que una API es RESTful cuando alcanza el nivel 4. Los otros niveles son solo peldaños para convertirse en uno. Hagamos una API RESTFUL siguiendo el modelo de madurez de Richardson
Enfoque: Crearemos una API RESTFUL llamada gfg-wiki. Insertaremos artículos y enviaremos requests HTTP. En este proceso, buscaremos, modificaremos y eliminaremos artículos. Robo3T se utilizará para la base de datos. El cartero se utilizará para enviar requests.
Para crear una API RESTFUL en node.js , instale:
Node: un entorno de tiempo de ejecución de JavaScript
- Enlace de descarga: https://nodejs.org/en/download/
Robo3t: una GUI de MongoDB. crearemos una base de datos usando robo3t.
- Enlace de descarga: https://robomongo.org/
Postman: una plataforma de desarrollo y prueba de API.
- Enlace de descarga: https://www.postman.com/
Visual Studio Code o (cualquier editor de código)
- Enlace de descarga: https://code.visualstudio.com/download
Extensión JSON visor pro Chrome
- Enlace de descarga: https://chrome.google.com/webstore/detail/json-viewer-pro/eifflpmocdbdmepbjaopkkhbfmdg
Paso 1: Cree un nuevo directorio, vaya a la terminal e inicialice NPM ejecutando el siguiente comando.
npm init -y
Inicializar npm
Paso 2: Instalar analizador de cuerpo, mangosta, express
- analizador de cuerpo: un middleware responsable de analizar el cuerpo de la solicitud entrante antes de que pueda ser manejado.
- expreso: marco node.js
- mongoose : Mongoose conecta MongoDB a la aplicación web Express
npm i body-parser mongoose express
Instalar paquetes
Paso 3: Cree un archivo app.js en el directorio actual y configure el servidor. Importaremos los paquetes a nuestro proyecto y configuraremos nuestro servidor.
app.js
// app.js file
// Setting up the server
// jshint esversion:6
const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require('mongoose');
const app = express();
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(express.static("public"));
app.listen(3000, function() {
console.log("Server started on port 3000");
});
Paso 4: Creación de una base de datos en Robo3T. Considere una base de datos de artículos con un título y contenido.
{
“título”: “gfg”,
“contenido”: “GeeksforGeeks es un portal de informática para geeks. ”
}
{
“title” : “REST”,
“content” : “REST significa Transferencia de Estado Representacional. ”
{
“title” : “API”,
“content” : “Interfaz de programación de aplicaciones”
}
{
“title” : “richardson-model”,
“content” : ” Califica las API en función de su adherencia a las restricciones REST”
}
{
“title ” : “Http”,
“content” : “Protocolo de transferencia de hipertexto (HTTP) es un protocolo utilizado
para transferir documentos hipermedia. ”
}
- Vaya a Robo3t y cree una nueva conexión.
- Cree una base de datos llamada gfg-wiki haciendo clic en el botón de nueva conexión.
- Se creará una base de datos ‘gfg-wiki’. Ahora haga clic en él y cree una nueva colección llamada ‘ artículos ‘
- Para insertar documentos, haga clic en los artículos y seleccione insertar documento.
- Copie cada documento de arriba e insértelo uno por uno.
- Para ver todos los documentos, haga clic en artículos.
Como puede ver, la base de datos se ve así:
base de datos de articulos
A continuación se muestra cómo crear una base de datos e insertar documentos.
Creando base de datos en Robo3T
Paso 5: Configure MongoDB y escriba el esquema de nuestros artículos para crear modelos. Para configurar MongoDB, usaremos mongoose. Conectaremos nuestra aplicación a la ubicación de MongoDB y agregaremos el nombre de la base de datos a la string de URL. De forma predeterminada, MongoDB usa el puerto 27017.
mongoose.connect("mongodb://localhost:27017/gfg-wiki", {useNewUrlParser: true});
Schema define la estructura de nuestra colección. Crearemos un esquema llamado artículoEsquema que consta de dos campos: título y contenido del artículo.
const articleSchema = {
title: String,
content: String
};
Ahora vamos a crear un modelo a partir del artículoEsquema
const Article = mongoose.model("Article", articleSchema);
Agregue el siguiente código a su código existente en el archivo app.js.
app.js
const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require('mongoose');
const app = express();
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(express.static("public"));
// connecting gfg-wiki database to our express application
mongoose.connect("mongodb://localhost:27017/gfg-wiki",
{ useNewUrlParser: true });
// Writing schema for articles collection
const articleSchema = {
title: String,
content: String
};
//creating a model around articleSchema
const Article = mongoose.model("Article", articleSchema);
app.listen(3000, function() {
console.log("Server started on port 3000");
});
Paso 6: Acceder a todos los artículos mediante el método GET. Podemos obtener todos los artículos enviando una solicitud de obtención especificando la ruta del recurso y una función de devolución de llamada que maneja la solicitud.
app.get(route, (req,res)=>{
})
Para recuperar todos los artículos, tenemos que encontrar los artículos y leerlos de la base de datos.
<ModelName>.find({conditions},function(err,results){
//using the result
});
Agregue el siguiente código a su archivo app.js existente.
app.js
// Fetching all the articles
app.get("/articles", (req, res) => {
Article.find((err, foundArticles) => {
if (!err) {
res.send(foundArticles)
} else {
res.send(err);
}
})
})
Inicie su aplicación ejecutando el siguiente comando
node app.js
Salida: Podemos acceder a los artículos en localhost:3000/articles.
Recuperando todos los artículos
Paso 7: Cree un nuevo artículo utilizando el método POST. Crearemos un nuevo artículo que se añadirá a la base de datos. Aquí, el cliente envía datos al servidor.
Todavía no tenemos un front-end, pero tenemos un servidor que tiene acceso a nuestra base de datos. Probaremos nuestra API usando Postman, en lugar de crear un formulario o una interfaz. Nuestro objetivo es enviar una solicitud de publicación a nuestro servidor.
Usaremos el método post:
app.post(route,(req,res)=>{
...
})
Una vez que el cliente envía la solicitud de publicación, debemos obtener esos datos mediante req.body.
Dirígete al cartero y envía una solicitud de publicación a localhost:3000/articles. En la pestaña del cuerpo, cambie la codificación a codificación de URL de formulario y agregue el título y el contenido en la clave, junto con el valor que representa los datos que queremos enviar junto con la solicitud.
| Llave | Valor |
| título | verbos http |
| contenido | Los verbos HTTP más comunes son POST, GET, PUT, PATCH y DELETE. |
Necesitamos guardar este artículo en nuestra base de datos.
const <constantName>=new <ModelName>({
<fieldName>:<fielddata>,..
});
Agregue el siguiente código al código anterior en el archivo app.js
app.js
// Posting a new article
app.post("/articles", (req, res) => {
const newArticle = new Article({
title: req.body.title,
content: req.body.content
});
// Saving the article
newArticle.save(function(err) {
if (!err) {
res.send("Successfully added a new article.");
} else {
res.send(err);
}
});
})
Reinicie su servidor y envíe una solicitud de publicación usando cartero.
Salida: Vaya a Robo3T y actualice su colección para ver el artículo agregado. Ahora tenemos una entrada adicional.
Enviar una solicitud de publicación para agregar un nuevo artículo
Paso 8: Obtener un artículo específico.
Leeremos un artículo específico de nuestra base de datos utilizando el método findOne.
<ModelName>.findone({conditions},(req,res)=>{
});
aquí, buscaremos el artículo con un título REST
Agregue el siguiente código a su archivo app.js.
app.js
// Fetching a specific article
app.get("/articles/:articleTitle", function(req, res) {
Article.findOne({ title: req.params.articleTitle },
function(err, foundArticle) {
if (foundArticle) {
res.send(foundArticle);
} else {
res.send("No articles matching that title was found.");
}
});
})
Salida : Especificaremos el título del artículo en la URL y se mostrará el artículo cuyo título coincida.
Obtener un artículo específico
Paso 9 : Sobrescribir un artículo con el método PUT.
Queremos enviar una nueva versión de un artículo. Para reemplazar un artículo existente, enviaremos una solicitud de venta.
app.put(route ,(req,res)=>{
...
});
Actualizaremos el artículo utilizando el método de actualización Mongoose.
La sobrescritura especifica que queremos reemplazar todo el artículo.
<ModelName>.update(
{conditions},
{updates},
{overwrite:true}
(err,results)=>{
})
Agregue el siguiente código a su archivo app.js
app.js
// Replacing a specific article
app.put("/articles/:articleTitle", (req, res) => {
Article.updateOne({ title: req.params.articleTitle },
{ title: req.body.title, content: req.body.content },
{ overwrite: true },
function(err) {
if (!err) {
res.send("Successfully updated the selected article.");
}
}
);
})
En este caso, cambiaremos nuestro título de API a Postman, y su contenido de Interfaz de programación de aplicaciones a Postman es una plataforma API.
title: Postman content: Postman is an API platform
enviando una solicitud de colocación a la ruta localhost:3000/articles/API
Si el servidor encuentra un parámetro con un título de API, reemplazará el título con un nuevo título y el contenido con uno nuevo.
Sobrescribir un artículo
Paso 9: Actualización de un artículo usando el método PATCH.
Actualizaremos un artículo existente enviando una solicitud de Parche con el título del artículo que deseamos actualizar. Para actualizar el artículo, debemos dar los campos que queremos cambiar en la pestaña del cuerpo.
Ahora que estamos cambiando solo un campo de un artículo en lugar de todo el artículo, el método de sobrescritura no es necesario cuando llamamos al método de actualización para actualizar nuestra base de datos. Para actualizar el artículo, debemos dar los campos que queremos cambiar en la pestaña del cuerpo.
Agrega el siguiente código en tu archivo app.js para modificar el artículo.
app.js
// Updating an article
app.patch("/articles/:articleTitle", function(req, res) {
Article.update({ title: req.params.articleTitle },
{ $set: req.body },
function(err) {
if (!err) {
res.send("Successfully updated article.");
} else {
res.send(err);
}
}
);
})
Salida : Actualiza solo los campos que proporcionamos. El título del artículo REST se actualiza a Restful.
Actualización de un artículo
Paso 10: Eliminación de todos los artículos mediante el método DELETE.
Para eliminar todos los artículos de nuestra base de datos, utilizaremos el método deleteMany mongoose y enviaremos una solicitud de eliminación al cartero.
Agregue el siguiente código a su archivo app.js
app.js
// Deleting all the articles
app.delete("/articles", function(req, res) {
Article.deleteMany(function(err) {
if (!err) {
res.send("Successfully deleted all articles.");
} else {
res.send(err);
}
});
});
Salida: enviaremos una solicitud de eliminación a localhost:3000/articles para eliminar todos nuestros artículos. Visite Robo3T y actualice su colección. Si enviamos una solicitud de eliminación de nuestro cartero, no observaremos ningún artículo.
Eliminación de todos los artículos.
El archivo app.js final:
app.js
// app.js file
// Setting up the server
// jshint esversion:6
const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require('mongoose');
const app = express();
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(express.static("public"));
//Connecting gfg-wiki database to our express application
mongoose.connect("mongodb://localhost:27017/gfg-wiki",
{ useNewUrlParser: true });
// Writing schema for articles collection
const articleSchema = {
title: String,
content: String
};
// Creating a model around articleSchema
const Article = mongoose.model("Article", articleSchema);
// Fetching all the articles
app.get("/articles", (req, res) => {
Article.find((err, foundArticles) => {
if (!err) {
res.send(foundArticles)
} else {
res.send(err);
}
})
})
// Posting a new article
app.post("/articles", (req, res) => {
const newArticle = new Article({
title: req.body.title,
content: req.body.content
});
// Saving the article
newArticle.save(function(err) {
if (!err) {
res.send("Successfully added a new article.");
} else {
res.send(err);
}
});
})
// Fetching a specific article
app.get("/articles/:articleTitle", function(req, res) {
Article.findOne({ title: req.params.articleTitle },
function(err, foundArticle) {
if (foundArticle) {
res.send(foundArticle);
} else {
res.send("No articles matching that title was found.");
}
});
})
// Replacing a specific article
app.put("/articles/:articleTitle", function(req, res) {
Article.update({ title: req.params.articleTitle },
{ title: req.body.title, content: req.body.content },
{ overwrite: true },
function(err) {
if (!err) {
res.send("Successfully updated the selected article.");
}
}
);
})
// Modifying an article
app.patch("/articles/:articleTitle", function(req, res) {
Article.update({ title: req.params.articleTitle },
{ $set: req.body },
function(err) {
if (!err) {
res.send("Successfully updated article.");
} else {
res.send(err);
}
}
);
})
// Deleting all the articles
app.delete("/articles", function(req, res) {
Article.deleteMany(function(err) {
if (!err) {
res.send("Successfully deleted all articles.");
} else {
res.send(err);
}
});
});
app.listen(3000, function() {
console.log("Server started on port 3000");
});
Publicación traducida automáticamente
Artículo escrito por riyaa7vermaa y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA