基于SSM框架的企业人事薪酬管理系统 - 源码深度解析

JavaJavaScriptHTMLCSSSSM框架MavenFreemarkerMySQL
2026-02-0810 浏览

文章摘要

本项目是基于SSM（Spring + Spring MVC + MyBatis）框架构建的企业人事薪酬管理系统，旨在为中小型企业提供一体化的员工信息与薪酬核算解决方案。其核心业务价值在于将分散的人事档案、考勤记录、绩效评估与工资计算流程整合到统一平台，解决了传统Excel手工操作效率低下、易出错、数...

在企业信息化管理日益重要的今天，人力资源与薪酬管理作为企业核心运营环节，亟需专业化的系统支持。传统基于Excel的手工操作模式存在效率低下、易出错、数据孤岛等问题，无法满足现代企业对数据准确性和时效性的要求。为此，我们设计并实现了一套基于SSM框架的企业级人力资源与薪酬管理平台，该系统将人事档案、考勤记录、绩效评估与工资核算等业务流程进行一体化整合，为企业提供全面的数字化管理解决方案。

系统架构与技术栈

该平台采用经典的分层架构设计，后端基于Spring+Spring MVC+MyBatis（SSM）框架组合，前端使用HTML+CSS+JavaScript技术栈，模板引擎采用Freemarker，项目构建工具为Maven，数据库选用MySQL 5.7。

技术架构层次分明：

  • 持久层：MyBatis负责数据持久化，通过XML映射文件实现Java对象与数据库表的ORM映射
  • 业务层：Spring框架管理业务逻辑和事务控制，通过依赖注入实现组件解耦
  • 控制层：Spring MVC处理HTTP请求，采用注解方式配置控制器，实现前后端数据交互
  • 视图层：Freemarker模板引擎渲染页面，结合Bootstrap等前端框架提供友好的用户界面
<!-- Maven依赖配置示例 -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.5</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
</dependencies>

数据库设计亮点分析

薪酬表（salary）设计深度解析

薪酬表作为系统的核心数据表，其设计体现了复杂业务逻辑的数据建模能力：

CREATE TABLE `salary` (
  `s_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `e_id` int(11) DEFAULT NULL COMMENT '员工id',
  `d_id` int(11) DEFAULT NULL COMMENT '部门ID',
  `s_time` date DEFAULT NULL COMMENT '时间某年某月',
  `s_state` int(11) DEFAULT NULL COMMENT '状态0暂存，1已发',
  `base_pay` double(11,2) DEFAULT NULL COMMENT '基本工资',
  `food_pay` double(11,2) DEFAULT NULL COMMENT '餐饮补贴',
  `post_pay` double(11,2) DEFAULT NULL COMMENT '岗位补贴',
  `working_year_pay` double(11,2) DEFAULT NULL COMMENT '工龄奖金',
  -- 省略其他字段...
  `individual_income_tax` double(11,2) DEFAULT NULL COMMENT '个人所得税',
  `should_pay` double(11,2) DEFAULT NULL COMMENT '应发工资',
  `actual_pay` double(11,2) DEFAULT NULL COMMENT '实发工资',
  PRIMARY KEY (`s_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=33 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=DYNAMIC

设计亮点分析：

  1. 字段精度控制：所有金额字段采用double(11,2)类型，确保小数点后两位精度，符合财务计算要求
  2. 状态管理机制：s_state字段实现工资单状态流转（0暂存/1已发），支持审批流程
  3. 时间维度设计：s_time字段记录工资所属年月，支持历史数据追溯和同比分析
  4. 索引优化策略：主键采用自增ID，同时建议对e_id、d_id、s_time建立复合索引，提升查询性能

月度考勤表（monthly_attendance）的业务建模

CREATE TABLE `monthly_attendance` (
  `ma_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `e_id` int(11) DEFAULT NULL COMMENT '员工id,外键',
  `attendance_time` date DEFAULT NULL COMMENT '某年某月的出勤情况',
  `sick_leave_num` int(11) DEFAULT NULL COMMENT '病假天数',
  `overtime_hour` double(11,2) DEFAULT NULL COMMENT '平时加班小时',
  `weekend_hour` double(11,2) DEFAULT NULL COMMENT '周末加班小时',
  `holiday_hour` double(11,2) DEFAULT NULL COMMENT '节假日加班小时',
  `late_num` int(11) DEFAULT NULL COMMENT '迟到次数',
  `early_num` int(11) DEFAULT NULL COMMENT '早退次数',
  `absence_num` int(11) DEFAULT NULL COMMENT '缺勤天数',
  `business_travel_num` int(11) DEFAULT NULL COMMENT '出差天数',
  `compassionate_leave_num` int(11) DEFAULT NULL COMMENT '事假天数',
  PRIMARY KEY (`ma_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=39 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=DYNAMIC

业务逻辑体现：

  • 精细化考勤分类：将加班时间细分为平时、周末、节假日三类，符合劳动法规定
  • 异常情况完整记录：涵盖迟到、早退、缺勤、各类请假等所有考勤异常类型
  • 月度汇总模式：按月度粒度统计，平衡数据量与查询性能的需求

考勤管理界面

核心功能实现详解

1. 部门管理模块

部门管理作为组织架构的基础，采用标准的CRUD操作模式，结合分页查询和条件筛选功能：

@Controller
@RequestMapping("/department")
public class DepartmentController {
    @Autowired
    public DepartmentService departmentService = null;

    /**
     * 分页查询部门信息
     */
    @RequestMapping("/findSelective.do")
    @ResponseBody
    public DepartmentPages findSelective(
            @RequestParam(value="page", defaultValue="1")int pageNum,
            @RequestParam(value="limit", defaultValue="5") int limit,
            @RequestParam(value="d_name", defaultValue="") String d_name) throws Exception {
        
        Department department = new Department();
        department.setdName(d_name);

        // PageHelper分页插件配置
        PageHelper.startPage(pageNum, limit);
        List<Department> list = departmentService.findSelective(department);
        PageInfo pageResult = new PageInfo(list);

        // 封装前端需要的分页数据结构
        DepartmentPages departmentPages = new DepartmentPages();
        departmentPages.setCode(0);
        departmentPages.setMsg("");
        departmentPages.setCount((int) pageResult.getTotal());
        departmentPages.setData(pageResult.getList());

        return departmentPages;
    }

    /**
     * 新增部门（防重复校验）
     */
    @RequestMapping("/add.do")
    @ResponseBody
    public int add(String d_name, String d_remark) throws Exception {
        Department department = departmentService.findByDname(d_name);
        
        // 同名部门校验
        if(department != null) {
            return department.getdId(); // 返回已存在部门的ID
        } else {
            Department d = new Department();
            d.setdId(null);
            d.setdName(d_name);
            d.setdRemark(d_remark);
            d.setdIsdel(1); // 设置可用状态
            departmentService.insertSelective(d);
            return 0; // 返回0表示新增成功
        }
    }
}

部门管理界面

2. 薪酬计算引擎

薪酬计算是系统的核心业务逻辑，涉及复杂的计算规则和税务处理：

@Service
public class SalaryCalculateService {
    
    /**
     * 计算应发工资
     */
    public double calculateShouldPay(Salary salary, MonthlyAttendance attendance) {
        double shouldPay = salary.getBasePay();
        
        // 累加各项补贴
        shouldPay += salary.getFoodPay();
        shouldPay += salary.getPostPay();
        shouldPay += salary.getWorkingYearPay();
        
        // 计算加班工资（区分平时、周末、节假日）
        double overtimePay = calculateOvertimePay(attendance);
        shouldPay += overtimePay;
        
        // 扣除请假费用
        double leaveDeduction = calculateLeaveDeduction(attendance);
        shouldPay -= leaveDeduction;
        
        return shouldPay;
    }
    
    /**
     * 计算个税（累进税率算法）
     */
    public double calculateIndividualIncomeTax(double taxableIncome) {
        double tax = 0;
        
        if (taxableIncome <= 5000) {
            tax = 0;
        } else if (taxableIncome <= 8000) {
            tax = (taxableIncome - 5000) * 0.03;
        } else if (taxableIncome <= 17000) {
            tax = (taxableIncome - 8000) * 0.1 + 90;
        }
        // 更多税率级别...
        
        return tax;
    }
    
    /**
     * 生成完整工资单
     */
    public Salary generateSalarySlip(Employee employee, MonthlyAttendance attendance) {
        Salary salary = new Salary();
        salary.setEId(employee.getEId());
        salary.setDId(employee.getDId());
        salary.setSTime(new Date());
        
        // 设置各项工资组成部分
        salary.setBasePay(employee.getBaseSalary());
        salary.setPostPay(calculatePostAllowance(employee.getPositionId()));
        
        // 计算考勤相关金额
        salary.setLatePay(calculateLateDeduction(attendance.getLateNum()));
        salary.setOvertimePay(calculateOvertimePay(attendance));
        
        // 计算社保公积金
        calculateSocialInsurance(salary, employee.getBaseSalary());
        
        // 最终计算
        double shouldPay = calculateShouldPay(salary, attendance);
        salary.setShouldPay(shouldPay);
        
        double actualPay = shouldPay - salary.getIndividualIncomeTax();
        salary.setActualPay(actualPay);
        
        return salary;
    }
}

薪酬查询界面

3. 工龄奖金管理

工龄奖金计算基于员工入职年限，采用配置化的奖金规则：

@Repository
public interface WorkingYearsBonusMapper {
    
    /**
     * 根据工龄年份查询对应奖金标准
     */
    @Select("SELECT wyb_bonus FROM working_years_bonus WHERE wyb_year = #{years}")
    Double findBonusByYears(Integer years);
    
    /**
     * 更新工龄奖金标准
     */
    @Update("UPDATE working_years_bonus SET wyb_bonus = #{bonus} WHERE wyb_year = #{years}")
    int updateBonusStandard(@Param("years") Integer years, @Param("bonus") Double bonus);
}

@Service
public class WorkingYearsBonusService {
    
    @Autowired
    private WorkingYearsBonusMapper workingYearsBonusMapper;
    
    /**
     * 计算员工工龄奖金
     */
    public double calculateWorkingYearsBonus(Date entryDate) {
        int years = calculateWorkingYears(entryDate);
        Double bonus = workingYearsBonusMapper.findBonusByYears(years);
        return bonus != null ? bonus : 0.0;
    }
    
    private int calculateWorkingYears(Date entryDate) {
        Calendar entryCal = Calendar.getInstance();
        entryCal.setTime(entryDate);
        Calendar nowCal = Calendar.getInstance();
        
        int years = nowCal.get(Calendar.YEAR) - entryCal.get(Calendar.YEAR);
        if (nowCal.get(Calendar.MONTH) < entryCal.get(Calendar.MONTH)) {
            years--;
        }
        return Math.max(years, 0); // 确保非负
    }
}

工龄奖金管理

4. MyBatis动态SQL在复杂查询中的应用

系统大量使用MyBatis的动态SQL功能处理多条件查询：

<!-- 薪酬查询的动态SQL映射 -->
<select id="selectSalaryByCondition" parameterType="map" resultType="com.esms.po.Salary">
    SELECT s.*, e.e_name as employeeName, d.d_name as departmentName
    FROM salary s
    LEFT JOIN employee e ON s.e_id = e.e_id
    LEFT JOIN department d ON s.d_id = d.d_id
    WHERE s.s_isdel = 1
    <if test="eId != null">
        AND s.e_id = #{eId}
    </if>
    <if test="dId != null">
        AND s.d_id = #{dId}
    </if>
    <if test="startTime != null">
        AND s.s_time >= #{startTime}
    </if>
    <if test="endTime != null">
        AND s.s_time &lt;= #{endTime}
    </if>
    <if test="sState != null">
        AND s.s_state = #{sState}
    </if>
    ORDER BY s.s_time DESC, s.s_id DESC
</select>

<!-- 考勤统计的动态SQL -->
<select id="selectAttendanceSummary" parameterType="map" resultType="map">
    SELECT 
        e.e_id,
        e.e_name,
        d.d_name,
        ma.attendance_time,
        SUM(ma.overtime_hour) as totalOvertime,
        SUM(ma.late_num) as totalLate,
        SUM(ma.absence_num) as totalAbsence
    FROM monthly_attendance ma
    JOIN employee e ON ma.e_id = e.e_id
    JOIN department d ON e.d_id = d.d_id
    WHERE ma.attendance_time BETWEEN #{startDate} AND #{endDate}
    <if test="departmentId != null">
        AND d.d_id = #{departmentId}
    </if>
    GROUP BY e.e_id, ma.attendance_time
    HAVING totalAbsence &lt;= #{maxAbsence}
</select>

实体模型设计

系统采用面向对象的设计思想，核心实体模型关系清晰：

/**
 * 部门实体类
 */
public class Department {
    private Integer dId;          // 部门ID
    private String dName;         // 部门名称
    private String dRemark;       // 部门备注
    private Integer dIsdel;       // 删除标志（软删除）
    
    // 关联的员工集合
    private List<Employee> employees;
    
    // getter/setter方法
    public Integer getDId() { return dId; }
    public void setDId(Integer dId) { this.dId = dId; }
    // 其他getter/setter...
}

/**
 * 员工实体类
 */
public class Employee {
    private Integer eId;          // 员工ID
    private String eName;         // 员工姓名
    private Integer dId;          // 所属部门ID
    private Date entryDate;       // 入职日期
    private Double baseSalary;    // 基本工资
    
    // 关联的部门对象
    private Department department;
    // 关联的考勤记录
    private List<MonthlyAttendance> attendanceRecords;
    // 关联的工资记录
    private List<Salary> salaryRecords;
}

员工管理界面

功能展望与优化方向

基于当前系统架构，未来可从以下几个方向进行功能扩展和性能优化：

1. 引入Redis缓存提升性能

@Service
public class SalaryCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String SALARY_CACHE_PREFIX = "salary:";
    private static final long CACHE_EXPIRE_HOURS = 24;
    
    /**
     * 缓存工资查询结果
     */
    public Salary getCachedSalary(Integer employeeId, Date salaryDate) {
        String cacheKey = SALARY_CACHE_PREFIX + employeeId + ":" + 
                         new SimpleDateFormat("yyyy-MM").format(salaryDate);
        
        Salary salary = (Salary) redisTemplate.opsForValue().get(cacheKey);
        if (salary == null) {
            salary = salaryMapper.selectByEmployeeAndDate(employeeId, salaryDate);
            if (salary != null) {
                redisTemplate.opsForValue().set(cacheKey, salary, 
                    CACHE_EXPIRE_HOURS, TimeUnit.HOURS);
            }
        }
        return salary;
    }
}

2. 微服务架构改造

将单体应用拆分为多个微服务：

  • 用户服务：负责员工信息、权限管理
  • 考勤服务：处理打卡、请假、加班等考勤业务
  • 薪酬服务：专门负责工资计算、个税处理
  • 报表服务：生成各类统计报表和分析图表

3. 增加消息队列异步处理

使用RabbitMQ或Kafka处理批量工资计算等耗时操作：

@Component
public class SalaryCalculateMessageListener {
    
    @RabbitListener(queues = "salary.calculate.queue")
    public void processSalaryCalculate(SalaryCalculateMessage message) {
        // 异步计算工资，避免阻塞主线程
        salaryCalculateService.batchCalculate(message.getEmployeeIds(), 
                                            message.getSalaryMonth());
    }
}

4. 移动端适配与PWA支持

开发响应式界面，支持PWA（渐进式Web应用）技术，使系统在移动设备上获得原生应用般的体验。

5. 人工智能辅助决策

集成机器学习算法，实现：

  • 离职风险预测
  • 薪酬合理性分析
  • 人力成本优化建议

总结

该企业级人力资源与薪酬管理平台基于成熟的SSM技术栈构建，通过精细化的数据库设计和模块化的代码架构，实现了人事管理、考勤统计、薪酬核算等核心业务流程的数字化管理。系统在数据准确性、业务完整性和用户体验方面都达到了生产级标准，为中小型企业提供了可靠的人力资源管理解决方案。

本文关键词
SSM框架企业人事管理薪酬管理系统源码解析数据库设计

上下篇

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