基于SSM框架的社区养老院综合管理系统 - 源码深度解析

JavaJavaScriptMavenHTMLCSSSSM框架MySQLJSP+Servlet
2026-02-205 浏览

文章摘要

本项目是基于SSM（Spring+SpringMVC+MyBatis）框架开发的社区养老院综合管理系统，旨在通过信息化手段提升社区养老服务的运营效率与管理水平。系统核心业务价值在于解决了传统养老院管理中信息孤岛、业务流程繁琐、服务响应滞后等痛点，将老人档案、护理服务、后勤管理、费用结算等模块进行一体...

随着人口老龄化趋势加剧，社区养老服务需求快速增长，传统养老机构面临管理效率低下、信息孤岛严重、服务响应滞后等挑战。针对这一现状，基于SSM框架的社区养老院综合管理系统应运而生，通过信息化手段实现养老服务的标准化、精细化和智能化管理。

系统采用经典的三层架构设计，前端使用JSP+Servlet技术结合HTML、CSS和JavaScript构建用户界面，后端基于Spring+SpringMVC+MyBatis框架实现业务逻辑，数据库采用MySQL进行数据存储。Maven作为项目构建工具，确保依赖管理的规范性和可维护性。

数据库架构设计亮点

系统数据库包含16张核心表，设计上充分考虑了养老院业务的实际需求和数据关联性。老人信息表（elderly）作为核心业务表，采用纵向扩展设计模式，将基本信息、健康状况、紧急联系人等字段进行合理划分：

CREATE TABLE elderly (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL,
    gender ENUM('男','女') NOT NULL,
    age INT,
    id_card VARCHAR(18) UNIQUE,
    health_status TEXT,
    bed_id INT,
    admission_date DATE,
    emergency_contact VARCHAR(20),
    contact_phone VARCHAR(11),
    created_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_time DATETIME ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (bed_id) REFERENCES bed(id)
);

护理记录表（nursing_records）的设计体现了业务操作的完整追溯性，通过外键关联老人、护理员和护理项目，确保数据的一致性和可审计性：

CREATE TABLE nursing_records (
    id INT PRIMARY KEY AUTO_INCREMENT,
    elderly_id INT NOT NULL,
    caregiver_id INT NOT NULL,
    nursing_item_id INT NOT NULL,
    start_time DATETIME,
    end_time DATETIME,
    details TEXT,
    status ENUM('待执行','进行中','已完成','已取消'),
    evaluation_score TINYINT,
    evaluation_comment TEXT,
    created_by INT,
    created_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (elderly_id) REFERENCES elderly(id),
    FOREIGN KEY (caregiver_id) REFERENCES caregiver(id),
    FOREIGN KEY (nursing_item_id) REFERENCES nursing_items(id)
);

费用管理表（expense_records）采用灵活的配置化设计，支持多种费用类型的动态管理，通过账单周期字段实现月度费用的自动生成：

CREATE TABLE expense_records (
    id INT PRIMARY KEY AUTO_INCREMENT,
    elderly_id INT NOT NULL,
    expense_type ENUM('床位费','护理费','餐饮费','医疗费','其他'),
    amount DECIMAL(10,2) NOT NULL,
    bill_cycle VARCHAR(7), -- 格式：YYYY-MM
    payment_status ENUM('未支付','部分支付','已支付','已退款'),
    due_date DATE,
    actual_payment_date DATE,
    remark TEXT,
    created_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (elderly_id) REFERENCES elderly(id)
);

核心业务功能实现

老人信息全生命周期管理

系统实现了老人从入院登记到日常护理的全流程管理。老人管理模块采用分层架构设计，Entity层定义老人实体模型，包含完整的属性映射：

@Entity
@Table(name = "elderly")
public class Elderly {
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String idCard;
    private String healthStatus;
    private Integer bedId;
    private Date admissionDate;
    private String emergencyContact;
    private String contactPhone;
    private Date createdTime;
    private Date updatedTime;
    
    // Getter和Setter方法
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }
    
    @Column(name = "name", nullable = false, length = 50)
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    // 其他属性的注解配置...
}

Service层封装复杂的业务逻辑，包括老人信息的增删改查、状态变更和关联数据处理：

@Service
@Transactional
public class ElderlyService {
    
    @Autowired
    private ElderlyMapper elderlyMapper;
    
    @Autowired
    private BedMapper bedMapper;
    
    public void addElderly(Elderly elderly) {
        // 验证身份证号唯一性
        if (elderlyMapper.countByIdCard(elderly.getIdCard()) > 0) {
            throw new BusinessException("身份证号已存在");
        }
        
        // 分配床位
        Bed availableBed = bedMapper.findAvailableBed();
        if (availableBed == null) {
            throw new BusinessException("暂无可用床位");
        }
        
        elderly.setBedId(availableBed.getId());
        elderly.setAdmissionDate(new Date());
        elderlyMapper.insert(elderly);
        
        // 更新床位状态
        availableBed.setStatus("已占用");
        bedMapper.update(availableBed);
    }
    
    public PageInfo<Elderly> getElderlyList(ElderlyQuery query, Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<Elderly> list = elderlyMapper.selectByQuery(query);
        return new PageInfo<>(list);
    }
}

老人管理界面

智能化护理任务调度

护理管理模块采用任务驱动模式，系统根据老人护理等级和个性化需求自动生成护理计划。Controller层通过RESTful接口提供任务分配和状态更新服务：

@RestController
@RequestMapping("/api/nursing")
public class NursingController {
    
    @Autowired
    private NursingService nursingService;
    
    @PostMapping("/assign")
    public ResponseEntity<Result> assignNursingTask(@RequestBody NursingAssignment assignment) {
        try {
            nursingService.assignTasks(assignment);
            return ResponseEntity.ok(Result.success("任务分配成功"));
        } catch (BusinessException e) {
            return ResponseEntity.badRequest().body(Result.error(e.getMessage()));
        }
    }
    
    @GetMapping("/tasks")
    public ResponseEntity<Result> getTodayTasks(
            @RequestParam Integer caregiverId,
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") Date date) {
        List<NursingTaskVO> tasks = nursingService.getTasksByCaregiverAndDate(caregiverId, date);
        return ResponseEntity.ok(Result.success(tasks));
    }
    
    @PutMapping("/tasks/{taskId}/status")
    public ResponseEntity<Result> updateTaskStatus(
            @PathVariable Integer taskId, 
            @RequestParam String status) {
        nursingService.updateTaskStatus(taskId, status);
        return ResponseEntity.ok(Result.success("状态更新成功"));
    }
}

护理任务分配算法综合考虑护理员技能等级、工作负荷和老人特殊需求，实现优化调度：

@Component
public class NursingScheduler {
    
    public List<NursingAssignment> generateAssignments(List<Elderly> elderlyList, 
                                                      List<Caregiver> caregivers) {
        List<NursingAssignment> assignments = new ArrayList<>();
        
        // 按护理等级对老人进行分组
        Map<String, List<Elderly>> elderlyByLevel = elderlyList.stream()
            .collect(Collectors.groupingBy(Elderly::getNursingLevel));
        
        // 按技能等级对护理员进行分组
        Map<String, List<Caregiver>> caregiversBySkill = caregivers.stream()
            .collect(Collectors.groupingBy(Caregiver::getSkillLevel));
        
        // 分配算法实现
        for (Map.Entry<String, List<Elderly>> entry : elderlyByLevel.entrySet()) {
            String level = entry.getKey();
            List<Caregiver> suitableCaregivers = caregiversBySkill.get(level);
            
            if (suitableCaregivers != null) {
                assignments.addAll(assignElderlyToCaregivers(entry.getValue(), suitableCaregivers));
            }
        }
        
        return assignments;
    }
    
    private List<NursingAssignment> assignElderlyToCaregivers(List<Elderly> elderlyList, 
                                                             List<Caregiver> caregivers) {
        // 具体的分配逻辑实现
        // 考虑每个护理员的工作负荷均衡
        // 考虑老人与护理员的匹配度
        // 生成最终的任务分配方案
    }
}

护理人员管理

精细化费用管理体系

费用管理模块实现自动计费、账单生成和支付跟踪功能。MyBatis的动态SQL功能支持复杂的费用查询和统计：

<!-- 费用查询的动态SQL配置 -->
<select id="selectExpenseByCondition" parameterType="ExpenseQuery" resultType="ExpenseRecord">
    SELECT er.*, e.name as elderly_name 
    FROM expense_records er
    LEFT JOIN elderly e ON er.elderly_id = e.id
    <where>
        <if test="elderlyName != null and elderlyName != ''">
            AND e.name LIKE CONCAT('%', #{elderlyName}, '%')
        </if>
        <if test="expenseType != null">
            AND er.expense_type = #{expenseType}
        </if>
        <if test="paymentStatus != null">
            AND er.payment_status = #{paymentStatus}
        </if>
        <if test="startDate != null">
            AND er.created_time >= #{startDate}
        </if>
        <if test="endDate != null">
            AND er.created_time <= #{endDate}
        </if>
        <if test="billCycle != null">
            AND er.bill_cycle = #{billCycle}
        </if>
    </where>
    ORDER BY er.created_time DESC
</select>

费用自动生成服务采用模板方法模式，支持不同费用类型的个性化计算规则：

@Service
public class ExpenseGenerationService {
    
    @Autowired
    private ExpenseTemplateService templateService;
    
    @Scheduled(cron = "0 0 1 1 * ?")  // 每月1日凌晨1点执行
    public void generateMonthlyExpenses() {
        List<Elderly> activeElderly = elderlyService.getActiveElderly();
        String billCycle = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM"));
        
        for (Elderly elderly : activeElderly) {
            generateElderlyExpenses(elderly, billCycle);
        }
    }
    
    private void generateElderlyExpenses(Elderly elderly, String billCycle) {
        // 获取费用模板
        List<ExpenseTemplate> templates = templateService.getTemplatesByLevel(elderly.getNursingLevel());
        
        for (ExpenseTemplate template : templates) {
            ExpenseRecord record = new ExpenseRecord();
            record.setElderlyId(elderly.getId());
            record.setExpenseType(template.getExpenseType());
            record.setAmount(calculateAmount(template, elderly));
            record.setBillCycle(billCycle);
            record.setDueDate(calculateDueDate());
            record.setPaymentStatus("未支付");
            
            expenseMapper.insert(record);
        }
    }
    
    private BigDecimal calculateAmount(ExpenseTemplate template, Elderly elderly) {
        // 根据模板规则和老人具体情况计算费用
        // 支持固定金额、按天计算、分级计价等多种模式
    }
}

费用管理界面

物资库存智能化管理

仓库管理模块采用实时库存监控和预警机制，通过Spring的声明式事务管理确保库存操作的原子性：

@Service
@Transactional
public class InventoryService {
    
    @Autowired
    private InventoryMapper inventoryMapper;
    
    @Autowired
    private InventoryHistoryMapper historyMapper;
    
    public void updateInventory(Integer itemId, Integer quantity, String operationType, String remark) {
        Inventory inventory = inventoryMapper.selectByItemId(itemId);
        if (inventory == null) {
            throw new BusinessException("库存记录不存在");
        }
        
        // 更新库存数量
        int newQuantity;
        switch (operationType) {
            case "入库":
                newQuantity = inventory.getQuantity() + quantity;
                break;
            case "出库":
                if (inventory.getQuantity() < quantity) {
                    throw new BusinessException("库存不足");
                }
                newQuantity = inventory.getQuantity() - quantity;
                break;
            default:
                throw new BusinessException("不支持的操作类型");
        }
        
        inventory.setQuantity(newQuantity);
        inventory.setUpdatedTime(new Date());
        inventoryMapper.update(inventory);
        
        // 记录库存变更历史
        InventoryHistory history = new InventoryHistory();
        history.setItemId(itemId);
        history.setQuantityChange(quantity);
        history.setOperationType(operationType);
        history.setRemark(remark);
        history.setCreatedTime(new Date());
        historyMapper.insert(history);
        
        // 检查库存预警
        checkInventoryAlert(inventory);
    }
    
    private void checkInventoryAlert(Inventory inventory) {
        if (inventory.getQuantity() <= inventory.getSafetyStock()) {
            // 触发库存预警通知
            alertService.sendInventoryAlert(inventory);
        }
    }
}

仓库管理界面

系统安全与权限控制

系统采用基于角色的访问控制（RBAC）模型，通过Spring拦截器实现细粒度的权限验证：

@Component
public class AuthInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        
        // 检查登录状态
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute("currentUser");
        if (user == null) {
            response.sendRedirect("/login");
            return false;
        }
        
        // 检查接口权限
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            RequiredPermission permission = handlerMethod.getMethodAnnotation(RequiredPermission.class);
            
            if (permission != null && !hasPermission(user, permission.value())) {
                response.setStatus(HttpStatus.FORBIDDEN.value());
                return false;
            }
        }
        
        return true;
    }
    
    private boolean hasPermission(User user, String requiredPermission) {
        // 检查用户是否拥有所需权限
        return user.getPermissions().contains(requiredPermission);
    }
}

技术架构优化与实践

性能优化策略

系统在数据访问层采用多级缓存策略，使用Redis作为分布式缓存，减少数据库访问压力：

@Service
public class ElderlyCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ElderlyMapper elderlyMapper;
    
    private static final String CACHE_KEY_PREFIX = "elderly:";
    private static final long CACHE_EXPIRE_TIME = 3600; // 1小时
    
    @Cacheable(value = "elderly", key = "#id")
    public Elderly getElderlyById(Integer id) {
        String cacheKey = CACHE_KEY_PREFIX + id;
        Elderly elderly = (Elderly) redisTemplate.opsForValue().get(cacheKey);
        
        if (elderly == null) {
            elderly = elderlyMapper.selectById(id);
            if (elderly != null) {
                redisTemplate.opsForValue().set(cacheKey, elderly, CACHE_EXPIRE_TIME, TimeUnit.SECONDS);
            }
        }
        
        return elderly;
    }
    
    @CacheEvict(value = "elderly", key = "#elderly.id")
    public void updateElderly(Elderly elderly) {
        elderlyMapper.update(elderly);
        // 清除相关缓存
        String cacheKey = CACHE_KEY_PREFIX + elderly.getId();
        redisTemplate.delete(cacheKey);
    }
}

异常处理机制

系统实现统一的异常处理机制，通过@ControllerAdvice注解捕获和处理各类异常：

@ControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    @ExceptionHandler(BusinessException.class)
    @ResponseBody
    public ResponseEntity<Result> handleBusinessException(BusinessException e) {
        logger.warn("业务异常: {}", e.getMessage());
        return ResponseEntity.badRequest().body(Result.error(e.getMessage()));
    }
    
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseEntity<Result> handleException(Exception e) {
        logger.error("系统异常: ", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(Result.error("系统繁忙，请稍后重试"));
    }
    
    @ExceptionHandler(AccessDeniedException.class)
    @ResponseBody
    public ResponseEntity<Result> handleAccessDeniedException(AccessDeniedException e) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body(Result.error("权限不足"));
    }
}

未来优化方向

  1. 移动端应用开发：开发配套的移动APP，支持护理人员现场记录护理情况、家属远程查看老人状态等功能。采用React Native或Flutter技术实现跨平台开发，通过RESTful API与现有系统对接。

  2. 物联网设备集成：集成智能床垫、手环等物联网设备，实时监测老人生命体征和活动轨迹。建立设备管理平台，通过MQTT协议接收设备数据，设置智能预警规则。

  3. 人工智能辅助决策：引入机器学习算法，基于历史护理数据预测老人健康风险，优化护理方案。使用Python开发预测模型，通过gRPC或REST API与Java系统集成。

  4. 微服务架构改造：将单体应用拆分为老人管理、护理服务、费用结算等微服务，提升系统可扩展性和维护性。采用Spring Cloud技术栈，实现服务注册发现、配置管理和链路追踪。

  5. 大数据分析平台：构建数据仓库，对养老院运营数据进行多维度分析，支持管理决策。使用Apache Spark进行数据处理，通过ECharts实现数据可视化展示。

系统通过完善的技术架构和业务功能设计，为社区养老院提供了全面的信息化解决方案，显著提升了养老服务的管理效率和服务质量。随着技术的不断发展和业务需求的深化，系统将持续优化演进，为养老事业的发展提供更有力的技术支撑。

本文关键词
SSM框架社区养老院管理系统源码解析数据库架构

上下篇

上一篇
没有更多文章
下一篇
没有更多文章