Visão geral
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
Por que usar MongoDB em um aplicativo React?
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.
Tutorial de início rápido
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 .
Configurar seu projeto
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 .
Verifique os pré-requisitos
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. |
Criar um cluster MongoDB Atlas
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.
Crie seus diretórios de projeto
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
Modifique seu package.json arquivo
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.
Configurar o back-end
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.
Configure seu servidor web expresso
Crie um arquivo denominado server.js no seu diretório react-quickstart/server e cole o seguinte código:
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}`); });
Definir variáveis de ambiente
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.
Criar endpoints de API do servidor
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:
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
Configurar o front-end
Depois de configurar o backend do aplicativo, siga as etapas desta seção para configurar o React e adicionar os componentes do frontend.
Adicione o modelo do React
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.
Instalar o Tailwind CSS
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:
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";
Configure o roteador do React
Navegue até o arquivo client/src/main.jsx e cole o seguinte código:
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 componenteRestaurantList, que chama o ponto de extremidade da API/restaurant/para exibir todos os restaurantes/browse: Renderiza o componenteRestaurantList, que chama o ponto de extremidade da API/restaurant/browsepara exibir restaurantes filtrados
Criar os componentes
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:
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:
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:
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;
Execute seu aplicativo
Por fim, siga as etapas nesta seção para executar seu aplicação e visualizar os dados renderizados do restaurante.
Execute o aplicação do servidor
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
Executar o aplicação cliente
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
Abra o site do aplicação
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:

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

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.
Recursos adicionais
Para saber mais sobre React, MongoDB e a pilha MERN, consulte os seguintes recursos:
Documentação doReact
Documentaçãodo driver Node.js