差旅报销管理系统
差旅报销管理系统
题目要求
差旅费报销管理信息系统（50分）
1、项目背景：
随着企业规模的扩大和业务的复杂化，报销管理成为了企业日常运营中不可或缺的一环。为了提高效率和减少人力成本，许多企业开始引入报销系统来简化和优化报销流程。为了避免人力物力财力浪费、降低办公成本、提高办事效率，是企业领导关注的一个重要课题，所以急切需要一套有效的“差旅费报销管理”系统。
此软件的主要用户包括财务人员、职员经理、总经理、职员，各个用户主要功能为：
（1）职员：出差申请，报销差旅费，查看出差申请、查看报销进度。
（2）部门经理：审批出差申请，审批差旅费报销（费用金额不超过1万元）、查询本职员差旅费花费情况。
（3）总经理：审批差旅费报销（费用金额超过1万元），统计各个职员本年度差旅费花费情况。
（4）财务人员：审核报销单据。
2.系统要求与评分标准：
2.1 页面要求
（1）系统可以通过浏览器直接访问；（1分）
（2）各个功能页面整体风格统一；
（3）首页为用户登录页面，职员、职员经理、总经理、财务人员四种角色用户登录后，进入相应的功能页，只能看到角色允许访问功能模块，用户登录界面包含用户、密码两个文本框，以及登录按钮；（4分）
（4）职员功能页：共包括出差申请、修改出差申请、撤回出差申请、报销差旅费、修改报销单据、查看出差申请、查看报销进度七项功能模块。
（5）部门经理功能页：审批出差申请、审批差旅费报销（费用金额不超过1万元）、查询差旅费花费情况、出差申请、报销差旅费、查看出差申请、查看报销进度七项功能模块。
（6）总经理功能页：审批出差申请，审批差旅费报销（费用金额超过1万元）、、查询差旅费花费情况、统计各个部门本年度差旅费花费情况四项功能模块。
（7）财务人员功能页：审核报销单据，查询报销情况。
2.2 业务流程：
差旅费报销流程如下所示：
（1） 职员出差前需要提出出差申请；
（2） 部门经理审批同意后，职员方可外出，如果部门经理尚未审批该申请，职员允许对出差申请进行修改和撤回（即删除）；
（3） 职员出差返回后，需在一个月内进行差旅费报销，超过期限不许报销；
（4） 职员出差返回后，在系统内报销差旅费清单，提交后先有部门经理审批同意，如果报销金额超过一万元，需要提交总经理进行二次审批，审批通过后财务人员针对报销内容进行审核，审核不通过，返回职员进行修改后，仍需按照流程再次审批，审核通过即可进行报销。
（5） 如果是部门经理外出出差则由总经理审批出差申请，审批差旅费报销。
2.3功能要求
（1）出差申请：职员和部门经理出差前需要提出出差申请单，经审批同意后方可出差，出差申请单主要内容包括：出差人姓名（自动填充）、部门（自动填充）、目的地、暂定出发日期、预计返回日期：出差类别（业务洽谈、培训、会议、其他）、出差事由如下图所示。（3分）
（2）修改出差申请：已提交申请，尚未审批，可以修改出差申请单中除姓名和部门外的其他内容。（2分）
（3）撤回出差申请：已提交的出差申请，尚未审批，可以删除该申请，一旦审批，不允许撤回该申请。（2分）
（4）差旅费报销：职员或者部门经理出差回来后，需要报销差旅费（5分）。
主要内容包括：报销编号（自动生成）、出差人姓名、部门、目的地、出发日期、返回日期、出差事由、出发车费、返回车费、伙食补助、公杂补助、住宿费、总金额（自动计算得出）。
（5）修改报销单据：提交的报销单据被财务人员审核不通过，将单据打回到申请人，申请人可以根据修改意见修改报销单据内容，二次提交审批。（4分）
（6）查看出差申请：职员或者部门经理登录成功后，以列表形式查看自己提交的出差申请，列表主要内容包括申请日期，申请事由，申请状态（待审核、通过，退回），审批理由（退回时需要填写退回理由），按照日期倒叙排列（即最新日期在最上面一条记录）。（3分）
（7）查看报销进度：职员或者部门经理登录成功后，以列表形式查看自己提交的报销单据，列表主要内容包括报销日期，报销事由，进度状态（待审批、部门通过、总经理通过、财务审核通过、退回），审批理由（退回时需要填写退回理由）。（3分）
（8）审批出差申请：部门经理可以审批本部门的出差申请，以列表形式显示，点击查看详细信息，选择通过或者退回（如果退回需要填写退回理由）（3分）
（9）审批差旅费报销：部门经理可以审批本部门的报销单据，以列表形式显示，点击查看详细信息，选择通过或者退回（如果退回需要填写退回理由），如果报销金额超过一万元，需要总经理进行二次审批，审批过程与部门经理审批一致（4分）
（10）查询差旅费花费情况：部门经理只能查询本部门的报销情况（财务人员审批通过的报销单据）、总经理可以查询全公司的报销情况。
查询条件：姓名、部门、报销总金额大于
查询结果列表显示：报销日期、报销人姓名、报销人部门、报销事由、报销总金额，点击该记录，可以显示该报销单据的全部详细信息（4分）
（11）统计各个部门本年度差旅费花费情况：总经理可以查询各个部门本年度的差旅费报销总金额，列表内容包括，部门编号、部门名称、花费总金额（2分）
（12）审核报销单据：财务人员审核通过部门经理或者总经理审批通过的报销单据，（5分）
主要审批内容包括：
①系统自动判断根据是否有出差申请，申请日期是否在报销日期之前，如果在之后则退回该报销；
②伙食补助标准、公杂补助费、住宿费三项标准是否超标，如果超标退回该报销。
符合上述标准则审批通过，不符合上述标准，则退回该报销。
（14）数据库评分标准：按照题目要求创建出差申请表、报销单据表、职员基本信息表，（3分），实现数据库连接正常（2分）。
后端代码编写
创建springboot项目
配置pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.5</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>day1125demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>day1125demo</name>
<description>day1125demo</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>3.0.3</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
配置application.properties
spring.application.name=day1125demo //（自己的项目名称）
server.port=9090 //（端口）
spring.datasource.url=jdbc:mysql://localhost:3306/user//（数据库）
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
mybatis.mapper-locations=classpath:mybatis/mappers/*.xml
#??mybatis???????????
mybatis.configuration.map-underscore-to-camel-case=true
#spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
后端项目结构如下
数据库建表语句
出差申请表
create table applytable
(
applyId varchar(255) not null
primary key,
applyName varchar(255) null,
department varchar(255) null,
destination varchar(255) null,
departureDate varchar(255) null,
returnDate varchar(255) null,
type varchar(255) null,
typeContent varchar(255) null,
reason varchar(255) null,
state varchar(255) null,
stateReason varchar(255) null
);
报销申请表
create table spendtable
(
spendId varchar(255) not null
primary key,
spendName varchar(255) null,
department varchar(255) null,
destination varchar(255) null,
departureDate varchar(255) null,
returnDate varchar(255) null,
reason varchar(255) null,
startFare varchar(255) null,
returnFare varchar(255) null,
foodAllowance varchar(255) null,
localTrans varchar(255) null,
accommodation varchar(255) null,
totalAmount varchar(255) null,
schedule varchar(255) null,
scheduleReason varchar(255) null
);
员工表
create table users
(
userId varchar(255) not null
primary key,
userName varchar(255) not null,
department varchar(255) null,
role varchar(255) null,
password varchar(255) not null
);
统一响应结果封装类
package com.example.day1125demo.pojo;
/**
* 统一响应结果封装类
*/
public class Result {
private static Integer code;//0失败，1成功
private String message;//提示错误信息
private Object data;//数据
//方便创建Result对象
//创建一个表示成功的Result对象，并传入具体数据
public static Result success(Object data) {
return new Result(1, "success", data);
}
//创建一个表示成功但没有具体数据的Result对象
public static Result success() {
return new Result(1, "success", null);
}
//创建一个表示失败的Result对象，并传入错误提示信息
public static Result error(String message) {
return new Result(code, message, null);
}
//无参构造和有参构造函数
public Result() {
}
public Result(Integer code, String message, Object data) {
this.code = code;
this.message = message;
this.data = data;
}
//重写Obiect类的toString()方法
// 以自定义的格式返回Result对象的字符串表示
// 方便在调试或输出时查看对象的内容
@Override
public String toString() {
return "Result [code=" + code + ", message=" + message + ", data=" + data + "]";
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
后端代码（实体类）
Apply(出差申请)
package com.example.day1125demo.pojo;
import lombok.Data;
@Data
public class Apply {
private String applyId;
private String applyName;
private String department;
private String destination;
private String departureDate;
private String returnDate;
private String type;
private String typeContent;
private String reason;
private String state;
private String stateReason;
@Override
public String toString() {
return "Apply{" +
"applyId='" + applyId + '\'' +
", applyName='" + applyName + '\'' +
", department='" + department + '\'' +
", destination='" + destination + '\'' +
", departureDate='" + departureDate + '\'' +
", returnDate='" + returnDate + '\'' +
", types='" + type + '\'' +
", typeContent='" + typeContent + '\'' +
", reason='" + reason + '\'' +
", state='" + state + '\'' +
", stateReason='" + stateReason + '\'' +
'}';
}
}
Spend(报销申请)
package com.example.day1125demo.pojo;
import lombok.Data;
@Data
public class Spend {
private String spendId;
private String spendName;
private String department;
private String destination;
private String departureDate;
private String returnDate;
private String reason;
private String startFare;
private String returnFare;
private String foodAllowance;
private String localTrans;
private String accommodation;
private String totalAmount;
private String schedule;
private String scheduleReason;
}
User(员工)
package com.example.day1125demo.pojo;
import lombok.Data;
@Data
public class User {
private String userId;
private String userName;
private String department;
private String role;
private String password;
}
后端代码(controller层)
ApplyController.java
package com.example.day1125demo.controller;
import com.example.day1125demo.Mapper.ApplyMapper;
import com.example.day1125demo.pojo.Apply;
import com.example.day1125demo.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@Controller
@RestController
public class ApplyController {
@Autowired
private ApplyMapper applyMapper;
@PostMapping("/addApply")
public ResponseEntity<String> insert(@RequestBody Apply apply) {
try {
System.out.println(apply);
// 检查所有字段是否非空
if (apply.getApplyId() == null || apply.getApplyName() == null || apply.getDepartment() == null ||
apply.getDestination() == null || apply.getDepartureDate() == null || apply.getReturnDate() == null ||
apply.getType() == null || apply.getTypeContent() == null || apply.getReason() == null ||
apply.getState() == null || apply.getStateReason() == null) {
return ResponseEntity.badRequest().body("所有字段都是必填项，请检查输入。");
}
// 插入记录
applyMapper.insert(apply);
return ResponseEntity.ok("插入成功");
} catch (Exception e) {
log.error("插入失败", e);
return ResponseEntity.internalServerError().body("插入失败: " + e.getMessage());
}
}
@DeleteMapping("/deleteApply")
public void delete(@RequestBody Apply apply) {
try{
applyMapper.delete(apply);
}catch (HttpMessageNotReadableException e) {
e.printStackTrace();
}
}
@PutMapping("/updateApply")
public ResponseEntity<Result> update(@RequestBody Apply apply) {
try {
// 先根据申请编号查询数据库中是否存在该记录
Apply existingApply = applyMapper.select(apply.getApplyId());
if (existingApply!= null ) {
// 如果记录存在，执行更新操作
applyMapper.update(apply);
// 更新成功，返回成功结果
return ResponseEntity.ok(Result.success("更新成功"));
} else {
// 如果记录不存在，返回失败结果及提示信息
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(Result.error("未找到对应申请编号的记录，无法更新。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生读取消息异常，返回失败结果及错误提示信息
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(Result.error("更新请求数据格式错误，请检查后重试。"));
} catch (Exception e) {
e.printStackTrace();
// 其他未知异常，返回失败结果及通用错误提示信息
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Result.error("更新过程发生错误，请稍后重试。"));
}
}
@PostMapping("/updateStates")
public ResponseEntity<Result> updateStates(@RequestBody Apply apply) {
try {
// 先根据申请编号查询数据库中是否存在该记录
Apply existingApply = applyMapper.select(apply.getApplyId());
if (existingApply!= null) {
// 如果记录存在，执行更新操作，仅传入需要更新的 state 和 stateReason 字段值以及 applyId
applyMapper.updateState(apply.getState(), apply.getStateReason(), apply.getApplyId());
// 更新成功，返回成功结果
return ResponseEntity.ok(Result.success("更新成功"));
} else {
// 如果记录不存在，返回失败结果及提示信息
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(Result.error("未找到对应申请编号的记录，无法更新。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生读取消息异常，返回失败结果及错误提示信息
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(Result.error("更新请求数据格式错误，请检查后重试。"));
} catch (Exception e) {
e.printStackTrace();
// 其他未知异常，返回失败结果及通用错误提示信息
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Result.error("更新过程发生错误，请稍后重试。"));
}
}
@PostMapping("/getApply")
public ResponseEntity<Result> select(@RequestBody Apply apply) {
String applyId = apply.getApplyId();
try {
Apply foundapply = applyMapper.select(applyId);
if (foundapply!= null) {
// 查询到数据，返回成功结果
return ResponseEntity.ok(Result.success(foundapply));
} else {
// 未查询到数据，返回失败结果及提示信息
return ResponseEntity.ok(Result.error("未查询到对应申请编号的记录，请检查申请编号是否正确。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生异常，返回失败结果及错误提示信息
return ResponseEntity.ok(Result.error("查询过程发生错误，请稍后重试。"));
}
}
@PostMapping("/getAll")
public ResponseEntity<List<Apply>> selectAll() {
List<Apply> applyList = applyMapper.selectAll();
System.out.println(applyList);
return ResponseEntity.ok(applyList);
}
}
SpendController.java
package com.example.day1125demo.controller;
import com.example.day1125demo.Mapper.SpendMapper;
import com.example.day1125demo.pojo.Result;
import com.example.day1125demo.pojo.Spend;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@Controller
@RestController
public class SpendController {
@Autowired
private SpendMapper spendMapper;
@PostMapping("/addSpend")
public ResponseEntity<String> insert(@RequestBody Spend spend) {
try {
System.out.println(spend);
// 检查所有字段是否非空
if (spend.getSpendId() == null || spend.getSpendName() == null || spend.getDepartment() == null ||
spend.getDestination() == null || spend.getDepartureDate() == null || spend.getReturnDate() == null ||
spend.getReason() == null || spend.getStartFare() == null || spend.getReturnFare() == null ||
spend.getFoodAllowance() == null || spend.getLocalTrans() == null ||spend.getAccommodation() == null||
spend.getTotalAmount() == null || spend.getSchedule() == null) {
return ResponseEntity.badRequest().body("所有字段都是必填项，请检查输入。");
}
// 插入记录
spendMapper.insert(spend);
return ResponseEntity.ok("插入成功");
} catch (Exception e) {
log.error("插入失败", e);
return ResponseEntity.internalServerError().body("插入失败: " + e.getMessage());
}
}
@DeleteMapping("/deleteSpend")
public void delete(@RequestBody Spend spend) {
try{
spendMapper.delete(spend);
}catch (HttpMessageNotReadableException e) {
e.printStackTrace();
}
}
@PutMapping("/updateSpend")
public ResponseEntity<Result> update(@RequestBody Spend spend) {
try {
// 先根据申请编号查询数据库中是否存在该记录
Spend existingApply = spendMapper.select(spend.getSpendId());
if (existingApply!= null) {
// 如果记录存在，执行更新操作
spendMapper.update(spend);
// 更新成功，返回成功结果
return ResponseEntity.ok(Result.success("更新成功"));
} else {
// 如果记录不存在，返回失败结果及提示信息
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(Result.error("未找到对应申请编号的记录，无法更新。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生读取消息异常，返回失败结果及错误提示信息
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(Result.error("更新请求数据格式错误，请检查后重试。"));
} catch (Exception e) {
e.printStackTrace();
// 其他未知异常，返回失败结果及通用错误提示信息
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Result.error("更新过程发生错误，请稍后重试。"));
}
}
@PostMapping("/updateSchedule")
public ResponseEntity<Result> updateStates(@RequestBody Spend spend) {
try {
// 先根据申请编号查询数据库中是否存在该记录
Spend existingSpend = spendMapper.select(spend.getSpendId());
if (existingSpend!= null) {
// 如果记录存在，执行更新操作，仅传入需要更新的 state 和 stateReason 字段值以及 applyId
spendMapper.updateSchedule(spend.getSchedule(), spend.getScheduleReason(), spend.getSpendId());
// 更新成功，返回成功结果
return ResponseEntity.ok(Result.success("更新成功"));
} else {
// 如果记录不存在，返回失败结果及提示信息
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(Result.error("未找到对应申请编号的记录，无法更新。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生读取消息异常，返回失败结果及错误提示信息
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(Result.error("更新请求数据格式错误，请检查后重试。"));
} catch (Exception e) {
e.printStackTrace();
// 其他未知异常，返回失败结果及通用错误提示信息
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(Result.error("更新过程发生错误，请稍后重试。"));
}
}
@PostMapping("/getSpend")
public ResponseEntity<Result> select(@RequestBody Spend spend) {
String spendId = spend.getSpendId();
try {
Spend foundspend = spendMapper.select(spendId);
if (foundspend!= null) {
// 查询到数据，返回成功结果
return ResponseEntity.ok(Result.success(foundspend));
} else {
// 未查询到数据，返回失败结果及提示信息
return ResponseEntity.ok(Result.error("未查询到对应申请编号的记录，请检查申请编号是否正确。"));
}
} catch (HttpMessageNotReadableException e) {
e.printStackTrace();
// 发生异常，返回失败结果及错误提示信息
return ResponseEntity.ok(Result.error("查询过程发生错误，请稍后重试。"));
}
}
@PostMapping("/getSpendAll")
public Result getSpendAll() {
List<Spend> spendList = spendMapper.selectAll();
System.out.println(spendList);
return Result.success(spendList);
}
}
UserController.java
package com.example.day1125demo.controller;
import com.example.day1125demo.Mapper.UserMapper;
import com.example.day1125demo.pojo.Result;
import com.example.day1125demo.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@Controller
@RestController
public class UserController {
@Autowired
private UserMapper userMapper;
@PostMapping("/add")
public void insert(@RequestBody User user) {
try {
System.out.println(user);
String userId = user.getUserId();
String userName = user.getUserName();
String department = user.getDepartment();
String role = user.getRole();
String password = user.getPassword();
userMapper.insert(user);
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
@PostMapping("/login")
public Result login(@RequestBody User user) {
try {
String userId = user.getUserId();
String password = user.getPassword();
// 假设这里通过userMapper去数据库查询验证用户是否存在及密码是否正确
User queriedUser = userMapper.findByUseridAndPassword(userId, password);
if (queriedUser!= null) {
// 登录成功，返回成功的Result对象，可根据需求添加更多数据到Result中，这里暂时只返回成功标识
Map<String, String> data = new HashMap<>();
data.put("role", queriedUser.getRole());
System.out.println(queriedUser.getRole());
System.out.println(data);
return Result.success(data);
} else {
// 登录失败，返回错误信息的Result对象
return Result.error("用户名或密码错误");
}
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
@DeleteMapping("/delete")
public void delete(@RequestBody User user) {
try {
System.out.println(user);
String userId = user.getUserId();
userMapper.deleteByUserId(userId);
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
@PostMapping("/get")
public Result findByUserIdAndDepartment(@RequestBody User user) {
String userId = user.getUserId();
String department = user.getDepartment();
// 使用UserMapper根据传入的userId和department查询用户信息
User foundUser = userMapper.findByUserIdAndDepartment(userId, department);
if (foundUser!= null) {
// 如果查询到用户，返回成功的Result对象，并将查询到的用户信息作为数据返回
return Result.success(foundUser);
} else {
// 如果未查询到用户，返回失败的Result对象，并设置相应的错误提示信息
return Result.error("未找到符合条件的用户");
}
}
@PutMapping("/update")
public Result update(@RequestBody User user) {
try{
String userId = user.getUserId();
String userName = user.getUserName();
String department = user.getDepartment();
String role = user.getRole();
String password = user.getPassword();
userMapper.updateByUserId(userId, userName, department, role, password);
return Result.success();
}catch (Exception e){
e.printStackTrace();
throw e;
}
}
}
后端代码(mapper层)
ApplyMapper.java
package com.example.day1125demo.Mapper;
import com.example.day1125demo.pojo.Apply;
import org.apache.ibatis.annotations.*;
import java.util.List;
@Mapper
public interface ApplyMapper {
@Insert("INSERT INTO applytable (" +
"applyId, applyName, department, destination, departureDate, returnDate, type, TypeContent, reason, state, stateReason) " +
"VALUES (" +
"#{applyId}, #{applyName}, #{department}, #{destination}, #{departureDate}, #{returnDate}, #{type}, #{typeContent}, #{reason}, #{state}, #{stateReason})")
void insert(Apply apply);
@Delete("delete from applytable where applyId = #{applyId}")
void delete(Apply apply);
@Update("update applytable SET applyId = #{applyId},applyName =#{applyName},department =#{department},destination = #{destination},departureDate =#{departureDate},returnDate=#{returnDate},type=#{type},typeContent = #{typeContent},reason = #{reason},state = #{state},stateReason = #{stateReason} WHERE applyId = #{applyId}")
void update(Apply apply);
@Update("update applytable SET state = #{state}, stateReason = #{stateReason} WHERE applyId = #{applyId}")
void updateState(String state, String stateReason, String applyId);
@Select("SELECT * FROM applytable WHERE applyId = #{applyId} ")
Apply select(String applyId);
@Select("SELECT * FROM applytable")
List<Apply> selectAll();
}
SpendMapper.java
package com.example.day1125demo.Mapper;
import com.example.day1125demo.pojo.Spend;
import org.apache.ibatis.annotations.*;
import java.util.List;
@Mapper
public interface SpendMapper {
@Insert("INSERT INTO spendtable (" +
"spendId, spendName, department, destination, departureDate, returnDate, reason, startFare, returnFare, foodAllowance, localTrans, accommodation, totalAmount, schedule, scheduleReason) " +
"VALUES (" +"#{spendId}, #{spendName}, #{department}, #{destination}, #{departureDate}, #{returnDate}, #{reason}, #{startFare}, #{returnFare}, #{foodAllowance}, #{localTrans}, #{accommodation}, #{totalAmount}, #{schedule}, #{scheduleReason})")
void insert(Spend spend);
@Delete("delete from spendtable where spendId = #{spendId}")
void delete(Spend spend);
@Update("update spendtable SET spendId = #{spendId},spendName =#{spendName},department =#{department},destination = #{destination},departureDate =#{departureDate},returnDate=#{returnDate},reason = #{reason},startFare=#{startFare},returnFare = #{returnFare},foodAllowance = #{foodAllowance},localTrans = #{localTrans},accommodation = #{accommodation},totalAmount = #{totalAmount},schedule = #{schedule},scheduleReason = #{scheduleReason} WHERE spendId = #{spendId}")
void update(Spend spend);
@Update("update spendtable SET schedule = #{schedule}, scheduleReason = #{scheduleReason} WHERE spendId = #{spendId}")
void updateSchedule(String schedule, String scheduleReason, String spendId);
@Select("SELECT * FROM spendtable WHERE spendId = #{spendId} ")
Spend select(String spendId);
@Select("SELECT * from spendtable")
List<Spend> selectAll();
}
UserMapper.java
package com.example.day1125demo.Mapper;
import com.example.day1125demo.pojo.User;
import org.apache.ibatis.annotations.*;
@Mapper
public interface UserMapper {
@Insert("INSERT INTO users(userId, userName, department, role, password) " +
"VALUES(#{userId},#{userName},#{department},#{role},#{password}) ")
void insert(User user);
@Select("SELECT userId, userName, department, role, password FROM users WHERE userId = #{userId} AND password = #{password}" )
User findByUseridAndPassword(String userId, String password);
@Delete("delete from users where userId = #{userId}")
void deleteByUserId(String userId);
@Select("SELECT * FROM users WHERE userId = #{userId} AND department = #{department}")
User findByUserIdAndDepartment(String userId, String department);
@Update("UPDATE users SET userId = #{userId},userName = #{userName},department =#{department},role = #{role},password = #{password} WHERE userId = #{userId}")
// 添加了WHERE条件确保只更新指定userId的记录，避免全表更新
void updateByUserId(String userId, String userName, String department, String role, String password);
}
以上是部分后端代码，仍然存在不完善的地方，需要优化。
下一篇会重点说明书写过程中遇到的跨越问题和解决办法。
浙公网安备 33010602011771号