## 技术栈
– Node.js + Express
– MySQL + Sequelize ORM
– Redis缓存
– Docker容器化

## 实现步骤

### 1. 项目初始化
$ mkdir nodejs-ecommerce
$ cd nodejs-ecommerce
$ npm init -y
$ npm install express mysql2 sequelize redis dotenv

### 2. 数据库配置
// config/database.js
const { Sequelize } = require(‘sequelize’);
require(‘dotenv’).config();

const sequelize = new Sequelize(
process.env.DB_NAME,
process.env.DB_USER,
process.env.DB_PASSWORD,
{
host: process.env.DB_HOST,
dialect: ‘mysql’,
logging: false
}
);

module.exports = sequelize;

### 3. 模型定义
// models/User.js
const { DataTypes } = require(‘sequelize’);
const sequelize = require(‘../config/database’);

const User = sequelize.define(‘User’, {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
name: {
type: DataTypes.STRING(50),
allowNull: false
},
email: {
type: DataTypes.STRING(100),
allowNull: false,
unique: true
},
password: {
type: DataTypes.STRING(255),
allowNull: false
}
});

module.exports = User;

// models/Product.js
const { DataTypes } = require(‘sequelize’);
const sequelize = require(‘../config/database’);

const Product = sequelize.define(‘Product’, {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
name: {
type: DataTypes.STRING(255),
allowNull: false
},
description: {
type: DataTypes.TEXT,
allowNull: false
},
price: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false
},
stock: {
type: DataTypes.INTEGER,
allowNull: false
}
});

module.exports = Product;

// models/Order.js
const { DataTypes } = require(‘sequelize’);
const sequelize = require(‘../config/database’);
const User = require(‘./User’);

const Order = sequelize.define(‘Order’, {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
userId: {
type: DataTypes.INTEGER,
allowNull: false,
references: {
model: User,
key: ‘id’
}
},
totalAmount: {
type: DataTypes.DECIMAL(10, 2),
allowNull: false
},
status: {
type: DataTypes.STRING(20),
allowNull: false,
defaultValue: ‘pending’
}
});

Order.belongsTo(User);
User.hasMany(Order);

module.exports = Order;

### 4. API实现
// routes/users.js
const express = require(‘express’);
const router = express.Router();
const User = require(‘../models/User’);

// 创建用户
router.post(‘/’, async (req, res) => {
try {
const user = await User.create(req.body);
res.status(201).json(user);
} catch (error) {
res.status(500).json({ error: error.message });
}
});

// 获取所有用户
router.get(‘/’, async (req, res) => {
try {
const users = await User.findAll();
res.json(users);
} catch (error) {
res.status(500).json({ error: error.message });
}
});

// 获取单个用户
router.get(‘/:id’, async (req, res) => {
try {
const user = await User.findByPk(req.params.id);
if (!user) {
return res.status(404).json({ message: ‘User not found’ });
}
res.json(user);
} catch (error) {
res.status(500).json({ error: error.message });
}
});

module.exports = router;

### 5. 主应用
// app.js
const express = require(‘express’);
const sequelize = require(‘./config/database’);
const userRoutes = require(‘./routes/users’);
const productRoutes = require(‘./routes/products’);
const orderRoutes = require(‘./routes/orders’);

const app = express();
app.use(express.json());

// 路由
app.use(‘/api/users’, userRoutes);
app.use(‘/api/products’, productRoutes);
app.use(‘/api/orders’, orderRoutes);

// 数据库连接
sequelize.sync()
.then(() => {
console.log(‘Database connected’);
app.listen(3000, () => {
console.log(‘Server running on port 3000’);
});
})
.catch(error => {
console.error(‘Database connection error:’, error);
});

### 6. 环境配置
// .env
DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=fgsales

### 7. Docker配置
// Dockerfile
FROM node:14

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

EXPOSE 3000

CMD [“node”, “app.js”]

// docker-compose.yml
version: ‘3.8’
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_DATABASE: fgsales
ports:
– “3306:3306”
volumes:
– mysql-data:/var/lib/mysql

app:
build: .
ports:
– “3000:3000”
depends_on:
– mysql
environment:
DB_HOST: mysql
DB_USER: root
DB_PASSWORD: password
DB_NAME: fgsales

volumes:
mysql-data:

### 8. 启动服务
$ docker-compose up -d

### 9. 测试API
$ curl -X POST http://localhost:3000/api/users -H “Content-Type: application/json” -d ‘{“name”: “风哥”, “email”: “fg@fgedu.net.cn”, “password”: “password123”}’

$ curl http://localhost:3000/api/users

$ curl http://localhost:3000/api/users/1

## 技术栈
– Python + Flask
– MySQL + SQLAlchemy ORM
– Pandas + Matplotlib
– Docker容器化

## 实现步骤

### 1. 项目初始化
$ mkdir python-analytics
$ cd python-analytics
$ python3 -m venv venv
$ source venv/bin/activate
$ pip install flask mysql-connector-python sqlalchemy pandas matplotlib

### 2. 数据库配置
# config.py
SQLALCHEMY_DATABASE_URI = ‘mysql://root:password@localhost/fgsales’
SQLALCHEMY_TRACK_MODIFICATIONS = False

### 3. 应用初始化
# app.py
from flask import Flask, render_template, jsonify
from flask_sqlalchemy import SQLAlchemy
import pandas as pd
import matplotlib.pyplot as plt
import io
import base64

app = Flask(__name__)
app.config.from_pyfile(‘config.py’)
db = SQLAlchemy(app)

### 4. 模型定义
# models.py
from app import db

class Sales(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer, nullable=False)
product_name = db.Column(db.String(255), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
price = db.Column(db.Float, nullable=False)
sale_date = db.Column(db.Date, nullable=False)
region = db.Column(db.String(100), nullable=False)

### 5. 数据分析API
# routes.py
from flask import Blueprint
from app import db
import pandas as pd
import matplotlib.pyplot as plt
import io
import base64
from models import Sales

analytics = Blueprint(‘analytics’, __name__)

@analytics.route(‘/sales-summary’)
def sales_summary():
# 从数据库获取数据
sales_data = Sales.query.all()

# 转换为DataFrame
df = pd.DataFrame([{
‘id’: sale.id,
‘product_id’: sale.product_id,
‘product_name’: sale.product_name,
‘quantity’: sale.quantity,
‘price’: sale.price,
‘sale_date’: sale.sale_date,
‘region’: sale.region
} for sale in sales_data])

# 计算总销售额
df[‘total’] = df[‘quantity’] * df[‘price’]
total_sales = df[‘total’].sum()

# 按产品分组
product_sales = df.groupby(‘product_name’)[‘total’].sum().sort_values(ascending=False)

# 按地区分组
region_sales = df.groupby(‘region’)[‘total’].sum().sort_values(ascending=False)

# 按日期分组
daily_sales = df.groupby(‘sale_date’)[‘total’].sum()

# 生成图表
plt.figure(figsize=(12, 6))

# 产品销售图表
plt.subplot(1, 3, 1)
product_sales.plot(kind=’bar’)
plt.title(‘Product Sales’)
plt.xticks(rotation=45)

# 地区销售图表
plt.subplot(1, 3, 2)
region_sales.plot(kind=’pie’, autopct=’%1.1f%%’)
plt.title(‘Region Sales’)

# 每日销售图表
plt.subplot(1, 3, 3)
daily_sales.plot(kind=’line’)
plt.title(‘Daily Sales’)
plt.xticks(rotation=45)

plt.tight_layout()

# 保存图表为base64
buffer = io.BytesIO()
plt.savefig(buffer, format=’png’)
buffer.seek(0)
image_base64 = base64.b64encode(buffer.getvalue()).decode(‘utf-8’)

return render_template(‘sales_summary.html’,
total_sales=total_sales,
product_sales=product_sales.to_dict(),
region_sales=region_sales.to_dict(),
daily_sales=daily_sales.to_dict(),
chart=image_base64)

### 6. 模板

Sales Summary

Total Sales: {{ total_sales }}

Product Sales

{% for product, sales in product_sales.items() %}
• {{ product }}: {{ sales }}

{% endfor %}

Region Sales

{% for region, sales in region_sales.items() %}
• {{ region }}: {{ sales }}

{% endfor %}

Daily Sales

{% for date, sales in daily_sales.items() %}
• {{ date }}: {{ sales }}

{% endfor %}

Sales Chart

### 7. 数据初始化
# init_data.py
from app import app, db
from models import Sales
from datetime import date

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

# 插入示例数据
sample_data = [
Sales(product_id=1, product_name=’Product A’, quantity=10, price=100, sale_date=date(2023, 1, 1), region=’North’),
Sales(product_id=2, product_name=’Product B’, quantity=20, price=50, sale_date=date(2023, 1, 1), region=’South’),
Sales(product_id=1, product_name=’Product A’, quantity=15, price=100, sale_date=date(2023, 1, 2), region=’East’),
Sales(product_id=3, product_name=’Product C’, quantity=5, price=200, sale_date=date(2023, 1, 2), region=’West’),
Sales(product_id=2, product_name=’Product B’, quantity=25, price=50, sale_date=date(2023, 1, 3), region=’North’),
]

for sale in sample_data:
db.session.add(sale)

db.session.commit()
print(‘Data initialized’)

### 8. Docker配置
# Dockerfile
FROM python:3.8

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD [“python”, “app.py”]

# requirements.txt
Flask
Flask-SQLAlchemy
mysql-connector-python
pandas
matplotlib

# docker-compose.yml
version: ‘3.8’
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_DATABASE: fgsales
ports:
– “3306:3306”
volumes:
– mysql-data:/var/lib/mysql

app:
build: .
ports:
– “5000:5000”
depends_on:
– mysql
environment:
FLASK_APP: app.py
FLASK_ENV: development

volumes:
mysql-data:

### 9. 启动服务
$ docker-compose up -d
$ docker-compose exec app python init_data.py

### 10. 访问应用
http://localhost:5000/sales-summary

## 技术栈
– Java + Spring Boot
– MySQL + Spring Data JPA
– Spring Security
– Docker容器化

## 实现步骤

### 1. 项目初始化
$ mkdir java-enterprise
$ cd java-enterprise
$ ./mvnw archetype:generate -DgroupId=com.fgedu -DartifactId=enterprise-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

### 2. 依赖配置



org.springframework.boot
spring-boot-starter-web


org.springframework.boot
spring-boot-starter-data-jpa


org.springframework.boot
spring-boot-starter-security


mysql
mysql-connector-java
runtime


org.springframework.boot
spring-boot-starter-test
test

### 3. 应用配置
# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/fgsales
spring.datasource.username=root
spring.datasource.password=password

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

spring.security.user.name=admin
spring.security.user.password=password

### 4. 模型定义
// src/main/java/com/fgedu/enterprise/app/model/User.java
package com.fgedu.enterprise.app.model;

import javax.persistence.*;

@Entity
@Table(name = “users”)
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;
private String email;
private String password;

// getters and setters
}

// src/main/java/com/fgedu/enterprise/app/model/Department.java
package com.fgedu.enterprise.app.model;

import javax.persistence.*;
import java.util.List;

@Entity
@Table(name = “departments”)
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;
private String description;

@OneToMany(mappedBy = “department”)
private List employees;

// getters and setters
}

// src/main/java/com/fgedu/enterprise/app/model/Employee.java
package com.fgedu.enterprise.app.model;

import javax.persistence.*;

@Entity
@Table(name = “employees”)
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;
private String position;
private double salary;

@ManyToOne
@JoinColumn(name = “department_id”)
private Department department;

// getters and setters
}

### 5. 仓库定义
// src/main/java/com/fgedu/enterprise/app/repository/UserRepository.java
package com.fgedu.enterprise.app.repository;

import com.fgedu.enterprise.app.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository {
User findByEmail(String email);
}

// src/main/java/com/fgedu/enterprise/app/repository/DepartmentRepository.java
package com.fgedu.enterprise.app.repository;

import com.fgedu.enterprise.app.model.Department;
import org.springframework.data.jpa.repository.JpaRepository;

public interface DepartmentRepository extends JpaRepository {
}

// src/main/java/com/fgedu/enterprise/app/repository/EmployeeRepository.java
package com.fgedu.enterprise.app.repository;

import com.fgedu.enterprise.app.model.Employee;
import org.springframework.data.jpa.repository.JpaRepository;

public interface EmployeeRepository extends JpaRepository {
}

### 6. 服务层
// src/main/java/com/fgedu/enterprise/app/service/UserService.java
package com.fgedu.enterprise.app.service;

import com.fgedu.enterprise.app.model.User;
import com.fgedu.enterprise.app.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {
@Autowired
private UserRepository userRepository;

@Autowired
private PasswordEncoder passwordEncoder;

public User save(User user) {
user.setPassword(passwordEncoder.encode(user.getPassword()));
return userRepository.save(user);
}

public User findByEmail(String email) {
return userRepository.findByEmail(email);
}
}

// src/main/java/com/fgedu/enterprise/app/service/DepartmentService.java
package com.fgedu.enterprise.app.service;

import com.fgedu.enterprise.app.model.Department;
import com.fgedu.enterprise.app.repository.DepartmentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DepartmentService {
@Autowired
private DepartmentRepository departmentRepository;

public List findAll() {
return departmentRepository.findAll();
}

public Department save(Department department) {
return departmentRepository.save(department);
}
}

### 7. 控制器
// src/main/java/com/fgedu/enterprise/app/controller/UserController.java
package com.fgedu.enterprise.app.controller;

import com.fgedu.enterprise.app.model.User;
import com.fgedu.enterprise.app.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(“/api/users”)
public class UserController {
@Autowired
private UserService userService;

@PostMapping
public User create(@RequestBody User user) {
return userService.save(user);
}

@GetMapping(“/{email}”)
public User findByEmail(@PathVariable String email) {
return userService.findByEmail(email);
}
}

// src/main/java/com/fgedu/enterprise/app/controller/DepartmentController.java
package com.fgedu.enterprise.app.controller;

import com.fgedu.enterprise.app.model.Department;
import com.fgedu.enterprise.app.service.DepartmentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping(“/api/departments”)
public class DepartmentController {
@Autowired
private DepartmentService departmentService;

@GetMapping
public List findAll() {
return departmentService.findAll();
}

@PostMapping
public Department create(@RequestBody Department department) {
return departmentService.save(department);
}
}

### 8. 主应用
// src/main/java/com/fgedu/enterprise/app/Application.java
package com.fgedu.enterprise.app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

### 9. Docker配置
# Dockerfile
FROM openjdk:11-jdk-slim

WORKDIR /app

COPY target/enterprise-app-1.0-SNAPSHOT.jar app.jar

EXPOSE 8080

CMD [“java”, “-jar”, “app.jar”]

# docker-compose.yml
version: ‘3.8’
services:
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_DATABASE: fgsales
ports:
– “3306:3306”
volumes:
– mysql-data:/var/lib/mysql

app:
build: .
ports:
– “8080:8080”
depends_on:
– mysql
environment:
SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/fgsales
SPRING_DATASOURCE_USERNAME: root
SPRING_DATASOURCE_PASSWORD: password

volumes:
mysql-data:

### 10. 构建和运行
$ ./mvnw package
$ docker-compose up -d

### 11. 测试API
$ curl -X POST http://localhost:8080/api/users -H “Content-Type: application/json” -d ‘{“name”: “风哥”, “email”: “fg@fgedu.net.cn”, “password”: “password123”}’ -u admin:password

$ curl http://localhost:8080/api/departments -H “Content-Type: application/json” -d ‘{“name”: “IT Department”, “description”: “Information Technology Department”}’ -u admin:password

$ curl http://localhost:8080/api/departments -u admin:password