养老院管理系统

一、项目背景

1.1 行业背景

随着我国人口老龄化进程加速，养老服务需求持续增长。传统养老机构在日常管理中普遍依赖纸质台账和人工记录，存在信息孤岛、效率低下、数据易丢失等问题。为提升养老机构的管理效率和服务质量，亟需一套信息化管理系统来实现业务流程的数字化、规范化。

1.2 项目概述

养老院管理系统（Nursing Home Management System）是一套基于 B/S 架构的综合管理平台，采用前后端分离的开发模式，涵盖老人档案管理、床位管理、护理管理、费用结算、报表统计等核心业务模块，旨在为养老机构提供一站式信息化解决方案。

1.3 项目目标

• 实现养老机构核心业务的数字化管理，替代传统纸质办公方式
• 提供直观的数据可视化看板，辅助管理层进行科学决策
• 建立完善的权限体系，确保数据安全和操作可追溯
• 降低管理成本，提高护理服务效率和老人满意度

1.4 适用对象

角色	职责
超级管理员	系统配置、用户管理、全模块权限
财务人员	费用结算、账单管理、报表统计
护理主管	护理计划制定、排班管理、老人档案查看
普通护工	护理记录填写、日常护理执行

---

二、系统架构

2.1 整体架构

系统采用经典的 B/S 三层架构，前后端完全分离，通过 RESTful API 进行数据交互。

┌─────────────────────────────────────────────────────┐
│                     浏览器 (Chrome)                   │
│                Vue.js 3 + Element Plus               │
└──────────────────────┬──────────────────────────────┘
                       │ HTTP / RESTful API
                       ▼
┌─────────────────────────────────────────────────────┐
│                   Nginx (反向代理)                     │
│            静态资源托管 / 接口转发                       │
└──────────────────────┬──────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────┐
│               Spring Boot 应用服务                    │
│  ┌───────────┬───────────┬───────────┬────────────┐ │
│  │Controller │  Service  │    DAO    │  Security  │ │
│  │   控制层   │   业务层   │  持久层   │  安全层     │ │
│  └───────────┴───────────┴───────────┴────────────┘ │
│  ┌───────────────────────────────────────────────┐   │
│  │         MyBatis-Plus / Spring Data Redis       │   │
│  └───────────────────────────────────────────────┘   │
└──────────┬────────────────────────┬─────────────────┘
           │                        │
           ▼                        ▼
    ┌─────────────┐          ┌─────────────┐
    │  MySQL 8.0  │          │    Redis     │
    │  持久化存储   │          │  缓存/会话   │
    └─────────────┘          └─────────────┘

2.2 技术选型

后端技术栈

技术	版本	用途
Java	21	开发语言
Spring Boot	4.0.4	应用框架
Spring Security	-	认证与授权（JWT）
MyBatis-Plus	3.5.15	ORM 框架，含分页插件和自动填充
MySQL	8.0	关系型数据库
Redis	7.x	缓存与会话管理
JJWT	0.12.6	JWT 令牌生成与验证
Knife4j	4.5.0	API 接口文档（Swagger 增强）
Lombok	-	简化 Java 代码
Maven	3.9+	项目构建与依赖管理

前端技术栈

技术	版本	用途
Vue.js	3.5.30	前端渐进式框架
Element Plus	2.13.6	UI 组件库
Vue Router	4.6.4	前端路由管理
Pinia	3.0.4	状态管理
Axios	1.13.6	HTTP 请求客户端
ECharts	6.0.0	数据可视化图表
Vite	8.0.1	前端构建工具
NProgress	0.2.0	页面加载进度条

2.3 后端分层架构

com.xiaoa.yanglao
├── config/                  # 配置类（Security、Redis、MyBatis-Plus、跨域等）
├── common/                  # 公共模块（统一响应封装、基类实体、常量）
├── exception/               # 异常处理（业务异常、全局异常处理器）
├── security/                # 安全模块（JWT 令牌、认证过滤器、用户认证服务）
├── modules/                 # 业务模块
│   ├── system/              #   系统管理（用户、角色、菜单、字典）
│   ├── elder/               #   老人档案（入院登记、档案管理、健康记录）
│   ├── bed/                 #   床位管理（楼栋、房间、床位、调床）
│   ├── care/                #   护理管理（护理记录、排班管理）
│   ├── finance/             #   费用结算（收费标准、账单、缴费、退费）
│   └── report/              #   报表统计（入住统计、费用统计、床位统计）
└── YanglaoApplication.java  # 启动类

每个业务模块遵循统一的分层结构：

层次	职责	技术
Controller 控制层	接收请求、参数校验、调用 Service	Spring MVC, Validation
Service 业务层	核心业务逻辑、事务管理	Spring Transaction
Mapper/DAO 持久层	数据库 CRUD 操作	MyBatis-Plus
Entity 实体层	数据库表映射对象	Lombok
DTO 传输层	请求/响应数据传输对象	Lombok

2.4 前端项目结构

frontend/src/
├── api/              # API 接口模块（按业务域组织）
│   ├── auth.js       #   认证接口
│   ├── elder.js      #   老人管理接口
│   ├── bed.js        #   床位管理接口
│   ├── care.js       #   护理管理接口
│   ├── finance.js    #   费用管理接口
│   ├── report.js     #   报表统计接口
│   └── system/       #   系统管理接口（user.js, role.js, menu.js, dict.js）
├── views/            # 页面组件
│   ├── login/        #   登录页
│   ├── dashboard/    #   首页看板
│   ├── system/       #   系统管理页面
│   ├── elder/        #   老人管理页面
│   ├── bed/          #   床位管理页面
│   ├── care/         #   护理管理页面
│   ├── finance/      #   费用管理页面
│   └── report/       #   报表统计页面
├── layout/           # 后台布局（侧边栏、顶栏、面包屑）
├── router/           # 路由配置
├── store/            # Pinia 状态管理
├── utils/            # 工具函数（Axios 封装等）
├── assets/           # 静态资源
├── App.vue           # 根组件
└── main.js           # 应用入口

---

三、功能模块说明

3.1 系统管理模块

提供系统的基础配置和权限管理功能。

功能	说明
用户管理	管理员、护工、财务等用户的增删改查，支持状态启禁用
角色管理	角色的创建、权限分配，基于 RBAC 模型
菜单管理	系统菜单的动态配置，支持目录/菜单/按钮三级
字典管理	系统常量数据维护，缓存至 Redis 提升访问性能

RBAC 权限模型：

用户(sys_user) ──多对多── 角色(sys_role) ──多对多── 菜单/权限(sys_menu)

3.2 老人档案管理模块

管理老人的全生命周期信息，从入院登记到退院办理。

功能	说明
入院登记	老人基本信息录入（姓名、性别、年龄、身份证号等）
档案管理	老人信息的查询、修改、列表展示
健康档案	健康状况记录、病史、过敏信息
家属信息	紧急联系人、家属关系维护
评估记录	老人入院评估、定期评估记录
退院办理	退院手续办理与记录

3.3 床位/房间管理模块

实现对养老院物理空间的精细化管理。

功能	说明
楼栋管理	楼栋信息维护（栋名、楼层数等）
房间管理	房间信息、房间类型、房间状态管理
床位管理	床位分配、床位状态实时展示（空闲/已入住/维修/预留）
调床记录	调床申请与历史记录跟踪

3.4 护理管理模块

功能	说明
护理记录	日常护理日志的填写与查询
排班管理	护工班次安排与管理

3.5 费用结算模块

功能	说明
收费标准	床位费、护理费、餐费等收费项设置
账单管理	月度账单生成、账单明细查询
缴费管理	缴费登记、缴费状态跟踪
退费管理	退院退费计算与处理

3.6 报表统计模块

基于 ECharts 提供可视化数据分析。

功能	说明
入住统计	入住率、入住/退住趋势分析
费用统计	收费汇总、月收入统计
床位统计	床位使用率、空床率、各状态分布

---

四、核心设计

4.1 认证授权机制

系统采用 JWT（JSON Web Token）实现无状态的身份认证，结合 Redis 进行 Token 的集中管理。

认证流程：

1. 用户提交用户名和密码 → AuthController 接收登录请求
2. 校验用户名密码（BCrypt 加密比对）
3. 校验通过 → JwtTokenProvider 生成 JWT Token
4. Token 存入 Redis（key: token:{userId}，过期时间 24h）
5. 返回 Token 和用户信息给前端
6. 前端存储 Token 到 localStorage

后续每次请求：
7. 前端在 HTTP Header 中携带 Authorization: Bearer {token}
8. JwtAuthenticationFilter 拦截请求，解析并验证 Token
9. 检查 Redis 中 Token 是否有效（判断用户是否已登出）
10. 验证通过 → 设置 SecurityContext → 放行请求

4.2 Redis 缓存策略

缓存项	Key 格式	过期时间	说明
登录令牌	token:{userId}	24h	JWT Token 存储
用户权限	user:perms:{userId}	30min	用户权限列表
字典数据	dict:{dictType}	不过期	系统字典缓存
床位状态	bed:status:{floor}	5min	楼层床位状态快照

4.3 统一响应格式

所有 API 接口统一返回以下 JSON 格式：

{
  "code": 200,
  "message": "操作成功",
  "data": { ... }
}

状态码	说明
200	操作成功
400	请求参数错误
401	未认证（Token 无效或过期）
403	无权限
500	服务器内部错误

4.4 RESTful API 规范

接口设计遵循 RESTful 风格：

GET    /api/elders          # 查询老人列表
GET    /api/elders/{id}     # 查询老人详情
POST   /api/elders          # 新增老人
PUT    /api/elders/{id}     # 修改老人信息
DELETE /api/elders/{id}     # 删除老人记录

4.5 数据库设计原则

1. 所有表使用 InnoDB 引擎，字符集 utf8mb4
2. 主键使用自增 BIGINT 类型
3. 每张表包含 create_time、update_time 公共字段（由 MyBatis-Plus 自动填充）
4. 逻辑删除使用 del_flag 字段（0-正常, 1-已删除）
5. 表名、字段名使用小写下划线命名
6. 关键查询字段建立索引

---

五、关键代码片段

5.1 统一响应封装 - Result.java

通过泛型封装所有接口的统一返回格式，保证前后端交互的规范性。

package com.xiaoa.yanglao.common;

import lombok.Data;

@Data
public class Result<T> {

    private int code;
    private String message;
    private T data;

    private Result() {}

    public static <T> Result<T> success() {
        return success(null);
    }

    public static <T> Result<T> success(T data) {
        Result<T> result = new Result<>();
        result.setCode(200);
        result.setMessage("操作成功");
        result.setData(data);
        return result;
    }

    public static <T> Result<T> error(String message) {
        return error(500, message);
    }

    public static <T> Result<T> error(int code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        return result;
    }
}

5.2 JWT 令牌管理 - JwtTokenProvider.java

负责 JWT Token 的生成、解析和验证，采用 HMAC-SHA 算法签名。

@Component
public class JwtTokenProvider {

    private final SecretKey key;
    private final long expiration;

    public JwtTokenProvider(@Value("${jwt.secret}") String secret,
                            @Value("${jwt.expiration}") long expiration) {
        this.key = Keys.hmacShaKeyFor(Base64.getDecoder().decode(secret));
        this.expiration = expiration;
    }

    // 生成 Token：包含用户ID和用户名
    public String generateToken(Long userId, String username) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expiration);
        return Jwts.builder()
                .subject(username)
                .claim("userId", userId)
                .issuedAt(now)
                .expiration(expiryDate)
                .signWith(key)
                .compact();
    }

    // 验证 Token 有效性
    public boolean validateToken(String token) {
        try {
            parseClaims(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private Claims parseClaims(String token) {
        return Jwts.parser()
                .verifyWith(key)
                .build()
                .parseSignedClaims(token)
                .getPayload();
    }
}

5.3 JWT 认证过滤器 - JwtAuthenticationFilter.java

每次请求经过此过滤器，自动解析 Token 并设置 Spring Security 的认证上下文。

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwtTokenProvider;
    private final UserDetailsService userDetailsService;
    private final RedisTemplate<String, Object> redisTemplate;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = resolveToken(request);
        if (StringUtils.hasText(token) && jwtTokenProvider.validateToken(token)) {
            Long userId = jwtTokenProvider.getUserIdFromToken(token);
            // 检查 Redis 中是否存在该 Token（用户未登出）
            String redisKey = Constants.TOKEN_PREFIX + userId;
            Object cachedToken = redisTemplate.opsForValue().get(redisKey);
            if (cachedToken != null) {
                String username = jwtTokenProvider.getUsernameFromToken(token);
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authentication =
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }

    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader(Constants.TOKEN_HEADER);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(Constants.TOKEN_PREFIX_BEARER)) {
            return bearerToken.substring(Constants.TOKEN_PREFIX_BEARER.length());
        }
        return null;
    }
}

5.4 Security 配置 - SecurityConfig.java

配置安全策略：禁用 CSRF（前后端分离）、使用无状态会话、放行登录和文档接口。

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf(AbstractHttpConfigurer::disable)
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/auth/login", "/auth/register").permitAll()
                .requestMatchers("/doc.html", "/webjars/**", "/v3/api-docs/**").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

5.5 全局异常处理 - GlobalExceptionHandler.java

统一捕获和处理系统异常，避免原始错误信息暴露给前端。

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    public Result<?> handleBusinessException(BusinessException e) {
        log.error("业务异常: {}", e.getMessage());
        return Result.error(e.getCode(), e.getMessage());
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result<?> handleValidationException(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getAllErrors().getFirst().getDefaultMessage();
        return Result.error(400, message);
    }

    @ExceptionHandler(Exception.class)
    public Result<?> handleException(Exception e) {
        log.error("系统异常", e);
        return Result.error("系统内部错误");
    }
}

5.6 实体基类 - BaseEntity.java

所有实体类的公共基类，自动维护主键和时间字段。

@Data
public class BaseEntity implements Serializable {

    @TableId(type = IdType.AUTO)
    private Long id;

    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}

5.7 老人实体 - Elder.java

老人档案的数据模型，继承 BaseEntity 自动获取公共字段。

@Data
@EqualsAndHashCode(callSuper = true)
@TableName("elder")
public class Elder extends BaseEntity {

    private String name;           // 姓名
    private Integer gender;        // 性别
    private Integer age;           // 年龄
    private String idCard;         // 身份证号
    private String phone;          // 联系电话
    private String photo;          // 照片
    private LocalDate birthday;    // 出生日期
    private String nativePlace;    // 籍贯
    private Integer maritalStatus; // 婚姻状况
    private LocalDate checkInDate; // 入院日期
    private LocalDate checkOutDate;// 退院日期
    private Integer status;        // 状态（在住/退住）
    private Integer careLevel;     // 护理等级
    private Long bedId;            // 床位ID
    private String remark;         // 备注

    @TableLogic
    private Integer delFlag;       // 逻辑删除标志
}

5.8 老人管理控制器 - ElderController.java

提供老人档案的完整 RESTful API，集成 Knife4j 接口文档注解。

@Tag(name = "老人档案管理")
@RestController
@RequestMapping("/elder")
@RequiredArgsConstructor
public class ElderController {

    private final ElderService elderService;

    @Operation(summary = "分页查询老人列表")
    @GetMapping("/list")
    public Result<PageResult<Elder>> list(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "10") int pageSize,
            @RequestParam(required = false) String name,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) Integer careLevel) {
        Page<Elder> page = elderService.listElders(pageNum, pageSize, name, status, careLevel);
        return Result.success(new PageResult<>(page.getTotal(), page.getRecords()));
    }

    @Operation(summary = "入院登记")
    @PostMapping("/checkIn")
    public Result<Void> checkIn(@RequestBody Elder elder) {
        elderService.checkIn(elder);
        return Result.success();
    }

    @Operation(summary = "退院办理")
    @PostMapping("/{id}/checkOut")
    public Result<Void> checkOut(@PathVariable Long id) {
        elderService.checkOut(id);
        return Result.success();
    }
}

5.9 认证控制器 - AuthController.java

处理用户登录和登出请求。

@Tag(name = "认证管理")
@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {

    private final SysUserService sysUserService;

    @Operation(summary = "用户登录")
    @PostMapping("/login")
    public Result<Map<String, Object>> login(@Valid @RequestBody LoginDTO loginDTO) {
        Map<String, Object> result = sysUserService.login(
            loginDTO.getUsername(), loginDTO.getPassword());
        return Result.success("登录成功", result);
    }

    @Operation(summary = "用户登出")
    @PostMapping("/logout")
    public Result<Void> logout() {
        Long userId = SecurityUtils.getUserId();
        if (userId != null) {
            sysUserService.logout(userId);
        }
        return Result.success("退出成功", null);
    }
}

5.10 MyBatis-Plus 配置 - MybatisPlusConfig.java

配置分页插件和公共字段自动填充，减少重复代码。

@Configuration
@MapperScan("com.xiaoa.yanglao.modules.*.mapper")
public class MybatisPlusConfig implements MetaObjectHandler {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", LocalDateTime::now, LocalDateTime.class);
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime::now, LocalDateTime.class);
    }
}

5.11 Axios 请求封装 - request.js

前端统一的 HTTP 请求封装，自动携带 Token、处理响应状态码和错误提示。

import axios from 'axios'
import { ElMessage, ElMessageBox } from 'element-plus'
import { useUserStore } from '@/store/user'
import router from '@/router'
import NProgress from 'nprogress'

const service = axios.create({
  baseURL: '/api',
  timeout: 15000
})

// 请求拦截器：自动携带 JWT Token
service.interceptors.request.use(config => {
  NProgress.start()
  const userStore = useUserStore()
  if (userStore.token) {
    config.headers['Authorization'] = 'Bearer ' + userStore.token
  }
  return config
})

// 响应拦截器：统一处理错误码
service.interceptors.response.use(response => {
  NProgress.done()
  const res = response.data
  if (res.code !== 200) {
    ElMessage.error(res.message || '请求失败')
    // 401 未认证 → 引导重新登录
    if (res.code === 401) {
      ElMessageBox.confirm('登录已过期，请重新登录', '提示', {
        confirmButtonText: '重新登录', type: 'warning'
      }).then(() => {
        const userStore = useUserStore()
        userStore.logout()
        router.push('/login')
      })
    }
    return Promise.reject(new Error(res.message || '请求失败'))
  }
  return res
})

export default service

5.12 Pinia 用户状态管理 - user.js

管理用户登录状态、Token 持久化和菜单权限。

import { defineStore } from 'pinia'
import { login as loginApi, logout as logoutApi } from '@/api/auth'

export const useUserStore = defineStore('user', {
  state: () => ({
    token: localStorage.getItem('token') || '',
    userInfo: JSON.parse(localStorage.getItem('userInfo') || '{}'),
    menus: []
  }),
  getters: {
    isLoggedIn: state => !!state.token
  },
  actions: {
    async login(loginForm) {
      const res = await loginApi(loginForm)
      this.token = res.data.token
      this.userInfo = res.data.user || {}
      localStorage.setItem('token', this.token)
      localStorage.setItem('userInfo', JSON.stringify(this.userInfo))
      return res
    },
    async logout() {
      try { await logoutApi() } catch (e) { /* ignore */ }
      this.token = ''
      this.userInfo = {}
      this.menus = []
      localStorage.removeItem('token')
      localStorage.removeItem('userInfo')
    }
  }
})

---

六、数据库设计

6.1 核心数据表

系统共包含以下核心数据表：

模块	表名	说明
系统管理	sys_user	用户表
	sys_role	角色表
	sys_user_role	用户角色关联表
	sys_menu	菜单权限表
	sys_role_menu	角色菜单关联表
	sys_dict_type	字典类型表
	sys_dict_data	字典数据表
老人管理	elder	老人档案表
	elder_family	老人家属表
	elder_health	老人健康档案表
	elder_assessment	老人评估记录表
床位管理	building	楼栋表
	room	房间表
	bed	床位表
	bed_transfer	调床记录表
护理管理	care_record	护理记录表
	care_schedule	护工排班表
费用管理	charge_item	收费项目表
	bill	账单表
	bill_detail	账单明细表
	payment	缴费记录表

6.2 用户表结构示例

CREATE TABLE `sys_user` (
  `id`          BIGINT NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `username`    VARCHAR(50) NOT NULL COMMENT '用户名',
  `password`    VARCHAR(200) NOT NULL COMMENT '密码（BCrypt加密）',
  `real_name`   VARCHAR(50) DEFAULT NULL COMMENT '真实姓名',
  `phone`       VARCHAR(20) DEFAULT NULL COMMENT '手机号',
  `email`       VARCHAR(100) DEFAULT NULL COMMENT '邮箱',
  `gender`      TINYINT DEFAULT 0 COMMENT '性别（0-未知, 1-男, 2-女）',
  `avatar`      VARCHAR(500) DEFAULT NULL COMMENT '头像地址',
  `status`      TINYINT DEFAULT 1 COMMENT '状态（0-禁用, 1-正常）',
  `del_flag`    TINYINT DEFAULT 0 COMMENT '删除标志（0-正常, 1-已删除）',
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

---

七、页面展示

7.1 登录页面

登录页面采用居中卡片式布局，渐变背景配合白色表单卡片，提供用户名和密码输入。

页面特性：

• 表单校验（用户名和密码必填）
• 回车键快速登录
• 登录成功后自动跳转至首页或原访问地址
• 渐变紫色背景（#667eea → #764ba2）

7.2 首页仪表盘

首页提供全局数据概览，分为三个区域：统计卡片、图表区域和快捷操作区。

统计卡片区（顶部）：

卡片	数据	趋势
在住老人数	实时统计	较上月增长/下降百分比
空余床位数	实时统计	较上月变化百分比
本月收入	财务汇总	较上月增长/下降百分比
待处理事项	待办计数	提示需及时处理

图表区域（中部）：

• 左侧：入住趋势图（柱状图 + 折线图组合），支持切换近半年/近一年
  • 蓝色柱状：入住人数
  • 红色柱状：退住人数
  • 绿色折线：在住总人数
• 右侧：床位使用情况（环形饼图），展示已入住/空闲/维修中/预留占比

快捷操作区（底部）：

• 左侧：最近动态时间线（入住、缴费、护理、调床、退费等事件）
• 右侧：快捷操作按钮（入院登记、老人列表、床位管理、护理记录、账单管理、排班管理）

7.3 后台管理布局

系统采用经典的后台管理布局：左侧固定导航栏 + 顶部面包屑 + 右侧内容区。

┌──────────┬──────────────────────────────────────────┐
│ [Logo]   │  ☰  首页 > 老人管理 > 老人列表    [管理员 ▼] │
│ 养老院    │──────────────────────────────────────────│
│ 管理系统  │                                          │
│──────────│           页面内容区                       │
│ ▸ 首页   │                                          │
│ ▾ 系统管理│         （router-view 动态渲染）            │
│   用户管理│                                          │
│   角色管理│                                          │
│   菜单管理│                                          │
│   字典管理│                                          │
│ ▾ 老人管理│                                          │
│   老人列表│                                          │
│   入院登记│                                          │
│ ▾ 床位管理│                                          │
│   楼栋管理│                                          │
│   房间管理│                                          │
│   床位管理│                                          │
│   调床记录│                                          │
│ ▾ 护理管理│                                          │
│   护理记录│                                          │
│   排班管理│                                          │
│ ▾ 费用管理│                                          │
│   收费标准│                                          │
│   账单管理│                                          │
│   缴费管理│                                          │
│   退费管理│                                          │
│ ▸ 报表统计│                                          │
└──────────┴──────────────────────────────────────────┘

布局特性：

• 侧边栏支持折叠/展开（宽度 220px ↔ 64px）
• 顶栏显示面包屑导航和用户信息
• 页面切换带淡入淡出过渡动画
• 页面标题动态跟随路由变化

---

八、部署架构

8.1 部署方案

服务器
├── Nginx (80/443)          # 反向代理、前端静态资源托管
├── Spring Boot App (8080)  # 后端服务（内嵌 Tomcat）
├── MySQL (3306)            # 关系型数据库
└── Redis (6379)            # 缓存服务

8.2 构建命令

后端构建：

# Maven 打包
mvn clean package -DskipTests

# 运行
java -jar target/yanglao-0.0.1-SNAPSHOT.jar

前端构建：

# 安装依赖
cd frontend && npm install

# 开发环境
npm run dev

# 生产构建
npm run build

---

九、项目总结

养老院管理系统是一个功能完备的 B/S 架构企业级应用，具备以下技术特点：

1. 架构规范：前后端分离，后端三层架构清晰，模块化程度高
2. 安全可靠：基于 JWT + Spring Security + Redis 的认证授权体系，RBAC 权限模型
3. 开发高效：MyBatis-Plus 自动填充与分页、Lombok 简化代码、Knife4j 自动生成 API 文档
4. 体验友好：Element Plus 组件库保证 UI 一致性，ECharts 提供丰富的数据可视化
5. 易于维护：统一响应格式、全局异常处理、RESTful API 规范，降低前后端对接成本