一溪风江月
0%

后端开发实战：Flask/Django/Node.js

发表于 阅读次数： 4000 13 分钟

后端开发是Web应用的核心，负责处理业务逻辑、数据存储和API接口。本文将带你学习三种主流的后端技术：Python的Flask和Django框架，以及Node.js平台，掌握API开发、数据库操作和服务器部署等核心技能。

Flask 轻量级 Python 框架

Flask是一个轻量级的Python Web框架，简单灵活，适合快速开发小型项目和API服务。

Flask 基础入门

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 安装 Flask
# pip install flask

from flask import Flask, jsonify, request

app = Flask(__name__)

# 简单路由
@app.route('/')
def index():
    return 'Hello, Flask!'

# JSON 响应
@app.route('/api/users')
def get_users():
    users = ['Alice', 'Bob', 'Charlie']
    return jsonify({'users': users})

# POST 请求
@app.route('/api/users', methods=['POST'])
def create_user():
    data = request.get_json()
    return jsonify({'message': 'User created', 'data': data}), 201

# 动态路由
@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    return jsonify({'user_id': user_id})

if __name__ == '__main__':
    app.run(debug=True)

Flask-SQLAlchemy 数据库操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# pip install flask-sqlalchemy
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mydb.db'
db = SQLAlchemy(app)

# 定义模型
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

def to_dict(self):
        return {'id': self.id, 'name': self.name, 'email': self.email}

# 创建表
with app.app_context():
    db.create_all()

# 添加数据
user = User(name='Alice', email='alice@example.com')
db.session.add(user)
db.session.commit()

# 查询数据
users = User.query.all()
user = User.query.get(1)
user = User.query.filter_by(name='Alice').first()

# 更新数据
user.name = 'Alice Smith'
db.session.commit()

# 删除数据
db.session.delete(user)
db.session.commit()

Django 全功能 Python 框架

Django是一个功能强大的Python Web框架，提供了完整的ORM、认证系统、管理后台等功能，适合大型项目开发。

Django 项目创建

1
2
3
4
5
6
7
8
9
10
# 安装 Django
pip install django

# 创建项目
django-admin startproject myproject
cd myproject

# 创建应用
python manage.py startapp myapp

# 运行开发服务器
python manage.py runserver

Django 模型和视图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# models.py
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    published_date = models.DateField()

    def __str__(self):
        return self.title

# views.py
from django.http import JsonResponse
from .models import Book

def book_list(request):
    books = Book.objects.all()
    data = [
        {'id': book.id, 'title': book.title,
         'author': book.author, 'price': str(book.price)}
        for book in books
    ]
    return JsonResponse({'books': data})

def book_detail(request, pk):
    book = Book.objects.get(pk=pk)
    data = {
        'id': book.id,
'title': book.title,
        'author': book.author,
'price': str(book.price)
    }
    return JsonResponse(data)

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('books/', views.book_list, name='book-list'),
    path('books/<int:pk>/', views.book_detail, name='book-detail'),
]

Django REST Framework

Django REST Framework是Django的REST API框架，提供了强大的序列化和视图功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# pip install djangorestframework
from rest_framework import serializers, viewsets
from .models import Book

# 序列化器
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'price', 'published_date']

# 视图集
class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import BookViewSet

router = DefaultRouter()
router.register(r'books', BookViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

Node.js 后端开发

Node.js是基于Chrome V8引擎的JavaScript运行时，使用JavaScript开发后端服务，适合构建高并发应用。

Express 框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// npm init -y
// npm install express

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

// 中间件
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 简单路由
app.get('/', (req, res) => {
    res.send('Hello, Express!');
});

// JSON 响应
app.get('/api/users', (req, res) => {
    const users = ['Alice', 'Bob', 'Charlie'];
    res.json({ users });
});

// POST 请求
app.post('/api/users', (req, res) => {
    const data = req.body;
    res.status(201).json({ message: 'User created', data });
});

// 动态路由
app.get('/api/users/:id', (req, res) => {
    res.json({ userId: req.params.id });
});

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

Node.js 数据库操作 - Mongoose

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// npm install mongoose
const mongoose = require('mongoose');

// 连接数据库
mongoose.connect('mongodb://localhost:27017/mydb')
    .then(() => console.log('Connected to MongoDB'))
    .catch(err => console.error('Connection error', err));

// 定义模式和模型
const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    age: { type: Number, default: 0 }
});

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

// 创建用户
const user = new User({
    name: 'Alice',
    email: 'alice@example.com',
    age: 25
});
await user.save();

// 查询用户
const users = await User.find();
const user = await User.findById(id);
const user = await User.findOne({ name: 'Alice' });

// 更新用户
await User.findByIdAndUpdate(id, { name: 'Alice Smith' });

// 删除用户
await User.findByIdAndDelete(id);

Koa 框架

Koa是Express团队开发的新一代Node.js框架，使用async/await语法，更简洁优雅。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// npm install koa koa-router koa-bodyparser
const Koa = require('koa');
const Router = require('koa-router');
const bodyParser = require('koa-bodyparser');

const app = new Koa();
const router = new Router();

// 中间件
app.use(bodyParser());

// 路由
router.get('/', async (ctx) => {
    ctx.body = 'Hello, Koa!';
});

router.get('/api/users', async (ctx) => {
    ctx.body = { users: ['Alice', 'Bob'] };
});

router.post('/api/users', async (ctx) => {
    const data = ctx.request.body;
    ctx.status = 201;
    ctx.body = { message: 'User created', data };
});

app.use(router.routes());
app.listen(3000);

后端部署

Python 应用部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 使用 Gunicorn 部署 Flask/Django
pip install gunicorn

# Flask 部署
gunicorn -w 4 -b 0.0.0.0:8000 app:app

# Django 部署
gunicorn -w 4 -b 0.0.0.0:8000 myproject.wsgi:application

# Nginx 配置
# /etc/nginx/sites-available/myapp
server {
    listen 80;
    server_name example.com;
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
    }
}

Node.js 应用部署

1
2
3
4
5
6
7
8
9
10
# 使用 PM2 管理 Node.js 进程
npm install -g pm2

# 启动应用
pm2 start app.js --name myapp

# 管理命令
pm2 list
pm2 restart myapp
pm2 logs myapp

总结

后端开发是Web应用的核心，掌握Flask、Django和Node.js三种技术可以应对不同场景的需求：

  • Flask：轻量级，适合小型项目和API服务
  • Django：全功能框架，适合大型企业级项目
  • Node.js：高并发，适合实时应用和微服务

学习后端开发需要掌握：路由配置、数据库操作、API设计、身份认证、服务器部署等核心技能。希望本文能帮助你快速入门后端开发！

-------------本文结束感谢您的阅读-------------

欢迎关注我的其它发布渠道