前端之node.js的express和路由

m0_74242675

于 2024-02-09 16:33:18 发布

阅读量1k

点赞数 31

文章标签：前端 node.js express

本文链接：https://blog.csdn.net/m0_74242675/article/details/136087064

版权

Node.js是一种运行在服务器端的JavaScript运行环境，它支持异步事件驱动的编程模型，非常适合构建高性能的网络应用程序。Express是一个基于Node.js的开发框架，它提供了一些简单而灵活的工具，用于帮助我们构建Web应用程序和API。

Express框架提供了一套简洁、灵活的路由系统，用于定义和处理不同的HTTP请求。在Express中，路由用于将请求的URL路径与对应的处理函数关联起来。

在Express中，我们通过调用app.get()、app.post()、app.put()等方法来定义不同类型的HTTP请求。这些方法接受两个参数：URL路径模式和处理函数。当请求的URL路径与定义的模式匹配时，相应的处理函数将被调用。

以下是一个使用Express路由的简单示例：

const express = require('express');
const app = express();

// 定义根路径的处理函数
app.get('/', (req, res) => {
  res.send('Hello, World!');
});

// 定义/users路径的处理函数
app.get('/users', (req, res) => {
  res.send('List of users');
});

// 启动服务器监听端口
app.listen(3000, () => {
  console.log('Server started on port 3000');
});

在上面的示例中，我们定义了两个路由：根路径’/‘和’/users’。当用户在浏览器中访问根路径时，会返回Hello, World!；当用户访问’/users’时，会返回List of users。

Express的路由系统还支持路径参数和查询参数的定义，以及动态路由的使用。这使得我们能够更灵活地处理不同的HTTP请求，构建出更为复杂和功能强大的Web应用程序。

1-路由-基础1

在Web开发中，路由（Routing）是决定客户端请求如何映射到服务器端处理函数或控制器的过程。这里以Node.js中的Express框架为例，来说明基础路由的使用：

const express = require('express');
const app = express();

// 基础路由示例：定义一个主页路由，当用户访问应用的根URL时，返回欢迎消息
app.get('/', function(req, res) {
  res.send('Welcome to the homepage!');
});

// 定义一个关于页面的路由，例如 /about
app.get('/about', function(req, res) {
  res.send('This is the about page.');
});

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

在这个例子中：

app.get() 是Express中用于定义GET请求处理的路由方法。
第一个参数 '/' 表示匹配所有对应用根目录的GET请求。
第二个参数是一个回调函数，当请求匹配该路由时会被调用。此函数接收两个参数：请求对象（req）和响应对象（res）。在这里我们通过 res.send() 方法发送响应内容给客户端。

同样地，第二个路由 /about 将匹配指向 “http://localhost:3000/about” 的GET请求，并返回相应的内容。

启动服务器后，根据不同的URL路径，客户端将接收到由不同路由处理程序生成的响应。

2-路由-基础2

继续深入基础路由的例子，这次我们将在Express框架中添加动态路由参数和中间件的使用：

const express = require('express');
const app = express();

// 基础路由示例：定义用户详情页面的路由，带有动态用户ID参数
app.get('/users/:id', function(req, res) {
  const userId = req.params.id;
  // 在实际应用中，这里会从数据库或其他数据源获取用户信息
  let userInfo = { id: userId, name: 'John Doe' }; // 假设这是从数据库获取的数据
  res.send(`User details for user ID: ${userId} - Name: ${userInfo.name}`);
});

// 使用中间件来处理所有以 '/api/' 开头的请求
app.use('/api', function(req, res, next) {
  console.log('API middleware triggered');
  // 可在此处进行身份验证、日志记录等操作
  next(); // 调用next()将控制权传递给下一个匹配的路由处理器
});

// 定义一个API路由实例，该路由受上面中间件影响
app.get('/api/user', function(req, res) {
  res.json({ message: 'This is a response from the API endpoint.' });
});

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

在这个例子中：

动态路由 /users/:id 中的 :id 是一个占位符，它能捕获URL路径中对应的任何值，并可以通过 req.params.id 访问。
我们定义了一个中间件函数，它会应用于所有以 /api/ 开头的请求。在实际场景中，这可以用于全局处理API相关的功能，如权限检查或响应格式化。
当请求到达 /api/user 路由时，首先会执行前面定义的中间件，然后执行此处的路由处理器函数并返回JSON格式的数据。

这样就展示了如何在Express中使用基础路由结合动态参数和中间件来构建更复杂的应用逻辑。

3-路由-获取请求参数

在Express框架中，根据请求类型（GET、POST等）和路由定义的方式，获取请求参数有几种不同的方法。以下是获取不同类型的请求参数的示例：

查询字符串参数 (GET请求):
当URL中包含查询字符串时，例如http://localhost:3000/users?name=John&age=30，可以使用 req.query 来获取这些参数。

app.get('/users', function(req, res) {
  const name = req.query.name;
  const age = req.query.age;

  res.send(`User's name is ${name} and their age is ${age}.`);
});

路径参数:
对于带有动态部分的路由，如/users/:id，可以通过 req.params 获取路径参数。

app.get('/users/:id', function(req, res) {
  const userId = req.params.id;

  res.send(`The requested user ID is ${userId}.`);
});

请求体参数 (POST, PUT, PATCH请求):
对于发送JSON或表单数据的请求，可以通过 body-parser 中间件来解析请求体，并通过 req.body 访问。

首先安装 body-parser：

npm install body-parser

然后在应用中配置中间件并获取请求体参数：

const express = require('express');
const bodyParser = require('body-parser');

app.use(bodyParser.json()); // 用于处理JSON格式的请求体
app.use(bodyParser.urlencoded({ extended: true })); // 用于处理urlencoded格式的表单数据

app.post('/users', function(req, res) {
  const name = req.body.name;
  const email = req.body.email;

  res.send(`New user created with name: ${name} and email: ${email}`);
});

以上示例展示了如何在Express中根据不同类型的请求参数进行处理。

4-路由-静态资源

在Express中，处理静态资源（如图片、CSS文件、JavaScript文件等）通常通过使用内置的express.static()中间件来实现。以下是一个例子：

const express = require('express');
const app = express();

// 假设你的应用中有名为 'public' 的目录用于存放静态资源
app.use(express.static('public'));

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// 现在假设public目录结构如下：
// public/
// └── images/
//     ├── image1.jpg
//     └── image2.png

// 当用户访问 http://localhost:3000/images/image1.jpg 时
// Express会自动从public/images/image1.jpg路径提供该图片

// 同样地，访问 http://localhost:3000/images/image2.png
// 将返回public/images/image2.png文件内容

在这个例子中，express.static('public')告诉Express框架，所有以/public开头的请求都应该从项目根目录下的public文件夹中查找对应的静态文件并直接返回给客户端。

这样，无需编写额外的路由处理器函数，即可轻松托管静态资源。

5-express-介绍与安装

Express框架介绍

Express是Node.js中一个流行且强大的Web应用框架，它简化了HTTP服务器的开发过程，提供了丰富的中间件机制、路由控制等功能。Express基于Node.js的http模块构建，允许开发者快速创建可扩展的Web应用程序和API服务。

安装Express的例子

要在Node.js项目中安装Express，请按照以下步骤操作：

首先确保已经安装了Node.js环境，并在命令行工具（如终端或命令提示符）中进入你的项目目录。
使用npm（Node包管理器）全局安装或本地安装Express。对于大多数项目，我们通常选择本地安装以将Express作为项目的依赖项包含在内。

本地安装Express：
```
npm install express --save
```
或使用 yarn：
```
yarn add express
```
--save参数会自动将Express添加到项目根目录下的package.json文件中的dependencies部分。
安装完成后，在你的项目中可以像下面这样引入并开始使用Express：

// app.js 文件内容

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World from Express!');
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server running on http://localhost:${port}`);
});

在这个例子中，我们创建了一个简单的Express应用，它监听3000端口，并对根URL（“/”）的GET请求返回 “Hello World from Express!” 的响应。要运行此应用，请保存代码并在命令行中执行：

node app.js

现在打开浏览器访问 http://localhost:3000，你应该能看到页面上显示“Hello World from Express!”。

6-express-基本路由

在Express框架中，路由是决定HTTP请求如何映射到特定处理函数的关键部分。以下是一个使用Express创建基本路由的例子：

// 首先确保已经安装了express模块并导入它
const express = require('express');
const app = express();

// 定义一个简单的GET路由，当用户访问根路径（"/"）时返回欢迎信息
app.get('/', (req, res) => {
  res.send('Welcome to the home page!');
});

// 定义另一个GET路由，用于展示用户详情页面，URL路径为 "/users/:userId"
app.get('/users/:userId', (req, res) => {
  const userId = req.params.userId;
  // 在实际应用中，这里可能会查询数据库获取用户信息
  res.send(`Showing details for user with ID: ${userId}`);
});

// 启动服务器监听指定端口（例如3000）
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

在这个例子中：

第一个路由 app.get('/') 表示对应用程序的根地址（即 “http://localhost:3000/”）发起的GET请求，将响应一条欢迎消息。
第二个路由 app.get('/users/:userId') 是一个动态路由，其中 :userId 是一个参数占位符，可以捕获URL中的任何值。在请求处理器中，通过 req.params.userId 访问这个值。

运行此代码后，启动了一个监听3000端口的Express服务器，当访问不同路径时，会触发对应的路由处理函数并返回相应的响应内容。

7-express-中间件

在Express框架中，中间件（Middleware）是一个非常重要的概念，它是一个处理HTTP请求的函数，可以访问请求对象（req）、响应对象（res）和应用程序请求-响应循环中的下一个中间件函数。中间件可以在请求到达路由处理器之前执行各种操作，例如验证、日志记录、内容压缩等。

下面是一个使用Express中间件的例子：

const express = require('express');
const app = express();

// 自定义简单中间件示例1：记录请求日志
app.use((req, res, next) => {
  console.log(`Time: ${new Date()}, Request Type: ${req.method}, URL: ${req.originalUrl}`);
  next(); // 调用next()将控制权传递给下一个中间件或路由处理器
});

// 自定义简单中间件示例2：检查用户是否登录
let isLoggedIn = (req, res, next) => {
  if (req.session.isLoggedIn) { // 假设有一个session机制来判断用户是否登录
    return next(); // 用户已登录，调用next()继续后续流程
  }
  
  res.status(401).send('Unauthorized'); // 用户未登录，返回错误状态码和消息
};

// 使用中间件
app.use(isLoggedIn); // 这个中间件将应用于所有路由

// 定义一个路由
app.get('/', (req, res) => {
  res.send('Welcome to the homepage!');
});

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

在这个例子中：

首个中间件用于打印每次请求的日志信息。
isLoggedIn 是一个自定义中间件，用来检查请求中的会话信息以确定用户是否已登录。如果用户未登录，则直接发送未经授权的响应，否则允许请求继续传递至其他中间件或路由处理器。
中间件 isLoggedIn 应用于所有路由，因此对任何路由发起请求前都会先进行登录检查。

8-express-获取请求参数

在Express框架中，获取请求参数有多种方式，取决于参数类型和传递方式。这里给出几个常见的例子：

查询字符串参数（GET请求）:
当URL中包含查询字符串时，如 http://localhost:3000/users?name=John&age=30。

app.get('/users', (req, res) => {
  const name = req.query.name;
  const age = req.query.age;

  res.send(`User's name is ${name} and their age is ${age}.`);
});

路径参数（路由中的动态部分）:
对于定义了动态段的路由，如 /users/:userId。

app.get('/users/:userId', (req, res) => {
  const userId = req.params.userId;

  res.send(`The requested user ID is ${userId}.`);
});

请求体参数（POST, PUT等请求）:
当发送JSON或表单数据时，需要先使用中间件如 body-parser 解析请求体。

首先安装 body-parser：

npm install body-parser

然后在应用中配置并使用它：

const express = require('express');
const bodyParser = require('body-parser');

app.use(bodyParser.json()); // 用于解析JSON格式的请求体
app.use(bodyParser.urlencoded({ extended: true })); // 用于解析urlencoded格式的表单数据

app.post('/users', (req, res) => {
  const name = req.body.name;
  const email = req.body.email;

  res.send(`New user created with name: ${name} and email: ${email}`);
});

以上示例展示了如何在Express中根据不同类型的请求参数进行处理。

9-express-静态资源

在Express中托管静态资源，如图片、CSS样式表、JavaScript文件等，通常使用 express.static 中间件。下面是一个例子：

const express = require('express');
const app = express();

// 假设你有一个名为 'public' 的目录，其中包含了你的静态资源文件
app.use(express.static('public'));

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// 现在假设 public 目录结构如下：
// public/
// ├── css/
// │   └── style.css
// ├── js/
// │   └── script.js
// └── images/
//     ├── image1.jpg
//     └── image2.png

// 当用户访问 http://localhost:3000/css/style.css 时
// Express会自动从public/css/style.css路径提供该CSS文件

// 同样地，访问 http://localhost:3000/js/script.js 或 http://localhost:3000/images/image1.jpg
// 将分别返回public/js/script.js和public/images/image1.jpg文件内容

在这个例子中，express.static('public')告诉Express框架应该从应用根目录下的public子目录提供静态文件服务。任何指向这个目录及其子目录的请求都会被处理并返回对应的静态文件。

10-express-服务端渲染与客户端渲染-1

在Express框架中实现服务端渲染（Server-side Rendering, SSR）和客户端渲染（Client-side Rendering, CSR）的例子：

服务端渲染 (SSR) - 使用 EJS 模板引擎：

首先，确保已安装 express 和 ejs：

npm install express ejs

然后创建一个简单的 Express 应用并使用 EJS 进行服务端渲染：

const express = require('express');
const app = express();
app.set('view engine', 'ejs');

// 假设我们有一个数据对象
let users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' }
];

// 定义路由处理函数，渲染带有数据的模板
app.get('/', (req, res) => {
  res.render('index', { users });
});

// 设置静态文件目录以提供CSS、JavaScript等资源
app.use(express.static('public'));

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// 创建名为 "views/index.ejs" 的EJS模板文件，并插入以下内容来显示用户列表
<!-- views/index.ejs -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>用户列表</title>
  <!-- 引入静态资源如CSS或JavaScript -->
  <link rel="stylesheet" href="/styles.css">
</head>
<body>
  <ul>
    <% for(let user of users) { %>
      <li><%= user.name %></li>
    <% } %>
  </ul>
</body>
</html>

在这个例子中，当用户访问主页时，服务器会读取EJS模板并填充数据，生成完整的HTML页面发送给浏览器。

客户端渲染 (CSR) - 使用纯前端技术（例如React）：

对于客户端渲染应用，通常不直接在Express中渲染模板。而是让Express返回一个基本的HTML骨架，包含加载客户端JavaScript应用所需的引用。实际的应用逻辑将在浏览器中通过JavaScript执行。

假设我们有一个基于React的应用：

// server.js (Express服务器部分)
// 返回仅包含基础结构和引用客户端JavaScript的HTML页面
app.get('/', (req, res) => {
  res.send(`
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>客户端渲染应用</title>
      <link rel="stylesheet" href="/styles.css">
      <script src="/bundle.js"></script> <!-- React应用被打包后的文件 -->
    </head>
    <body>
      <div id="root"></div> <!-- React将在此处挂载组件 -->
    </body>
    </html>
  `);
});

// 公共静态资源路径设置同上
app.use(express.static('public'));

app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// client/App.js (React应用部分，需要构建后生成bundle.js)
import React from 'react';
import ReactDOM from 'react-dom';

function App() {
  const users = [/*...*/]; // 用户数据可以从API获取

  return (
    <ul>
      {users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

ReactDOM.hydrate(<App />, document.getElementById('root'));

在CSR的例子中，Express只负责提供初始的HTML结构以及静态资源，React应用的实际渲染过程发生在客户端，即用户的浏览器中。

11-express-服务端渲染与客户端渲染-2

服务端渲染 (SSR) - 使用 Express 和 Pug 模板引擎：

首先安装 express 和 pug：

npm install express pug

然后创建一个使用 Pug 进行服务端渲染的 Express 应用：

const express = require('express');
const app = express();
app.set('view engine', 'pug');

// 假设我们有一些数据
let products = [
  { id: 1, name: 'Product A' },
  { id: 2, name: 'Product B' }
];

// 定义路由处理函数，渲染带有数据的模板
app.get('/', (req, res) => {
  res.render('index', { products });
});

// 设置静态文件目录
app.use(express.static('public'));

// 启动服务器监听3000端口
app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// 创建名为 "views/index.pug" 的Pug模板文件，并插入以下内容来显示产品列表
// views/index.pug
doctype html
html(lang="en")
  head
    title 商品列表
    link(rel='stylesheet', href='/styles.css')
  body
    h1 商品列表
    ul
      each product in products
        li #{product.name}

客户端渲染 (CSR) - 使用 React 和 ReactDOM.render：

在这个例子中，Express 仅返回一个基本 HTML 文件，React 应用在客户端加载和渲染数据。

// server.js (Express服务器部分)
app.get('/', (req, res) => {
  res.send(`
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>客户端渲染应用</title>
      <link rel="stylesheet" href="/styles.css">
      <script src="/bundle.js"></script> <!-- 包含React应用的打包文件 -->
    </head>
    <body>
      <div id="root"></div>
    </body>
    </html>
  `);
});

// 公共静态资源路径设置同上
app.use(express.static('public'));

app.listen(3000, () => {
  console.log('Server is running on port 3000...');
});

// client/App.js (React应用部分)
import React from 'react';
import ReactDOM from 'react-dom';

class ProductList extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      products: [/*...*/] // 从API获取或预定义的产品数据
    };
  }

  render() {
    return (
      <ul>
        {this.state.products.map(product => (
          <li key={product.id}>{product.name}</li>
        ))}
      </ul>
    );
  }
}

// 在浏览器环境中执行时，ReactDOM.render 渲染组件到DOM节点
if (typeof window !== 'undefined') {
  ReactDOM.render(
    <ProductList />,
    document.getElementById('root')
  );
}

在 CSR 示例中，当用户访问主页时，Express 返回一个基础HTML页面，其中包含指向React应用程序包（bundle.js）的引用。React应用启动后，在客户端解析并渲染数据，生成动态用户界面。

12-express-生成器

Express 应用生成器可以帮助快速创建一个基于 Express.js 的基础项目结构。以下是一个使用 Express 生成器（express-generator）来创建新项目的例子：

步骤：

全局安装 express-generator：
```
npm install -g express-generator
```
创建新的 Express 应用，例如命名为 myapp 并使用 EJS 模板引擎（也可以是 Jade、Pug 或其他支持的模板引擎）：
```
express --view=ejs myapp
```
或者，如果你想要不指定模板引擎，默认会使用 Pug：
```
express myapp
```
进入新创建的项目目录并安装依赖：
```
cd myapp
npm install
```
启动项目：
```
npm start
```

这样，你就会得到一个基本的 Express 项目结构，其中包含了入口文件（app.js）、路由文件、静态资源目录、视图目录以及其他配置文件。默认情况下，生成的应用程序监听的是 3000 端口，访问 http://localhost:3000/ 即可看到 “Welcome to Express” 页面。

生成的项目结构大致如下：

myapp
├── app.js
├── bin
│   └── www
├── package.json
├── public
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.ejs
    └── index.ejs

现在你可以根据需要扩展和修改这个项目骨架以构建你的实际应用。

13-MongoDB-介绍

MongoDB 是一个流行的开源 NoSQL 数据库，它使用文档型数据模型进行数据存储。在 MongoDB 中，数据以 JSON-like 的格式（称为 BSON）存储在集合（collections）中，每个集合包含多个文档（documents），每个文档可以有任意数量的字段，并且结构可以动态变化。

以下是一个简单的 MongoDB 使用例子：

创建一个数据库和集合：
虽然在 MongoDB 中并不需要显式地创建数据库，但当你向不存在的数据库写入数据时，数据库会被自动创建。同样，当插入第一个文档到不存在的集合中时，集合也会被创建。

// 假设我们正在使用 MongoDB 的 Node.js 驱动程序
const MongoClient = require('mongodb').MongoClient;
const uri = 'mongodb://localhost:27017';

MongoClient.connect(uri, { useNewUrlParser: true }, (err, client) => {
  if (err) throw err;

  const db = client.db('myDatabase'); // 创建或连接到名为 myDatabase 的数据库
  const collection = db.collection('users'); // 指定或创建名为 users 的集合

  // 插入一个文档
  const userDocument = {
    _id: new ObjectId(), // 自动生成唯一 ID
    name: "John Doe",
    email: "john.doe@example.com",
    age: 30,
    hobbies: ["reading", "programming"],
    address: {
      street: "123 Main St.",
      city: "New York",
      country: "USA"
    }
  };

  collection.insertOne(userDocument, (err, result) => {
    if (err) throw err;
    console.log(`Inserted a document with id ${result.insertedId}`);
    // ...其他操作...
    
    // 关闭数据库连接
    client.close();
  });
});

在这个例子中，我们首先连接到本地 MongoDB 服务器，并指定要使用的数据库和集合。然后，我们创建了一个用户文档并将其插入到 users 集合中。这个用户文档具有丰富的结构，包括字符串、数字以及嵌套的对象和数组。

查询示例：
假设我们要从刚才创建的 users 集合中查找所有年龄大于 25 岁的用户：

collection.find({ age: { $gt: 25 } }).toArray((err, docs) => {
  if (err) throw err;
  
  console.log("Users older than 25:");
  docs.forEach(doc => console.log(doc));
});

以上代码会查询集合中的所有文档，其中 age 字段值大于 25 的文档将被返回并打印出来。

14-MongoDB-安装与启动

以下是一个在 Linux 系统中安装和启动 MongoDB 3.0.7 版本的例子：

安装 MongoDB

下载安装包：
首先，从官方地址下载适用于您 Linux 发行版的 MongoDB 安装包。例如，在命令行中执行（假设您正在使用的是支持 RHEL 6.2 的系统）：
```
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel62-3.0.7.tgz
```
解压压缩包：
解压缩下载的文件到 /usr/mongodb 目录下（如果您之前没有创建该目录，需要先创建）：
```
mkdir -p /usr/mongodb
tar xvzf mongodb-linux-x86_64-rhel62-3.0.7.tgz -C /usr/mongodb
```

安装准备：
将解压后的文件夹重命名为一个更简洁的名称以方便管理，如 mongodb：

mv /usr/mongodb/mongodb-linux-x86_64-rhel62-3.0.7 /usr/mongodb/mongodb

创建数据存储目录，例如在 /var/lib/mongodb：

sudo mkdir -p /var/lib/mongodb
sudo chown `id -u` /var/lib/mongodb

创建日志文件目录，例如在 /var/log/mongodb：

sudo mkdir -p /var/log/mongodb
sudo chown `id -u` /var/log/mongodb

设置开机自启动：
虽然上述步骤完成了 MongoDB 的基本安装，但为了能在系统启动时自动运行 MongoDB，通常需要创建一个 systemd 服务单元文件或编写 init.d 脚本来实现。对于较新版本的 Linux（如 Ubuntu 15.04 及以后版本，CentOS 7 及以后版本），可以创建一个 systemd 服务文件：
```
sudo nano /etc/systemd/system/mongod.service
```
在这个文件中写入如下内容（根据您的实际路径进行调整）：
```
[Unit]
Description=MongoDB Database Server
Documentation=https://docs.mongodb.org/manual
After=network.target

[Service]
User=mongodb
Group=mongodb
ExecStart=/usr/mongodb/mongodb/bin/mongod --dbpath /var/lib/mongodb --logpath /var/log/mongodb/mongodb.log --fork
Restart=always

[Install]
WantedBy=multi-user.target
```
接着启用并启动服务：
```
sudo systemctl daemon-reload
sudo systemctl enable mongod
sudo systemctl start mongod
```

检查 MongoDB 是否成功启动

通过检查日志或连接到数据库来确认 MongoDB 是否已经成功启动：

# 查看 MongoDB 是否正常运行
sudo systemctl status mongod

# 如果MongoDB 正在监听默认端口 27017，你可以尝试连接
mongo

现在您应该已经成功安装并启动了 MongoDB 服务，并且可以在系统启动时自动运行。请注意，上述步骤是基于较早的 MongoDB 版本和 Linux 环境，不同版本和环境可能需要不同的配置步骤，请根据实际情况查阅官方文档以获取最新指导。

15-MongoDB-命令行操作-1

在 MongoDB 命令行工具（mongo shell）中，你可以执行各种数据库操作。以下是一个使用命令行连接到 MongoDB 服务器、选择数据库并执行基本 CRUD 操作的例子：

启动 MongoDB 服务：
首先确保你的 MongoDB 服务已经启动。在终端中，如果你是在 Linux 或 macOS 系统上，可以运行 mongod（假设 MongoDB 已经正确安装并且配置了默认路径）。对于 Windows 用户，通常通过服务管理器或命令行启动。
打开 MongoDB Shell：
在另一个终端窗口中输入 mongo 来启动 MongoDB 的交互式 shell。
连接到 MongoDB 实例：
默认情况下，MongoDB shell 会连接到本地的 MongoDB 实例（端口为 27017），无需指定任何连接参数。
选择一个数据库：
如果你想使用或操作名为 “myDatabase” 的数据库，首先确认它是否存在，如果不存在则会被自动创建：
```
use myDatabase
```

插入数据：
插入一个文档到名为 “users” 的集合中：

db.users.insert({
  name: "John Doe",
  age: 30,
  email: "john.doe@example.com"
});

查询数据：
查询 “users” 集合中的所有文档：
```
db.users.find()
```
更新数据：
更新 “users” 集合中第一个名字为 “John Doe” 的文档，将年龄改为 31：
```
db.users.updateOne({ name: "John Doe" }, { $set: { age: 31 } });
```
删除数据：
删除 “users” 集合中第一个名字为 “John Doe” 的文档：
```
db.users.deleteOne({ name: "John Doe" });
```

请注意，以上操作都是在 MongoDB shell 中直接执行的 JavaScript 代码。在实际开发中，你也可以使用 Node.js 的 MongoDB 驱动程序或其他语言的客户端库来执行这些操作。

16-MongoDB-命令行操作-2

继续介绍 MongoDB 命令行操作的更多示例：

查询特定条件的数据：
查询 “users” 集合中所有年龄大于等于 30 的用户文档：
```
db.users.find({ age: { $gte: 30 } });
```
排序与分页：
查询 “users” 集合中的所有用户，并按年龄升序排序，只返回前5条记录：
```
db.users.find().sort({ age: 1 }).limit(5);
```

聚合操作：
计算 “users” 集合中用户的平均年龄：

db.users.aggregate([
  { $group: { _id: null, averageAge: { $avg: "$age" } } }
]);

创建索引：
在 “users” 集合的 “email” 字段上创建一个唯一索引：
```
db.users.createIndex({ email: 1 }, { unique: true });
```
切换数据库：
如果你想要从当前数据库切换到另一个已经存在的数据库（例如 “myOtherDatabase”），可以使用 use 命令：
```
use myOtherDatabase
```
显示所有集合：
显示当前选择数据库中的所有集合：
```
show collections
```
查看数据库统计信息：
获取当前选择数据库的统计信息，如数据大小、文件数量等：
```
db.stats()
```

以上就是在 MongoDB 命令行工具中进行的一些基本和进阶操作示例。通过这些命令，你可以直接管理数据库和集合，执行查询、更新、删除以及更复杂的数据库操作。

17-MongoDB-可视化操作

MongoDB 的可视化操作通常通过图形界面工具来实现，例如 MongoDB Compass、Robo 3T（以前称为 Robomongo）或 Studio 3T。以下是一个使用 MongoDB Compass 进行可视化操作的例子：

安装并启动 MongoDB Compass：
首先从 MongoDB 官方网站下载并安装 MongoDB Compass（https://www.mongodb.com/try/download/compass）。安装完成后，打开 MongoDB Compass 应用程序。
连接到 MongoDB 实例：
在 MongoDB Compass 中，提供连接信息以连接到您的 MongoDB 实例：
- Connection String (连接字符串)：根据你的 MongoDB 服务器设置填写，如 mongodb://localhost:27017 或者包含认证信息的完整连接字符串。
- Authentication (认证)：如果需要，输入数据库用户名和密码。
- Connect to a specific database (连接到特定数据库)：在这里选择或输入要连接的数据库名称。
查看与管理数据库和集合：
连接成功后，MongoDB Compass 将显示所有可用的数据库。选择一个数据库，左侧栏将列出该数据库下的所有集合（表）以及集合的基本统计信息。
查询数据：
- 点击一个集合，右侧区域将显示文档列表。
- 可以在顶部的搜索框中输入 JSON 格式的查询条件进行过滤。
- 使用工具栏上的按钮执行各种 CRUD 操作，例如插入新的文档、更新现有文档或删除文档。
可视化查询：
- MongoDB Compass 提供了可视化的查询构建器，可以帮助你构建复杂的查询而无需直接编写查询语句。
- 点击查询构建器图标，通过拖拽字段、选择比较运算符等方式构建查询条件，然后点击运行以查看结果。
索引管理：
- 在集合的详情页可以查看和管理索引。
- 可以创建新的索引，编辑现有索引，或者删除不再需要的索引。

这些是使用 MongoDB Compass 进行可视化操作的一些基本步骤。通过这样的图形化工具，用户可以更直观地管理和操作 MongoDB 数据库中的内容。

18-MongoDB-nodejs操作-1

以下是一个使用 Node.js 的 MongoDB 驱动（如 mongodb 或者更现代的驱动 mongoose）连接数据库并执行基本 CRUD 操作的例子：

假设我们使用原生的 mongodb 驱动进行操作：

const MongoClient = require('mongodb').MongoClient;
const uri = 'mongodb://localhost:27017/myDatabase';

// 创建一个异步函数以处理数据库操作
async function dbOperations() {
  // 连接到 MongoDB
  const client = await MongoClient.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true });
  console.log("Connected to MongoDB");

  // 选择指定数据库
  const db = client.db();
  
  // 选择或创建集合（表）
  const usersCollection = db.collection('users');

  // 插入数据
  const resultInsert = await usersCollection.insertOne({
    name: "John Doe",
    age: 30,
    email: "john.doe@example.com"
  });

  console.log(`Inserted document with ID: ${resultInsert.insertedId}`);

  // 查询数据
  const foundUser = await usersCollection.findOne({ name: "John Doe" });
  console.log("Found user:", foundUser);

  // 更新数据
  const updateResult = await usersCollection.updateOne(
    { _id: resultInsert.insertedId },
    { $set: { age: 31 } }
  );
  console.log(`Modified ${updateResult.modifiedCount} document(s)`);

  // 删除数据
  const deleteResult = await usersCollection.deleteOne({ name: "John Doe" });
  console.log(`Deleted ${deleteResult.deletedCount} document(s)`);

  // 关闭数据库连接
  await client.close();
}

// 执行数据库操作
dbOperations().catch(console.error);

请注意，以上代码示例使用了 async/await 语法，确保在 Node.js 环境下支持。同时，你需要先安装 MongoDB 驱动：

npm install mongodb

如果你正在使用 Mongoose，那么相关的操作会有所不同，但概念相似，例如：

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/myDatabase', { useNewUrlParser: true, useUnifiedTopology: true });

// 定义用户模型（Schema）
const UserSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String
});

const User = mongoose.model('User', UserSchema);

async function dbOperations() {
  // ...
  // 使用 Mongoose 插入数据
  const user = new User({ name: "John Doe", age: 30, email: "john.doe@example.com" });
  await user.save();

  // 查询数据
  const foundUser = await User.findOne({ name: "John Doe" });

  // 更新数据
  foundUser.age = 31;
  await foundUser.save();

  // 删除数据
  await User.deleteOne({ name: "John Doe" });

  // 关闭 Mongoose 连接（在应用退出时通常由 Mongoose 自动处理）
  // mongoose.connection.close();
}

// 执行数据库操作
dbOperations().catch(console.error);

在这两个例子中，我们首先连接到本地 MongoDB 实例，并与名为 “myDatabase” 的数据库交互。然后，在 “users” 集合上执行插入、查询、更新和删除等操作。

19-MongoDB-nodejs操作-2

继续介绍 Node.js 中使用 MongoDB 的更多操作示例，这次我们将展示如何使用 mongodb 驱动执行聚合操作和批量插入数据：

const MongoClient = require('mongodb').MongoClient;
const uri = 'mongodb://localhost:27017/myDatabase';

async function dbOperations() {
  const client = await MongoClient.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true });
  console.log("Connected to MongoDB");
  const db = client.db();
  const usersCollection = db.collection('users');

  // 插入多个文档（批量插入）
  const manyUsers = [
    { name: "Alice", age: 25, email: "alice@example.com" },
    { name: "Bob", age: 30, email: "bob@example.com" },
    { name: "Charlie", age: 35, email: "charlie@example.com" }
  ];

  const resultInsertMany = await usersCollection.insertMany(manyUsers);
  console.log(`Inserted ${resultInsertMany.insertedCount} documents with IDs:`, resultInsertMany.insertedIds);

  // 聚合操作 - 计算所有用户的平均年龄
  const avgAgeResult = await usersCollection.aggregate([
    { $group: { _id: null, averageAge: { $avg: "$age" } } }
  ]).toArray();

  console.log("Average age of all users:", avgAgeResult[0].averageAge);

  // 关闭数据库连接
  await client.close();
}

dbOperations().catch(console.error);

在这个例子中，我们首先展示了如何使用 insertMany() 方法一次性插入多个文档到集合中。然后，我们使用了 aggregate() 方法进行聚合操作，计算所有用户年龄的平均值。

请注意，实际开发时应确保在程序退出前关闭与数据库的连接，这里由于是演示代码，所以直接放在了一个函数内。在生产环境中，您可能需要处理连接异常、监听连接断开事件并重新连接等问题。
最后求点赞，求分享，求抱抱…

m0_74242675

关注

31
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
前端之node.js的express和路由

Express框架介绍Express是Node.js中一个流行且强大的Web应用框架，它简化了HTTP服务器的开发过程，提供了丰富的中间件机制、路由控制等功能。Express基于Node.js的http模块构建，允许开发者快速创建可扩展的Web应用程序和API服务。安装Express的例子要在Node.js项目中安装Express，请按照以下步骤操作：首先确保已经安装了Node.js环境，并在命令行工具（如终端或命令提示符）中进入你的项目目录。
复制链接

扫一扫