Node.js+Vue+Express构建实验室共享预约系统-代码聚汇网

Node.js+Vue+Express构建实验室共享预约系统

VanessaDu·2026-08-10·阅读 22 GEO检测（免费）

Node.jsVue.jsExpress

|难度：普通|阅读约 57 分钟

1. 实验室共享预约系统的技术选型与架构设计

实验室资源管理一直是高校和科研机构面临的痛点问题。传统的人工预约方式效率低下，容易出现时间冲突和资源浪费。基于Node.js+Vue+Express的技术栈构建的实验室共享预约系统，能够有效解决这些问题。

这个系统的核心价值在于：

实现实验室设备、场地等资源的在线预约和统一管理
可视化展示资源使用状态，避免时间冲突
提高实验室资源利用率和管理效率

1.1 为什么选择Node.js+Vue+Express

这套技术组合在现代Web开发中非常流行，主要原因包括：

后端选择Node.js+Express的考量：

高性能I/O处理能力，适合处理大量并发预约请求
轻量级框架，开发效率高
丰富的npm生态，可以快速集成各种功能模块
与前端Vue.js天然契合，都使用JavaScript语言

前端选择Vue.js的优势：

响应式数据绑定，实时更新预约状态
组件化开发，便于构建复杂的预约界面
丰富的UI组件库，快速搭建美观的界面
渐进式框架，学习曲线平缓

1.2 系统架构设计

整个系统采用前后端分离架构：

code复制客户端层(Vue.js) ↔ API层(Express) ↔ 服务层(Node.js) ↔ 数据库层

核心模块划分：

用户认证模块：处理登录、权限管理
资源管理模块：实验室、设备等资源CRUD
预约管理模块：处理预约、取消、修改等操作
统计报表模块：生成资源使用情况统计
消息通知模块：预约确认、提醒等

提示：在实际开发中，建议采用模块化开发方式，每个功能模块独立开发测试，最后进行集成。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 开发环境搭建与项目初始化

2.1 Node.js环境配置

首先需要安装Node.js运行环境：

bash复制# 下载Node.js LTS版本
# Windows用户建议使用nvm-windows管理多版本
nvm install 16.14.2
nvm use 16.14.2

# 验证安装
node -v
npm -v

如果遇到PowerShell执行策略问题（如npm.ps1无法加载），可以这样解决：

powershell复制# 以管理员身份运行PowerShell
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

2.2 Vue项目初始化

使用Vue CLI创建前端项目：

bash复制npm install -g @vue/cli
vue create lab-reservation-frontend
cd lab-reservation-frontend

推荐选择配置：

Vue 3
TypeScript
Router
Vuex
CSS Pre-processors (Sass/SCSS)
ESLint + Prettier

2.3 Express后端项目初始化

创建后端项目：

bash复制mkdir lab-reservation-backend
cd lab-reservation-backend
npm init -y
npm install express body-parser cors mongoose jsonwebtoken bcryptjs dotenv

基本目录结构：

code复制backend/
├── config/       # 配置文件
├── controllers/  # 控制器
├── models/       # 数据模型
├── routes/       # 路由
├── middlewares/  # 中间件
├── utils/        # 工具函数
└── app.js        # 主入口文件

3. 核心功能实现

3.1 数据库设计与建模

使用MongoDB作为数据库，主要集合设计：

用户模型(User)：

javascript复制const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  role: { type: String, enum: ['admin', 'teacher', 'student'], default: 'student' },
  email: { type: String, required: true, unique: true },
  department: String,
  createdAt: { type: Date, default: Date.now }
});

实验室资源模型(LabResource)：

javascript复制const resourceSchema = new mongoose.Schema({
  name: { type: String, required: true },
  type: { type: String, enum: ['room', 'equipment', 'software'], required: true },
  location: String,
  description: String,
  capacity: Number,
  status: { type: String, enum: ['available', 'maintenance', 'out_of_service'], default: 'available' },
  restrictions: [String] // 使用限制条件
});

预约记录模型(Reservation)：

javascript复制const reservationSchema = new mongoose.Schema({
  user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  resource: { type: mongoose.Schema.Types.ObjectId, ref: 'LabResource', required: true },
  startTime: { type: Date, required: true },
  endTime: { type: Date, required: true },
  purpose: String,
  status: { type: String, enum: ['pending', 'approved', 'rejected', 'cancelled'], default: 'pending' },
  createdAt: { type: Date, default: Date.now }
});

3.2 用户认证与权限控制

使用JWT实现认证：

javascript复制// auth.controller.js
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');

exports.login = async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await User.findOne({ username });
    
    if (!user || !(await bcrypt.compare(password, user.password))) {
      return res.status(401).json({ message: 'Invalid credentials' });
    }
    
    const token = jwt.sign(
      { userId: user._id, role: user.role },
      process.env.JWT_SECRET,
      { expiresIn: '1d' }
    );
    
    res.json({ token, user: { id: user._id, username: user.username, role: user.role } });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

权限中间件：

javascript复制// auth.middleware.js
const jwt = require('jsonwebtoken');

exports.authenticate = (req, res, next) => {
  const token = req.header('Authorization')?.replace('Bearer ', '');
  
  if (!token) {
    return res.status(401).json({ message: 'No token provided' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ message: 'Invalid token' });
  }
};

exports.authorize = (roles) => {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ message: 'Forbidden' });
    }
    next();
  };
};

3.3 预约业务逻辑实现

核心预约服务：

javascript复制// reservation.service.js
const checkAvailability = async (resourceId, startTime, endTime) => {
  const conflicts = await Reservation.find({
    resource: resourceId,
    status: { $in: ['approved', 'pending'] },
    $or: [
      { startTime: { $lt: endTime }, endTime: { $gt: startTime } },
      { startTime: { $gte: startTime, $lt: endTime } }
    ]
  });
  
  return conflicts.length === 0;
};

exports.createReservation = async (userId, resourceId, startTime, endTime, purpose) => {
  const isAvailable = await checkAvailability(resourceId, startTime, endTime);
  
  if (!isAvailable) {
    throw new Error('The resource is not available during the requested time slot');
  }
  
  const reservation = new Reservation({
    user: userId,
    resource: resourceId,
    startTime,
    endTime,
    purpose
  });
  
  return await reservation.save();
};

4. 前端界面开发与交互实现

4.1 使用Vue Router构建SPA

路由配置示例：

javascript复制// router/index.ts
const routes = [
  {
    path: '/',
    component: HomeView,
    meta: { requiresAuth: true }
  },
  {
    path: '/login',
    component: LoginView,
    meta: { guestOnly: true }
  },
  {
    path: '/resources',
    component: ResourceListView,
    meta: { requiresAuth: true }
  },
  {
    path: '/resources/:id',
    component: ResourceDetailView,
    meta: { requiresAuth: true }
  },
  {
    path: '/reservations',
    component: ReservationListView,
    meta: { requiresAuth: true }
  },
  {
    path: '/admin',
    component: AdminDashboard,
    meta: { requiresAuth: true, roles: ['admin'] }
  }
];

4.2 使用Vuex进行状态管理

Store模块划分：

javascript复制// store/index.ts
export default createStore({
  modules: {
    auth: {
      state: () => ({
        user: null,
        token: null
      }),
      mutations: {
        SET_USER(state, user) {
          state.user = user;
        },
        SET_TOKEN(state, token) {
          state.token = token;
        }
      }
    },
    resources: {
      state: () => ({
        list: [],
        current: null
      }),
      mutations: {
        SET_LIST(state, list) {
          state.list = list;
        },
        SET_CURRENT(state, resource) {
          state.current = resource;
        }
      }
    }
  }
});

4.3 核心页面实现

资源日历视图组件：

vue复制<template>
  <div class="resource-calendar">
    <div class="calendar-header">
      <button @click="prevWeek">←</button>
      <h2>{{ weekRange }}</h2>
      <button @click="nextWeek">→</button>
    </div>
    
    <div class="time-grid">
      <div class="time-column">
        <div class="time-slot" v-for="hour in hours" :key="hour">
          {{ hour }}:00
        </div>
      </div>
      
      <div 
        class="resource-column" 
        v-for="resource in resources" 
        :key="resource._id"
      >
        <div class="resource-header">{{ resource.name }}</div>
        
        <div 
          class="time-slot" 
          v-for="hour in hours" 
          :key="`${resource._id}-${hour}`"
          @click="handleSlotClick(resource, hour)"
        >
          <div 
            class="reservation-block" 
            v-for="res in getReservations(resource, hour)"
            :key="res._id"
            :style="getBlockStyle(res)"
            @click.stop="handleReservationClick(res)"
          >
            {{ res.user.username }} - {{ res.purpose }}
          </div>
        </div>
      </div>
    </div>
    
    <ReservationModal 
      v-if="showModal" 
      :resource="selectedResource"
      :timeSlot="selectedTimeSlot"
      @close="showModal = false"
      @submit="handleReservationSubmit"
    />
  </div>
</template>

<script lang="ts">
import { defineComponent, computed, ref } from 'vue';
import { useStore } from 'vuex';
import ReservationModal from './ReservationModal.vue';

export default defineComponent({
  components: { ReservationModal },
  setup() {
    const store = useStore();
    const currentDate = ref(new Date());
    const selectedResource = ref(null);
    const selectedTimeSlot = ref(null);
    const showModal = ref(false);
    
    const hours = Array.from({ length: 12 }, (_, i) => i + 8); // 8:00 - 19:00
    
    const weekRange = computed(() => {
      const start = new Date(currentDate.value);
      start.setDate(start.getDate() - start.getDay());
      
      const end = new Date(start);
      end.setDate(end.getDate() + 6);
      
      return `${start.toLocaleDateString()} - ${end.toLocaleDateString()}`;
    });
    
    const resources = computed(() => store.state.resources.list);
    
    function getReservations(resource: any, hour: number) {
      // 过滤获取指定资源在指定小时的预约记录
    }
    
    function getBlockStyle(reservation: any) {
      // 计算预约块的位置和高度样式
    }
    
    function handleSlotClick(resource: any, hour: number) {
      selectedResource.value = resource;
      selectedTimeSlot.value = hour;
      showModal.value = true;
    }
    
    function handleReservationSubmit(reservationData: any) {
      // 提交预约请求
    }
    
    return {
      hours,
      weekRange,
      resources,
      selectedResource,
      selectedTimeSlot,
      showModal,
      getReservations,
      getBlockStyle,
      handleSlotClick,
      handleReservationSubmit
    };
  }
});
</script>

5. 系统部署与性能优化

5.1 生产环境部署

前端部署：

bash复制npm run build
# 生成的dist目录可以部署到Nginx或CDN

Nginx配置示例：

nginx复制server {
  listen 80;
  server_name lab-reservation.example.com;
  
  location / {
    root /var/www/lab-reservation-frontend/dist;
    try_files $uri $uri/ /index.html;
  }
  
  location /api {
    proxy_pass http://localhost:3000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
  }
}

后端部署：

使用PM2管理Node.js进程：

bash复制npm install -g pm2
pm2 start ecosystem.config.js

ecosystem.config.js配置：

javascript复制module.exports = {
  apps: [{
    name: 'lab-reservation-api',
    script: './app.js',
    instances: 'max',
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      PORT: 3000,
      MONGODB_URI: 'mongodb://user:password@host:port/database',
      JWT_SECRET: 'your-secret-key'
    }
  }]
};

5.2 性能优化建议

数据库优化：

为常用查询字段添加索引
使用Redis缓存热门资源和预约数据
实现分页查询，避免一次性加载大量数据

API优化：

实现请求限流，防止恶意刷单
使用compression中间件压缩响应
启用HTTP/2提升传输效率

前端优化：

按需加载组件和路由
使用虚拟滚动处理长列表
实现服务端渲染(SSR)提升首屏速度

注意：在开发过程中要持续进行性能监控，可以使用New Relic或PM2的内置监控功能。

6. 常见问题与解决方案

6.1 时间冲突检测问题

在实际运行中，时间冲突检测可能会出现边界条件问题。改进后的检测逻辑：

javascript复制const checkAvailability = async (resourceId, startTime, endTime, excludeReservationId = null) => {
  const query = {
    resource: resourceId,
    status: { $in: ['approved', 'pending'] },
    $or: [
      { startTime: { $lt: endTime }, endTime: { $gt: startTime } },
      { startTime: { $gte: startTime, $lt: endTime } },
      { endTime: { $gt: startTime, $lte: endTime } }
    ]
  };
  
  if (excludeReservationId) {
    query._id = { $ne: excludeReservationId };
  }
  
  const conflicts = await Reservation.find(query);
  return conflicts.length === 0;
};

6.2 时区处理问题

系统需要统一处理时区问题，建议：

数据库存储UTC时间
前端根据用户偏好显示本地时间
API接口明确时区参数

时间转换工具函数：

javascript复制// 前端时间处理
import { format, parseISO } from 'date-fns';
import { utcToZonedTime, zonedTimeToUtc } from 'date-fns-tz';

const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;

export function displayLocalTime(utcDate) {
  return format(utcToZonedTime(parseISO(utcDate), userTimezone), 'yyyy-MM-dd HH:mm');
}

export function convertToUTC(localDate, localTime) {
  const dateStr = `${localDate}T${localTime}:00`;
  return zonedTimeToUtc(dateStr, userTimezone).toISOString();
}

6.3 批量预约处理

实现批量预约接口：

javascript复制exports.createBatchReservations = async (userId, requests) => {
  const results = [];
  
  for (const request of requests) {
    try {
      const isAvailable = await checkAvailability(
        request.resourceId, 
        request.startTime, 
        request.endTime
      );
      
      if (!isAvailable) {
        results.push({
          resourceId: request.resourceId,
          success: false,
          message: 'Resource not available'
        });
        continue;
      }
      
      const reservation = new Reservation({
        user: userId,
        resource: request.resourceId,
        startTime: request.startTime,
        endTime: request.endTime,
        purpose: request.purpose
      });
      
      await reservation.save();
      results.push({
        resourceId: request.resourceId,
        success: true,
        reservationId: reservation._id
      });
    } catch (error) {
      results.push({
        resourceId: request.resourceId,
        success: false,
        message: error.message
      });
    }
  }
  
  return results;
};

7. 系统扩展与进阶功能

7.1 移动端适配

使用Vue的响应式设计原则实现移动端适配：

使用flexbox和grid布局
实现触摸友好的交互
添加PWA支持，实现离线功能

vue复制<template>
  <div class="reservation-card" :class="{ 'mobile-view': isMobile }">
    <!-- 内容 -->
  </div>
</template>

<script>
import { computed } from 'vue';
import { useDisplay } from 'vuetify';

export default {
  setup() {
    const { mobile } = useDisplay();
    const isMobile = computed(() => mobile.value);
    
    return { isMobile };
  }
};
</script>

<style scoped>
.reservation-card {
  display: flex;
  /* 桌面样式 */
}

.mobile-view {
  flex-direction: column;
  /* 移动样式 */
}

@media (max-width: 768px) {
  /* 响应式调整 */
}
</style>

7.2 第三方集成

日历服务集成：

可以将预约数据同步到Google Calendar或Outlook：

javascript复制const { google } = require('googleapis');

async function syncToGoogleCalendar(user, reservation) {
  const oauth2Client = new google.auth.OAuth2(
    process.env.GOOGLE_CLIENT_ID,
    process.env.GOOGLE_CLIENT_SECRET,
    process.env.GOOGLE_REDIRECT_URI
  );
  
  oauth2Client.setCredentials({
    access_token: user.googleAccessToken,
    refresh_token: user.googleRefreshToken
  });
  
  const calendar = google.calendar({ version: 'v3', auth: oauth2Client });
  
  const event = {
    summary: `实验室预约 - ${reservation.resource.name}`,
    location: reservation.resource.location,
    description: reservation.purpose,
    start: { dateTime: reservation.startTime, timeZone: 'UTC' },
    end: { dateTime: reservation.endTime, timeZone: 'UTC' }
  };
  
  try {
    const response = await calendar.events.insert({
      calendarId: 'primary',
      resource: event
    });
    return response.data.id;
  } catch (error) {
    console.error('Google Calendar sync failed:', error);
    throw error;
  }
}

7.3 数据分析与可视化

使用ECharts实现资源使用率可视化：

vue复制<template>
  <div class="analytics-dashboard">
    <div ref="usageChart" class="chart-container"></div>
  </div>
</template>

<script>
import { onMounted, ref } from 'vue';
import * as echarts from 'echarts';
import { fetchUsageData } from '@/api/analytics';

export default {
  setup() {
    const usageChart = ref(null);
    
    onMounted(async () => {
      const data = await fetchUsageData();
      const chart = echarts.init(usageChart.value);
      
      const option = {
        title: { text: '实验室资源使用率' },
        tooltip: {},
        xAxis: { data: data.categories },
        yAxis: { type: 'value' },
        series: [{
          name: '使用小时数',
          type: 'bar',
          data: data.values
        }]
      };
      
      chart.setOption(option);
      
      window.addEventListener('resize', () => chart.resize());
    });
    
    return { usageChart };
  }
};
</script>

8. 安全防护措施

8.1 输入验证与过滤

使用express-validator进行请求验证：

javascript复制const { body, validationResult } = require('express-validator');

exports.validateReservation = [
  body('resourceId').isMongoId(),
  body('startTime').isISO8601(),
  body('endTime').isISO8601(),
  body('purpose').trim().escape().isLength({ max: 500 }),
  (req, res, next) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    next();
  }
];

8.2 防止重复预约

使用Redis实现分布式锁：

javascript复制const redis = require('redis');
const client = redis.createClient();

async function acquireLock(userId, resourceId, ttl = 10) {
  const lockKey = `lock:reservation:${userId}:${resourceId}`;
  return new Promise((resolve) => {
    client.set(lockKey, '1', 'EX', ttl, 'NX', (err, ok) => {
      resolve(ok === 'OK');
    });
  });
}

async function releaseLock(userId, resourceId) {
  const lockKey = `lock:reservation:${userId}:${resourceId}`;
  return new Promise((resolve) => {
    client.del(lockKey, resolve);
  });
}

exports.createReservationWithLock = async (userId, resourceId, startTime, endTime, purpose) => {
  const hasLock = await acquireLock(userId, resourceId);
  
  if (!hasLock) {
    throw new Error('Another reservation request is in progress');
  }
  
  try {
    const reservation = await createReservation(userId, resourceId, startTime, endTime, purpose);
    return reservation;
  } finally {
    await releaseLock(userId, resourceId);
  }
};

8.3 定期数据备份

实现MongoDB自动备份脚本：

javascript复制const { exec } = require('child_process');
const path = require('path');
const fs = require('fs');
const cron = require('node-cron');

function backupDatabase() {
  const date = new Date();
  const backupDir = path.join(__dirname, 'backups');
  const backupFile = path.join(backupDir, `labreservation-${date.toISOString()}.gz`);
  
  if (!fs.existsSync(backupDir)) {
    fs.mkdirSync(backupDir, { recursive: true });
  }
  
  const cmd = `mongodump --uri="${process.env.MONGODB_URI}" --archive=${backupFile} --gzip`;
  
  exec(cmd, (error, stdout, stderr) => {
    if (error) {
      console.error('Backup failed:', error);
      return;
    }
    console.log('Backup successful:', backupFile);
    
    // 清理旧备份，保留最近7天
    fs.readdir(backupDir, (err, files) => {
      if (err) return;
      
      const now = new Date().getTime();
      const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
      
      files.forEach(file => {
        const filePath = path.join(backupDir, file);
        const stat = fs.statSync(filePath);
        
        if (stat.mtimeMs < weekAgo) {
          fs.unlinkSync(filePath);
          console.log('Deleted old backup:', filePath);
        }
      });
    });
  });
}

// 每天凌晨2点执行备份
cron.schedule('0 2 * * *', backupDatabase);

9. 测试策略与质量保证

9.1 单元测试实现

使用Jest编写测试用例：

javascript复制// reservation.service.test.js
const { createReservation, checkAvailability } = require('./reservation.service');
const Reservation = require('../models/reservation');

jest.mock('../models/reservation');

describe('Reservation Service', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  
  describe('checkAvailability', () => {
    it('should return true when no conflicts exist', async () => {
      Reservation.find.mockResolvedValue([]);
      
      const isAvailable = await checkAvailability(
        'resource1',
        new Date('2023-01-01T09:00:00Z'),
        new Date('2023-01-01T10:00:00Z')
      );
      
      expect(isAvailable).toBe(true);
    });
    
    it('should return false when conflicts exist', async () => {
      Reservation.find.mockResolvedValue([{ _id: 'conflict1' }]);
      
      const isAvailable = await checkAvailability(
        'resource1',
        new Date('2023-01-01T09:00:00Z'),
        new Date('2023-01-01T10:00:00Z')
      );
      
      expect(isAvailable).toBe(false);
    });
  });
  
  describe('createReservation', () => {
    it('should create reservation when resource is available', async () => {
      Reservation.find.mockResolvedValue([]);
      const mockSave = jest.fn().mockResolvedValue({ _id: 'res1' });
      Reservation.mockImplementation(() => ({ save: mockSave }));
      
      const reservation = await createReservation(
        'user1',
        'resource1',
        new Date('2023-01-01T09:00:00Z'),
        new Date('2023-01-01T10:00:00Z'),
        '实验需要'
      );
      
      expect(mockSave).toHaveBeenCalled();
      expect(reservation).toHaveProperty('_id', 'res1');
    });
  });
});

9.2 E2E测试方案

使用Cypress进行端到端测试：

javascript复制// cypress/integration/reservation.spec.js
describe('Reservation Flow', () => {
  beforeEach(() => {
    cy.login('testuser@example.com', 'password123');
    cy.visit('/resources');
  });
  
  it('should allow user to make a reservation', () => {
    cy.get('[data-testid="resource-card"]').first().click();
    cy.get('[data-testid="calendar-slot"]').eq(10).click(); // 选择上午10点
    
    cy.get('[data-testid="purpose-input"]').type('化学实验');
    cy.get('[data-testid="submit-btn"]').click();
    
    cy.contains('预约成功').should('be.visible');
    cy.get('[data-testid="my-reservations"]').should('contain', '化学实验');
  });
  
  it('should show error when time slot is taken', () => {
    // 先创建一个预约
    cy.createTestReservation(
      'resource1',
      '2023-01-01T09:00:00Z',
      '2023-01-01T10:00:00Z'
    );
    
    // 尝试预约相同时间段
    cy.get('[data-testid="resource-card"]').first().click();
    cy.get('[data-testid="calendar-slot"]').eq(9).click(); // 上午9点
    
    cy.get('[data-testid="purpose-input"]').type('物理实验');
    cy.get('[data-testid="submit-btn"]').click();
    
    cy.contains('时间段已被占用').should('be.visible');
  });
});

9.3 性能测试方法

使用Artillery进行负载测试：

yaml复制# load-test.yml
config:
  target: "http://localhost:3000"
  phases:
    - duration: 60
      arrivalRate: 10
      name: "Warm up"
    - duration: 120
      arrivalRate: 50
      rampTo: 100
      name: "Ramp up load"
    - duration: 300
      arrivalRate: 100
      name: "Sustained load"
  processor: "./auth-hook.js"
  
scenarios:
  - name: "Browse resources"
    flow:
      - post:
          url: "/api/auth/login"
          json:
            username: "testuser"
            password: "testpass"
          capture:
            json: "$.token"
            as: "authToken"
      - get:
          url: "/api/resources"
          headers:
            Authorization: "Bearer {{ authToken }}"
      - think: 1
      - get:
          url: "/api/resources/1"
          headers:
            Authorization: "Bearer {{ authToken }}"
  
  - name: "Make reservation"
    flow:
      - post:
          url: "/api/auth/login"
          json:
            username: "testuser"
            password: "testpass"
          capture:
            json: "$.token"
            as: "authToken"
      - post:
          url: "/api/reservations"
          headers:
            Authorization: "Bearer {{ authToken }}"
          json:
            resourceId: "1"
            startTime: "2023-01-01T09:00:00Z"
            endTime: "2023-01-01T10:00:00Z"
            purpose: "Load test"

10. 项目总结与经验分享

在开发实验室共享预约系统的过程中，积累了一些有价值的经验：

时间处理要谨慎：初期没有统一时区处理，导致跨时区用户遇到显示问题。后来强制使用UTC存储，前端按用户时区显示，解决了这个问题。
并发控制很重要：在没有实现分布式锁之前，出现过重复预约的情况。引入Redis锁机制后，彻底解决了这个问题。
前端状态管理：随着预约流程变得复杂，Vuex的模块化设计大大简化了状态管理。建议从一开始就采用模块化设计。
测试覆盖率：项目中期才开始补充测试，发现很多边界条件没考虑到。建议从项目开始就建立测试框架，TDD方式开发。
文档自动化：使用Swagger自动生成API文档，节省了大量维护文档的时间。

javascript复制// swagger.js
const swaggerJsdoc = require('swagger-jsdoc');
const swaggerUi = require('swagger-ui-express');

const options = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: '实验室预约系统API',
      version: '1.0.0',
      description: '实验室资源共享预约平台API文档'
    },
    servers: [{ url: '/api' }]
  },
  apis: ['./routes/*.js']
};

const specs = swaggerJsdoc(options);

app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(specs));

对于想要进一步扩展功能的开发者，可以考虑：

增加设备使用日志记录功能
实现实验室门禁系统集成
添加设备故障报修流程
开发微信小程序版本
引入机器学习预测资源使用高峰