Menu Docs
Página inicial do Docs
/ /

Integre o MongoDB com o React

Neste guia, você pode aprender como criar um aplicação da web React que usa a pilha MERN. A pilha MERN é uma estrutura de desenvolvimento web que usa MongoDB, Express, React e Node.js e consiste nas seguintes camadas:

  • Camada de banco de dados: o MongoDB fornece armazenamento e recuperação de dados

  • Camada de aplicativo: Express e Node.js compõem a camada intermediária da lógica do lado do servidor

  • Camada de apresentação: o React implementa a interface do usuário e interações de front-end

Ao armazenar os dados do aplicação React no MongoDB, você pode usar o modelo de dados do documento para criar expressões de query complexas. A flexibilidade do modelo de documento permite armazenar estruturas de dados aninhadas e iterar rapidamente no design do aplicação . Você também pode expandir seu aplicação facilmente usando os recursos de dimensionamento horizontal do MongoDB.

A pilha MERN com MongoDB oferece suporte a aplicativos que exigem estruturas de dados dinâmicas e em evolução. Como resultado, essa estrutura é bem projetada para aplicativos do mundo real, como painéis em tempo real ou aplicativos de uma página que atualizam o conteúdo continuamente.

Este tutorial mostra como construir um aplicação da web usando a pilha MERN. O aplicação acessa dados de restaurantes de amostra, consulta os dados e exibe os resultados em um site hospedado localmente. O tutorial também inclui instruções sobre como se conectar a um cluster MongoDB hospedado no MongoDB Atlas e acessar e exibir dados de seu banco de dados.

Dica

Se você preferir se conectar ao MongoDB usando o driver Node.js sem React, consulte o guia Introdução ao driver Node.js .

Siga as etapas nesta seção para instalar as dependências do projeto , criar um cluster do Atlas e configurar os diretórios do aplicação .

1

Para criar o aplicativo Quick Start, você precisa do seguinte software instalado em seu ambiente de desenvolvimento:

Pré-requisitos
Notas

Baixe a versão LTS mais recente ou a versão mais recente.

Editor de código

Este tutorial utiliza o Visual Studio Code, mas você pode utilizar o editor de sua escolha.

Aplicativo de terminal e shell

Para usuários do MacOS, use o Terminal ou um aplicativo semelhante. Para usuários do Windows, use o PowerShell.

2

O MongoDB Atlas é um serviço de banco de dados de nuvem totalmente gerenciado que hospeda suas implementações do MongoDB . Se você não tiver uma implementação do MongoDB , poderá criar um cluster do MongoDB gratuitamente (nenhum cartão de crédito necessário) concluindo o tutorial de Introdução ao MongoDB . O tutorial de Introdução ao MongoDB também demonstra como carregar conjuntos de dados de exemplo em seu cluster, incluindo o sample_restaurants banco de dados usado neste tutorial.

Para se conectar ao cluster MongoDB , você deve usar um URI de conexão. Para saber como recuperar seu URI de conexão, consulte a seção Adicionar sua string de conexão do tutorial de Introdução ao MongoDB .

Dica

Salve sua string de conexão em um local seguro.

3

Execute o seguinte comando no seu terminal para criar um diretório para seu projeto denominado react-quickstart:

mkdir react-quickstart
cd react-quickstart

Em seguida, execute os seguintes comandos a partir do diretório react-quickstart para criar uma pasta para o backend denominada server e inicializar o arquivo package.json:

mkdir server
cd server
npm init -y
4

Navegue até o package.json arquivo no react-quickstart/server diretório. Para usar os módulos ECMAScript, o formato padrão para empacotar código JavaScript para reutilização, substitua a linha existente que especifica o "type" campo pela seguinte linha:

"type": "module",

Execute o seguinte comando para instalar as dependências mongodb, express e cors:

npm install mongodb express cors

Este comando instala o MongoDB , a estrutura da web Express e o pacote cors Node.js que permite o compartilhamento de recursos entre origens.

Após configurar a estrutura e as dependências do projeto , siga as etapas desta seção para configurar seu servidor da web e conectar-se ao MongoDB.

1

Crie um arquivo denominado server.js no seu diretório react-quickstart/server e cole o seguinte código:

react-quickstart/ servidor/ servidor.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

No diretório server, crie um arquivo config.env que armazena as seguintes variáveis:

MONGODB_URI=<connection URI>
PORT=5050

Substitua <connection URI> o espaço reservado pelo URI de conexão que você salvou em uma etapa anterior.

3

No diretório server, crie um subdiretório denominado routes. Crie um arquivo denominado restaurant.js no subdiretório routes e cole o seguinte código:

react-quickstart/ servidor/routes/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 arquivo acessa a coleção restaurants no banco de dados do sample_restaurants e define os seguintes endpoints do GET:

  • /: recupera todos os restaurantes da coleção de amostras

  • /browse: recupera restaurantes que correspondem aos critérios de query, que filtra restaurantes no Queins que contêm a palavra "Moon" no nome

Depois de configurar o backend do aplicativo, siga as etapas desta seção para configurar o React e adicionar os componentes do frontend.

1

No react-quickstart diretório, execute os seguintes comandos para adicionar os arquivos de modelo React usando Vite:

npm create vite@latest client

Este comando solicita que você responda a uma série de perguntas de configuração. Para cada pergunta, escolha as seguintes respostas no menu suspenso:

  • Selecione uma estrutura: React

  • Selecione uma variante: JavaScript

  • Usar rolldown-vite (experimental)?: Não

  • Instalar com npm e começar agora?: Não

Após executar o comando, seu projeto tem um diretório client que contém andaime front-end.

2

Este aplicação de exemplo usa o framework Tailwind CSS para formatação da UI. Para instalá-lo, navegue até o diretório client criado na etapa anterior e execute o seguinte comando:

npm install tailwindcss @tailwindcss/vite

Após instalar, navegue até seu arquivo vite.config.js. Adicione o plugin @tailwindcss/vite atualizando as declarações de importação e a array plugins, conforme mostrado nas linhas destacadas:

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()
],
})

Em seguida, navegue até o arquivo client/src/index.css e adicione a seguinte declaração de importação:

@import "tailwindcss";
3

Para habilitar o roteamento de página do lado do cliente para o React, instale o pacote react-router-dom executando o seguinte comando no diretório client:

npm install -D react-router-dom
4

Navegue até o arquivo client/src/main.jsx e cole o seguinte 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 arquivo configura o roteamento do lado do cliente e define as seguintes rotas:

  • /: Renderiza o componente RestaurantList, que chama o ponto de extremidade da API /restaurant/ para exibir todos os restaurantes

  • /browse: Renderiza o componente RestaurantList, que chama o ponto de extremidade da API /restaurant/browse para exibir restaurantes filtrados

5

Execute os seguintes comandos a partir do diretório client para criar uma nova pasta denominada components que contém dois arquivos:

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

O arquivo Navbar.jsx configura uma barra de navegação que vincula aos componentes necessários. Cole o seguinte código neste arquivo:

react-quickstart/ cliente/src/components/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>
);
}

O arquivo RestaurantList.jsx é o componente de visualização dos restaurantes e recupera e exibe as informações do restaurante. Cole o seguinte código neste arquivo:

react-quickstart/ cliente/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>
</>
);
}

Por fim, navegue até o arquivo client/src/App.jsx. Esse arquivo é o componente de layout principal e garante que o componente Navbar seja renderizado no topo de cada página acima do componente filho. Cole o seguinte código neste arquivo:

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 fim, siga as etapas nesta seção para executar seu aplicação e visualizar os dados renderizados do restaurante.

1

Navegue até o diretório react-quickstart/server e execute o seguinte comando para iniciar o servidor:

node --env-file=config.env server

Se bem-sucedido, este comando gera as seguintes informações:

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

Em uma janela de terminal separada, navegue até o diretório react-quickstart/client. Execute o seguinte comando para iniciar o front-end do React:

npm run dev

Se bem-sucedido, este comando gera as seguintes informações:

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 o http://localhost:5173/ URL, recuperado da etapa anterior. A página de destino inicial exibe uma lista de todos os restaurantes na sample_restaurants.restaurants coleção:

A página de destino que exibe todos os restaurantes

Em seguida, navegue até o URL http://localhost:5173/browse para visualizar os restaurantes que correspondem name à borough query de campo e:

A página web que exibe os restaurantes correspondentes

Parabéns por concluir o tutorial de início rápido!

Depois de concluir essas etapas, você tem um aplicação web React que se conecta à implantação do MongoDB , executa uma query em dados de restaurante de amostra e renderiza um resultado recuperado.

Para saber mais sobre React, MongoDB e a pilha MERN, consulte os seguintes recursos:

Voltar

Problemas e ajuda

Nesta página