Docs Menu
Docs Home
/ /

Integrar MongoDB con React

En esta guía, puedes aprender cómo crear una aplicación web React que utiliza el stack MERN. La pila MERN es un marco de desarrollo web que utiliza MongoDB, Express, React y Node.js y consta de las siguientes capas:

  • Capa de base de datos: MongoDB proporciona almacenamiento y recuperación de datos.

  • Capa de aplicación: Express y Node.js constituyen el nivel intermedio para la lógica del lado del servidor.

  • Capa de presentación: React implementa la interfaz de usuario y las interacciones del front-end.

Al almacenar los datos de su aplicación React en MongoDB, puede usar el modelo de datos del documento para crear expresiones de consulta complejas. La flexibilidad del modelo del documento le permite almacenar estructuras de datos anidadas e iterar rápidamente en el diseño de su aplicación. También puede expandir su aplicación fácilmente utilizando las capacidades de escalado horizontal de MongoDB.

La pila MERN con MongoDB admite aplicaciones que requieren estructuras de datos dinámicas y en evolución. Como resultado, este marco está bien diseñado para aplicaciones del mundo real, como tableros en tiempo real o aplicaciones de una sola página que actualizan el contenido de forma continua.

Este tutorial muestra cómo crear una aplicación web utilizando la pila MERN. La aplicación accede a datos de muestra de restaurantes, los consulta y muestra los resultados en un sitio web alojado localmente. El tutorial también incluye instrucciones para conectarse a un clúster de MongoDB alojado en MongoDB Atlas y acceder y mostrar datos de su base de datos.

Tip

Si prefiere conectarse a MongoDB utilizando el controlador Node.js sin React, consulte la Comiencea utilizar la guía del controlador Node.js.

Siga los pasos de esta sección para instalar las dependencias del proyecto, crear un clúster Atlas y configurar los directorios de la aplicación.

1

Para crear la aplicación de inicio rápido, necesita el siguiente software instalado en su entorno de desarrollo:

Requisito previo
notas

Descargue la última versión LTS o la última versión de lanzamiento.

Editor de código

Este tutorial utiliza Visual Studio Code, pero puedes usar el editor que prefieras.

Aplicación de terminal y shell

Para usuarios de macOS, usen Terminal o una aplicación similar. Para usuarios de Windows, usen PowerShell.

2

MongoDB Atlas es un servicio de base de datos en la nube totalmente administrado que aloja sus implementaciones de MongoDB. Si no tiene una implementación de MongoDB, puede crear un clúster de MongoDB gratis (sin tarjeta de crédito) completando el tutorial de introducción a MongoDB. Este tutorial también muestra cómo cargar conjuntos de datos de muestra en su clúster, incluyendo... sample_restaurants base de datos que se emplea en este tutorial.

Para conectarte a tu clúster de MongoDB, debes usar un URI de conexión. Para saber cómo recuperar tu URI de conexión, consulta la sección Agrega tu cadena de conexión del tutorial Primeros pasos de MongoDB.

Importante

Guarde su cadena de conexión en una ubicación segura.

3

Ejecute el siguiente comando en su terminal para crear un directorio para su proyecto llamado react-quickstart:

mkdir react-quickstart
cd react-quickstart

Luego, ejecute los siguientes comandos desde el directorio react-quickstart para crear una carpeta para el back end llamada server e inicializar el archivo package.json:

mkdir server
cd server
npm init -y
4

Navega al archivo package.json en el directorio react-quickstart/server. Para utilizar módulos ECMAScript, el formato estándar para empaquetar código JavaScript reutilizable, sustituya la línea existente que especifica el campo "type" por la siguiente línea:

"type": "module",

Ejecute el siguiente comando para instalar las dependencias mongodb, express y cors:

npm install mongodb express cors

Este comando instala MongoDB, el marco web Express y el paquete cors Node.js que permite compartir recursos entre orígenes.

Después de configurar la estructura y las dependencias del proyecto, siga los pasos de esta sección para configurar su servidor web y conectarse a MongoDB.

1

Crea un archivo llamado server.js en tu directorio react-quickstart/server y pega el siguiente código:

react-quickstart/server/server.js
import express from "express";
import cors from "cors";
import restaurants from "./routes/restaurant.js";
const PORT = process.env.PORT || 5050;
const app = express();
app.use(cors());
app.use(express.json());
app.use("/restaurant", restaurants);
// start the Express server
app.listen(PORT, () => {
console.log(`Server listening on port ${PORT}`);
});
2

En el directorio server, cree un archivo config.env que almacene las siguientes variables:

MONGODB_URI=<connection URI>
PORT=5050

Reemplace <connection URI> el marcador de posición con la URI de conexión que guardó en un paso anterior.

3

En el directorio server, cree un subdirectorio llamado routes. Cree un archivo llamado restaurant.js en el subdirectorio routes y pegue el siguiente código:

react-quickstart/servidor/rutas/restaurant.js
import express from "express";
import db from "../db/connection.js";
// Creates an instance of the Express router, used to define our routes
const router = express.Router();
// Gets a list of all the restaurants
router.get("/", async (req, res) => {
let collection = await db.collection("restaurants");
let results = await collection.find({}).toArray();
res.send(results).status(200);
});
// Lists restaurants that match the query filter
router.get("/browse", async (req, res) => {
try {
let collection = await db.collection("restaurants");
let query = {
borough: "Queens",
name: { $regex: "Moon", $options: "i" },
};
let results = await collection.find(query).toArray();
res.send(results).status(200);
} catch (err) {
console.error(err);
res.status(500).send("Error browsing restaurants");
}
});
export default router;

Este archivo accede a la colección restaurants en la base de datos sample_restaurants y define los siguientes endpoints GET:

  • /:Recupera todos los restaurantes de la colección de muestras

  • /browse: Recupera restaurantes que cumplen los criterios de la query, la cual filtra los restaurantes de Queens que contienen la palabra "Moon" en el nombre

Después de configurar el back end de la aplicación, sigue los pasos de esta sección para configurar React y añadir los componentes del front end.

1

En el react-quickstart directorio, ejecute los siguientes comandos para agregar los archivos de plantilla de React usando Vite:

npm create vite@latest client

Este comando le solicita que responda a una serie de preguntas de configuración. Para cada pregunta, elija las siguientes respuestas en el menú desplegable:

  • Seleccione un marco: React

  • Seleccione una variante: JavaScript

  • ¿Usar rolldown-vite (Experimental)?: No

  • ¿Instalar con npm y empezar ahora?: No

Después de ejecutar el comando, su proyecto tiene un directorio client que contiene el andamiaje del frontend.

2

Esta aplicación de ejemplo utiliza el framework Tailwind CSS para el formato de la interfaz de usuario. Para instalarlo, acceda al directorio client creado en el paso anterior y ejecute el siguiente comando:

npm install tailwindcss @tailwindcss/vite

Después de instalar, dirígete a tu archivo vite.config.js. Añade el plugin @tailwindcss/vite actualizando las declaraciones de importación y el arreglo plugins, como se muestra en las líneas resaltadas:

react-quickstart/cliente/vite.config.js
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import tailwindcss from '@tailwindcss/vite'
// https://vite.dev/config/
export default defineConfig({
plugins: [
react(),
tailwindcss()
],
})

Luego, navegue hasta el archivo client/src/index.css y agregue la siguiente declaración de importación:

@import "tailwindcss";
3

Para habilitar el enrutamiento de páginas del lado del cliente a React, instale el paquete react-router-dom ejecutando el siguiente comando en el directorio client:

npm install -D react-router-dom
4

Navega al archivo client/src/main.jsx y pega el siguiente código:

react-quickstart/cliente/src/main.jsx
import * as React from "react";
import * as ReactDOM from "react-dom/client";
import { createBrowserRouter, RouterProvider } from "react-router-dom";
import App from "./App";
import RestaurantList from "./components/RestaurantList";
import "./index.css";
const router = createBrowserRouter([
{
path: "/",
element: <App />,
children: [
{
path: "/",
element: <RestaurantList />,
},
],
},
{
path: "/browse",
element: <App />,
children: [
{
path: "/browse",
element: <RestaurantList />,
},
],
},
]);
ReactDOM.createRoot(document.getElementById("root")).render(
<React.StrictMode>
<RouterProvider router={router} />
</React.StrictMode>,
);

Este archivo configura el enrutamiento del lado del cliente y define las siguientes rutas:

  • /: Renderiza el componente RestaurantList, que llama al endpoint de la API /restaurant/ para mostrar todos los restaurantes

  • /browse: Representa el componente RestaurantList, que llama al punto final de la API /restaurant/browse para mostrar los restaurantes filtrados

5

Ejecuta los siguientes comandos desde el directorio client para crear una nueva carpeta llamada components que contenga dos archivos:

mkdir src/components
cd src/components
touch Navbar.jsx RestaurantList.jsx

El archivo Navbar.jsx configura una barra de navegación que enlaza con los componentes necesarios. Pegue el siguiente código en este archivo:

react-quickstart/cliente/src/componentes/Navbar.jsx
import { NavLink } from "react-router-dom";
export default function Navbar() {
return (
<div>
<nav className="flex justify-between items-center mb-6">
<NavLink to="/">
<img
alt="MongoDB logo"
className="h-10 inline"
src="https://d3cy9zhslanhfa.cloudfront.net/media/3800C044-6298-4575-A05D5C6B7623EE37/4B45D0EC-3482-4759-82DA37D8EA07D229/webimage-8A27671A-8A53-45DC-89D7BF8537F15A0D.png"
></img>
</NavLink>
</nav>
</div>
);
}

El archivo RestaurantList.jsx es el componente de visualización de los restaurantes y recupera y muestra la información del restaurante. Pegue el siguiente código en este archivo:

react-quickstart/client/src/components/RestaurantList.jsx
import { useEffect, useState } from "react";
import { useLocation } from "react-router-dom";
const Restaurant = (props) => (
<tr className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
<td className="p-4 align-middle [&:has([role=checkbox])]:pr-0">
{props.restaurant.name}
</td>
<td className="p-4 align-middle [&:has([role=checkbox])]:pr-0">
{props.restaurant.borough}
</td>
<td className="p-4 align-middle [&:has([role=checkbox])]:pr-0">
{props.restaurant.cuisine}
</td>
</tr>
);
export default function RestaurantList() {
const [restaurants, setRestaurants] = useState([]);
const location = useLocation();
// Fetches the restaurants from the database
useEffect(() => {
async function getRestaurants() {
// Determines which endpoint to call based on current route
const endpoint =
location.pathname === "/browse"
? "http://localhost:5050/restaurant/browse"
: "http://localhost:5050/restaurant/";
const response = await fetch(endpoint);
if (!response.ok) {
const message = `An error occurred: ${response.statusText}`;
console.error(message);
return;
}
const restaurants = await response.json();
setRestaurants(restaurants);
}
getRestaurants();
return;
}, [location.pathname]);
// Maps each restaurant on the table
function restaurantList() {
return restaurants.map((restaurant) => {
return <Restaurant restaurant={restaurant} key={restaurant._id} />;
});
}
// Retrieves the dynamic title based on current route
const getTitle = () => {
return location.pathname === "/browse"
? 'Filtered Restaurants (Queens, containing "Moon")'
: "All Restaurants";
};
// Displays the restaurants table
return (
<>
<h3 className="text-lg font-semibold p-4">{getTitle()}</h3>
<div className="border rounded-lg overflow-hidden">
<div className="relative w-full overflow-auto">
<table className="w-full caption-bottom text-sm">
<thead className="[&_tr]:border-b">
<tr className="border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted">
<th className="h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0">
Name
</th>
<th className="h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0">
Borough
</th>
<th className="h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0">
Cuisine
</th>
</tr>
</thead>
<tbody className="[&_tr:last-child]:border-0">
{restaurantList()}
</tbody>
</table>
</div>
</div>
</>
);
}

Finalmente, navegue hasta el archivo client/src/App.jsx. Este archivo es el componente principal de diseño y garantiza que el componente Navbar se renderice en la parte superior de cada página, encima del componente secundario. Pegue el siguiente código en este archivo:

react-quickstart/cliente/src/App.jsx
import { Outlet } from "react-router-dom";
import Navbar from "./components/Navbar";
const App = () => {
return (
<div className="w-full p-6">
<Navbar />
<Outlet />
</div>
);
};
export default App;

Por último, sigue los pasos de esta sección para ejecutar la aplicación y ver los datos del restaurante renderizados.

1

Navega al directorio react-quickstart/server y ejecuta el siguiente comando para iniciar el servidor:

node --env-file=config.env server

Si es exitoso, este comando muestra la siguiente información:

Pinged your deployment. You successfully connected to MongoDB!
Server listening on port 5050
2

En una ventana de terminal separada, navegue al directorio react-quickstart/client. Ejecuta el siguiente comando para arrancar el front end de React:

npm run dev

Si es exitoso, este comando muestra la siguiente información:

VITE v7.2.4 ready in 298 ms
➜ Local: http://localhost:5173/
➜ Network: use --host to expose
➜ press h + enter to show help
3

Abra la URL http://localhost:5173/, obtenida en el paso anterior. La página de destino inicial muestra una lista de todos los restaurantes de la sample_restaurants.restaurants colección:

La página de destino que muestra todos los restaurantes.

Luego, navegue a la URL http://localhost:5173/browse para ver los restaurantes que coinciden con la name borough consulta de los campos y:

La página web que muestra los restaurantes coincidentes

¡Felicitaciones por completar el tutorial de inicio rápido!

Después de completar estos pasos, tendrá una aplicación web React que se conecta a su implementación de MongoDB, ejecuta una consulta en datos de muestra del restaurante y presenta un resultado recuperado.

Para obtener más información sobre React, MongoDB y la pila MERN, consulte los siguientes recursos:

Volver

Integración de Angular

En esta página