智能健身饮食规划平台：AI驱动的健康管理系统

---

🏠 项目展示

FitPro 是一个功能完整、设计精美的智能健身饮食规划Web应用。它将AI智能推荐与数据记录管理完美结为用户提供全方位的健康管理体验。

项目概述

设计背景

在现代都市生活中，越来越多的人开始关注健康管理，但面临以下痛点：

• 专业指导成本高：私人健身教练和营养师服务价格昂贵
• 传统APP功能单一：大多数健身应用只是简单的数据记录工具
• 缺乏个性化方案：通用的健身计划难以满足每个人的特定需求
• 数据管理分散：饮食、运动、体重数据分散在不同平台，难以统一分析

正是在这样的背景下，我们设计并开发了FitPro智能健身饮食规划平台。

项目特色

这个平台是一个完整的Web应用，具有以下特色：

• 前后端分离架构：前端使用原生JS，后端使用FastAPI，技术栈简洁高效
• Dify AI工作流集成：利用AI生成真正个性化的健身计划和饮食建议
• 完整的数据记录闭环：形成"记录→分析→建议→再记录"的完整健康管理流程
• 精美的UI设计：现代化的界面设计，优秀的用户体验

技术架构

整体架构与业务逻辑

┌─────────────────┐
│   前端界面      │  HTML/CSS/JavaScript + Axios
└────────┬────────┘
         │ HTTP/REST API
         ↓
┌─────────────────┐
│  FastAPI后端    │  Python + SQLAlchemy + Pydantic
└────────┬────────┘
         │
    ┌────┴────┐
    ↓         ↓
┌───────┐ ┌─────────┐
│ MySQL │ │ Dify AI │
└───────┘ └─────────┘

技术选型说明

后端技术栈：

• FastAPI：目前Python生态中性能最好的Web框架之一，自带Swagger API文档，开发效率高
• SQLAlchemy 2.0：强大的ORM框架，用于数据库操作
• Pydantic：数据验证和序列化
• JWT：身份认证
• MySQL：关系型数据库，存储用户数据和记录

前端技术栈：

• 原生HTML/CSS/JavaScript：无需构建工具，部署简单
• Axios：HTTP客户端，用于API通信

AI服务：

• Dify：开源的AI应用开发平台，提供可视化工作流编排，用于生成个性化建议

项目结构

智能健身系统/
├── backend/
│   ├── app/
│   │   ├── api/              # API路由层
│   │   │   ├── auth.py       # 认证相关接口
│   │   │   ├── body_data.py  # 身体数据接口
│   │   │   ├── diet.py       # 饮食记录接口
│   │   │   ├── exercise.py   # 运动记录接口
│   │   │   └── ai.py         # AI功能接口
│   │   ├── core/             # 核心模块
│   │   │   ├── config.py     # 配置
│   │   │   └── security.py   # 安全认证
│   │   ├── models/           # 数据库模型
│   │   ├── schemas/          # Pydantic验证模型
│   │   ├── crud/             # 数据库操作
│   │   ├── services/         # 业务服务
│   │   │   └── dify_service.py # Dify AI服务
│   │   └── main.py           # 应用入口
│   └── requirements.txt
└── frontend/
    ├── index.html
    ├── css/styles.css
    └── js/
        ├── main.js           # 主逻辑
        ├── auth-api.js       # 认证
        ├── body-data.js      # 身体数据
        ├── diet.js           # 饮食记录
        ├── exercise.js       # 运动记录
        └── ai.js             # AI功能

核心功能模块详解

1. 用户认证模块

我们采用JWT（JSON Web Token）机制实现身份认证。

核心代码示例：

from datetime import datetime, timedelta
from typing import Optional
from jose import JWTError, jwt
from passlib.context import CryptContext

from app.core.config import get_settings

settings = get_settings()

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def verify_password(plain_password: str, hashed_password: str) -> bool:
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password: str) -> str:
    return pwd_context.hash(password)

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=settings.JWT_ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})

    encoded_jwt = jwt.encode(to_encode,
                             settings.JWT_SECRET_KEY,
                             algorithm=settings.JWT_ALGORITHM)
    return encoded_jwt

认证流程：

1. 用户输入邮箱和密码登录
2. 后端验证密码，使用bcrypt加密存储和比对
3. 验证成功后生成JWT Token返回给前端
4. 前端将Token存储在localStorage中
5. 后续请求在Header中携带Token
6. 后端验证Token并获取用户信息

前端Token管理：

const apiClient = axios.create({
    baseURL: API_BASE_URL,
    timeout: 60000,
    headers: {
        'Content-Type': 'application/json'
    }
});

apiClient.interceptors.request.use(
    (config) => {
        const token = localStorage.getItem('token');
        if (token) {
            config.headers.Authorization = `Bearer ${token}`;
        }
        return config;
    },
    (error) => {
        return Promise.reject(error);
    }
);

apiClient.interceptors.response.use(
    (response) => response,
    (error) => {
        console.error('API Error:', error);
        if (error.response && error.response.status === 401) {
            localStorage.removeItem('token');
            localStorage.removeItem('user');
            // 自动跳转到登录页
            document.querySelectorAll('.page').forEach(page => page.classList.remove('active'));
            const loginPage = document.getElementById('login-page');
            if (loginPage) {
                loginPage.classList.add('active');
            }
        }
        return Promise.reject(error);
    }
);

2. 数据库设计

系统设计了4张核心数据表：

from sqlalchemy import Column, Integer, String, Float, DateTime
from sqlalchemy.sql import func
from sqlalchemy.orm import relationship
from app.database import Base

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    username = Column(String(50), unique=True, index=True, nullable=False)
    email = Column(String(100), unique=True, index=True, nullable=False)
    hashed_password = Column(String(255), nullable=False)
    
    height = Column(Float)
    weight = Column(Float)
    age = Column(Integer)
    gender = Column(String(10))
    body_fat_rate = Column(Float)
    activity_level = Column(String(20))
    
    daily_calorie_target = Column(Float)
    
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    
    diet_records = relationship("DietRecord", back_populates="user", cascade="all, delete-orphan")
    exercise_records = relationship("ExerciseRecord", back_populates="user", cascade="all, delete-orphan")
    fitness_plans = relationship("FitnessPlan", back_populates="user", cascade="all, delete-orphan")
    weight_trends = relationship("WeightTrend", back_populates="user", cascade="all, delete-orphan")

其他核心表：

• diet_records：饮食记录表
• exercise_records：运动记录表
• weight_trends：体重趋势表

所有表都通过外键与用户表关联，并设置了级联删除，保证数据一致性。

3. CRUD操作层

我将数据库操作封装在独立的CRUD层中，实现了关注点分离。

from sqlalchemy.orm import Session
from typing import Optional
from app.models.user import User
from app.schemas.user import UserCreate, UserUpdate
from app.core.security import get_password_hash, verify_password

def get_user(db: Session, user_id: int) -> Optional[User]:
    return db.query(User).filter(User.id == user_id).first()

def get_user_by_email(db: Session, email: str) -> Optional[User]:
    return db.query(User).filter(User.email == email).first()

def create_user(db: Session, user: UserCreate) -> User:
    hashed_password = get_password_hash(user.password)
    db_user = User(
        username=user.username,
        email=user.email,
        hashed_password=hashed_password
    )
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

def update_user(db: Session, user_id: int, user_update: UserUpdate) -> Optional[User]:
    db_user = get_user(db, user_id)
    if not db_user:
        return None
    
    update_data = user_update.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(db_user, field, value)
    
    db.commit()
    db.refresh(db_user)
    return db_user

4. Dify AI工作流集成

这是整个系统最核心的部分！我们通过Dify工作流提供智能建议。

import httpx
from app.core.config import get_settings

settings = get_settings()

async def call_dify_workflow(inputs: dict) -> str:
    """
    调用Dify工作流并返回结果
    """
    print(f"🔗 调用Dify工作流: {settings.DIFY_WORKFLOW_URL}")
    print(f"📤 发送数据: {inputs}")

    headers = {
        "Authorization": f"Bearer {settings.DIFY_API_KEY_WORKFLOW}",
        "Content-Type": "application/json"
    }

    data = {
        "inputs": inputs,
        "response_mode": "blocking",
        "user": "user-1"
    }

    try:
        async with httpx.AsyncClient(timeout=120) as client:
            response = await client.post(
                settings.DIFY_WORKFLOW_URL,
                headers=headers,
                json=data
            )

        print(f"📥 Dify响应状态: {response.status_code}")

        if response.status_code != 200:
            return f"Dify调用失败 (状态码: {response.status_code})"

        result = response.json()

        if result.get("data") and result["data"].get("outputs"):
            outputs = result["data"]["outputs"]
            if outputs.get("answer"):
                return outputs["answer"]

        return str(result)

    except Exception as e:
        print(f"❌ 请求异常: {e}")
        return f"请求失败: {str(e)}"

async def generate_fitness_plan(height: float, weight: float, user_data: dict) -> dict:
    """
    生成健身计划
    """
    inputs = {
        "query": f"身高: {height}cm, 体重: {weight}kg，请生成健身计划",
        "user": f"user_{user_data.get('user_id', 'unknown')}",
        "weight": str(weight),
        "height": str(height),
        "age": str(user_data.get('age', '')),
        "gender": str(user_data.get('gender', '')),
        "calorie_target": str(user_data.get('daily_calorie_target', 2000))
    }

    answer = await call_dify_workflow(inputs)

    bmi = round(weight / ((height / 100) ** 2), 1) if height > 0 else 0

    return {
        "success": True,
        "fitness_plan": answer,
        "bmi": bmi,
        "height": height,
        "weight": weight
    }

设计思路：

1. 不是直接将用户原始数据丢给AI
2. 先在系统中进行业务计算（如剩余热量 = 目标 - 已摄入）
3. 然后将计算结果作为上下文传给Dify
4. 这样AI生成的建议更加精准和个性化

---

界面功能详细展示

FitPro拥有五个核心功能页面，每个页面都经过精心设计，提供优秀的用户体验。

1. 登录/注册页面

登录页面采用左右分栏设计：

• 左侧展示区：渐变橙色主题色，展示品牌Logo和功能亮点预览
• 右侧表单区：支持登录和注册Tab切换，表单设计简洁优雅
  

[前端代码展示：

<div class="login-container">
    <div class="login-left">
        <div class="logo">
            <div class="logo-icon">💪</div>
            <h1>FitPro</h1>
        </div>
        <p class="tagline">开启您的健康之旅</p>
    </div>
    <div class="login-right">
        <!-- 登录/注册表单
    </div>
</div>

---

2. 仪表盘页面

这是用户登录后的首页，设计了五个统计卡片：

卡片功能	说明
**今日摄入	显示今日已摄入热量与目标热量
运动消耗	今日运动消耗的热量统计
今日饮水	可视化进度条 + 8个水杯展示
当前体重	最新记录的体重数据
连续打卡	展示用户坚持记录的天数

喝水功能亮点：

• 8个水杯可视化进度条，每喝一杯水点亮一个
• 支持一键+1杯、+2杯快捷按钮
• 实时计算剩余可摄入热量 = 目标 - 已摄入 + 运动消耗

---

3. 饮食记录页面

**特色功能：

• 早餐、午餐、晚餐、加餐四餐分类
• 预设常见食物快速选择
• 实时计算本餐热量
• AI健康做法查询（集成Dify AI）

**快速食物预设示例：

• 预设了米饭、面条、鸡胸肉、蔬菜等常见食物，点击即可快速添加
  

---

🏃 4. 运动记录页面

特色功能：

• 多种运动类型选择（跑步、骑行、游泳等
• 输入时长自动计算热量消耗
• AI运动指导查询
• 运动历史记录列表
  

热量自动计算公式：

// 根据运动类型的MET值计算消耗
const metValues = {
    'running': 10,
    'cycling': 8,
    'swimming': 12,
    'gym': 7,
    'yoga': 4
};
const caloriesBurned = met * weight * (duration / 60);

---

5. 健康数据页面

**身体数据管理：

• 身高、体重、年龄、性别基础信息
• 活动水平和健身目标设定
• 自动计算BMI、基础代谢率（BMR）
• 每日目标热量推荐

计算公式：

• BMI = 体重(kg) / 身高²(m)
• 男性BMR = 10 × 体重 + 6.25 × 身高 - 5 × 年龄 + 5
• 女性BMR = 10 × 体重 + 6.25 × 身高 - 5 × 年龄 - 161
  

---

6. AI智能助手页面

四大AI智能功能，是整个应用的核心：

1. **个性化健身计划生成
2. **智能饮食计划推荐
3. **食材健康做法查询
4. **运动动作指导建议
   

---

UI设计特色与前端实现

设计理念

FitPro的UI设计遵循以下原则：

1. 直观性：用户无需学习即可上手
2. 一致性：色彩、间距、组件风格统一
3. 反馈性：用户操作有明确的视觉反馈
4. 美观性：现代化的渐变设计与卡片布局

色彩系统

主色调：橙色渐变 (#FF7D29 → #E66A1C)

• 象征活力、健康、积极向上

功能色彩：

• 绿色 ：摄入、健康、成功
• 蓝色 ：饮水、信息、中性
• 橙色 ：运动、消耗、活力
• 红色 ：警告、删除、错误

[CSS变量定义示例：

:root {
    --primary: #FF7D29;
    --primary-light: #FFB380;
    --primary-dark: #E66A1C;
    --success: #10B981;
    --info: #3B82F6;
    --warning: #F59E0B;
}

布局架构

**主应用布局采用经典的侧边栏+内容区设计：

┌─────────────────────────────────────────┐
│  Sidebar          │    Main Content     │
│                   │                     │
│  📊 仪表盘       │  [Top Bar]          │
│  🍽️ 饮食记录    │                     │
│  🏃 运动记录    │  [Content Cards]    │
│  ⚖️ 健康数据    │                     │
│  🤖 AI助手      │                     │
│                   │                     │
│  [User Info]      │                     │
└─────────────────────────────────────────┘

交互细节

1. 按钮悬停效果：

   • 上移 2px + 阴影加深
   • 给用户明确的可点击反馈

2. Toast通知：

   • 喝水打卡成功、记录保存等操作有Toast提示
   • 带渐入渐出动画效果

3. 数据更新动画：

   • 统计卡片数值变化有平滑过渡

前端架构

模块化的JS文件组织：

frontend/js/
├── main.js           # 应用入口、全局状态、导航
├── auth-api.js       # 认证API、登录注册逻辑
├── body-data.js      # 身体数据管理、BMI计算
├── diet.js           # 饮食记录功能
├── exercise.js       # 运动记录功能
├── ai.js             # AI功能集成
└── weight.js         # 体重趋势管理

前端状态管理：

• 使用 localStorage 存储用户数据和记录
• 使用事件机制实现组件间通信
• bodyDataSaved、pageChanged 等自定义事件

示例：事件驱动的数据流

// 监听身体数据保存事件
document.addEventListener('bodyDataSaved', function(e) {
    console.log('收到身体数据更新', e.detail);
    // 更新相关页面显示
});

---

技术亮点

1. 前后端分离架构

前端通过REST API与后端通信，完全解耦，便于独立开发和部署。

FastAPI应用初始化：
[backend/app/main.py](file:///d:\飞思Python-ppt文件夹\智能健身系统\backend\app\main.py)

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

from app.database import engine, Base
from app.api import api_router

# 自动创建数据库表
Base.metadata.create_all(bind=engine)

app = FastAPI(
    title="FitPro - 智能健身饮食规划平台",
    description="AI驱动的智能健身饮食管理系统",
    version="1.0.0",
)

# 配置CORS，允许跨域请求
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 统一挂载API路由
app.include_router(api_router, prefix="/api/v1")

---

2. JWT安全认证详解

我们实现了完整的JWT认证流程，包括：

1. 用户注册 → 密码bcrypt加密 → 存入数据库
2. 用户登录 → 验证密码 → 生成JWT Token → 返回给前端
3. API请求 → 前端携带Token → 后端验证 → 获取用户信息

密码加密：

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def get_password_hash(password: str):
    return pwd_context.hash(password)

def verify_password(plain_password: str, hashed_password: str):
    return pwd_context.verify(plain_password, hashed_password)

Token生成与验证：

from jose import JWTError, jwt
from datetime import datetime, timedelta

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
    to_encode = data.copy()
    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=1440))
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

def decode_access_token(token: str):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except JWTError:
        return None

依赖注入获取当前用户：

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/v1/auth/login")

def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="无法验证凭证",
    )
    
    payload = decode_access_token(token)
    if not payload:
        raise credentials_exception
    
    user_id = payload.get("sub")
    user = get_user(db, user_id=int(user_id))
    if not user:
        raise credentials_exception
    
    return user

---

3. Dify AI工作流集成技术详解

**为什么选择Dify？

• 可视化工作流编排，无需代码即可调整AI提示词
• 支持多种LLM模型（GPT、Claude、本地模型等）
• 提供完善的API和SDK

Dify调用核心代码：

import httpx

async def call_dify_workflow(inputs: dict) -> str:
    headers = {
        "Authorization": f"Bearer {DIFY_API_KEY_WORKFLOW}",
        "Content-Type": "application/json"
    }
    
    data = {
        "inputs": inputs,
        "response_mode": "blocking",  # 阻塞模式，等待完整结果
        "user": "user-1"
    }
    
    try:
        async with httpx.AsyncClient(timeout=120) as client:
            response = await client.post(
                DIFY_WORKFLOW_URL,
                headers=headers,
                json=data
            )
        
        result = response.json()
        
        # 尝试多种方式提取AI回复
        if result.get("data") and result["data"].get("outputs"):
            outputs = result["data"]["outputs"]
            if outputs.get("answer"):
                return outputs["answer"]
        
        return str(result)
        
    except Exception as e:
        print(f"❌ Dify调用异常: {e}")
        return f"请求失败: {str(e)}"

设计亮点：先计算后AI
我们的设计不是直接把原始数据丢给AI，而是先在系统中进行业务计算，再传给AI：

@router.post("/generate-fitness-plan")
async def generate_fitness_plan(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    # 1. 先在系统中计算BMI等指标
    bmi = calculate_bmi(current_user.height, current_user.weight)
    
    # 2. 计算推荐热量
    recommended_calories = calculate_daily_target(current_user)
    
    # 3. 将计算结果作为上下文传给AI
    inputs = {
        "height": current_user.height,
        "weight": current_user.weight,
        "age": current_user.age,
        "gender": current_user.gender,
        "bmi": bmi,
        "recommended_calories": recommended_calories,
        "goal": current_user.goal
    }
    
    # 4. 调用Dify获取个性化方案
    plan = await call_dify_workflow(inputs)
    
    return {"success": True, "plan": plan, "bmi": bmi}

这样AI生成的方案会更加精准和个性化。

---

4. 数据库设计与ORM操作

用户表设计：

from sqlalchemy import Column, Integer, String, Float, DateTime
from sqlalchemy.sql import func
from sqlalchemy.orm import relationship

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    hashed_password = Column(String(255), nullable=False)
    
    # 身体数据
    height = Column(Float)
    weight = Column(Float)
    age = Column(Integer)
    gender = Column(String(10))
    body_fat_rate = Column(Float)
    activity_level = Column(String(20))
    daily_calorie_target = Column(Float)
    
    # 时间戳
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    
    # 关联关系
    diet_records = relationship("DietRecord", back_populates="user", cascade="all, delete-orphan")
    exercise_records = relationship("ExerciseRecord", back_populates="user", cascade="all, delete-orphan")

CRUD操作封装：

from sqlalchemy.orm import Session

def create_user(db: Session, user_create: UserCreate):
    hashed_password = get_password_hash(user_create.password)
    db_user = User(
        username=user_create.username,
        email=user_create.email,
        hashed_password=hashed_password
    )
    db.add(db_user)
    db.commit()
    db.refresh(db_user)  # 刷新获取自增ID
    return db_user

def update_user(db: Session, user_id: int, user_update: UserUpdate):
    db_user = get_user(db, user_id)
    if not db_user:
        return None
    
    # 使用exclude_unset只更新用户实际修改的字段
    update_data = user_update.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(db_user, field, value)
    
    db.commit()
    db.refresh(db_user)
    return db_user

---

5. 前端API请求拦截器

我们使用Axios拦截器统一处理Token携带和错误：

const apiClient = axios.create({
    baseURL: API_BASE_URL,
    timeout: 60000
});

// 请求拦截器：自动添加Token
apiClient.interceptors.request.use(config => {
    const token = localStorage.getItem('token');
    if (token) {
        config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
});

// 响应拦截器：统一处理401错误
apiClient.interceptors.response.use(
    response => response,
    error => {
        if (error.response && error.response.status === 401) {
            localStorage.removeItem('token');
            localStorage.removeItem('user');
            // 自动跳转登录页
            showPage('login');
        }
        return Promise.reject(error);
    }
);

实现思路

核心业务流程

1. 用户注册登录 → 获取JWT Token
2. 完善个人信息 → 身高、体重、年龄、目标等
3. 日常记录 → 饮食、运动、喝水
4. AI辅助 → 生成计划、获取建议
5. 数据反馈 → 查看统计、趋势分析

技术设计原则

1. 关注点分离：API层、CRUD层、服务层各司其职
2. 安全性：密码加密、Token认证、权限验证
3. 可扩展性：模块化设计，易于添加新功能
4. 用户体验：响应式设计、实时反馈、操作便捷

应用价值

这个系统可以帮助：

1. 都市白领：无需专业教练，也能获得个性化建议
2. 健身爱好者：完整记录训练数据，科学规划
3. 减肥塑形人群：精准热量管理，AI推荐食谱
4. 健康管理初学者：降低使用门槛，引导养成习惯

---

总结与展望

项目成果与收获

完整的前后端分离架构

• 前端：原生 HTML + CSS + JavaScript + Axios
• 后端：FastAPI + SQLAlchemy + Pydantic
• 数据库：MySQL

JWT安全认证机制

• 密码 bcrypt 加密存储
• Token 有效期 24 小时
• 前端拦截器自动处理
• 后端依赖注入自动验证

Dify AI工作流集成

• 统一的服务封装
• 异步调用不阻塞
• 支持多种 AI 场景
• 先计算后 AI 的设计模式

完整的CRUD操作

• SQLAlchemy ORM 操作
• 链式查询构建
• exclude_unset 部分更新
• 删除时双重权限验证

美观实用的用户界面

• 现代化渐变设计
• 直观的卡片布局
• 优秀的交互反馈
• 实用的功能模块

---

未来规划实用功能

• 智能定时提醒
  集成 Notification API，支持喝水、运动、用餐多场景定时提醒，帮助用户养成规律的健康生活习惯。

• AI 食物拍照识别
  接入视觉AI接口，拍照即可自动识别食物种类，精准估算食物热量，快速记录饮食数据。

• 个性化 AI 推荐
  基于用户日常行为数据机器学习，动态优化推荐策略，输出高适配性的个性化饮食、运动预测建议。

• 智能健康报告
  自动生成月度健康报告，完成数据趋势分析，支持PDF格式导出，方便用户复盘健康状态变化。

---

技术改进方向

架构优化：

• 引入 Redis 缓存
• 异步任务队列
• 微服务拆分（AI 服务独立）

性能优化：

• 数据库索引优化
• 前端懒加载
• CDN 静态资源

安全增强：

• OAuth2 第三方登录
• 数据加密存储
• 操作日志审计

开发效率：

• 自动化测试
• CI/CD 流水线
• Docker 容器化

---

结语

本智能健身饮食规划平台是一套从零搭建的全流程实战项目，技术体系完整、落地性强。项目深度整合 Dify AI 工作流，打造出智能化、个性化的健康管理服务。
从需求梳理、架构设计，到代码开发与项目交付，我全程独立完成整套开发流程，积累了扎实的项目实战经验。
希望平台能为使用者带去健康与便捷，也欢迎各位交流探讨、洽谈合作。

---

参考资源

• FastAPI 官方文档
• SQLAlchemy 2.0 文档
• Dify AI 官网
• Passlib 密码加密
• Axios HTTP 客户端

---

版本历史

版本	日期	说明
1.0.0	2026-06-01	初始版本，完整功能实现

---