diff --git a/src/main/java/com/controller/ChatController.java b/src/main/java/com/controller/ChatController.java index 72929cd..3c28be2 100644 --- a/src/main/java/com/controller/ChatController.java +++ b/src/main/java/com/controller/ChatController.java @@ -1,34 +1,63 @@ -package com.controller; + +ppackage com.controller; import java.io.File; +// 导入用于高精度十进制计算的类 import java.math.BigDecimal; +// 导入处理 URL 的类 import java.net.URL; +// 导入用于格式化日期的类 import java.text.SimpleDateFormat; +// 导入阿里巴巴的 JSON 处理类 import com.alibaba.fastjson.JSONObject; +// 导入常用的集合类 import java.util.*; +// 导入 Spring 框架用于 Bean 属性复制的工具类 import org.springframework.beans.BeanUtils; +// 导入 Servlet 请求相关类 import javax.servlet.http.HttpServletRequest; +// 导入 Spring 上下文加载器类 import org.springframework.web.context.ContextLoader; +// 导入 Servlet 上下文类 import javax.servlet.ServletContext; +// 导入自定义的 Token 服务类 import com.service.TokenService; +// 导入自定义的工具类包 import com.utils.*; +// 导入反射调用异常类 import java.lang.reflect.InvocationTargetException; +// 导入自定义的字典服务类 import com.service.DictionaryService; +// 导入 Apache Commons 提供的字符串工具类 import org.apache.commons.lang3.StringUtils; +// 导入自定义的忽略权限注解类 import com.annotation.IgnoreAuth; +// 导入日志记录器接口 import org.slf4j.Logger; +// 导入日志记录器工厂类 import org.slf4j.LoggerFactory; +// 导入 Spring 的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入 Spring 的控制器注解 import org.springframework.stereotype.Controller; +// 导入 Spring 的请求映射注解 import org.springframework.web.bind.annotation.*; +// 导入 MyBatis-Plus 的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入 MyBatis-Plus 的查询包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的实体类包 import com.entity.*; +// 导入自定义的视图实体类包 import com.entity.view.*; +// 导入自定义的服务类包 import com.service.*; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入阿里巴巴的 JSON 处理类 import com.alibaba.fastjson.*; /** @@ -69,37 +98,36 @@ public class ChatController { /** * 后端列表 * 处理获取在线咨询后端列表数据的请求 - * - * @param params 包含请求参数的 Map，如分页参数、排序参数等 + * @param params 包含请求参数的 Map，如分页参数、排序参数等 * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/page") - public R page(@RequestParam Map params, HttpServletRequest request) { + public R page(@RequestParam Map params, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和请求参数 - logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 获取当前用户的角色信息 String role = String.valueOf(request.getSession().getAttribute("role")); // 这个条件永远为 false，这里的代码逻辑可能有误，正常不会进入此分支 - if (false) - return R.error(511, "永不会进入"); + if(false) + return R.error(511,"永不会进入"); // 如果用户角色是 "用户"，则将用户 ID 添加到请求参数中 - else if ("用户".equals(role)) - params.put("yonghuId", request.getSession().getAttribute("userId")); + else if("用户".equals(role)) + params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果用户角色是 "医生"，则将医生 ID 添加到请求参数中 - else if ("医生".equals(role)) - params.put("yishengId", request.getSession().getAttribute("userId")); + else if("医生".equals(role)) + params.put("yishengId",request.getSession().getAttribute("userId")); // 如果请求参数中没有指定排序字段，则默认按 id 排序 - if (params.get("orderBy") == null || params.get("orderBy") == "") { - params.put("orderBy", "id"); + if(params.get("orderBy")==null || params.get("orderBy")==""){ + params.put("orderBy","id"); } // 调用 ChatService 的 queryPage 方法获取分页数据 PageUtils page = chatService.queryPage(params); // 将分页数据中的列表转换为 ChatView 类型的列表 - List list = (List) page.getList(); + List list =(List)page.getList(); // 遍历列表，对每个 ChatView 对象进行字典表数据转换 - for (ChatView c : list) { + for(ChatView c:list){ dictionaryService.dictionaryConvert(c, request); } // 返回成功响应，并将分页数据封装在 data 属性中 @@ -109,29 +137,28 @@ public class ChatController { /** * 后端详情 * 处理获取在线咨询后端详情数据的请求 - * - * @param id 要查询的在线咨询记录的 ID + * @param id 要查询的在线咨询记录的 ID * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request) { + public R info(@PathVariable("id") Long id, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和要查询的 ID - logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 根据 ID 查询在线咨询记录 ChatEntity chat = chatService.selectById(id); // 如果查询到记录 - if (chat != null) { + if(chat !=null){ // 将 ChatEntity 转换为 ChatView ChatView view = new ChatView(); // 使用 BeanUtils 将 ChatEntity 的属性复制到 ChatView 中 - BeanUtils.copyProperties(chat, view); + BeanUtils.copyProperties( chat , view ); // 级联查询用户信息 YonghuEntity yonghu = yonghuService.selectById(chat.getYonghuId()); // 如果查询到用户信息 - if (yonghu != null) { + if(yonghu != null){ // 将用户信息的部分属性复制到 ChatView 中，并排除指定字段 - BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"}); + BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"}); // 设置 ChatView 中的用户 ID view.setYonghuId(yonghu.getId()); } @@ -140,9 +167,9 @@ public class ChatController { dictionaryService.dictionaryConvert(view, request); // 返回成功响应，并将处理后的 ChatView 数据封装在 data 属性中 return R.ok().put("data", view); - } else { + }else { // 如果未查询到记录，返回错误响应 - return R.error(511, "查不到数据"); + return R.error(511,"查不到数据"); } } @@ -150,23 +177,22 @@ public class ChatController { /** * 后端保存 * 处理保存在线咨询记录的请求 - * - * @param chat 要保存的在线咨询实体对象 + * @param chat 要保存的在线咨询实体对象 * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/save") - public R save(@RequestBody ChatEntity chat, HttpServletRequest request) { + public R save(@RequestBody ChatEntity chat, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和要保存的 ChatEntity 对象 - logger.debug("save方法:,,Controller:{},,chat:{}", this.getClass().getName(), chat.toString()); + logger.debug("save方法:,,Controller:{},,chat:{}",this.getClass().getName(),chat.toString()); // 获取当前用户的角色信息 String role = String.valueOf(request.getSession().getAttribute("role")); // 这个条件永远为 false，这里的代码逻辑可能有误，正常不会进入此分支 - if (false) - return R.error(511, "永远不会进入"); + if(false) + return R.error(511,"永远不会进入"); // 如果用户角色是 "用户"，则设置在线咨询记录的用户 ID - else if ("用户".equals(role)) + else if("用户".equals(role)) chat.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 创建查询条件，检查是否已存在相同数据 @@ -178,35 +204,34 @@ public class ChatController { .eq("chat_types", chat.getChatTypes()); // 记录查询条件的 SQL 片段日志 - logger.info("sql语句:" + queryWrapper.getSqlSegment()); + logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 根据查询条件查询是否已存在相同数据 ChatEntity chatEntity = chatService.selectOne(queryWrapper); // 如果不存在相同数据 - if (chatEntity == null) { + if(chatEntity==null){ // 设置插入时间为当前时间 chat.setInsertTime(new Date()); // 插入在线咨询记录 chatService.insert(chat); // 返回成功响应 return R.ok(); - } else { + }else { // 如果存在相同数据，返回错误响应 - return R.error(511, "表中有相同数据"); + return R.error(511,"表中有相同数据"); } } /** * 后端修改 * 处理修改在线咨询记录的请求 - * - * @param chat 要修改的在线咨询实体对象 + * @param chat 要修改的在线咨询实体对象 * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/update") - public R update(@RequestBody ChatEntity chat, HttpServletRequest request) { + public R update(@RequestBody ChatEntity chat, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和要修改的 ChatEntity 对象 - logger.debug("update方法:,,Controller:{},,chat:{}", this.getClass().getName(), chat.toString()); + logger.debug("update方法:,,Controller:{},,chat:{}",this.getClass().getName(),chat.toString()); // 获取当前用户的角色信息 String role = String.valueOf(request.getSession().getAttribute("role")); @@ -217,7 +242,7 @@ public class ChatController { // 创建查询条件，检查是否已存在相同数据（排除当前要修改的记录） Wrapper queryWrapper = new EntityWrapper() - .notIn("id", chat.getId()) + .notIn("id",chat.getId()) .andNew() .eq("yonghu_id", chat.getYonghuId()) .eq("chat_issue", chat.getChatIssue()) @@ -226,32 +251,31 @@ public class ChatController { .eq("chat_types", chat.getChatTypes()); // 记录查询条件的 SQL 片段日志 - logger.info("sql语句:" + queryWrapper.getSqlSegment()); + logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 根据查询条件查询是否已存在相同数据 ChatEntity chatEntity = chatService.selectOne(queryWrapper); // 如果不存在相同数据 - if (chatEntity == null) { + if(chatEntity==null){ // 根据 ID 更新在线咨询记录 chatService.updateById(chat); // 返回成功响应 return R.ok(); - } else { + }else { // 如果存在相同数据，返回错误响应 - return R.error(511, "表中有相同数据"); + return R.error(511,"表中有相同数据"); } } /** * 删除 * 处理删除在线咨询记录的请求 - * * @param ids 要删除的在线咨询记录的 ID 数组 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids) { + public R delete(@RequestBody Integer[] ids){ // 记录调试日志，输出方法名、控制器类名和要删除的 ID 数组 - logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 批量删除在线咨询记录 chatService.deleteBatchIds(Arrays.asList(ids)); // 返回成功响应 @@ -261,50 +285,49 @@ public class ChatController { /** * 批量上传 * 处理批量插入在线咨询记录的请求，从 Excel 文件中读取数据并插入 - * * @param fileName 上传的 Excel 文件的文件名 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/batchInsert") - public R save(String fileName) { + public R save( String fileName){ // 记录调试日志，输出方法名、控制器类名和文件名 - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); try { // 创建用于存储上传的在线咨询实体对象的列表 List chatList = new ArrayList<>(); // 创建用于存储要查询的字段的 Map - Map> seachFields = new HashMap<>(); + Map> seachFields= new HashMap<>(); // 获取当前时间 Date date = new Date(); // 获取文件名的后缀位置 int lastIndexOf = fileName.lastIndexOf("."); // 如果没有找到后缀 - if (lastIndexOf == -1) { + if(lastIndexOf == -1){ // 返回错误响应，提示文件没有后缀 - return R.error(511, "该文件没有后缀"); - } else { + return R.error(511,"该文件没有后缀"); + }else{ // 获取文件后缀 String suffix = fileName.substring(lastIndexOf); // 如果后缀不是.xls - if (!".xls".equals(suffix)) { + if(!".xls".equals(suffix)){ // 返回错误响应，提示只支持.xls 后缀的 Excel 文件 - return R.error(511, "只支持后缀为xls的excel文件"); - } else { + return R.error(511,"只支持后缀为xls的excel文件"); + }else{ // 获取文件的 URL URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 创建文件对象 File file = new File(resource.getFile()); // 如果文件不存在 - if (!file.exists()) { + if(!file.exists()){ // 返回错误响应，提示找不到上传文件 - return R.error(511, "找不到上传文件，请联系管理员"); - } else { + return R.error(511,"找不到上传文件，请联系管理员"); + }else{ // 从 Excel 文件中读取数据 List> dataList = PoiUtil.poiImport(file.getPath()); // 删除第一行（通常是表头） dataList.remove(0); // 遍历数据列表 - for (List data : dataList) { + for(List data:dataList){ // 创建在线咨询实体对象 ChatEntity chatEntity = new ChatEntity(); @@ -320,35 +343,34 @@ public class ChatController { } } } - } catch (Exception e) { + }catch (Exception e){ // 如果发生异常，返回错误响应，提示批量插入数据异常 - return R.error(511, "批量插入数据异常，请联系管理员"); + return R.error(511,"批量插入数据异常，请联系管理员"); } } /** * 前端列表 * 处理获取在线咨询前端列表数据的请求，此方法忽略权限验证 - * - * @param params 包含请求参数的 Map，如分页参数、排序参数等 + * @param params 包含请求参数的 Map，如分页参数、排序参数等 * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request) { + public R list(@RequestParam Map params, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和请求参数 - logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 如果没有指定排序字段，就默认按 id 倒序排序 - if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) { - params.put("orderBy", "id"); + if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ + params.put("orderBy","id"); } // 调用 ChatService 的 queryPage 方法获取分页数据 PageUtils page = chatService.queryPage(params); // 将分页数据中的列表转换为 ChatView 类型的列表 - List list = (List) page.getList(); + List list =(List)page.getList(); // 遍历列表，对每个 ChatView 对象进行字典表数据转换 - for (ChatView c : list) + for(ChatView c:list) dictionaryService.dictionaryConvert(c, request); // 返回成功响应，并将分页数据封装在 data 属性中 return R.ok().put("data", page); @@ -357,30 +379,29 @@ public class ChatController { /** * 前端详情 * 处理获取在线咨询前端详情数据的请求 - * - * @param id 要查询的在线咨询记录的 ID + * @param id 要查询的在线咨询记录的 ID * @param request HttpServletRequest 对象，包含请求的相关信息 * @return R 类型的响应对象，封装了请求处理的结果 */ @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request) { + public R detail(@PathVariable("id") Long id, HttpServletRequest request){ // 记录调试日志，输出方法名、控制器类名和要查询的 ID - logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 根据 ID 查询在线咨询记录 ChatEntity chat = chatService.selectById(id); // 如果查询到记录 - if (chat != null) { + if(chat !=null){ // 将 ChatEntity 转换为 ChatView ChatView view = new ChatView(); // 使用 BeanUtils 将 ChatEntity 的属性复制到 ChatView 中 - BeanUtils.copyProperties(chat, view); + BeanUtils.copyProperties( chat , view ); // 级联查询用户信息 YonghuEntity yonghu = yonghuService.selectById(chat.getYonghuId()); // 如果查询到用户信息 - if (yonghu != null) { + if(yonghu != null){ // 将用户信息的部分属性复制到 ChatView 中，并排除指定字段 - BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createDate"}); + BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"}); // 设置 ChatView 中的用户 ID view.setYonghuId(yonghu.getId()); } @@ -389,10 +410,10 @@ public class ChatController { dictionaryService.dictionaryConvert(view, request); // 返回成功响应，并将处理后的 ChatView 数据封装在 data 属性中 return R.ok().put("data", view); - } else { + }else { // 如果未查询到记录，返回错误响应 - return R.error(511, "查不到数据"); + return R.error(511,"查不到数据"); } } -} +/** \ No newline at end of file diff --git a/src/main/java/com/controller/CommonController.java b/src/main/java/com/controller/CommonController.java index ec44fea..696742c 100644 --- a/src/main/java/com/controller/CommonController.java +++ b/src/main/java/com/controller/CommonController.java @@ -39,26 +39,19 @@ import com.utils.R; * 通用接口 */ @RestController -public class CommonController { - // 用于记录日志 +public class CommonController{ private static final Logger logger = LoggerFactory.getLogger(CommonController.class); // 注入CommonService，处理通用业务逻辑 @Autowired private CommonService commonService; - // 注入ConfigService，用于配置信息的操作 + @Autowired private ConfigService configService; - // 百度人脸识别客户端 + private static AipFace client = null; - // 百度地图AK（Access Key） + private static String BAIDU_DITU_AK = null; - - /** - * 根据经纬度获取城市信息 - * @param lng 经度 - * @param lat 纬度 - * @return 返回包含城市信息的结果对象 - */ + @RequestMapping("/location") public R location(String lng, String lat) { // 如果BAIDU_DITU_AK为空，从配置中获取 @@ -128,8 +121,7 @@ public class CommonController { } catch (IOException e) { // 处理IO异常 e.printStackTrace(); - } - // 返回包含比对结果的数据对象 + } return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString())); } @@ -209,16 +201,13 @@ public class CommonController { */ @RequestMapping("/remind/{tableName}/{columnName}/{type}") @IgnoreAuth - public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, - @PathVariable("type") String type, @RequestParam Map map) { - // 将表名、列名、类型添加到参数Map中 + public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, + @PathVariable("type") String type,@RequestParam Map map) { map.put("table", tableName); map.put("column", columnName); map.put("type", type); - - // 如果类型为日期 - if (type.equals("2")) { - // 创建日期格式化对象 + + if(type.equals("2")) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 获取当前日期 Calendar c = Calendar.getInstance(); @@ -228,10 +217,8 @@ public class CommonController { if (map.get("remindstart") != null) { // 解析提醒开始日期偏移量 Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - // 设置日期 - c.setTime(new Date()); - // 计算提醒开始日期 - c.add(Calendar.DAY_OF_MONTH, remindStart); + c.setTime(new Date()); + c.add(Calendar.DAY_OF_MONTH,remindStart); remindStartDate = c.getTime(); // 将提醒开始日期格式化后添加到参数Map中 map.put("remindstart", sdf.format(remindStartDate)); @@ -249,7 +236,7 @@ public class CommonController { map.put("remindend", sdf.format(remindEndDate)); } } - // 调用CommonService获取提醒记录数 + int count = commonService.remindCount(map); // 返回包含提醒记录数的结果对象 return R.ok().put("count", count); @@ -347,20 +334,21 @@ public class CommonController { } /** - * 查询平均评分 - * @param params 包含查询参数的Map - * @return 返回包含平均评分结果的结果对象 - */ - @IgnoreAuth - @RequestMapping("/queryScore") - public R queryScore(@RequestParam Map params) { - // 记录日志 - logger.debug("queryScore:,,Controller:{},,params:{}", this.getClass().getName(), params); - // 调用CommonService查询平均评分 - Map queryScore = commonService.queryScore(params); - // 返回包含平均评分结果的结果对象 - return R.ok().put("data", queryScore); - } + tableName 查询表 + condition1 条件1 + condition1Value 条件1值 + average 计算平均评分 + 取值 + 有值 Number(res.data.value.toFixed(1)) + 无值 if(res.data){} + * */ + @IgnoreAuth + @RequestMapping("/queryScore") + public R queryScore(@RequestParam Map params) { + logger.debug("queryScore:,,Controller:{},,params:{}",this.getClass().getName(),params); + Map queryScore = commonService.queryScore(params); + return R.ok().put("data", queryScore); + } /** * 查询字典表的分组统计总条数 @@ -433,33 +421,28 @@ public class CommonController { return R.ok().put("data", result); } - /** - * 柱状图求和 - * @param params 包含查询参数的Map - * @return 返回包含柱状图求和结果的结果对象 - */ - @RequestMapping("/barSum") - public R barSum(@RequestParam Map params) { - // 记录日志 - logger.debug("barSum方法:,,Controller:{},,params:{}", this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params)); - // 是否有级联表相关 - Boolean isJoinTableFlag = false; - // 第一优先 - String one = ""; - // 第二优先 - String two = ""; - - // 处理当前表 - Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")), Map.class); - params.put("thisTable", thisTable); - - // 处理级联表 - String joinTableString = String.valueOf(params.get("joinTable")); - if (StringUtil.isNotEmpty(joinTableString)) { - Map joinTable = JSON.parseObject(joinTableString, Map.class); - params.put("joinTable", joinTable); - isJoinTableFlag = true; - } + /** + * 柱状图求和 + */ + @RequestMapping("/barSum") + public R barSum(@RequestParam Map params) { + logger.debug("barSum方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params)); + Boolean isJoinTableFlag = false;//是否有级联表相关 + String one = "";//第一优先 + String two = "";//第二优先 + + //处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组 + //当前表 + Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class); + params.put("thisTable",thisTable); + + //级联表 + String joinTableString = String.valueOf(params.get("joinTable")); + if(StringUtil.isNotEmpty(joinTableString)) { + Map joinTable = JSON.parseObject(joinTableString, Map.class); + params.put("joinTable", joinTable); + isJoinTableFlag = true; + } // 处理当前表日期 if (StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))) { @@ -603,32 +586,27 @@ public class CommonController { } /** - * 柱状图统计 - * @param params 包含查询参数的Map - * @return 返回包含柱状图统计结果的结果对象 - */ - @RequestMapping("/barCount") - public R barCount(@RequestParam Map params) { - // 记录日志 - logger.debug("barCount方法:,,Controller:{},,params:{}", this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params)); - // 是否有级联表相关 - Boolean isJoinTableFlag = false; - // 第一优先 - String one = ""; - // 第二优先 - String two = ""; - - // 处理当前表 - Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")), Map.class); - params.put("thisTable", thisTable); - - // 处理级联表 - String joinTableString = String.valueOf(params.get("joinTable")); - if (StringUtil.isNotEmpty(joinTableString)) { - Map joinTable = JSON.parseObject(joinTableString, Map.class); - params.put("joinTable", joinTable); - isJoinTableFlag = true; - } + * 柱状图统计 + */ + @RequestMapping("/barCount") + public R barCount(@RequestParam Map params) { + logger.debug("barCount方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params)); + Boolean isJoinTableFlag = false;//是否有级联表相关 + String one = "";//第一优先 + String two = "";//第二优先 + + //处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组 + //当前表 + Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class); + params.put("thisTable",thisTable); + + //级联表 + String joinTableString = String.valueOf(params.get("joinTable")); + if(StringUtil.isNotEmpty(joinTableString)) { + Map joinTable = JSON.parseObject(joinTableString, Map.class); + params.put("joinTable", joinTable); + isJoinTableFlag = true; + } // 处理当前表日期 if (StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))) { diff --git a/src/main/java/com/controller/ConfigController.java b/src/main/java/com/controller/ConfigController.java index 6e9f123..9569096 100644 --- a/src/main/java/com/controller/ConfigController.java +++ b/src/main/java/com/controller/ConfigController.java @@ -1,111 +1,156 @@ - package com.controller; - +// 导入用于操作数组的工具类 import java.util.Arrays; +// 导入Map接口，用于存储键值对 import java.util.Map; +// 导入Spring的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的路径变量注解，用于从URL中获取参数 import org.springframework.web.bind.annotation.PathVariable; +// 导入Spring的POST请求映射注解 import org.springframework.web.bind.annotation.PostMapping; +// 导入Spring的请求体注解，用于获取请求体中的数据 import org.springframework.web.bind.annotation.RequestBody; +// 导入Spring的请求映射注解，用于映射请求路径 import org.springframework.web.bind.annotation.RequestMapping; +// 导入Spring的请求参数注解，用于获取请求参数 import org.springframework.web.bind.annotation.RequestParam; +// 导入Spring的RESTful控制器注解 import org.springframework.web.bind.annotation.RestController; +// 导入自定义的忽略权限验证注解 import com.annotation.IgnoreAuth; +// 导入MyBatis-Plus的实体包装器类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入配置实体类 import com.entity.ConfigEntity; +// 导入配置服务接口 import com.service.ConfigService; +// 导入分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入自定义的验证工具类 import com.utils.ValidatorUtils; /** * 登录相关 */ +// 映射请求路径，所有以/config开头的请求都会由该控制器处理 @RequestMapping("config") +// 声明该类为RESTful控制器 @RestController -public class ConfigController{ - - @Autowired - private ConfigService configService; +public class ConfigController { + + // 自动注入配置服务接口的实现类实例 + @Autowired + private ConfigService configService; - /** + /** * 列表 */ + // 映射/page请求路径，支持GET请求 @RequestMapping("/page") - public R page(@RequestParam Map params,ConfigEntity config){ + public R page(@RequestParam Map params, ConfigEntity config) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = configService.queryPage(params); + // 调用配置服务的queryPage方法，根据请求参数进行分页查询 + PageUtils page = configService.queryPage(params); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } - - /** + + /** * 列表 */ + // 映射/list请求路径，支持GET请求，且忽略权限验证 @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params,ConfigEntity config){ + public R list(@RequestParam Map params, ConfigEntity config) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = configService.queryPage(params); + // 调用配置服务的queryPage方法，根据请求参数进行分页查询 + PageUtils page = configService.queryPage(params); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** * 信息 */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") String id){ + public R info(@PathVariable("id") String id) { + // 调用配置服务的selectById方法，根据ID查询配置信息 ConfigEntity config = configService.selectById(id); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 详情 */ + // 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，且忽略权限验证 @IgnoreAuth @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") String id){ + public R detail(@PathVariable("id") String id) { + // 调用配置服务的selectById方法，根据ID查询配置信息 ConfigEntity config = configService.selectById(id); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 根据name获取信息 */ + // 映射/info请求路径，支持GET请求 @RequestMapping("/info") - public R infoByName(@RequestParam String name){ + public R infoByName(@RequestParam String name) { + // 调用配置服务的selectOne方法，根据名称查询配置信息 ConfigEntity config = configService.selectOne(new EntityWrapper().eq("name", "faceFile")); + // 返回成功响应，并将查询到的配置信息放入响应数据中 return R.ok().put("data", config); } - + /** * 保存 */ + // 映射/save请求路径，支持POST请求 @PostMapping("/save") - public R save(@RequestBody ConfigEntity config){ + public R save(@RequestBody ConfigEntity config) { + // 注释掉的代码，原本用于验证实体数据的合法性 // ValidatorUtils.validateEntity(config); - configService.insert(config); + // 调用配置服务的insert方法，将配置信息插入数据库 + configService.insert(config); + // 返回成功响应 return R.ok(); } /** * 修改 */ + // 映射/update请求路径，支持GET或POST请求 @RequestMapping("/update") - public R update(@RequestBody ConfigEntity config){ + public R update(@RequestBody ConfigEntity config) { + // 注释掉的代码，原本用于验证实体数据的合法性 // ValidatorUtils.validateEntity(config); - configService.updateById(config);//全部更新 + // 调用配置服务的updateById方法，根据ID更新配置信息，全部字段更新 + configService.updateById(config); + // 返回成功响应 return R.ok(); } /** * 删除 */ + // 映射/delete请求路径，支持GET或POST请求 @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - configService.deleteBatchIds(Arrays.asList(ids)); + public R delete(@RequestBody Long[] ids) { + // 调用配置服务的deleteBatchIds方法，根据ID数组批量删除配置信息 + configService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/DictionaryController.java b/src/main/java/com/controller/DictionaryController.java index 489f8a8..33da60e 100644 --- a/src/main/java/com/controller/DictionaryController.java +++ b/src/main/java/com/controller/DictionaryController.java @@ -1,35 +1,62 @@ - package com.controller; +// 导入文件操作类 import java.io.File; +// 导入用于高精度计算的类 import java.math.BigDecimal; +// 导入用于处理URL的类 import java.net.URL; +// 导入用于日期格式化的类 import java.text.SimpleDateFormat; +// 导入阿里巴巴的JSON对象类 import com.alibaba.fastjson.JSONObject; +// 导入常用的集合类 import java.util.*; +// 导入Spring的Bean属性复制工具类 import org.springframework.beans.BeanUtils; +// 导入Servlet请求相关类 import javax.servlet.http.HttpServletRequest; +// 导入Spring的上下文加载器类 import org.springframework.web.context.ContextLoader; +// 导入Servlet上下文类 import javax.servlet.ServletContext; +// 导入令牌服务类 import com.service.TokenService; +// 导入自定义工具类 import com.utils.*; +// 导入反射调用异常类 import java.lang.reflect.InvocationTargetException; - +// 导入字典服务类 import com.service.DictionaryService; +// 导入Apache Commons提供的字符串工具类 import org.apache.commons.lang3.StringUtils; +// 导入自定义的忽略权限注解类 import com.annotation.IgnoreAuth; +// 导入日志记录器接口 import org.slf4j.Logger; +// 导入日志记录器工厂类 import org.slf4j.LoggerFactory; +// 导入Spring的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的控制器注解 import org.springframework.stereotype.Controller; +// 导入Spring的请求映射注解 import org.springframework.web.bind.annotation.*; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的查询包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的实体类 import com.entity.*; +// 导入自定义的视图类 import com.entity.view.*; +// 导入自定义的服务类 import com.service.*; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入阿里巴巴的JSON工具类 import com.alibaba.fastjson.*; /** @@ -37,214 +64,284 @@ import com.alibaba.fastjson.*; * 后端接口 * @author * @email -*/ + */ +// 声明该类为RESTful控制器 @RestController +// 声明该类为控制器 @Controller +// 映射请求路径，所有以/dictionary开头的请求都会由该控制器处理 @RequestMapping("/dictionary") public class DictionaryController { + // 日志记录器，用于记录当前控制器类的日志信息 private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class); - @Autowired - private DictionaryService dictionaryService; - - - @Autowired - private TokenService tokenService; - - //级联表service - - @Autowired + // 此处注解有误，应为@Autowired，自动注入用户服务类 + @Autow private YonghuService yonghuService; + // 自动注入医生服务类 @Autowired private YishengService yishengService; - /** - * 后端列表 - */ + * 后端列表 + */ + // 映射/page请求路径，支持GET请求，且忽略权限验证 @RequestMapping("/page") @IgnoreAuth - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果请求参数中没有指定排序字段，则默认按id排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用字典服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = dictionaryService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(DictionaryView c:list){ - //修改对应字典表字段 + // 将分页结果中的列表转换为字典视图列表 + List list = (List) page.getList(); + // 遍历字典视图列表 + for (DictionaryView c : list) { + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(c, request); } + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用字典服务的selectById方法，根据id查询字典实体 DictionaryEntity dictionary = dictionaryService.selectById(id); - if(dictionary !=null){ - //entity转view + // 如果查询到字典实体 + if (dictionary != null) { + // 创建字典视图对象 DictionaryView view = new DictionaryView(); - BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中 - - //修改对应字典表字段 + // 使用BeanUtils将字典实体的属性复制到字典视图中 + BeanUtils.copyProperties(dictionary, view); + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将字典视图对象放入响应数据中 return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存 + */ + // 映射/save请求路径，支持POST请求 @RequestMapping("/save") - public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); - + public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的字典实体信息 + logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); - + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件 Wrapper queryWrapper = new EntityWrapper() - .eq("dic_code", dictionary.getDicCode()) - .eq("index_name", dictionary.getIndexName()) - ; - if(dictionary.getDicCode().contains("_erji_types")){ - queryWrapper.eq("super_id",dictionary.getSuperId()); + .eq("dic_code", dictionary.getDicCode()) + .eq("index_name", dictionary.getIndexName()); + // 如果字典代码包含_erji_types，则添加super_id的查询条件 + if (dictionary.getDicCode().contains("_erji_types")) { + queryWrapper.eq("super_id", dictionary.getSuperId()); } - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据 DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); - if(dictionaryEntity==null){ + // 如果未查询到相同数据 + if (dictionaryEntity == null) { + // 设置字典实体的创建时间为当前时间 dictionary.setCreateTime(new Date()); + // 调用字典服务的insert方法，将字典实体插入数据库 dictionaryService.insert(dictionary); - //字典表新增数据,把数据再重新查出,放入监听器中 + // 查询所有字典实体 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 获取Servlet上下文 ServletContext servletContext = request.getServletContext(); - Map> map = new HashMap<>(); - for(DictionaryEntity d :dictionaryEntities){ + // 创建一个Map用于存储字典数据 + Map> map = new HashMap<>(); + // 遍历所有字典实体 + for (DictionaryEntity d : dictionaryEntities) { + // 获取当前字典代码对应的子Map Map m = map.get(d.getDicCode()); - if(m ==null || m.isEmpty()){ + // 如果子Map为空，则创建一个新的子Map + if (m == null || m.isEmpty()) { m = new HashMap<>(); } - m.put(d.getCodeIndex(),d.getIndexName()); - map.put(d.getDicCode(),m); + // 将当前字典实体的代码索引和索引名称存入子Map + m.put(d.getCodeIndex(), d.getIndexName()); + // 将子Map存入主Map + map.put(d.getDicCode(), m); } - servletContext.setAttribute("dictionaryMap",map); + // 将主Map存入Servlet上下文的属性中 + servletContext.setAttribute("dictionaryMap", map); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改 + */ + // 映射/update请求路径，支持POST请求 @RequestMapping("/update") - public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); - + public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要修改的字典实体信息 + logger.debug("update方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); - //根据字段查询是否有相同数据 + // 此条件注释掉，表示永远不会进入该分支 +// if (false) +// return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，排除当前要修改的记录 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",dictionary.getId()) - .eq("dic_code", dictionary.getDicCode()) - .eq("index_name", dictionary.getIndexName()) - ; - - if(dictionary.getDicCode().contains("_erji_types")){ - queryWrapper.eq("super_id",dictionary.getSuperId()); + .notIn("id", dictionary.getId()) + .eq("dic_code", dictionary.getDicCode()) + .eq("index_name", dictionary.getIndexName()); + // 如果字典代码包含_erji_types，则添加super_id的查询条件 + if (dictionary.getDicCode().contains("_erji_types")) { + queryWrapper.eq("super_id", dictionary.getSuperId()); } - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据 DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); - if(dictionaryEntity==null){ - dictionaryService.updateById(dictionary);//根据id更新 - //如果字典表修改数据的话,把数据再重新查出,放入监听器中 + // 如果未查询到相同数据 + if (dictionaryEntity == null) { + // 调用字典服务的updateById方法，根据id更新字典实体 + dictionaryService.updateById(dictionary); + // 查询所有字典实体 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 获取Servlet上下文 ServletContext servletContext = request.getServletContext(); - Map> map = new HashMap<>(); - for(DictionaryEntity d :dictionaryEntities){ + // 创建一个Map用于存储字典数据 + Map> map = new HashMap<>(); + // 遍历所有字典实体 + for (DictionaryEntity d : dictionaryEntities) { + // 获取当前字典代码对应的子Map Map m = map.get(d.getDicCode()); - if(m ==null || m.isEmpty()){ + // 如果子Map为空，则创建一个新的子Map + if (m == null || m.isEmpty()) { m = new HashMap<>(); } - m.put(d.getCodeIndex(),d.getIndexName()); - map.put(d.getDicCode(),m); + // 将当前字典实体的代码索引和索引名称存入子Map + m.put(d.getCodeIndex(), d.getIndexName()); + // 将子Map存入主Map + map.put(d.getDicCode(), m); } - servletContext.setAttribute("dictionaryMap",map); + // 将主Map存入Servlet上下文的属性中 + servletContext.setAttribute("dictionaryMap", map); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 删除 - */ + * 删除 + */ + // 映射/delete请求路径，支持POST请求 @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + public R delete(@RequestBody Integer[] ids) { + // 记录方法调用日志，包含控制器类名和要删除的记录id数组 + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用字典服务的deleteBatchIds方法，根据id数组批量删除记录 dictionaryService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } /** * 最大值 */ + // 映射/maxCodeIndex请求路径，支持POST请求 @RequestMapping("/maxCodeIndex") - public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){ - logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); + public R maxCodeIndex(@RequestBody DictionaryEntity dictionary) { + // 记录方法调用日志，包含控制器类名和传入的字典实体信息 + logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 创建一个列表，用于存储排序字段 List descs = new ArrayList<>(); + // 添加按code_index降序排序的字段 descs.add("code_index"); + // 创建查询包装器，用于构建查询条件 Wrapper queryWrapper = new EntityWrapper() .eq("dic_code", dictionary.getDicCode()) .orderDesc(descs); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectList方法，根据查询条件查询字典实体列表 List dictionaryEntityList = dictionaryService.selectList(queryWrapper); - if(dictionaryEntityList != null ){ - return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1); - }else{ - return R.ok().put("maxCodeIndex",1); + // 如果查询到的列表不为空 + if (dictionaryEntityList != null) { + // 返回成功响应，并将最大的code_index加1作为结果放入响应数据中 + return R.ok().put("maxCodeIndex", dictionaryEntityList.get(0).getCodeIndex() + 1); + } else { + // 如果未查询到数据，返回成功响应，并将最大的code_index设为1 + return R.ok().put("maxCodeIndex", 1); } } /** * 批量上传 */ + // 映射/batchInsert请求路径，支持POST请求 @RequestMapping("/batchInsert") - public R save( String fileName){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); try { - List dictionaryList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + // 创建一个列表，用于存储要上传的字典实体 + List dictionaryList = new ArrayList<>(); + // 创建一个Map，用于存储要查询的字段 + Map> seachFields = new HashMap<>(); + // 获取当前时间 Date date = new Date(); + // 获取文件名中最后一个点的索引 int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + // 如果文件名中没有点，返回错误响应，错误码为511 + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { + // 获取文件后缀 String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + // 如果文件后缀不是.xls，返回错误响应，错误码为511 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 获取文件的URL + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); + // 创建文件对象 File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + // 如果文件不存在，返回错误响应，错误码为511 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 使用PoiUtil工具类读取xls文件的数据 + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除第一行数据，因为第一行通常是表头 + dataList.remove(0); + // 遍历数据列表 + for (List data : dataList) { + // 创建一个新的字典实体 DictionaryEntity dictionaryEntity = new DictionaryEntity(); + // 以下代码注释掉，表示需要根据实际情况修改字段赋值 // dictionaryEntity.setDicCode(data.get(0)); //字段 要改的 // dictionaryEntity.setDicName(data.get(0)); //字段名 要改的 // dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的 @@ -252,26 +349,22 @@ public class DictionaryController { // dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的 // dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的 // dictionaryEntity.setCreateTime(date);//时间 + // 将字典实体添加到上传列表中 dictionaryList.add(dictionaryEntity); - - //把要查询是否重复的字段放入map中 + // 把要查询是否重复的字段放入map中 } - //查询是否重复 + // 调用字典服务的insertBatch方法，批量插入字典实体 dictionaryService.insertBatch(dictionaryList); + // 返回成功响应 return R.ok(); } } } - }catch (Exception e){ - return R.error(511,"批量插入数据异常，请联系管理员"); + } catch (Exception e) { + // 如果发生异常，返回错误响应，错误码为511 + return R.error(511, "批量插入数据异常，请联系管理员"); } } - - - - - - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/FileController.java b/src/main/java/com/controller/FileController.java index 7bd4f8e..a5d1e85 100644 --- a/src/main/java/com/controller/FileController.java +++ b/src/main/java/com/controller/FileController.java @@ -1,110 +1,370 @@ package com.controller; +// 导入文件操作类 import java.io.File; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.util.Arrays; -import java.util.Date; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Random; -import java.util.UUID; - -import org.apache.commons.io.FileUtils; +// 导入用于高精度计算的类 +import java.math.BigDecimal; +// 导入用于处理URL的类 +import java.net.URL; +// 导入用于日期格式化的类 +import java.text.SimpleDateFormat; +// 导入阿里巴巴的JSON对象类 +import com.alibaba.fastjson.JSONObject; +// 导入常用的集合类 +import java.util.*; +// 导入Spring的Bean属性复制工具类 +import org.springframework.beans.BeanUtils; +// 导入Servlet请求相关类 +import javax.servlet.http.HttpServletRequest; +// 导入Spring的上下文加载器类 +import org.springframework.web.context.ContextLoader; +// 导入Servlet上下文类 +import javax.servlet.ServletContext; +// 导入令牌服务类 +import com.service.TokenService; +// 导入自定义工具类 +import com.utils.*; +// 导入反射调用异常类 +import java.lang.reflect.InvocationTargetException; +// 导入字典服务类 +import com.service.DictionaryService; +// 导入Apache Commons提供的字符串工具类 import org.apache.commons.lang3.StringUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpStatus; -import org.springframework.http.MediaType; -import org.springframework.http.ResponseEntity; -import org.springframework.util.ResourceUtils; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; -import org.springframework.web.multipart.MultipartFile; - +// 导入自定义的忽略权限注解类 import com.annotation.IgnoreAuth; +// 导入日志记录器接口 +import org.slf4j.Logger; +// 导入日志记录器工厂类 +import org.slf4j.LoggerFactory; +// 导入Spring的自动注入注解 +import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的控制器注解 +import org.springframework.stereotype.Controller; +// 导入Spring的请求映射注解 +import org.springframework.web.bind.annotation.*; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; -import com.entity.ConfigEntity; -import com.entity.EIException; -import com.service.ConfigService; +// 导入MyBatis-Plus的查询包装器接口 +import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的实体类 +import com.entity.*; +// 导入自定义的视图类 +import com.entity.view.*; +// 导入自定义的服务类 +import com.service.*; +// 导入自定义的分页工具类 +import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入阿里巴巴的JSON工具类 +import com.alibaba.fastjson.*; /** - * 上传文件映射表 + * 字典表 + * 后端接口 + * @author + * @email */ +// 声明该类为RESTful控制器 @RestController -@RequestMapping("file") -@SuppressWarnings({"unchecked","rawtypes"}) -public class FileController{ +// 声明该类为控制器 +@Controller +// 映射请求路径，所有以/dictionary开头的请求都会由该控制器处理 +@RequestMapping("/dictionary") +public class DictionaryController { + // 日志记录器，用于记录当前控制器类的日志信息 + private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class); + + // 此处注解有误，应为@Autowired，自动注入用户服务类 + @Autow + private YonghuService yonghuService; + // 自动注入医生服务类 @Autowired - private ConfigService configService; + private YishengService yishengService; + /** - * 上传文件 + * 后端列表 */ - @RequestMapping("/upload") - public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception { - if (file.isEmpty()) { - throw new EIException("上传文件不能为空"); + // 映射/page请求路径，支持GET请求，且忽略权限验证 + @RequestMapping("/page") + @IgnoreAuth + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果请求参数中没有指定排序字段，则默认按id排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } - String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1); - File path = new File(ResourceUtils.getURL("classpath:static").getPath()); - if(!path.exists()) { - path = new File(""); + // 调用字典服务的queryPage方法，根据请求参数进行分页查询 + PageUtils page = dictionaryService.queryPage(params); + + // 将分页结果中的列表转换为字典视图列表 + List list = (List) page.getList(); + // 遍历字典视图列表 + for (DictionaryView c : list) { + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(c, request); } - File upload = new File(path.getAbsolutePath(),"/upload/"); - if(!upload.exists()) { - upload.mkdirs(); + // 返回成功响应，并将分页查询结果放入响应数据中 + return R.ok().put("data", page); + } + + /** + * 后端详情 + */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量 + @RequestMapping("/info/{id}") + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用字典服务的selectById方法，根据id查询字典实体 + DictionaryEntity dictionary = dictionaryService.selectById(id); + // 如果查询到字典实体 + if (dictionary != null) { + // 创建字典视图对象 + DictionaryView view = new DictionaryView(); + // 使用BeanUtils将字典实体的属性复制到字典视图中 + BeanUtils.copyProperties(dictionary, view); + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将字典视图对象放入响应数据中 + return R.ok().put("data", view); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); } - String fileName = new Date().getTime()+"."+fileExt; - File dest = new File(upload.getAbsolutePath()+"/"+fileName); - file.transferTo(dest); - if(StringUtils.isNotBlank(type) && type.equals("1")) { - ConfigEntity configEntity = configService.selectOne(new EntityWrapper().eq("name", "faceFile")); - if(configEntity==null) { - configEntity = new ConfigEntity(); - configEntity.setName("faceFile"); - configEntity.setValue(fileName); - } else { - configEntity.setValue(fileName); + } + + /** + * 后端保存 + */ + // 映射/save请求路径，支持POST请求 + @RequestMapping("/save") + public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的字典实体信息 + logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 从请求会话中获取用户角色 + String role = String.valueOf(request.getSession().getAttribute("role")); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件 + Wrapper queryWrapper = new EntityWrapper() + .eq("dic_code", dictionary.getDicCode()) + .eq("index_name", dictionary.getIndexName()); + // 如果字典代码包含_erji_types，则添加super_id的查询条件 + if (dictionary.getDicCode().contains("_erji_types")) { + queryWrapper.eq("super_id", dictionary.getSuperId()); + } + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据 + DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); + // 如果未查询到相同数据 + if (dictionaryEntity == null) { + // 设置字典实体的创建时间为当前时间 + dictionary.setCreateTime(new Date()); + // 调用字典服务的insert方法，将字典实体插入数据库 + dictionaryService.insert(dictionary); + // 查询所有字典实体 + List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 获取Servlet上下文 + ServletContext servletContext = request.getServletContext(); + // 创建一个Map用于存储字典数据 + Map> map = new HashMap<>(); + // 遍历所有字典实体 + for (DictionaryEntity d : dictionaryEntities) { + // 获取当前字典代码对应的子Map + Map m = map.get(d.getDicCode()); + // 如果子Map为空，则创建一个新的子Map + if (m == null || m.isEmpty()) { + m = new HashMap<>(); + } + // 将当前字典实体的代码索引和索引名称存入子Map + m.put(d.getCodeIndex(), d.getIndexName()); + // 将子Map存入主Map + map.put(d.getDicCode(), m); } - configService.insertOrUpdate(configEntity); + // 将主Map存入Servlet上下文的属性中 + servletContext.setAttribute("dictionaryMap", map); + // 返回成功响应 + return R.ok(); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } - return R.ok().put("file", fileName); } - + /** - * 下载文件 + * 后端修改 */ - @IgnoreAuth - @RequestMapping("/download") - public ResponseEntity download(@RequestParam String fileName) { - try { - File path = new File(ResourceUtils.getURL("classpath:static").getPath()); - if(!path.exists()) { - path = new File(""); - } - File upload = new File(path.getAbsolutePath(),"/upload/"); - if(!upload.exists()) { - upload.mkdirs(); + // 映射/update请求路径，支持POST请求 + @RequestMapping("/update") + public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要修改的字典实体信息 + logger.debug("update方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 从请求会话中获取用户角色 + String role = String.valueOf(request.getSession().getAttribute("role")); + // 此条件注释掉，表示永远不会进入该分支 +// if (false) +// return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，排除当前要修改的记录 + Wrapper queryWrapper = new EntityWrapper() + .notIn("id", dictionary.getId()) + .eq("dic_code", dictionary.getDicCode()) + .eq("index_name", dictionary.getIndexName()); + // 如果字典代码包含_erji_types，则添加super_id的查询条件 + if (dictionary.getDicCode().contains("_erji_types")) { + queryWrapper.eq("super_id", dictionary.getSuperId()); + } + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectOne方法，根据查询条件查询是否存在相同数据 + DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); + // 如果未查询到相同数据 + if (dictionaryEntity == null) { + // 调用字典服务的updateById方法，根据id更新字典实体 + dictionaryService.updateById(dictionary); + // 查询所有字典实体 + List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 获取Servlet上下文 + ServletContext servletContext = request.getServletContext(); + // 创建一个Map用于存储字典数据 + Map> map = new HashMap<>(); + // 遍历所有字典实体 + for (DictionaryEntity d : dictionaryEntities) { + // 获取当前字典代码对应的子Map + Map m = map.get(d.getDicCode()); + // 如果子Map为空，则创建一个新的子Map + if (m == null || m.isEmpty()) { + m = new HashMap<>(); + } + // 将当前字典实体的代码索引和索引名称存入子Map + m.put(d.getCodeIndex(), d.getIndexName()); + // 将子Map存入主Map + map.put(d.getDicCode(), m); } - File file = new File(upload.getAbsolutePath()+"/"+fileName); - if(file.exists()){ - /*if(!fileService.canRead(file, SessionManager.getSessionUser())){ - getResponse().sendError(403); - }*/ - HttpHeaders headers = new HttpHeaders(); - headers.setContentType(MediaType.APPLICATION_OCTET_STREAM); - headers.setContentDispositionFormData("attachment", fileName); - return new ResponseEntity(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED); + // 将主Map存入Servlet上下文的属性中 + servletContext.setAttribute("dictionaryMap", map); + // 返回成功响应 + return R.ok(); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); + } + } + + /** + * 删除 + */ + // 映射/delete请求路径，支持POST请求 + @RequestMapping("/delete") + public R delete(@RequestBody Integer[] ids) { + // 记录方法调用日志，包含控制器类名和要删除的记录id数组 + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用字典服务的deleteBatchIds方法，根据id数组批量删除记录 + dictionaryService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 + return R.ok(); + } + + /** + * 最大值 + */ + // 映射/maxCodeIndex请求路径，支持POST请求 + @RequestMapping("/maxCodeIndex") + public R maxCodeIndex(@RequestBody DictionaryEntity dictionary) { + // 记录方法调用日志，包含控制器类名和传入的字典实体信息 + logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + // 创建一个列表，用于存储排序字段 + List descs = new ArrayList<>(); + // 添加按code_index降序排序的字段 + descs.add("code_index"); + // 创建查询包装器，用于构建查询条件 + Wrapper queryWrapper = new EntityWrapper() + .eq("dic_code", dictionary.getDicCode()) + .orderDesc(descs); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用字典服务的selectList方法，根据查询条件查询字典实体列表 + List dictionaryEntityList = dictionaryService.selectList(queryWrapper); + // 如果查询到的列表不为空 + if (dictionaryEntityList != null) { + // 返回成功响应，并将最大的code_index加1作为结果放入响应数据中 + return R.ok().put("maxCodeIndex", dictionaryEntityList.get(0).getCodeIndex() + 1); + } else { + // 如果未查询到数据，返回成功响应，并将最大的code_index设为1 + return R.ok().put("maxCodeIndex", 1); + } + } + + /** + * 批量上传 + */ + // 映射/batchInsert请求路径，支持POST请求 + @RequestMapping("/batchInsert") + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); + try { + // 创建一个列表，用于存储要上传的字典实体 + List dictionaryList = new ArrayList<>(); + // 创建一个Map，用于存储要查询的字段 + Map> seachFields = new HashMap<>(); + // 获取当前时间 + Date date = new Date(); + // 获取文件名中最后一个点的索引 + int lastIndexOf = fileName.lastIndexOf("."); + // 如果文件名中没有点，返回错误响应，错误码为511 + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { + // 获取文件后缀 + String suffix = fileName.substring(lastIndexOf); + // 如果文件后缀不是.xls，返回错误响应，错误码为511 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 获取文件的URL + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); + // 创建文件对象 + File file = new File(resource.getFile()); + // 如果文件不存在，返回错误响应，错误码为511 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 使用PoiUtil工具类读取xls文件的数据 + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除第一行数据，因为第一行通常是表头 + dataList.remove(0); + // 遍历数据列表 + for (List data : dataList) { + // 创建一个新的字典实体 + DictionaryEntity dictionaryEntity = new DictionaryEntity(); + // 以下代码注释掉，表示需要根据实际情况修改字段赋值 +// dictionaryEntity.setDicCode(data.get(0)); //字段 要改的 +// dictionaryEntity.setDicName(data.get(0)); //字段名 要改的 +// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的 +// dictionaryEntity.setIndexName(data.get(0)); //编码名字 要改的 +// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的 +// dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的 +// dictionaryEntity.setCreateTime(date);//时间 + // 将字典实体添加到上传列表中 + dictionaryList.add(dictionaryEntity); + + // 把要查询是否重复的字段放入map中 + } + + // 调用字典服务的insertBatch方法，批量插入字典实体 + dictionaryService.insertBatch(dictionaryList); + // 返回成功响应 + return R.ok(); + } + } } - } catch (IOException e) { - e.printStackTrace(); + } catch (Exception e) { + // 如果发生异常，返回错误响应，错误码为511 + return R.error(511, "批量插入数据异常，请联系管理员"); } - return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR); } - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/GuahaoController.java b/src/main/java/com/controller/GuahaoController.java index f953ab6..e0c609f 100644 --- a/src/main/java/com/controller/GuahaoController.java +++ b/src/main/java/com/controller/GuahaoController.java @@ -1,35 +1,63 @@ - package com.controller; +// 导入文件操作相关类 import java.io.File; +// 导入用于高精度计算的类 import java.math.BigDecimal; +// 导入用于处理URL的类 import java.net.URL; +// 导入用于日期格式化的类 import java.text.SimpleDateFormat; +// 导入阿里巴巴的JSON对象类 import com.alibaba.fastjson.JSONObject; +// 导入常用的集合类 import java.util.*; +// 导入Spring的Bean属性复制工具类 import org.springframework.beans.BeanUtils; +// 导入Servlet请求相关类 import javax.servlet.http.HttpServletRequest; +// 导入Spring的上下文加载器类 import org.springframework.web.context.ContextLoader; +// 导入Servlet上下文类 import javax.servlet.ServletContext; +// 导入令牌服务类 import com.service.TokenService; +// 导入自定义工具类 import com.utils.*; +// 导入反射调用异常类 import java.lang.reflect.InvocationTargetException; +// 导入字典服务类 import com.service.DictionaryService; +// 导入Apache Commons提供的字符串工具类 import org.apache.commons.lang3.StringUtils; +// 导入自定义的忽略权限注解类 import com.annotation.IgnoreAuth; +// 导入日志记录器接口 import org.slf4j.Logger; +// 导入日志记录器工厂类 import org.slf4j.LoggerFactory; +// 导入Spring的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的控制器注解 import org.springframework.stereotype.Controller; +// 导入Spring的请求映射注解 import org.springframework.web.bind.annotation.*; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的查询包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的实体类 import com.entity.*; +// 导入自定义的视图类 import com.entity.view.*; +// 导入自定义的服务类 import com.service.*; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入阿里巴巴的JSON工具类 import com.alibaba.fastjson.*; /** @@ -37,205 +65,276 @@ import com.alibaba.fastjson.*; * 后端接口 * @author * @email -*/ + */ +// 声明该类为RESTful控制器 @RestController +// 声明该类为控制器 @Controller +// 映射请求路径，所有以/guahao开头的请求都会由该控制器处理 @RequestMapping("/guahao") public class GuahaoController { + // 日志记录器，用于记录当前控制器类的日志信息 private static final Logger logger = LoggerFactory.getLogger(GuahaoController.class); + // 自动注入挂号服务类，用于处理挂号相关业务逻辑 @Autowired private GuahaoService guahaoService; - + // 自动注入令牌服务类 @Autowired private TokenService tokenService; + // 自动注入字典服务类 @Autowired private DictionaryService dictionaryService; - //级联表service + // 级联表service，自动注入医生服务类 @Autowired private YishengService yishengService; + // 级联表service，自动注入用户服务类 @Autowired private YonghuService yonghuService; - - /** - * 后端列表 - */ + * 后端列表 + */ + // 映射/page请求路径，支持GET请求 @RequestMapping("/page") - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永不会进入"); - else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); - else if("医生".equals(role)) - params.put("yishengId",request.getSession().getAttribute("userId")); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永不会进入"); + // 如果用户角色为"用户" + else if ("用户".equals(role)) + // 在请求参数中添加用户id + params.put("yonghuId", request.getSession().getAttribute("userId")); + // 如果用户角色为"医生" + else if ("医生".equals(role)) + // 在请求参数中添加医生id + params.put("yishengId", request.getSession().getAttribute("userId")); + // 如果请求参数中没有指定排序字段，则默认按id排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用挂号服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = guahaoService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(GuahaoView c:list){ - //修改对应字典表字段 + // 将分页结果中的列表转换为挂号视图列表 + List list = (List) page.getList(); + // 遍历挂号视图列表 + for (GuahaoView c : list) { + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(c, request); } + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用挂号服务的selectById方法，根据id查询挂号实体 GuahaoEntity guahao = guahaoService.selectById(id); - if(guahao !=null){ - //entity转view + // 如果查询到挂号实体 + if (guahao != null) { + // 创建挂号视图对象 GuahaoView view = new GuahaoView(); - BeanUtils.copyProperties( guahao , view );//把实体数据重构到view中 - - //级联表 - YishengEntity yisheng = yishengService.selectById(guahao.getYishengId()); - if(yisheng != null){ - BeanUtils.copyProperties( yisheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYishengId(yisheng.getId()); - } - //级联表 - YonghuEntity yonghu = yonghuService.selectById(guahao.getYonghuId()); - if(yonghu != null){ - BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYonghuId(yonghu.getId()); - } - //修改对应字典表字段 + // 使用BeanUtils将挂号实体的属性复制到挂号视图中 + BeanUtils.copyProperties(guahao, view); + + // 级联查询医生信息 + YishengEntity yisheng = yishengService.selectById(guahao.getYishengId()); + // 如果查询到医生信息 + if (yisheng != null) { + // 将医生信息的部分属性复制到挂号视图中，并排除指定字段 + BeanUtils.copyProperties(yisheng, view, new String[]{"id", "createTime", "insertTime", "updateTime"}); + // 设置挂号视图中的医生id + view.setYishengId(yisheng.getId()); + } + // 级联查询用户信息 + YonghuEntity yonghu = yonghuService.selectById(guahao.getYonghuId()); + // 如果查询到用户信息 + if (yonghu != null) { + // 将用户信息的部分属性复制到挂号视图中，并排除指定字段 + BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"}); + // 设置挂号视图中的用户id + view.setYonghuId(yonghu.getId()); + } + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将挂号视图对象放入响应数据中 return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存 + */ + // 映射/save请求路径，支持POST请求 @RequestMapping("/save") - public R save(@RequestBody GuahaoEntity guahao, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,guahao:{}",this.getClass().getName(),guahao.toString()); - + public R save(@RequestBody GuahaoEntity guahao, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的挂号实体信息 + logger.debug("save方法:,,Controller:{},,guahao:{}", this.getClass().getName(), guahao.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); - else if("医生".equals(role)) + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永远不会进入"); + // 如果用户角色为"医生" + else if ("医生".equals(role)) + // 设置挂号实体的医生id为当前会话中的用户id guahao.setYishengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); - else if("用户".equals(role)) + // 如果用户角色为"用户" + else if ("用户".equals(role)) + // 设置挂号实体的用户id为当前会话中的用户id guahao.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); + // 创建查询包装器，用于构建查询条件 Wrapper queryWrapper = new EntityWrapper() - .eq("yisheng_id", guahao.getYishengId()) - .eq("yonghu_id", guahao.getYonghuId()) - .eq("guahao_uuin_number", guahao.getGuahaoUuinNumber()) - .eq("guahao_time", new SimpleDateFormat("yyyy-MM-dd").format(guahao.getGuahaoTime())) - .eq("guahao_types", guahao.getGuahaoTypes()) - .eq("guahao_status_types", guahao.getGuahaoStatusTypes()) - .eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes()) - .eq("guahao_yesno_text", guahao.getGuahaoYesnoText()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .eq("yisheng_id", guahao.getYishengId()) + .eq("yonghu_id", guahao.getYonghuId()) + .eq("guahao_uuin_number", guahao.getGuahaoUuinNumber()) + .eq("guahao_time", new SimpleDateFormat("yyyy-MM-dd").format(guahao.getGuahaoTime())) + .eq("guahao_types", guahao.getGuahaoTypes()) + .eq("guahao_status_types", guahao.getGuahaoStatusTypes()) + .eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes()) + .eq("guahao_yesno_text", guahao.getGuahaoYesnoText()); + + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用挂号服务的selectOne方法，根据查询条件查询是否存在相同数据 GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper); - if(guahaoEntity==null){ + // 如果未查询到相同数据 + if (guahaoEntity == null) { + // 设置挂号审核类型为1 guahao.setGuahaoYesnoTypes(1); + // 设置挂号实体的创建时间为当前时间 guahao.setCreateTime(new Date()); + // 调用挂号服务的insert方法，将挂号实体插入数据库 guahaoService.insert(guahao); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改 + */ + // 映射/update请求路径，支持POST请求 @RequestMapping("/update") - public R update(@RequestBody GuahaoEntity guahao, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,guahao:{}",this.getClass().getName(),guahao.toString()); - + public R update(@RequestBody GuahaoEntity guahao, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要修改的挂号实体信息 + logger.debug("update方法:,,Controller:{},,guahao:{}", this.getClass().getName(), guahao.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); -// else if("医生".equals(role)) + // 此条件注释掉，表示永远不会进入该分支 +// if (false) +// return R.error(511, "永远不会进入"); +// else if ("医生".equals(role)) // guahao.setYishengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); -// else if("用户".equals(role)) +// else if ("用户".equals(role)) // guahao.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); - //根据字段查询是否有相同数据 + // 创建查询包装器，用于构建查询条件，排除当前要修改的记录 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",guahao.getId()) - .andNew() - .eq("yisheng_id", guahao.getYishengId()) - .eq("yonghu_id", guahao.getYonghuId()) - .eq("guahao_uuin_number", guahao.getGuahaoUuinNumber()) - .eq("guahao_time", guahao.getGuahaoTime()) - .eq("guahao_types", guahao.getGuahaoTypes()) - .eq("guahao_status_types", guahao.getGuahaoStatusTypes()) - .eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes()) - .eq("guahao_yesno_text", guahao.getGuahaoYesnoText()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .notIn("id", guahao.getId()) + .andNew() + .eq("yisheng_id", guahao.getYishengId()) + .eq("yonghu_id", guahao.getYonghuId()) + .eq("guahao_uuin_number", guahao.getGuahaoUuinNumber()) + .eq("guahao_time", guahao.getGuahaoTime()) + .eq("guahao_types", guahao.getGuahaoTypes()) + .eq("guahao_status_types", guahao.getGuahaoStatusTypes()) + .eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes()) + .eq("guahao_yesno_text", guahao.getGuahaoYesnoText()); + + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用挂号服务的selectOne方法，根据查询条件查询是否存在相同数据 GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper); - if(guahaoEntity==null){ - guahaoService.updateById(guahao);//根据id更新 + // 如果未查询到相同数据 + if (guahaoEntity == null) { + // 调用挂号服务的updateById方法，根据id更新挂号实体 + guahaoService.updateById(guahao); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 删除 - */ + * 删除 + */ + // 映射/delete请求路径，支持POST请求 @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + public R delete(@RequestBody Integer[] ids) { + // 记录方法调用日志，包含控制器类名和要删除的记录id数组 + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用挂号服务的deleteBatchIds方法，根据id数组批量删除记录 guahaoService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - /** * 批量上传 */ + // 映射/batchInsert请求路径，支持POST请求 @RequestMapping("/batchInsert") - public R save( String fileName){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); try { - List guahaoList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + // 创建一个列表，用于存储要上传的挂号实体 + List guahaoList = new ArrayList<>(); + // 创建一个Map，用于存储要查询的字段 + Map> seachFields = new HashMap<>(); + // 获取当前时间 Date date = new Date(); + // 获取文件名中最后一个点的索引 int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + // 如果文件名中没有点，返回错误响应，错误码为511 + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { + // 获取文件后缀 String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + // 如果文件后缀不是.xls，返回错误响应，错误码为511 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 获取文件的URL + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); + // 创建文件对象 File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + // 如果文件不存在，返回错误响应，错误码为511 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 使用PoiUtil工具类读取xls文件的数据 + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除第一行数据，因为第一行通常是表头 + dataList.remove(0); + // 遍历数据列表 + for (List data : dataList) { + // 创建一个新的挂号实体 GuahaoEntity guahaoEntity = new GuahaoEntity(); + // 以下代码注释掉，表示需要根据实际情况修改字段赋值 // guahaoEntity.setYishengId(Integer.valueOf(data.get(0))); //医生 要改的 // guahaoEntity.setYonghuId(Integer.valueOf(data.get(0))); //用户 要改的 // guahaoEntity.setGuahaoUuinNumber(Integer.valueOf(data.get(0))); //就诊识别码 要改的 @@ -245,119 +344,10 @@ public class GuahaoController { // guahaoEntity.setGuahaoYesnoTypes(Integer.valueOf(data.get(0))); //挂号审核 要改的 // guahaoEntity.setGuahaoYesnoText(data.get(0)); //审核结果 要改的 // guahaoEntity.setCreateTime(date);//时间 + // 将挂号实体添加到上传列表中 guahaoList.add(guahaoEntity); - - //把要查询是否重复的字段放入map中 + // 把要查询是否重复的字段放入map中 } - //查询是否重复 - guahaoService.insertBatch(guahaoList); - return R.ok(); - } - } - } - }catch (Exception e){ - return R.error(511,"批量插入数据异常，请联系管理员"); - } - } - - - - - - /** - * 前端列表 - */ - @IgnoreAuth - @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - - // 没有指定排序字段就默认id倒序 - if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ - params.put("orderBy","id"); - } - PageUtils page = guahaoService.queryPage(params); - - //字典表数据转换 - List list =(List)page.getList(); - for(GuahaoView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 - return R.ok().put("data", page); - } - - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - GuahaoEntity guahao = guahaoService.selectById(id); - if(guahao !=null){ - - - //entity转view - GuahaoView view = new GuahaoView(); - BeanUtils.copyProperties( guahao , view );//把实体数据重构到view中 - - //级联表 - YishengEntity yisheng = yishengService.selectById(guahao.getYishengId()); - if(yisheng != null){ - BeanUtils.copyProperties( yisheng , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYishengId(yisheng.getId()); - } - //级联表 - YonghuEntity yonghu = yonghuService.selectById(guahao.getYonghuId()); - if(yonghu != null){ - BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYonghuId(yonghu.getId()); - } - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } - } - - - /** - * 前端保存 - */ - @RequestMapping("/add") - public R add(@RequestBody GuahaoEntity guahao, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,guahao:{}",this.getClass().getName(),guahao.toString()); - Wrapper queryWrapper = new EntityWrapper() - .eq("yisheng_id", guahao.getYishengId()) - .eq("yonghu_id", guahao.getYonghuId()) - .eq("guahao_uuin_number", guahao.getGuahaoUuinNumber()) - .eq("guahao_types", guahao.getGuahaoTypes()) - .eq("guahao_status_types", guahao.getGuahaoStatusTypes()) - .eq("guahao_yesno_types", guahao.getGuahaoYesnoTypes()) - .eq("guahao_yesno_text", guahao.getGuahaoYesnoText()) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - GuahaoEntity guahaoEntity = guahaoService.selectOne(queryWrapper); - if(guahaoEntity==null){ - guahao.setGuahaoYesnoTypes(1); - guahao.setCreateTime(new Date()); - YonghuEntity userId = yonghuService.selectById((Integer) request.getSession().getAttribute("userId")); - YishengEntity yishengEntity = yishengService.selectById(guahao.getYishengId()); - if(userId.getNewMoney() params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永不会进入"); - else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); - else if("医生".equals(role)) - params.put("yishengId",request.getSession().getAttribute("userId")); - params.put("jiankangjiaoyuDeleteStart",1);params.put("jiankangjiaoyuDeleteEnd",1); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永不会进入"); + // 如果用户角色为"用户" + else if ("用户".equals(role)) + // 在请求参数中添加用户id + params.put("yonghuId", request.getSession().getAttribute("userId")); + // 如果用户角色为"医生" + else if ("医生".equals(role)) + // 在请求参数中添加医生id + params.put("yishengId", request.getSession().getAttribute("userId")); + // 设置查询条件，限定健康教育未被删除（逻辑删除字段值为1） + params.put("jiankangjiaoyuDeleteStart", 1); + params.put("jiankangjiaoyuDeleteEnd", 1); + // 如果请求参数中没有指定排序字段，则默认按id排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用健康教育服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = jiankangjiaoyuService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(JiankangjiaoyuView c:list){ - //修改对应字典表字段 + // 将分页结果中的列表转换为健康教育视图列表 + List list = (List) page.getList(); + // 遍历健康教育视图列表 + for (JiankangjiaoyuView c : list) { + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(c, request); } + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量，用于获取指定id的健康教育信息详情 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用健康教育服务的selectById方法，根据id查询健康教育实体 JiankangjiaoyuEntity jiankangjiaoyu = jiankangjiaoyuService.selectById(id); - if(jiankangjiaoyu !=null){ - //entity转view + // 如果查询到健康教育实体 + if (jiankangjiaoyu != null) { + // 创建健康教育视图对象 JiankangjiaoyuView view = new JiankangjiaoyuView(); - BeanUtils.copyProperties( jiankangjiaoyu , view );//把实体数据重构到view中 + // 使用BeanUtils将健康教育实体的属性复制到健康教育视图中 + BeanUtils.copyProperties(jiankangjiaoyu, view); - //修改对应字典表字段 + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将健康教育视图对象放入响应数据中 return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存 + */ + // 映射/save请求路径，支持POST请求，用于保存新的健康教育信息 @RequestMapping("/save") - public R save(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,jiankangjiaoyu:{}",this.getClass().getName(),jiankangjiaoyu.toString()); - + public R save(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的健康教育实体信息 + logger.debug("save方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，检查是否存在相同的健康教育信息 Wrapper queryWrapper = new EntityWrapper() - .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) - .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) - .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()) - ; + .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) + .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) + .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据 JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper); - if(jiankangjiaoyuEntity==null){ + // 如果未查询到相同数据 + if (jiankangjiaoyuEntity == null) { + // 设置插入时间为当前时间 jiankangjiaoyu.setInsertTime(new Date()); + // 设置逻辑删除字段为1，表示未删除 jiankangjiaoyu.setJiankangjiaoyuDelete(1); + // 设置创建时间为当前时间 jiankangjiaoyu.setCreateTime(new Date()); + // 调用健康教育服务的insert方法，将健康教育实体插入数据库 jiankangjiaoyuService.insert(jiankangjiaoyu); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改 + */ + // 映射/update请求路径，支持POST请求，用于修改已有的健康教育信息 @RequestMapping("/update") - public R update(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,jiankangjiaoyu:{}",this.getClass().getName(),jiankangjiaoyu.toString()); - + public R update(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要修改的健康教育实体信息 + logger.debug("update方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); - //根据字段查询是否有相同数据 + // 此条件注释掉，表示永远不会进入该分支 +// if (false) +// return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，排除当前要修改的记录，检查是否存在相同的健康教育信息 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",jiankangjiaoyu.getId()) - .andNew() - .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) - .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) - .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .notIn("id", jiankangjiaoyu.getId()) + .andNew() + .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) + .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) + .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()); + + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据 JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper); - if("".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto()) || "null".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto())){ - jiankangjiaoyu.setJiankangjiaoyuPhoto(null); + // 如果健康教育照片字段为空字符串或"null"，则将其设置为null + if ("".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto()) || "null".equals(jiankangjiaoyu.getJiankangjiaoyuPhoto())) { + jiankangjiaoyu.setJiankangjiaoyuPhoto(null); } - if(jiankangjiaoyuEntity==null){ - jiankangjiaoyuService.updateById(jiankangjiaoyu);//根据id更新 + // 如果未查询到相同数据 + if (jiankangjiaoyuEntity == null) { + // 调用健康教育服务的updateById方法，根据id更新健康教育实体 + jiankangjiaoyuService.updateById(jiankangjiaoyu); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 删除 - */ + * 删除 + */ + // 映射/delete请求路径，支持POST请求，用于删除健康教育信息（逻辑删除） @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + public R delete(@RequestBody Integer[] ids) { + // 记录方法调用日志，包含控制器类名和要删除的记录id数组 + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 创建一个ArrayList，用于存储要更新的健康教育实体 ArrayList list = new ArrayList<>(); - for(Integer id:ids){ + // 遍历要删除的记录id数组 + for (Integer id : ids) { + // 创建一个新的健康教育实体 JiankangjiaoyuEntity jiankangjiaoyuEntity = new JiankangjiaoyuEntity(); + // 设置健康教育实体的id jiankangjiaoyuEntity.setId(id); + // 设置逻辑删除字段为2，表示已删除 jiankangjiaoyuEntity.setJiankangjiaoyuDelete(2); + // 将健康教育实体添加到列表中 list.add(jiankangjiaoyuEntity); } - if(list != null && list.size() >0){ + // 如果列表不为空 + if (list != null && list.size() > 0) { + // 调用健康教育服务的updateBatchById方法，批量更新健康教育实体 jiankangjiaoyuService.updateBatchById(list); } + // 返回成功响应 return R.ok(); } - /** * 批量上传 */ + // 映射/batchInsert请求路径，支持POST请求，用于批量上传健康教育信息 @RequestMapping("/batchInsert") - public R save( String fileName){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); try { - List jiankangjiaoyuList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + // 创建一个列表，用于存储要上传的健康教育实体 + List jiankangjiaoyuList = new ArrayList<>(); + // 创建一个Map，用于存储要查询的字段 + Map> seachFields = new HashMap<>(); + // 获取当前时间 Date date = new Date(); + // 获取文件名中最后一个点的索引 int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + // 如果文件名中没有点，返回错误响应，错误码为511 + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { + // 获取文件后缀 String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + // 如果文件后缀不是.xls，返回错误响应，错误码为511 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 获取文件的URL + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); + // 创建文件对象 File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + // 如果文件不存在，返回错误响应，错误码为511 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 使用PoiUtil工具类读取xls文件的数据 + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除第一行数据，因为第一行通常是表头 + dataList.remove(0); + // 遍历数据列表 + for (List data : dataList) { + // 创建一个新的健康教育实体 JiankangjiaoyuEntity jiankangjiaoyuEntity = new JiankangjiaoyuEntity(); + // 以下代码注释掉，表示需要根据实际情况修改字段赋值 // jiankangjiaoyuEntity.setJiankangjiaoyuName(data.get(0)); //健康教育标题 要改的 // jiankangjiaoyuEntity.setJiankangjiaoyuTypes(Integer.valueOf(data.get(0))); //健康教育类型 要改的 // jiankangjiaoyuEntity.setJiankangjiaoyuPhoto("");//照片 @@ -227,94 +327,111 @@ public class JiankangjiaoyuController { // jiankangjiaoyuEntity.setJiankangjiaoyuContent("");//照片 // jiankangjiaoyuEntity.setJiankangjiaoyuDelete(1);//逻辑删除字段 // jiankangjiaoyuEntity.setCreateTime(date);//时间 + // 将健康教育实体添加到上传列表中 jiankangjiaoyuList.add(jiankangjiaoyuEntity); - - //把要查询是否重复的字段放入map中 + // 把要查询是否重复的字段放入map中 } - //查询是否重复 + // 调用健康教育服务的insertBatch方法，批量插入健康教育实体 jiankangjiaoyuService.insertBatch(jiankangjiaoyuList); + // 返回成功响应 return R.ok(); } } } - }catch (Exception e){ - return R.error(511,"批量插入数据异常，请联系管理员"); + } catch (Exception e) { + // 如果发生异常，返回错误响应，错误码为511 + return R.error(511, "批量插入数据异常，请联系管理员"); } } - - - - /** - * 前端列表 - */ + * 前端列表 + */ + // 映射/list请求路径，支持GET请求，用于前端获取健康教育信息的分页列表，忽略权限验证 @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - - // 没有指定排序字段就默认id倒序 - if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ - params.put("orderBy","id"); + public R list(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果请求参数中没有指定排序字段，则默认按id倒序排序 + if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) { + params.put("orderBy", "id"); } + // 调用健康教育服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = jiankangjiaoyuService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(JiankangjiaoyuView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 + // 将分页结果中的列表转换为健康教育视图列表 + List list = (List) page.getList(); + // 遍历健康教育视图列表 + for (JiankangjiaoyuView c : list) + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(c, request); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 前端详情 - */ + * 前端详情 + */ + // 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，用于前端获取指定id的健康教育信息详情 @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R detail(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用健康教育服务的selectById方法，根据id查询健康教育实体 JiankangjiaoyuEntity jiankangjiaoyu = jiankangjiaoyuService.selectById(id); - if(jiankangjiaoyu !=null){ - - - //entity转view - JiankangjiaoyuView view = new JiankangjiaoyuView(); - BeanUtils.copyProperties( jiankangjiaoyu , view );//把实体数据重构到view中 + // 如果查询到健康教育实体 + if (jiankangjiaoyu != null) { + // 创建健康教育视图对象 + JiankangjiaoyuView view = new JiankangjiaoyuView(); + // 使用BeanUtils将健康教育实体的属性复制到健康教育视图中 + BeanUtils.copyProperties(jiankangjiaoyu, view); - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将健康教育视图对象放入响应数据中 + return R.ok().put("data", view); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); + } } - /** - * 前端保存 - */ + * 前端保存 + */ + // 映射/add请求路径，支持POST请求，用于前端保存新的健康教育信息 @RequestMapping("/add") - public R add(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,jiankangjiaoyu:{}",this.getClass().getName(),jiankangjiaoyu.toString()); + public R add(@RequestBody JiankangjiaoyuEntity jiankangjiaoyu, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的健康教育实体信息 + logger.debug("add方法:,,Controller:{},,jiankangjiaoyu:{}", this.getClass().getName(), jiankangjiaoyu.toString()); + // 创建查询包装器，用于构建查询条件，检查是否存在相同的健康教育信息 Wrapper queryWrapper = new EntityWrapper() - .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) - .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) - .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .eq("jiankangjiaoyu_name", jiankangjiaoyu.getJiankangjiaoyuName()) + .eq("jiankangjiaoyu_types", jiankangjiaoyu.getJiankangjiaoyuTypes()) + .eq("jiankangjiaoyu_delete", jiankangjiaoyu.getJiankangjiaoyuDelete()); + + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用健康教育服务的selectOne方法，根据查询条件查询是否存在相同数据 JiankangjiaoyuEntity jiankangjiaoyuEntity = jiankangjiaoyuService.selectOne(queryWrapper); - if(jiankangjiaoyuEntity==null){ + // 如果未查询到相同数据 + if (jiankangjiaoyuEntity == null) { + // 设置插入时间为当前时间 jiankangjiaoyu.setInsertTime(new Date()); + // 设置逻辑删除字段为1，表示未删除 jiankangjiaoyu.setJiankangjiaoyuDelete(1); + // 设置创建时间为当前时间 jiankangjiaoyu.setCreateTime(new Date()); - jiankangjiaoyuService.insert(jiankangjiaoyu); + // 调用健康教育服务的insert方法，将健康教育实体插入数据库 + jiankangjiaoyuService.insert(jiankangjiaoyu); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } - - -} +} \ No newline at end of file diff --git a/src/main/java/com/controller/NewsController.java b/src/main/java/com/controller/NewsController.java index b60b121..2ae7a01 100644 --- a/src/main/java/com/controller/NewsController.java +++ b/src/main/java/com/controller/NewsController.java @@ -1,35 +1,63 @@ - package com.controller; +// 导入文件操作相关类 import java.io.File; +// 导入用于高精度计算的类 import java.math.BigDecimal; +// 导入用于处理URL的类 import java.net.URL; +// 导入用于日期格式化的类 import java.text.SimpleDateFormat; +// 导入阿里巴巴的JSON对象类 import com.alibaba.fastjson.JSONObject; +// 导入常用的集合类 import java.util.*; +// 导入Spring的Bean属性复制工具类 import org.springframework.beans.BeanUtils; +// 导入Servlet请求相关类 import javax.servlet.http.HttpServletRequest; +// 导入Spring的上下文加载器类 import org.springframework.web.context.ContextLoader; +// 导入Servlet上下文类 import javax.servlet.ServletContext; +// 导入令牌服务类 import com.service.TokenService; +// 导入自定义工具类 import com.utils.*; +// 导入反射调用异常类 import java.lang.reflect.InvocationTargetException; +// 导入字典服务类 import com.service.DictionaryService; +// 导入Apache Commons提供的字符串工具类 import org.apache.commons.lang3.StringUtils; +// 导入自定义的忽略权限注解类 import com.annotation.IgnoreAuth; +// 导入日志记录器接口 import org.slf4j.Logger; +// 导入日志记录器工厂类 import org.slf4j.LoggerFactory; +// 导入Spring的自动注入注解 import org.springframework.beans.factory.annotation.Autowired; +// 导入Spring的控制器注解 import org.springframework.stereotype.Controller; +// 导入Spring的请求映射注解 import org.springframework.web.bind.annotation.*; +// 导入MyBatis-Plus的实体包装器类 import com.baomidou.mybatisplus.mapper.EntityWrapper; +// 导入MyBatis-Plus的查询包装器接口 import com.baomidou.mybatisplus.mapper.Wrapper; +// 导入自定义的实体类 import com.entity.*; +// 导入自定义的视图类 import com.entity.view.*; +// 导入自定义的服务类 import com.service.*; +// 导入自定义的分页工具类 import com.utils.PageUtils; +// 导入自定义的响应结果类 import com.utils.R; +// 导入阿里巴巴的JSON工具类 import com.alibaba.fastjson.*; /** @@ -37,268 +65,322 @@ import com.alibaba.fastjson.*; * 后端接口 * @author * @email -*/ + */ +// 声明该类为RESTful控制器，用于处理HTTP请求并返回JSON数据 @RestController +// 声明该类为Spring MVC控制器 @Controller +// 映射请求路径，所有以/news开头的请求都会由该控制器处理 @RequestMapping("/news") public class NewsController { + // 日志记录器，用于记录当前控制器类的日志信息 private static final Logger logger = LoggerFactory.getLogger(NewsController.class); + // 自动注入新闻服务类，用于处理新闻相关业务逻辑 @Autowired private NewsService newsService; - + // 自动注入令牌服务类 @Autowired private TokenService tokenService; + // 自动注入字典服务类，用于字典表数据转换 @Autowired private DictionaryService dictionaryService; - //级联表service - + // 级联表service，自动注入用户服务类 @Autowired private YonghuService yonghuService; + // 级联表service，自动注入医生服务类 @Autowired private YishengService yishengService; - /** - * 后端列表 - */ + * 后端列表 + */ + // 映射/page请求路径，支持GET请求，用于获取公告信息的分页列表 @RequestMapping("/page") - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永不会进入"); - else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); - else if("医生".equals(role)) - params.put("yishengId",request.getSession().getAttribute("userId")); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永不会进入"); + // 如果用户角色为"用户" + else if ("用户".equals(role)) + // 在请求参数中添加用户id + params.put("yonghuId", request.getSession().getAttribute("userId")); + // 如果用户角色为"医生" + else if ("医生".equals(role)) + // 在请求参数中添加医生id + params.put("yishengId", request.getSession().getAttribute("userId")); + // 如果请求参数中没有指定排序字段，则默认按id排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用新闻服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = newsService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(NewsView c:list){ - //修改对应字典表字段 + // 将分页结果中的列表转换为新闻视图列表 + List list = (List) page.getList(); + // 遍历新闻视图列表 + for (NewsView c : list) { + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(c, request); } + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + */ + // 映射/info/{id}请求路径，支持GET请求，{id}为路径变量，用于获取指定id的公告信息详情 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用新闻服务的selectById方法，根据id查询新闻实体 NewsEntity news = newsService.selectById(id); - if(news !=null){ - //entity转view + // 如果查询到新闻实体 + if (news != null) { + // 创建新闻视图对象 NewsView view = new NewsView(); - BeanUtils.copyProperties( news , view );//把实体数据重构到view中 + // 使用BeanUtils将新闻实体的属性复制到新闻视图中 + BeanUtils.copyProperties(news, view); - //修改对应字典表字段 + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将新闻视图对象放入响应数据中 return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存 + */ + // 映射/save请求路径，支持POST请求，用于保存新的公告信息 @RequestMapping("/save") - public R save(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); - + public R save(@RequestBody NewsEntity news, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的新闻实体信息 + logger.debug("save方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); + // 此条件永远为false，注释掉的代码表示永远不会进入该分支 + if (false) + return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，检查是否存在相同的公告信息 Wrapper queryWrapper = new EntityWrapper() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; + .eq("news_name", news.getNewsName()) + .eq("news_types", news.getNewsTypes()); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用新闻服务的selectOne方法，根据查询条件查询是否存在相同数据 NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if(newsEntity==null){ + // 如果未查询到相同数据 + if (newsEntity == null) { + // 设置插入时间为当前时间 news.setInsertTime(new Date()); + // 设置创建时间为当前时间 news.setCreateTime(new Date()); + // 调用新闻服务的insert方法，将新闻实体插入数据库 newsService.insert(news); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改 + */ + // 映射/update请求路径，支持POST请求，用于修改已有的公告信息 @RequestMapping("/update") - public R update(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); - + public R update(@RequestBody NewsEntity news, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要修改的新闻实体信息 + logger.debug("update方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString()); + // 从请求会话中获取用户角色 String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); - //根据字段查询是否有相同数据 + // 此条件注释掉，表示永远不会进入该分支 +// if (false) +// return R.error(511, "永远不会进入"); + // 创建查询包装器，用于构建查询条件，排除当前要修改的记录，检查是否存在相同的公告信息 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",news.getId()) - .andNew() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .notIn("id", news.getId()) + .andNew() + .eq("news_name", news.getNewsName()) + .eq("news_types", news.getNewsTypes()); + + // 记录生成的SQL查询语句 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用新闻服务的selectOne方法，根据查询条件查询是否存在相同数据 NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())){ - news.setNewsPhoto(null); + // 如果新闻照片字段为空字符串或"null"，则将其设置为null + if ("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())) { + news.setNewsPhoto(null); } - if(newsEntity==null){ - newsService.updateById(news);//根据id更新 + // 如果未查询到相同数据 + if (newsEntity == null) { + // 调用新闻服务的updateById方法，根据id更新新闻实体 + newsService.updateById(news); + // 返回成功响应 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果查询到相同数据，返回错误响应，错误码为511 + return R.error(511, "表中有相同数据"); } } /** - * 删除 - */ + * 删除 + */ + // 映射/delete请求路径，支持POST请求，用于删除公告信息 @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + public R delete(@RequestBody Integer[] ids) { + // 记录方法调用日志，包含控制器类名和要删除的记录id数组 + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用新闻服务的deleteBatchIds方法，根据id数组批量删除记录 newsService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 return R.ok(); } - /** * 批量上传 */ + // 映射/batchInsert请求路径，支持POST请求，用于批量上传公告信息 @RequestMapping("/batchInsert") - public R save( String fileName){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); try { - List newsList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + // 创建一个列表，用于存储要上传的新闻实体 + List newsList = new ArrayList<>(); + // 创建一个Map，用于存储要查询的字段 + Map> seachFields = new HashMap<>(); + // 获取当前时间 Date date = new Date(); + // 获取文件名中最后一个点的索引 int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + // 如果文件名中没有点，返回错误响应，错误码为511 + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { + // 获取文件后缀 String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + // 如果文件后缀不是.xls，返回错误响应，错误码为511 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 获取文件的URL + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); + // 创建文件对象 File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + // 如果文件不存在，返回错误响应，错误码为511 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 使用PoiUtil工具类读取xls文件的数据 + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除第一行数据，因为第一行通常是表头 + dataList.remove(0); + // 遍历数据列表 + for (List data : dataList) { + // 创建一个新的新闻实体 NewsEntity newsEntity = new NewsEntity(); + // 以下代码注释掉，表示需要根据实际情况修改字段赋值 // newsEntity.setNewsName(data.get(0)); //公告名称 要改的 // newsEntity.setNewsPhoto("");//照片 // newsEntity.setNewsTypes(Integer.valueOf(data.get(0))); //公告类型 要改的 // newsEntity.setInsertTime(date);//时间 // newsEntity.setNewsContent("");//照片 // newsEntity.setCreateTime(date);//时间 + // 将新闻实体添加到上传列表中 newsList.add(newsEntity); - - //把要查询是否重复的字段放入map中 + // 把要查询是否重复的字段放入map中 } - //查询是否重复 + // 调用新闻服务的insertBatch方法，批量插入新闻实体 newsService.insertBatch(newsList); + // 返回成功响应 return R.ok(); } } } - }catch (Exception e){ - return R.error(511,"批量插入数据异常，请联系管理员"); + } catch (Exception e) { + // 如果发生异常，返回错误响应，错误码为511 + return R.error(511, "批量插入数据异常，请联系管理员"); } } - - - - /** - * 前端列表 - */ + * 前端列表 + */ + // 映射/list请求路径，支持GET请求，用于前端获取公告信息的分页列表，忽略权限验证 @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - - // 没有指定排序字段就默认id倒序 - if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ - params.put("orderBy","id"); + public R list(@RequestParam Map params, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求参数 + logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果请求参数中没有指定排序字段，则默认按id倒序排序 + if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) { + params.put("orderBy", "id"); } + // 调用新闻服务的queryPage方法，根据请求参数进行分页查询 PageUtils page = newsService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(NewsView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 + // 将分页结果中的列表转换为新闻视图列表 + List list = (List) page.getList(); + // 遍历新闻视图列表 + for (NewsView c : list) + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(c, request); + // 返回成功响应，并将分页查询结果放入响应数据中 return R.ok().put("data", page); } /** - * 前端详情 - */ + * 前端详情 + */ + // 映射/detail/{id}请求路径，支持GET请求，{id}为路径变量，用于前端获取指定id的公告信息详情 @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R detail(@PathVariable("id") Long id, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和请求的id + logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用新闻服务的selectById方法，根据id查询新闻实体 NewsEntity news = newsService.selectById(id); - if(news !=null){ - - - //entity转view - NewsView view = new NewsView(); - BeanUtils.copyProperties( news , view );//把实体数据重构到view中 + // 如果查询到新闻实体 + if (news != null) { + // 创建新闻视图对象 + NewsView view = new NewsView(); + // 使用BeanUtils将新闻实体的属性复制到新闻视图中 + BeanUtils.copyProperties(news, view); - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } + // 调用字典服务的dictionaryConvert方法，修改对应字典表字段 + dictionaryService.dictionaryConvert(view, request); + // 返回成功响应，并将新闻视图对象放入响应数据中 + return R.ok().put("data", view); + } else { + // 如果未查询到数据，返回错误响应，错误码为511 + return R.error(511, "查不到数据"); + } } - /** - * 前端保存 - */ + * 前端保存 + */ + // 映射/add请求路径，支持POST请求，用于前端保存新的公告信息 @RequestMapping("/add") - public R add(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); - Wrapper queryWrapper = new EntityWrapper() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if(newsEntity==null){ - news.setInsertTime(new Date()); - news.setCreateTime(new Date()); - newsService.insert(news); - return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } - - -} + public R add(@RequestBody NewsEntity news, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的新闻实体信息 + logger.debug("add方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString()); + // 创建查询包装器，用于构建查询条件，检查是否存在相同的公告信息 \ No newline at end of file diff --git a/src/main/java/com/controller/UsersController.java b/src/main/java/com/controller/UsersController.java index 2b15447..7034532 100644 --- a/src/main/java/com/controller/UsersController.java +++ b/src/main/java/com/controller/UsersController.java @@ -1,7 +1,5 @@ - package com.controller; - import java.util.Arrays; import java.util.Map; @@ -28,141 +26,209 @@ import com.utils.R; /** * 登录相关 */ +// 定义请求映射路径，所有以/users开头的请求会被该控制器处理 @RequestMapping("users") +// 声明该类为一个RESTful风格的控制器，用于处理HTTP请求并返回JSON数据 @RestController public class UsersController { - + + // 自动注入UsersService，用于处理与用户相关的业务逻辑 @Autowired private UsersService usersService; - + + // 自动注入TokenService，用于处理与令牌相关的业务逻辑 @Autowired private TokenService tokenService; /** - * 登录 + * 处理用户登录请求 + * @param username 用户名 + * @param password 密码 + * @param captcha 验证码（当前代码未实际使用该参数） + * @param request HTTP请求对象 + * @return R类型的响应对象，包含登录结果信息 */ - @IgnoreAuth + @IgnoreAuth // 忽略权限验证的注解 @PostMapping(value = "/login") public R login(String username, String password, String captcha, HttpServletRequest request) { + // 根据用户名查询用户实体 UsersEntity user = usersService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null || !user.getPassword().equals(password)) { + // 如果用户不存在或者用户输入的密码与数据库中存储的密码不匹配 + if (user == null || !user.getPassword().equals(password)) { + // 返回错误响应，提示账号或密码不正确 return R.error("账号或密码不正确"); } - String token = tokenService.generateToken(user.getId(),username, "users", user.getRole()); + // 生成用户令牌，参数依次为用户ID、用户名、用户类型标识、用户角色 + String token = tokenService.generateToken(user.getId(), username, "users", user.getRole()); + // 创建一个成功的响应对象 R r = R.ok(); + // 将生成的令牌放入响应数据中 r.put("token", token); - r.put("role",user.getRole()); - r.put("userId",user.getId()); + // 将用户的角色信息放入响应数据中 + r.put("role", user.getRole()); + // 将用户的ID信息放入响应数据中 + r.put("userId", user.getId()); + // 返回响应对象 return r; } - + /** * 注册 */ @IgnoreAuth @PostMapping(value = "/register") - public R register(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); - if(usersService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); - } - usersService.insert(user); - return R.ok(); - } + public R register(@RequestBody UsersEntity user) { +// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用 + // 根据用户名查询数据库，判断用户是否已经存在 + if (usersService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + // 如果用户已存在，返回错误响应 + return R.error("用户已存在"); + } + // 将新用户插入到数据库中 + usersService.insert(user); + // 返回成功响应 + return R.ok(); + } /** * 退出 */ @GetMapping(value = "logout") public R logout(HttpServletRequest request) { + // 使当前用户的会话失效，实现退出登录 request.getSession().invalidate(); + // 返回成功响应，并附带退出成功的提示信息 return R.ok("退出成功"); } - + /** - * 密码重置 - */ - @IgnoreAuth + * 处理用户密码重置请求 + * @param username 用户名 + * @param request HTTP请求对象 + * @return R类型的响应对象，包含密码重置结果信息 + */ + @IgnoreAuth // 忽略权限验证的注解 @RequestMapping(value = "/resetPass") - public R resetPass(String username, HttpServletRequest request){ - UsersEntity user = usersService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null) { - return R.error("账号不存在"); - } - user.setPassword("123456"); - usersService.update(user,null); - return R.ok("密码已重置为：123456"); - } - + public R resetPass(String username, HttpServletRequest request) { + // 根据用户名查询用户实体 + UsersEntity user = usersService.selectOne(new EntityWrapper().eq("username", username)); + // 如果用户不存在 + if (user == null) { + // 返回错误响应，提示账号不存在 + return R.error("账号不存在"); + } + // 将用户密码重置为默认值123456 + user.setPassword("123456"); + // 更新用户信息到数据库（第二个参数为null，可能表示更新时不设置额外的条件） + usersService.update(user, null); + // 返回成功响应，并附带密码已重置的提示信息 + return R.ok("密码已重置为：123456"); + } + + /** + * 处理获取用户列表的分页请求 + * @param params 包含分页和查询条件的参数Map + * @param user 用户实体对象，可能用于构建查询条件 + * @return R类型的响应对象，包含分页后的用户列表数据 + */ + @RequestMapping("/page") + public R page(@RequestParam Map params, UsersEntity user) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + // 调用usersService的queryPage方法进行分页查询，MPUtil.sort等方法用于处理查询条件和排序 + PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); + // 返回成功响应，并将分页结果数据放入响应中 + return R.ok().put("data", page); + } + /** - * 列表 - */ - @RequestMapping("/page") - public R page(@RequestParam Map params,UsersEntity user){ - EntityWrapper ew = new EntityWrapper(); - PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); - return R.ok().put("data", page); - } + * 处理获取用户列表的请求 + * @param user 用户实体对象，用于构建查询条件 + * @return R类型的响应对象，包含用户列表数据 + */ + @RequestMapping("/list") + public R list(UsersEntity user) { + // 创建一个EntityWrapper对象 + EntityWrapper ew = new EntityWrapper(); + // 根据用户实体对象构建查询条件，使用MPUtil.allEQMapPre方法设置相等条件 + ew.allEq(MPUtil.allEQMapPre(user, "user")); + // 调用usersService的selectListView方法查询用户列表，并将结果放入响应中返回 + return R.ok().put("data", usersService.selectListView(ew)); + } /** - * 列表 - */ - @RequestMapping("/list") - public R list( UsersEntity user){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( user, "user")); - return R.ok().put("data", usersService.selectListView(ew)); - } - - /** - * 信息 - */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") String id){ - UsersEntity user = usersService.selectById(id); - return R.ok().put("data", user); - } - - /** - * 获取用户的session用户信息 - */ - @RequestMapping("/session") - public R getCurrUser(HttpServletRequest request){ - Integer id = (Integer)request.getSession().getAttribute("userId"); - UsersEntity user = usersService.selectById(id); - return R.ok().put("data", user); - } - - /** - * 保存 - */ - @PostMapping("/save") - public R save(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); - if(usersService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); - } - user.setPassword("123456"); - usersService.insert(user); - return R.ok(); - } - - /** - * 修改 - */ - @RequestMapping("/update") - public R update(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); - usersService.updateById(user);//全部更新 - return R.ok(); - } - - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - usersService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } -} + * 处理获取指定用户信息的请求 + * @param id 用户ID，通过路径变量获取 + * @return R类型的响应对象，包含指定用户的信息 + */ + @RequestMapping("/info/{id}") + public R info(@PathVariable("id") String id) { + // 根据用户ID查询用户实体 + UsersEntity user = usersService.selectById(id); + // 返回成功响应，并将用户信息放入响应中 + return R.ok().put("data", user); + } + + /** + * 处理获取当前会话用户信息的请求 + * @param request HTTP请求对象 + * @return R类型的响应对象，包含当前会话用户的信息 + */ + @RequestMapping("/session") + public R getCurrUser(HttpServletRequest request) { + // 从当前会话中获取用户ID + Integer id = (Integer) request.getSession().getAttribute("userId"); + // 根据用户ID查询用户实体 + UsersEntity user = usersService.selectById(id); + // 返回成功响应，并将用户信息放入响应中 + return R.ok().put("data", user); + } + + /** + * 处理保存新用户的请求 + * @param user 用户实体对象，通过请求体获取 + * @return R类型的响应对象，包含保存结果信息 + */ + @PostMapping("/save") + public R save(@RequestBody UsersEntity user) { +// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用 + // 根据用户名查询数据库，判断用户是否已经存在 + if (usersService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + // 如果用户已存在，返回错误响应 + return R.error("用户已存在"); + } + // 设置用户密码为默认值123456 + user.setPassword("123456"); + // 将用户插入到数据库中 + usersService.insert(user); + // 返回成功响应 + return R.ok(); + } + + /** + * 处理更新用户信息的请求 + * @param user 用户实体对象，通过请求体获取 + * @return R类型的响应对象，包含更新结果信息 + */ + @RequestMapping("/update") + public R update(@RequestBody UsersEntity user) { +// ValidatorUtils.validateEntity(user); // 被注释掉的代码，可能用于验证用户实体的合法性，目前未启用 + // 根据用户ID更新用户信息到数据库 + usersService.updateById(user); // 全部更新 + // 返回成功响应 + return R.ok(); + } + + /** + * 处理删除用户的请求 + * @param ids 要删除的用户ID数组，通过请求体获取 + * @return R类型的响应对象，包含删除结果信息 + */ + @RequestMapping("/delete") + public R delete(@RequestBody Long[] ids) { + // 根据用户ID数组批量删除用户 + usersService.deleteBatchIds(Arrays.asList(ids)); + // 返回成功响应 + return R.ok(); + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/YishengController.java b/src/main/java/com/controller/YishengController.java index bca53e8..7e0e8bb 100644 --- a/src/main/java/com/controller/YishengController.java +++ b/src/main/java/com/controller/YishengController.java @@ -36,278 +36,307 @@ import com.alibaba.fastjson.*; * 后端接口 * @author * @email - */ +*/ @RestController +// 声明为Spring MVC控制器 @Controller +// 定义请求映射路径，所有以/yisheng开头的请求由该控制器处理 @RequestMapping("/yisheng") public class YishengController { + // 日志记录器，用于记录当前控制器的日志信息 private static final Logger logger = LoggerFactory.getLogger(YishengController.class); + // 自动注入医生服务类，用于处理医生相关业务逻辑 @Autowired - private YishengService yishengService; // 医生服务 + private YishengService yishengService; + @Autowired - private TokenService tokenService; // token服务 + private TokenService tokenService; @Autowired - private DictionaryService dictionaryService; // 字典服务 - - //级联表service + private DictionaryService dictionaryService; + // 级联表service，自动注入用户服务类 @Autowired - private YonghuService yonghuService; // 用户服务 - + private YonghuService yonghuService; /** - * 后端列表 - */ + * 后端列表 + */ @RequestMapping("/page") public R page(@RequestParam Map params, HttpServletRequest request){ logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色 + String role = String.valueOf(request.getSession().getAttribute("role")); if(false) return R.error(511,"永不会进入"); else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，添加用户ID参数 + params.put("yonghuId",request.getSession().getAttribute("userId")); else if("医生".equals(role)) - params.put("yishengId",request.getSession().getAttribute("userId")); // 如果是医生角色，添加医生ID参数 + params.put("yishengId",request.getSession().getAttribute("userId")); if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); // 默认按ID排序 + params.put("orderBy","id"); } - PageUtils page = yishengService.queryPage(params); // 分页查询 + PageUtils page = yishengService.queryPage(params); //字典表数据转换 List list =(List)page.getList(); for(YishengView c:list){ //修改对应字典表字段 - dictionaryService.dictionaryConvert(c, request); // 转换字典字段 + dictionaryService.dictionaryConvert(c, request); } - return R.ok().put("data", page); // 返回分页数据 + return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + */ @RequestMapping("/info/{id}") public R info(@PathVariable("id") Long id, HttpServletRequest request){ logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - YishengEntity yisheng = yishengService.selectById(id); // 根据ID查询医生 + YishengEntity yisheng = yishengService.selectById(id); if(yisheng !=null){ //entity转view YishengView view = new YishengView(); - BeanUtils.copyProperties( yisheng , view ); // 把实体数据重构到view中 + BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中 //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); // 转换字典字段 - return R.ok().put("data", view); // 返回医生详情 + dictionaryService.dictionaryConvert(view, request); + return R.ok().put("data", view); }else { - return R.error(511,"查不到数据"); // 查询不到返回错误 + return R.error(511,"查不到数据"); } } /** - * 后端保存 - */ + * 后端保存 + */ @RequestMapping("/save") - public R save(@RequestBody YishengEntity yisheng, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,yisheng:{}",this.getClass().getName(),yisheng.toString()); + public R save(@RequestBody YishengEntity yisheng, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要保存的医生实体信息 + logger.debug("save方法:,,Controller:{},,yisheng:{}", this.getClass().getName(), yisheng.toString()); - String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色 + String role = String.valueOf(request.getSession().getAttribute("role")); if(false) return R.error(511,"永远不会进入"); - // 构建查询条件：用户名或手机号 Wrapper queryWrapper = new EntityWrapper() .eq("username", yisheng.getUsername()) .or() .eq("yisheng_phone", yisheng.getYishengPhone()); logger.info("sql语句:"+queryWrapper.getSqlSegment()); - YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在 + YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); if(yishengEntity==null){ - yisheng.setCreateTime(new Date()); // 设置创建时间 - yisheng.setPassword("123456"); // 设置默认密码 - yishengService.insert(yisheng); // 插入新医生数据 - return R.ok(); // 返回成功 + yisheng.setCreateTime(new Date()); + yisheng.setPassword("123456"); + yishengService.insert(yisheng); + return R.ok(); }else { - return R.error(511,"账户或者联系方式已经被使用"); // 已存在返回错误 + return R.error(511,"账户或者联系方式已经被使用"); } } /** - * 后端修改 - */ + * 后端修改 + */ @RequestMapping("/update") - public R update(@RequestBody YishengEntity yisheng, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,yisheng:{}",this.getClass().getName(),yisheng.toString()); - - String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色 - // 构建查询条件：排除当前ID，查询用户名或手机号是否已被其他记录使用 + public R update(@RequestBody YishengEntity yisheng, HttpServletRequest request) { + // 记录方法调用日志，包含控制器类名和要更新的医生实体信息 + logger.debug("update方法:,,Controller:{},,yisheng:{}", this.getClass().getName(), yisheng.toString()); + + String role = String.valueOf(request.getSession().getAttribute("role")); +// if(false) +// return R.error(511,"永远不会进入"); + //根据字段查询是否有相同数据 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",yisheng.getId()) - .andNew() - .eq("username", yisheng.getUsername()) - .or() - .eq("yisheng_phone", yisheng.getYishengPhone()); + .notIn("id",yisheng.getId()) + .andNew() + .eq("username", yisheng.getUsername()) + .or() + .eq("yisheng_phone", yisheng.getYishengPhone()) + ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); - YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否冲突 + YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); if("".equals(yisheng.getYishengPhoto()) || "null".equals(yisheng.getYishengPhoto())){ - yisheng.setYishengPhoto(null); // 处理空照片 + yisheng.setYishengPhoto(null); } if(yishengEntity==null){ - yishengService.updateById(yisheng); // 根据id更新 - return R.ok(); // 返回成功 + yishengService.updateById(yisheng);//根据id更新 + return R.ok(); }else { - return R.error(511,"账户或者联系方式已经被使用"); // 冲突返回错误 + return R.error(511,"账户或者联系方式已经被使用"); } } /** - * 删除 - */ + * 删除 + */ @RequestMapping("/delete") public R delete(@RequestBody Integer[] ids){ logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); - yishengService.deleteBatchIds(Arrays.asList(ids)); // 批量删除 - return R.ok(); // 返回成功 + yishengService.deleteBatchIds(Arrays.asList(ids)); + return R.ok(); } /** - * 批量上传 + * 批量上传医生信息 */ @RequestMapping("/batchInsert") - public R save( String fileName){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName) { + // 记录方法调用日志，包含控制器类名和文件名 + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); try { - List yishengList = new ArrayList<>(); // 上传的数据列表 - Map> seachFields= new HashMap<>(); // 要查询的字段 + List yishengList = new ArrayList<>();//上传的东西 + Map> seachFields= new HashMap<>();//要查询的字段 Date date = new Date(); + // 获取文件名中最后一个点的索引 int lastIndexOf = fileName.lastIndexOf("."); if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); // 文件后缀检查 + return R.error(511,"该文件没有后缀"); }else{ String suffix = fileName.substring(lastIndexOf); if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); // 文件格式检查 + return R.error(511,"只支持后缀为xls的excel文件"); }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径 + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 File file = new File(resource.getFile()); if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); // 文件存在检查 + return R.error(511,"找不到上传文件，请联系管理员"); }else{ - List> dataList = PoiUtil.poiImport(file.getPath()); // 读取xls文件 - dataList.remove(0); // 删除第一行提示行 + List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 + dataList.remove(0);//删除第一行，因为第一行是提示 for(List data:dataList){ - //循环处理每行数据 + //循环 YishengEntity yishengEntity = new YishengEntity(); - // 这里注释掉的代码是字段映射示例，实际使用时需要根据Excel列对应关系修改 - yishengList.add(yishengEntity); // 添加到列表 - - // 把要查询是否重复的字段放入map中 - // 医生工号 - if(seachFields.containsKey("yishengUuidNumber")){ - List yishengUuidNumber = seachFields.get("yishengUuidNumber"); - yishengUuidNumber.add(data.get(0)); // 要改的 - }else{ - List yishengUuidNumber = new ArrayList<>(); - yishengUuidNumber.add(data.get(0)); // 要改的 - seachFields.put("yishengUuidNumber",yishengUuidNumber); - } - // 账户 - if(seachFields.containsKey("username")){ - List username = seachFields.get("username"); - username.add(data.get(0)); // 要改的 - }else{ - List username = new ArrayList<>(); - username.add(data.get(0)); // 要改的 - seachFields.put("username",username); - } - // 联系方式 - if(seachFields.containsKey("yishengPhone")){ - List yishengPhone = seachFields.get("yishengPhone"); - yishengPhone.add(data.get(0)); // 要改的 - }else{ - List yishengPhone = new ArrayList<>(); - yishengPhone.add(data.get(0)); // 要改的 - seachFields.put("yishengPhone",yishengPhone); - } +// yishengEntity.setYishengUuidNumber(data.get(0)); //医生工号 要改的 +// yishengEntity.setUsername(data.get(0)); //账户 要改的 +// //yishengEntity.setPassword("123456");//密码 +// yishengEntity.setYishengName(data.get(0)); //医生名称 要改的 +// yishengEntity.setYishengTypes(Integer.valueOf(data.get(0))); //科室 要改的 +// yishengEntity.setZhiweiTypes(Integer.valueOf(data.get(0))); //职位 要改的 +// yishengEntity.setYishengZhichneg(data.get(0)); //职称 要改的 +// yishengEntity.setYishengPhoto("");//照片 +// yishengEntity.setYishengPhone(data.get(0)); //联系方式 要改的 +// yishengEntity.setYishengGuahao(data.get(0)); //挂号须知 要改的 +// yishengEntity.setYishengEmail(data.get(0)); //邮箱 要改的 +// yishengEntity.setYishengNewMoney(data.get(0)); //挂号价格 要改的 +// yishengEntity.setYishengContent("");//照片 +// yishengEntity.setCreateTime(date);//时间 + yishengList.add(yishengEntity); + + + //把要查询是否重复的字段放入map中 + //医生工号 + if(seachFields.containsKey("yishengUuidNumber")){ + List yishengUuidNumber = seachFields.get("yishengUuidNumber"); + yishengUuidNumber.add(data.get(0));//要改的 + }else{ + List yishengUuidNumber = new ArrayList<>(); + yishengUuidNumber.add(data.get(0));//要改的 + seachFields.put("yishengUuidNumber",yishengUuidNumber); + } + //账户 + if(seachFields.containsKey("username")){ + List username = seachFields.get("username"); + username.add(data.get(0));//要改的 + }else{ + List username = new ArrayList<>(); + username.add(data.get(0));//要改的 + seachFields.put("username",username); + } + //联系方式 + if(seachFields.containsKey("yishengPhone")){ + List yishengPhone = seachFields.get("yishengPhone"); + yishengPhone.add(data.get(0));//要改的 + }else{ + List yishengPhone = new ArrayList<>(); + yishengPhone.add(data.get(0));//要改的 + seachFields.put("yishengPhone",yishengPhone); + } } - // 查询是否重复 - // 医生工号 + //查询是否重复 + //医生工号 List yishengEntities_yishengUuidNumber = yishengService.selectList(new EntityWrapper().in("yisheng_uuid_number", seachFields.get("yishengUuidNumber"))); - if(yishengEntities_yishengUuidNumber.size() >0 ){ + if (yishengEntities_yishengUuidNumber.size() > 0) { ArrayList repeatFields = new ArrayList<>(); - for(YishengEntity s:yishengEntities_yishengUuidNumber){ + for (YishengEntity s : yishengEntities_yishengUuidNumber) { repeatFields.add(s.getYishengUuidNumber()); } - return R.error(511,"数据库的该表中的 [医生工号] 字段已经存在 存在数据为:"+repeatFields.toString()); + return R.error(511, "数据库的该表中的 [医生工号] 字段已经存在 存在数据为:" + repeatFields.toString()); } // 账户 List yishengEntities_username = yishengService.selectList(new EntityWrapper().in("username", seachFields.get("username"))); - if(yishengEntities_username.size() >0 ){ + if (yishengEntities_username.size() > 0) { ArrayList repeatFields = new ArrayList<>(); - for(YishengEntity s:yishengEntities_username){ + for (YishengEntity s : yishengEntities_username) { repeatFields.add(s.getUsername()); } - return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString()); + return R.error(511, "数据库的该表中的 [账户] 字段已经存在 存在数据为:" + repeatFields.toString()); } // 联系方式 List yishengEntities_yishengPhone = yishengService.selectList(new EntityWrapper().in("yisheng_phone", seachFields.get("yishengPhone"))); - if(yishengEntities_yishengPhone.size() >0 ){ + if (yishengEntities_yishengPhone.size() > 0) { ArrayList repeatFields = new ArrayList<>(); - for(YishengEntity s:yishengEntities_yishengPhone){ + for (YishengEntity s : yishengEntities_yishengPhone) { repeatFields.add(s.getYishengPhone()); } - return R.error(511,"数据库的该表中的 [联系方式] 字段已经存在 存在数据为:"+repeatFields.toString()); + return R.error(511, "数据库的该表中的 [联系方式] 字段已经存在 存在数据为:" + repeatFields.toString()); } - yishengService.insertBatch(yishengList); // 批量插入 + yishengService.insertBatch(yishengList); return R.ok(); } } } }catch (Exception e){ - return R.error(511,"批量插入数据异常，请联系管理员"); // 异常处理 + return R.error(511,"批量插入数据异常，请联系管理员"); } } /** - * 登录 - */ + * 登录 + */ @IgnoreAuth @RequestMapping(value = "/login") public R login(String username, String password, String captcha, HttpServletRequest request) { - YishengEntity yisheng = yishengService.selectOne(new EntityWrapper().eq("username", username)); // 根据用户名查询 + YishengEntity yisheng = yishengService.selectOne(new EntityWrapper().eq("username", username)); if(yisheng==null || !yisheng.getPassword().equals(password)) - return R.error("账号或密码不正确"); // 验证账号密码 - String token = tokenService.generateToken(yisheng.getId(),username, "yisheng", "医生"); // 生成token + return R.error("账号或密码不正确"); + // // 获取监听器中的字典表 + // ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext(); + // Map> dictionaryMap= (Map>) servletContext.getAttribute("dictionaryMap"); + // Map role_types = dictionaryMap.get("role_types"); + // role_types.get(.getRoleTypes()); + String token = tokenService.generateToken(yisheng.getId(),username, "yisheng", "医生"); R r = R.ok(); - r.put("token", token); // 返回token - r.put("role","医生"); // 返回角色 - r.put("username",yisheng.getYishengName()); // 返回医生姓名 - r.put("tableName","yisheng"); // 返回表名 - r.put("userId",yisheng.getId()); // 返回用户ID + r.put("token", token); + r.put("role","医生"); + r.put("username",yisheng.getYishengName()); + r.put("tableName","yisheng"); + r.put("userId",yisheng.getId()); return r; } /** - * 注册 - */ + * 注册 + */ @IgnoreAuth @PostMapping(value = "/register") public R register(@RequestBody YishengEntity yisheng){ - // 构建查询条件：用户名或手机号 +// ValidatorUtils.validateEntity(user); Wrapper queryWrapper = new EntityWrapper() - .eq("username", yisheng.getUsername()) - .or() - .eq("yisheng_phone", yisheng.getYishengPhone()); - YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在 + .eq("username", yisheng.getUsername()) + .or() + .eq("yisheng_phone", yisheng.getYishengPhone()) + ; + YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); if(yishengEntity != null) - return R.error("账户或者联系方式已经被使用"); // 已存在返回错误 - yisheng.setYishengNewMoney(0.0); // 设置初始金额 - yisheng.setCreateTime(new Date()); // 设置创建时间 - yishengService.insert(yisheng); // 插入新医生 - return R.ok(); // 返回成功 + return R.error("账户或者联系方式已经被使用"); + yisheng.setYishengNewMoney(0.0); + yisheng.setCreateTime(new Date()); + yishengService.insert(yisheng); + return R.ok(); } /** @@ -316,63 +345,69 @@ public class YishengController { @GetMapping(value = "/resetPassword") public R resetPassword(Integer id){ YishengEntity yisheng = new YishengEntity(); - yisheng.setPassword("123456"); // 重置为默认密码 + yisheng.setPassword("123456"); yisheng.setId(id); - yishengService.updateById(yisheng); // 更新密码 - return R.ok(); // 返回成功 + yishengService.updateById(yisheng); + return R.ok(); } + /** * 忘记密码 */ @IgnoreAuth @RequestMapping(value = "/resetPass") public R resetPass(String username, HttpServletRequest request) { - YishengEntity yisheng = yishengService.selectOne(new EntityWrapper().eq("username", username)); // 根据用户名查询 + YishengEntity yisheng = yishengService.selectOne(new EntityWrapper().eq("username", username)); if(yisheng!=null){ - yisheng.setPassword("123456"); // 重置为默认密码 - boolean b = yishengService.updateById(yisheng); // 更新密码 + yisheng.setPassword("123456"); + boolean b = yishengService.updateById(yisheng); if(!b){ - return R.error(); // 更新失败 + return R.error(); } }else{ - return R.error("账号不存在"); // 账号不存在 + return R.error("账号不存在"); } - return R.ok(); // 返回成功 + return R.ok(); } + /** - * 获取用户的session用户信息 - */ + * 获取用户的session用户信息 + */ @RequestMapping("/session") public R getCurrYisheng(HttpServletRequest request){ - Integer id = (Integer)request.getSession().getAttribute("userId"); // 获取session中的用户ID - YishengEntity yisheng = yishengService.selectById(id); // 查询用户信息 + Integer id = (Integer)request.getSession().getAttribute("userId"); + YishengEntity yisheng = yishengService.selectById(id); if(yisheng !=null){ //entity转view YishengView view = new YishengView(); - BeanUtils.copyProperties( yisheng , view ); // 复制属性到view + BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中 //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); // 转换字典字段 - return R.ok().put("data", view); // 返回用户信息 + dictionaryService.dictionaryConvert(view, request); + return R.ok().put("data", view); }else { - return R.error(511,"查不到数据"); // 查询不到返回错误 + return R.error(511,"查不到数据"); } } + /** - * 退出 - */ + * 退出 + */ @GetMapping(value = "logout") public R logout(HttpServletRequest request) { - request.getSession().invalidate(); // 使session失效 - return R.ok("退出成功"); // 返回退出成功 + request.getSession().invalidate(); + return R.ok("退出成功"); } + + + /** - * 前端列表 - */ + * 前端列表 + */ @IgnoreAuth @RequestMapping("/list") public R list(@RequestParam Map params, HttpServletRequest request){ @@ -382,55 +417,60 @@ public class YishengController { if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ params.put("orderBy","id"); } - PageUtils page = yishengService.queryPage(params); // 分页查询 + PageUtils page = yishengService.queryPage(params); //字典表数据转换 List list =(List)page.getList(); for(YishengView c:list) - dictionaryService.dictionaryConvert(c, request); // 转换字典字段 - return R.ok().put("data", page); // 返回分页数据 + dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 + return R.ok().put("data", page); } /** - * 前端详情 - */ + * 前端详情 + */ @RequestMapping("/detail/{id}") public R detail(@PathVariable("id") Long id, HttpServletRequest request){ logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - YishengEntity yisheng = yishengService.selectById(id); // 根据ID查询 - if(yisheng !=null){ - //entity转view - YishengView view = new YishengView(); - BeanUtils.copyProperties( yisheng , view ); // 复制属性到view + YishengEntity yisheng = yishengService.selectById(id); + if(yisheng !=null){ - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); // 转换字典字段 - return R.ok().put("data", view); // 返回详情 - }else { - return R.error(511,"查不到数据"); // 查询不到返回错误 - } + + //entity转view + YishengView view = new YishengView(); + BeanUtils.copyProperties( yisheng , view );//把实体数据重构到view中 + + //修改对应字典表字段 + dictionaryService.dictionaryConvert(view, request); + return R.ok().put("data", view); + }else { + return R.error(511,"查不到数据"); + } } + /** - * 前端保存 - */ + * 前端保存 + */ @RequestMapping("/add") public R add(@RequestBody YishengEntity yisheng, HttpServletRequest request){ logger.debug("add方法:,,Controller:{},,yisheng:{}",this.getClass().getName(),yisheng.toString()); - // 构建查询条件：用户名或手机号 Wrapper queryWrapper = new EntityWrapper() - .eq("username", yisheng.getUsername()) - .or() - .eq("yisheng_phone", yisheng.getYishengPhone()); + .eq("username", yisheng.getUsername()) + .or() + .eq("yisheng_phone", yisheng.getYishengPhone()) + ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); - YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); // 查询是否已存在 + YishengEntity yishengEntity = yishengService.selectOne(queryWrapper); if(yishengEntity==null){ - yisheng.setCreateTime(new Date()); // 设置创建时间 - yisheng.setPassword("123456"); // 设置默认密码 - yishengService.insert(yisheng); // 插入新医生 - return R.ok(); // 返回成功 + yisheng.setCreateTime(new Date()); + yisheng.setPassword("123456"); + yishengService.insert(yisheng); + return R.ok(); }else { - return R.error(511,"账户或者联系方式已经被使用"); // 已存在返回错误 + return R.error(511,"账户或者联系方式已经被使用"); } } -} \ No newline at end of file + + +} diff --git a/src/main/java/com/controller/YonghuController.java b/src/main/java/com/controller/YonghuController.java index 472a731..5ccb116 100644 --- a/src/main/java/com/controller/YonghuController.java +++ b/src/main/java/com/controller/YonghuController.java @@ -32,11 +32,11 @@ import com.utils.R; import com.alibaba.fastjson.*; /** - * 用户控制器 + * 用户 * 后端接口 * @author * @email - */ +*/ @RestController @Controller @RequestMapping("/yonghu") @@ -44,69 +44,61 @@ public class YonghuController { private static final Logger logger = LoggerFactory.getLogger(YonghuController.class); @Autowired - private YonghuService yonghuService; // 用户服务 + private YonghuService yonghuService; + @Autowired - private TokenService tokenService; // token服务 + private TokenService tokenService; @Autowired private DictionaryService dictionaryService; // 字典服务 //级联表service @Autowired - private YishengService yishengService; // 医生服务 + private YishengService yishengService; + /** - * 后端列表 - * 分页查询用户数据 - */ + * 后端列表 + */ @RequestMapping("/page") public R page(@RequestParam Map params, HttpServletRequest request){ logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); String role = String.valueOf(request.getSession().getAttribute("role")); - // 权限控制 if(false) return R.error(511,"永不会进入"); else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，只查询自己的数据 + params.put("yonghuId",request.getSession().getAttribute("userId")); else if("医生".equals(role)) - params.put("yishengId",request.getSession().getAttribute("userId")); // 如果是医生角色，添加医生ID参数 - - // 设置查询未删除的用户（删除状态为1表示未删除） + params.put("yishengId",request.getSession().getAttribute("userId")); params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1); - - // 默认按id排序 if(params.get("orderBy")==null || params.get("orderBy")==""){ params.put("orderBy","id"); } - - // 调用服务层查询分页数据 PageUtils page = yonghuService.queryPage(params); - // 字典表数据转换 + //字典表数据转换 List list =(List)page.getList(); for(YonghuView c:list){ - // 修改对应字典表字段 + //修改对应字典表字段 dictionaryService.dictionaryConvert(c, request); } return R.ok().put("data", page); } /** - * 后端详情 - * 根据ID查询用户详情 - */ + * 后端详情 + */ @RequestMapping("/info/{id}") public R info(@PathVariable("id") Long id, HttpServletRequest request){ logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - // 根据ID查询用户 YonghuEntity yonghu = yonghuService.selectById(id); if(yonghu !=null){ - // entity转view + //entity转view YonghuView view = new YonghuView(); BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 - // 修改对应字典表字段 + //修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); return R.ok().put("data", view); }else { @@ -115,9 +107,8 @@ public class YonghuController { } /** - * 后端保存 - * 新增用户 - */ + * 后端保存 + */ @RequestMapping("/save") public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); @@ -126,24 +117,23 @@ public class YonghuController { if(false) return R.error(511,"永远不会进入"); - // 构建查询条件：检查用户名、手机号、身份证号是否已存在 Wrapper queryWrapper = new EntityWrapper() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .or() - .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) - .andNew() - .eq("yonghu_delete", 1) // 未删除的用户 - ; + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .or() + .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) + .andNew() + .eq("yonghu_delete", 1) + ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); if(yonghuEntity==null){ - yonghu.setYonghuDelete(1); // 设置未删除状态 - yonghu.setCreateTime(new Date()); // 设置创建时间 - yonghu.setPassword("123456"); // 设置默认密码 - yonghuService.insert(yonghu); // 插入新用户 + yonghu.setYonghuDelete(1); + yonghu.setCreateTime(new Date()); + yonghu.setPassword("123456"); + yonghuService.insert(yonghu); return R.ok(); }else { return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用"); @@ -151,32 +141,32 @@ public class YonghuController { } /** - * 后端修改 - * 更新用户信息 - */ + * 后端修改 + */ @RequestMapping("/update") public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); String role = String.valueOf(request.getSession().getAttribute("role")); - // 构建查询条件：检查其他用户是否已使用要修改的用户名、手机号或身份证号 +// if(false) +// return R.error(511,"永远不会进入"); + //根据字段查询是否有相同数据 Wrapper queryWrapper = new EntityWrapper() - .notIn("id",yonghu.getId()) // 排除当前用户 - .andNew() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .or() - .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) - .andNew() - .eq("yonghu_delete", 1) // 未删除的用户 - ; + .notIn("id",yonghu.getId()) + .andNew() + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .or() + .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) + .andNew() + .eq("yonghu_delete", 1) + ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); - // 处理空照片 if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){ - yonghu.setYonghuPhoto(null); + yonghu.setYonghuPhoto(null); } if(yonghuEntity==null){ yonghuService.updateById(yonghu);//根据id更新 @@ -187,9 +177,8 @@ public class YonghuController { } /** - * 删除 - * 逻辑删除用户（将删除状态设为2） - */ + * 删除 + */ @RequestMapping("/delete") public R delete(@RequestBody Integer[] ids){ logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); @@ -197,18 +186,17 @@ public class YonghuController { for(Integer id:ids){ YonghuEntity yonghuEntity = new YonghuEntity(); yonghuEntity.setId(id); - yonghuEntity.setYonghuDelete(2); // 设置删除状态为2 + yonghuEntity.setYonghuDelete(2); list.add(yonghuEntity); } if(list != null && list.size() >0){ - yonghuService.updateBatchById(list); // 批量更新 + yonghuService.updateBatchById(list); } return R.ok(); } /** * 批量上传 - * 通过Excel批量导入用户数据 */ @RequestMapping("/batchInsert") public R save( String fileName){ @@ -235,41 +223,52 @@ public class YonghuController { for(List data:dataList){ //循环 YonghuEntity yonghuEntity = new YonghuEntity(); - // 这里注释掉的代码是示例，实际应该根据Excel列映射字段 +// yonghuEntity.setUsername(data.get(0)); //账户 要改的 +// //yonghuEntity.setPassword("123456");//密码 +// yonghuEntity.setYonghuName(data.get(0)); //用户姓名 要改的 +// yonghuEntity.setYonghuPhoto("");//照片 +// yonghuEntity.setYonghuPhone(data.get(0)); //用户手机号 要改的 +// yonghuEntity.setYonghuIdNumber(data.get(0)); //用户身份证号 要改的 +// yonghuEntity.setYonghuEmail(data.get(0)); //邮箱 要改的 +// yonghuEntity.setSexTypes(Integer.valueOf(data.get(0))); //性别 要改的 +// yonghuEntity.setNewMoney(data.get(0)); //余额 要改的 +// yonghuEntity.setYonghuDelete(1);//逻辑删除字段 +// yonghuEntity.setCreateTime(date);//时间 yonghuList.add(yonghuEntity); + //把要查询是否重复的字段放入map中 - //账户 - if(seachFields.containsKey("username")){ - List username = seachFields.get("username"); - username.add(data.get(0));//要改的 - }else{ - List username = new ArrayList<>(); - username.add(data.get(0));//要改的 - seachFields.put("username",username); - } - //用户手机号 - if(seachFields.containsKey("yonghuPhone")){ - List yonghuPhone = seachFields.get("yonghuPhone"); - yonghuPhone.add(data.get(0));//要改的 - }else{ - List yonghuPhone = new ArrayList<>(); - yonghuPhone.add(data.get(0));//要改的 - seachFields.put("yonghuPhone",yonghuPhone); - } - //用户身份证号 - if(seachFields.containsKey("yonghuIdNumber")){ - List yonghuIdNumber = seachFields.get("yonghuIdNumber"); - yonghuIdNumber.add(data.get(0));//要改的 - }else{ - List yonghuIdNumber = new ArrayList<>(); - yonghuIdNumber.add(data.get(0));//要改的 - seachFields.put("yonghuIdNumber",yonghuIdNumber); - } + //账户 + if(seachFields.containsKey("username")){ + List username = seachFields.get("username"); + username.add(data.get(0));//要改的 + }else{ + List username = new ArrayList<>(); + username.add(data.get(0));//要改的 + seachFields.put("username",username); + } + //用户手机号 + if(seachFields.containsKey("yonghuPhone")){ + List yonghuPhone = seachFields.get("yonghuPhone"); + yonghuPhone.add(data.get(0));//要改的 + }else{ + List yonghuPhone = new ArrayList<>(); + yonghuPhone.add(data.get(0));//要改的 + seachFields.put("yonghuPhone",yonghuPhone); + } + //用户身份证号 + if(seachFields.containsKey("yonghuIdNumber")){ + List yonghuIdNumber = seachFields.get("yonghuIdNumber"); + yonghuIdNumber.add(data.get(0));//要改的 + }else{ + List yonghuIdNumber = new ArrayList<>(); + yonghuIdNumber.add(data.get(0));//要改的 + seachFields.put("yonghuIdNumber",yonghuIdNumber); + } } //查询是否重复 - //账户 + //账户 List yonghuEntities_username = yonghuService.selectList(new EntityWrapper().in("username", seachFields.get("username")).eq("yonghu_delete", 1)); if(yonghuEntities_username.size() >0 ){ ArrayList repeatFields = new ArrayList<>(); @@ -278,7 +277,7 @@ public class YonghuController { } return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString()); } - //用户手机号 + //用户手机号 List yonghuEntities_yonghuPhone = yonghuService.selectList(new EntityWrapper().in("yonghu_phone", seachFields.get("yonghuPhone")).eq("yonghu_delete", 1)); if(yonghuEntities_yonghuPhone.size() >0 ){ ArrayList repeatFields = new ArrayList<>(); @@ -287,7 +286,7 @@ public class YonghuController { } return R.error(511,"数据库的该表中的 [用户手机号] 字段已经存在 存在数据为:"+repeatFields.toString()); } - //用户身份证号 + //用户身份证号 List yonghuEntities_yonghuIdNumber = yonghuService.selectList(new EntityWrapper().in("yonghu_id_number", seachFields.get("yonghuIdNumber")).eq("yonghu_delete", 1)); if(yonghuEntities_yonghuIdNumber.size() >0 ){ ArrayList repeatFields = new ArrayList<>(); @@ -307,20 +306,21 @@ public class YonghuController { } /** - * 登录 - * 用户登录接口 - */ + * 登录 + */ @IgnoreAuth @RequestMapping(value = "/login") public R login(String username, String password, String captcha, HttpServletRequest request) { - // 根据用户名查询用户 YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper().eq("username", username)); if(yonghu==null || !yonghu.getPassword().equals(password)) return R.error("账号或密码不正确"); else if(yonghu.getYonghuDelete() != 1) return R.error("账户已被删除"); - - // 生成token + // // 获取监听器中的字典表 + // ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext(); + // Map> dictionaryMap= (Map>) servletContext.getAttribute("dictionaryMap"); + // Map role_types = dictionaryMap.get("role_types"); + // role_types.get(.getRoleTypes()); String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户"); R r = R.ok(); r.put("token", token); @@ -332,27 +332,24 @@ public class YonghuController { } /** - * 注册 - * 用户注册接口 - */ + * 注册 + */ @IgnoreAuth @PostMapping(value = "/register") public R register(@RequestBody YonghuEntity yonghu){ - // 检查用户名、手机号、身份证号是否已存在 +// ValidatorUtils.validateEntity(user); Wrapper queryWrapper = new EntityWrapper() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .or() - .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) - .andNew() - .eq("yonghu_delete", 1) - ; + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .or() + .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) + .andNew() + .eq("yonghu_delete", 1) + ; YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); if(yonghuEntity != null) return R.error("账户或者用户手机号或者用户身份证号已经被使用"); - - // 设置默认值 yonghu.setNewMoney(0.0); yonghu.setYonghuDelete(1); yonghu.setCreateTime(new Date()); @@ -362,41 +359,40 @@ public class YonghuController { /** * 重置密码 - * 将用户密码重置为默认值123456 */ @GetMapping(value = "/resetPassword") public R resetPassword(Integer id){ YonghuEntity yonghu = new YonghuEntity(); - yonghu.setPassword("123456"); // 设置默认密码 + yonghu.setPassword("123456"); yonghu.setId(id); yonghuService.updateById(yonghu); return R.ok(); } + /** * 忘记密码 - * 通过用户名重置密码 */ @IgnoreAuth @RequestMapping(value = "/resetPass") public R resetPass(String username, HttpServletRequest request) { YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper().eq("username", username)); if(yonghu!=null){ - yonghu.setPassword("123456"); // 重置为默认密码 + yonghu.setPassword("123456"); boolean b = yonghuService.updateById(yonghu); if(!b){ - return R.error(); + return R.error(); } }else{ - return R.error("账号不存在"); + return R.error("账号不存在"); } return R.ok(); } + /** - * 获取用户的session用户信息 - * 获取当前登录用户的信息 - */ + * 获取用户的session用户信息 + */ @RequestMapping("/session") public R getCurrYonghu(HttpServletRequest request){ Integer id = (Integer)request.getSession().getAttribute("userId"); @@ -414,20 +410,22 @@ public class YonghuController { } } + /** - * 退出 - * 用户注销登录 - */ + * 退出 + */ @GetMapping(value = "logout") public R logout(HttpServletRequest request) { - request.getSession().invalidate(); // 使session失效 + request.getSession().invalidate(); return R.ok("退出成功"); } + + + /** - * 前端列表 - * 提供给前端使用的用户列表接口 - */ + * 前端列表 + */ @IgnoreAuth @RequestMapping("/list") public R list(@RequestParam Map params, HttpServletRequest request){ @@ -447,53 +445,55 @@ public class YonghuController { } /** - * 前端详情 - * 提供给前端使用的用户详情接口 - */ + * 前端详情 + */ @RequestMapping("/detail/{id}") public R detail(@PathVariable("id") Long id, HttpServletRequest request){ logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); YonghuEntity yonghu = yonghuService.selectById(id); - if(yonghu !=null){ - //entity转view - YonghuView view = new YonghuView(); - BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 + if(yonghu !=null){ - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } + + //entity转view + YonghuView view = new YonghuView(); + BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 + + //修改对应字典表字段 + dictionaryService.dictionaryConvert(view, request); + return R.ok().put("data", view); + }else { + return R.error(511,"查不到数据"); + } } + /** - * 前端保存 - * 提供给前端使用的用户新增接口 - */ + * 前端保存 + */ @RequestMapping("/add") public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); - // 检查用户名、手机号、身份证号是否已存在 Wrapper queryWrapper = new EntityWrapper() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .or() - .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) - .andNew() - .eq("yonghu_delete", 1) - ; + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .or() + .eq("yonghu_id_number", yonghu.getYonghuIdNumber()) + .andNew() + .eq("yonghu_delete", 1) + ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); if(yonghuEntity==null){ - yonghu.setYonghuDelete(1); // 设置未删除状态 - yonghu.setCreateTime(new Date()); // 设置创建时间 - yonghu.setPassword("123456"); // 设置默认密码 - yonghuService.insert(yonghu); + yonghu.setYonghuDelete(1); + yonghu.setCreateTime(new Date()); + yonghu.setPassword("123456"); + yonghuService.insert(yonghu); return R.ok(); }else { return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用"); } } -} \ No newline at end of file + + +} diff --git a/src/main/java/com/entity/ChatEntity.java b/src/main/java/com/entity/ChatEntity.java index 772d087..c665b59 100644 --- a/src/main/java/com/entity/ChatEntity.java +++ b/src/main/java/com/entity/ChatEntity.java @@ -1,277 +1,310 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解，确保字段不为空字符串 import javax.validation.constraints.NotBlank; +// 导入 JSR 303 验证注解，确保集合或数组不为空 import javax.validation.constraints.NotEmpty; +// 导入 JSR 303 验证注解，确保字段不为 null import javax.validation.constraints.NotNull; - +// 导入 Jackson 注解，用于忽略 JSON 序列化和反序列化时的某些属性 import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表集合类 import java.util.List; - +// 导入 Spring 框架用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** * 在线咨询 * - * @author + * @author * @email */ +// 指定该类对应数据库中的 chat 表 @TableName("chat") +// 实现 Serializable 接口，使该类的对象可以进行序列化和反序列化操作 public class ChatEntity implements Serializable { + // 序列化版本号，确保序列化和反序列化的兼容性 private static final long serialVersionUID = 1L; + // 无参构造函数，方便创建 ChatEntity 类的实例 + public ChatEntity() { - public ChatEntity() { - - } - - public ChatEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参构造函数，接收一个泛型对象 t，将其属性复制到当前 ChatEntity 对象 + public ChatEntity(T t) { + try { + // 使用 BeanUtils 工具类复制属性 + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // 若复制属性过程中出现异常，打印异常堆栈信息 + e.printStackTrace(); + } + } /** * 主键 */ + // 指定该字段为主键，且主键生成策略为自增 @TableId(type = IdType.AUTO) + // 指定该字段对应数据库表中的 id 字段 @TableField(value = "id") - + // 主键，用于唯一标识一条在线咨询记录 private Integer id; - /** * 提问用户 */ + // 指定该字段对应数据库表中的 yonghu_id 字段 @TableField(value = "yonghu_id") - + // 提问用户的 ID，关联用户表 private Integer yonghuId; - /** * 问题 */ + // 指定该字段对应数据库表中的 chat_issue 字段 @TableField(value = "chat_issue") - + // 用户提出的问题内容 private String chatIssue; - /** * 问题时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 指定该字段对应数据库表中的 issue_time 字段 @TableField(value = "issue_time") - + // 用户提出问题的时间 private Date issueTime; - /** * 回复 */ + // 指定该字段对应数据库表中的 chat_reply 字段 @TableField(value = "chat_reply") - + // 针对用户问题的回复内容 private String chatReply; - /** * 回复时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 指定该字段对应数据库表中的 reply_time 字段 @TableField(value = "reply_time") - + // 回复用户问题的时间 private Date replyTime; - /** * 状态 */ + // 指定该字段对应数据库表中的 zhuangtai_types 字段 @TableField(value = "zhuangtai_types") - + // 在线咨询的状态，可能用整数表示不同状态，如 0 表示待回复，1 表示已回复等 private Integer zhuangtaiTypes; - /** * 数据类型 */ + // 指定该字段对应数据库表中的 chat_types 字段 @TableField(value = "chat_types") - + // 在线咨询的数据类型，可能用整数表示不同类型，如 1 表示文字咨询，2 表示图片咨询等 private Integer chatTypes; - /** * 创建时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "insert_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 指定该字段对应数据库表中的 insert_time 字段，且在插入数据时自动填充 + @TableField(value = "insert_time", fill = FieldFill.INSERT) + // 该条在线咨询记录的创建时间 private Date insertTime; - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 获取主键的方法 public Integer getId() { return id; } - /** - * 获取：主键 - */ - + * 获取：主键 + */ + // 设置主键的方法 public void setId(Integer id) { this.id = id; } + /** - * 设置：提问用户 - */ + * 设置：提问用户 + */ + // 获取提问用户 ID 的方法 public Integer getYonghuId() { return yonghuId; } - /** - * 获取：提问用户 - */ - + * 获取：提问用户 + */ + // 设置提问用户 ID 的方法 public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } + /** - * 设置：问题 - */ + * 设置：问题 + */ + // 获取问题内容的方法 public String getChatIssue() { return chatIssue; } - /** - * 获取：问题 - */ - + * 获取：问题 + */ + // 设置问题内容的方法 public void setChatIssue(String chatIssue) { this.chatIssue = chatIssue; } + /** - * 设置：问题时间 - */ + * 设置：问题时间 + */ + // 获取问题时间的方法 public Date getIssueTime() { return issueTime; } - /** - * 获取：问题时间 - */ - + * 获取：问题时间 + */ + // 设置问题时间的方法 public void setIssueTime(Date issueTime) { this.issueTime = issueTime; } + /** - * 设置：回复 - */ + * 设置：回复 + */ + // 获取回复内容的方法 public String getChatReply() { return chatReply; } - /** - * 获取：回复 - */ - + * 获取：回复 + */ + // 设置回复内容的方法 public void setChatReply(String chatReply) { this.chatReply = chatReply; } + /** - * 设置：回复时间 - */ + * 设置：回复时间 + */ + // 获取回复时间的方法 public Date getReplyTime() { return replyTime; } - /** - * 获取：回复时间 - */ - + * 获取：回复时间 + */ + // 设置回复时间的方法 public void setReplyTime(Date replyTime) { this.replyTime = replyTime; } + /** - * 设置：状态 - */ + * 设置：状态 + */ + // 获取状态的方法 public Integer getZhuangtaiTypes() { return zhuangtaiTypes; } - /** - * 获取：状态 - */ - + * 获取：状态 + */ + // 设置状态的方法 public void setZhuangtaiTypes(Integer zhuangtaiTypes) { this.zhuangtaiTypes = zhuangtaiTypes; } + /** - * 设置：数据类型 - */ + * 设置：数据类型 + */ + // 获取数据类型的方法 public Integer getChatTypes() { return chatTypes; } - /** - * 获取：数据类型 - */ - + * 获取：数据类型 + */ + // 设置数据类型的方法 public void setChatTypes(Integer chatTypes) { this.chatTypes = chatTypes; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 获取创建时间的方法 public Date getInsertTime() { return insertTime; } - /** - * 获取：创建时间 - */ - + * 获取：创建时间 + */ + // 设置创建时间的方法 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + // 重写 toString 方法，方便打印对象信息 @Override public String toString() { return "Chat{" + - "id=" + id + - ", yonghuId=" + yonghuId + - ", chatIssue=" + chatIssue + - ", issueTime=" + issueTime + - ", chatReply=" + chatReply + - ", replyTime=" + replyTime + - ", zhuangtaiTypes=" + zhuangtaiTypes + - ", chatTypes=" + chatTypes + - ", insertTime=" + insertTime + - "}"; + "id=" + id + + ", yonghuId=" + yonghuId + + ", chatIssue=" + chatIssue + + ", issueTime=" + issueTime + + ", chatReply=" + chatReply + + ", replyTime=" + replyTime + + ", zhuangtaiTypes=" + zhuangtaiTypes + + ", chatTypes=" + chatTypes + + ", insertTime=" + insertTime + + "}"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/ConfigEntity.java b/src/main/java/com/entity/ConfigEntity.java index 7078bc2..327fd00 100644 --- a/src/main/java/com/entity/ConfigEntity.java +++ b/src/main/java/com/entity/ConfigEntity.java @@ -7,22 +7,21 @@ import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.enums.IdType; /** -* @author yangliyuan -* @version 创建时间：2020年2月7日 下午8:36:05 -* 类说明 : -*/ + * @author yangliyuan + * @version 创建时间：2020年2月7日 下午8:36:05 + * 类说明 : + */ @TableName("config") public class ConfigEntity implements Serializable{ -private static final long serialVersionUID = 1L; - + // 定义主键字段 @TableId(type = IdType.AUTO) private Long id; - + /** - * key + * name */ private String name; - + /** * value */ @@ -51,5 +50,4 @@ private static final long serialVersionUID = 1L; public void setValue(String value) { this.value = value; } - -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/DictionaryEntity.java b/src/main/java/com/entity/DictionaryEntity.java index e49ac9d..a0ab3ec 100644 --- a/src/main/java/com/entity/DictionaryEntity.java +++ b/src/main/java/com/entity/DictionaryEntity.java @@ -1,249 +1,276 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解（在当前代码中未实际使用） import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - +// 导入 Jackson 注解（在当前代码中未实际使用） import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表集合类（在当前代码中未实际使用） import java.util.List; - +// 导入 Spring 框架用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** * 字典表 * - * @author + * @author * @email */ +// 使用 TableName 注解指定该类对应的数据库表名为 "dictionary" @TableName("dictionary") +// 定义泛型类 DictionaryEntity，实现 Serializable 接口，以便对象可以进行序列化和反序列化 public class DictionaryEntity implements Serializable { + // 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; + // 无参构造函数，用于创建 DictionaryEntity 对象 + public DictionaryEntity() { - public DictionaryEntity() { - - } - - public DictionaryEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法 + // 将对象 t 的属性复制到当前 DictionaryEntity 对象中 + public DictionaryEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // 如果在复制属性过程中出现异常，打印异常堆栈信息 + e.printStackTrace(); + } + } /** * 主键 */ + // 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO） @TableId(type = IdType.AUTO) + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id" @TableField(value = "id") - + // 存储字典表记录的主键值，用于唯一标识一条记录 private Integer id; - /** * 字段 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "dic_code" @TableField(value = "dic_code") - + // 存储字典表中的字段代码，可能用于标识不同的字典项类别等 private String dicCode; - /** * 字段名 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "dic_name" @TableField(value = "dic_name") - + // 存储字典表中字段的名称，与 dicCode 对应，提供更易读的名称标识 private String dicName; - /** * 编码 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "code_index" @TableField(value = "code_index") - + // 存储字典表中某一字典项的编码值，可能用于内部编码或排序等用途 private Integer codeIndex; - /** * 编码名字 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "index_name" @TableField(value = "index_name") - + // 存储编码对应的名称，与 codeIndex 对应，提供更详细的编码描述 private String indexName; - /** * 父字段id */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "super_id" @TableField(value = "super_id") - + // 存储当前字典项的父字段 ID，用于表示字典项之间的层级关系 private Integer superId; - /** * 备注 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "beizhu" @TableField(value = "beizhu") - + // 存储关于当前字典项的备注信息，用于记录额外的说明或注意事项 private String beizhu; - /** * 创建时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"， + // 并设置在插入数据时自动填充当前时间 + @TableField(value = "create_time", fill = FieldFill.INSERT) + // 存储字典表记录的创建时间，用于记录数据的创建时间戳 private Date createTime; - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 获取主键值的方法，外部可以通过调用该方法获取 id 字段的值 public Integer getId() { return id; } - /** - * 获取：主键 - */ - + * 获取：主键 + */ + // 设置主键值的方法，外部可以通过调用该方法设置 id 字段的值 public void setId(Integer id) { this.id = id; } + /** - * 设置：字段 - */ + * 设置：字段 + */ + // 获取字段代码值的方法，外部可以通过调用该方法获取 dicCode 字段的值 public String getDicCode() { return dicCode; } - /** - * 获取：字段 - */ - + * 获取：字段 + */ + // 设置字段代码值的方法，外部可以通过调用该方法设置 dicCode 字段的值 public void setDicCode(String dicCode) { this.dicCode = dicCode; } + /** - * 设置：字段名 - */ + * 设置：字段名 + */ + // 获取字段名称值的方法，外部可以通过调用该方法获取 dicName 字段的值 public String getDicName() { return dicName; } - /** - * 获取：字段名 - */ - + * 获取：字段名 + */ + // 设置字段名称值的方法，外部可以通过调用该方法设置 dicName 字段的值 public void setDicName(String dicName) { this.dicName = dicName; } + /** - * 设置：编码 - */ + * 设置：编码 + */ + // 获取编码值的方法，外部可以通过调用该方法获取 codeIndex 字段的值 public Integer getCodeIndex() { return codeIndex; } - /** - * 获取：编码 - */ - + * 获取：编码 + */ + // 设置编码值的方法，外部可以通过调用该方法设置 codeIndex 字段的值 public void setCodeIndex(Integer codeIndex) { this.codeIndex = codeIndex; } + /** - * 设置：编码名字 - */ + * 设置：编码名字 + */ + // 获取编码名称值的方法，外部可以通过调用该方法获取 indexName 字段的值 public String getIndexName() { return indexName; } - /** - * 获取：编码名字 - */ - + * 获取：编码名字 + */ + // 设置编码名称值的方法，外部可以通过调用该方法设置 indexName 字段的值 public void setIndexName(String indexName) { this.indexName = indexName; } + /** - * 设置：父字段id - */ + * 设置：父字段id + */ + // 获取父字段 ID 值的方法，外部可以通过调用该方法获取 superId 字段的值 public Integer getSuperId() { return superId; } - /** - * 获取：父字段id - */ - + * 获取：父字段id + */ + // 设置父字段 ID 值的方法，外部可以通过调用该方法设置 superId 字段的值 public void setSuperId(Integer superId) { this.superId = superId; } + /** - * 设置：备注 - */ + * 设置：备注 + */ + // 获取备注信息值的方法，外部可以通过调用该方法获取 beizhu 字段的值 public String getBeizhu() { return beizhu; } - /** - * 获取：备注 - */ - + * 获取：备注 + */ + // 设置备注信息值的方法，外部可以通过调用该方法设置 beizhu 字段的值 public void setBeizhu(String beizhu) { this.beizhu = beizhu; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 获取创建时间值的方法，外部可以通过调用该方法获取 createTime 字段的值 public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ - + * 获取：创建时间 + */ + // 设置创建时间值的方法，外部可以通过调用该方法设置 createTime 字段的值 public void setCreateTime(Date createTime) { this.createTime = createTime; } + // 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录 @Override public String toString() { return "Dictionary{" + - "id=" + id + - ", dicCode=" + dicCode + - ", dicName=" + dicName + - ", codeIndex=" + codeIndex + - ", indexName=" + indexName + - ", superId=" + superId + - ", beizhu=" + beizhu + - ", createTime=" + createTime + - "}"; - } -} + "id=" + id + + ", dicCode=" + dicCode + + ", dicName=" + dicName + + ", codeIndex=" + codeIndex + + ", indexName=" + indexName + + ", superId=" + superId + + ", beizhu=" + beizhu + + ", createTime=" + createTime + + "}"; + } +} \ No newline at end of file diff --git a/src/main/java/com/entity/EIException.java b/src/main/java/com/entity/EIException.java index 2ebfb56..1245d2e 100644 --- a/src/main/java/com/entity/EIException.java +++ b/src/main/java/com/entity/EIException.java @@ -1,52 +1,64 @@ - package com.entity; /** * 自定义异常 */ +// 定义一个名为EIException的类，它继承自RuntimeException，表明这是一个运行时异常类 public class EIException extends RuntimeException { + // 定义序列化版本号，用于在序列化和反序列化过程中确保兼容性 private static final long serialVersionUID = 1L; - - private String msg; - private int code = 500; - - public EIException(String msg) { + + // 用于存储异常的详细信息，描述异常发生的情况 + private String msg; + // 用于存储异常的状态码，默认值为500，通常表示服务器内部错误 + private int code = 500; + + // 构造函数，接受一个字符串参数msg，将其设置为异常信息，并调用父类的构造函数传递异常信息 + public EIException(String msg) { super(msg); this.msg = msg; } - + + // 构造函数，接受一个字符串参数msg和一个Throwable对象e， + // 将msg设置为异常信息，调用父类的构造函数传递异常信息和异常原因 public EIException(String msg, Throwable e) { super(msg, e); this.msg = msg; } - + + // 构造函数，接受一个字符串参数msg和一个整数参数code， + // 将msg设置为异常信息，code设置为异常状态码，并调用父类的构造函数传递异常信息 public EIException(String msg, int code) { super(msg); this.msg = msg; this.code = code; } - + + // 构造函数，接受一个字符串参数msg、一个整数参数code和一个Throwable对象e， + // 将msg设置为异常信息，code设置为异常状态码，调用父类的构造函数传递异常信息和异常原因 public EIException(String msg, int code, Throwable e) { super(msg, e); this.msg = msg; this.code = code; } + // 获取异常信息的方法，返回存储的异常信息字符串 public String getMsg() { return msg; } + // 设置异常信息的方法，将传入的字符串设置为新的异常信息 public void setMsg(String msg) { this.msg = msg; } + // 获取异常状态码的方法，返回存储的异常状态码 public int getCode() { return code; } + // 设置异常状态码的方法，将传入的整数设置为新的异常状态码 public void setCode(int code) { this.code = code; } - - -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/GuahaoEntity.java b/src/main/java/com/entity/GuahaoEntity.java index d2aec62..b7bba0b 100644 --- a/src/main/java/com/entity/GuahaoEntity.java +++ b/src/main/java/com/entity/GuahaoEntity.java @@ -1,299 +1,330 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解（在当前代码中未实际使用） import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - +// 导入 Jackson 注解（在当前代码中未实际使用） import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表集合类（在当前代码中未实际使用） import java.util.List; - +// 导入 Spring 框架用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** * 挂号 * - * @author + * @author * @email */ +// 使用 TableName 注解指定该类对应的数据库表名为 "guahao" @TableName("guahao") +// 定义泛型类 GuahaoEntity，实现 Serializable 接口，以便对象可以进行序列化和反序列化 public class GuahaoEntity implements Serializable { + // 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; + // 无参构造函数，用于创建 GuahaoEntity 对象 + public GuahaoEntity() { - public GuahaoEntity() { - - } - - public GuahaoEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法 + // 将对象 t 的属性复制到当前 GuahaoEntity 对象中 + public GuahaoEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // 如果在复制属性过程中出现异常，打印异常堆栈信息 + e.printStackTrace(); + } + } /** * 主键 */ + // 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO） @TableId(type = IdType.AUTO) + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id" @TableField(value = "id") - + // 存储挂号记录的主键值，用于唯一标识一条挂号记录 private Integer id; - /** * 医生 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "yisheng_id" @TableField(value = "yisheng_id") - + // 存储挂号对应的医生 ID，关联医生表 private Integer yishengId; - /** * 用户 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "yonghu_id" @TableField(value = "yonghu_id") - + // 存储挂号的用户 ID，关联用户表 private Integer yonghuId; - /** * 就诊识别码 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_uuin_number" @TableField(value = "guahao_uuin_number") - + // 存储就诊的唯一识别码，用于标识具体的就诊记录 private String guahaoUuinNumber; - /** * 挂号时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd") - @DateTimeFormat + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_time" @TableField(value = "guahao_time") - + // 存储挂号的具体时间 private Date guahaoTime; - /** * 时间类型 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_types" @TableField(value = "guahao_types") - + // 存储挂号的时间类型，可能表示上午、下午、晚上等不同时间段，用整数标识 private Integer guahaoTypes; - /** * 挂号状态 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_status_types" @TableField(value = "guahao_status_types") - + // 存储挂号的状态，例如已挂号、已取消、已就诊等，用整数标识不同状态 private Integer guahaoStatusTypes; - /** * 挂号审核 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_yesno_types" @TableField(value = "guahao_yesno_types") - + // 存储挂号审核的结果，可能表示通过、不通过等，用整数标识 private Integer guahaoYesnoTypes; - /** * 审核结果 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "guahao_yesno_text" @TableField(value = "guahao_yesno_text") - + // 存储挂号审核结果的具体文本描述，例如不通过的原因等 private String guahaoYesnoText; - /** * 创建时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"， + // 并设置在插入数据时自动填充当前时间 + @TableField(value = "create_time", fill = FieldFill.INSERT) + // 存储挂号记录的创建时间，用于记录数据的创建时间戳 private Date createTime; - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 获取主键值的方法，外部可以通过调用该方法获取 id 字段的值 public Integer getId() { return id; } - /** - * 获取：主键 - */ - + * 获取：主键 + */ + // 设置主键值的方法，外部可以通过调用该方法设置 id 字段的值 public void setId(Integer id) { this.id = id; } + /** - * 设置：医生 - */ + * 设置：医生 + */ + // 获取医生 ID 值的方法，外部可以通过调用该方法获取 yishengId 字段的值 public Integer getYishengId() { return yishengId; } - /** - * 获取：医生 - */ - + * 获取：医生 + */ + // 设置医生 ID 值的方法，外部可以通过调用该方法设置 yishengId 字段的值 public void setYishengId(Integer yishengId) { this.yishengId = yishengId; } + /** - * 设置：用户 - */ + * 设置：用户 + */ + // 获取用户 ID 值的方法，外部可以通过调用该方法获取 yonghuId 字段的值 public Integer getYonghuId() { return yonghuId; } - /** - * 获取：用户 - */ - + * 获取：用户 + */ + // 设置用户 ID 值的方法，外部可以通过调用该方法设置 yonghuId 字段的值 public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } + /** - * 设置：就诊识别码 - */ + * 设置：就诊识别码 + */ + // 获取就诊识别码值的方法，外部可以通过调用该方法获取 guahaoUuinNumber 字段的值 public String getGuahaoUuinNumber() { return guahaoUuinNumber; } - /** - * 获取：就诊识别码 - */ - + * 获取：就诊识别码 + */ + // 设置就诊识别码值的方法，外部可以通过调用该方法设置 guahaoUuinNumber 字段的值 public void setGuahaoUuinNumber(String guahaoUuinNumber) { this.guahaoUuinNumber = guahaoUuinNumber; } + /** - * 设置：挂号时间 - */ + * 设置：挂号时间 + */ + // 获取挂号时间值的方法，外部可以通过调用该方法获取 guahaoTime 字段的值 public Date getGuahaoTime() { return guahaoTime; } - /** - * 获取：挂号时间 - */ - + * 获取：挂号时间 + */ + // 设置挂号时间值的方法，外部可以通过调用该方法设置 guahaoTime 字段的值 public void setGuahaoTime(Date guahaoTime) { this.guahaoTime = guahaoTime; } + /** - * 设置：时间类型 - */ + * 设置：时间类型 + */ + // 获取时间类型值的方法，外部可以通过调用该方法获取 guahaoTypes 字段的值 public Integer getGuahaoTypes() { return guahaoTypes; } - /** - * 获取：时间类型 - */ - + * 获取：时间类型 + */ + // 设置时间类型值的方法，外部可以通过调用该方法设置 guahaoTypes 字段的值 public void setGuahaoTypes(Integer guahaoTypes) { this.guahaoTypes = guahaoTypes; } + /** - * 设置：挂号状态 - */ + * 设置：挂号状态 + */ + // 获取挂号状态值的方法，外部可以通过调用该方法获取 guahaoStatusTypes 字段的值 public Integer getGuahaoStatusTypes() { return guahaoStatusTypes; } - /** - * 获取：挂号状态 - */ - + * 获取：挂号状态 + */ + // 设置挂号状态值的方法，外部可以通过调用该方法设置 guahaoStatusTypes 字段的值 public void setGuahaoStatusTypes(Integer guahaoStatusTypes) { this.guahaoStatusTypes = guahaoStatusTypes; } + /** - * 设置：挂号审核 - */ + * 设置：挂号审核 + */ + // 获取挂号审核值的方法，外部可以通过调用该方法获取 guahaoYesnoTypes 字段的值 public Integer getGuahaoYesnoTypes() { return guahaoYesnoTypes; } - /** - * 获取：挂号审核 - */ - + * 获取：挂号审核 + */ + // 设置挂号审核值的方法，外部可以通过调用该方法设置 guahaoYesnoTypes 字段的值 public void setGuahaoYesnoTypes(Integer guahaoYesnoTypes) { this.guahaoYesnoTypes = guahaoYesnoTypes; } + /** - * 设置：审核结果 - */ + * 设置：审核结果 + */ + // 获取审核结果值的方法，外部可以通过调用该方法获取 guahaoYesnoText 字段的值 public String getGuahaoYesnoText() { return guahaoYesnoText; } - /** - * 获取：审核结果 - */ - + * 获取：审核结果 + */ + // 设置审核结果值的方法，外部可以通过调用该方法设置 guahaoYesnoText 字段的值 public void setGuahaoYesnoText(String guahaoYesnoText) { this.guahaoYesnoText = guahaoYesnoText; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 获取创建时间值的方法，外部可以通过调用该方法获取 createTime 字段的值 public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ - + * 获取：创建时间 + */ + // 设置创建时间值的方法，外部可以通过调用该方法设置 createTime 字段的值 public void setCreateTime(Date createTime) { this.createTime = createTime; } + // 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录 @Override public String toString() { return "Guahao{" + - "id=" + id + - ", yishengId=" + yishengId + - ", yonghuId=" + yonghuId + - ", guahaoUuinNumber=" + guahaoUuinNumber + - ", guahaoTime=" + guahaoTime + - ", guahaoTypes=" + guahaoTypes + - ", guahaoStatusTypes=" + guahaoStatusTypes + - ", guahaoYesnoTypes=" + guahaoYesnoTypes + - ", guahaoYesnoText=" + guahaoYesnoText + - ", createTime=" + createTime + - "}"; + "id=" + id + + ", yishengId=" + yishengId + + ", yonghuId=" + yonghuId + + ", guahaoUuinNumber=" + guahaoUuinNumber + + ", guahaoTime=" + guahaoTime + + ", guahaoTypes=" + guahaoTypes + + ", guahaoStatusTypes=" + guahaoStatusTypes + + ", guahaoYesnoTypes=" + guahaoYesnoTypes + + ", guahaoYesnoText=" + guahaoYesnoText + + ", createTime=" + createTime + + "}"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/JiankangjiaoyuEntity.java b/src/main/java/com/entity/JiankangjiaoyuEntity.java index e4c4d78..ebe1515 100644 --- a/src/main/java/com/entity/JiankangjiaoyuEntity.java +++ b/src/main/java/com/entity/JiankangjiaoyuEntity.java @@ -1,251 +1,279 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解，可用于字段验证，当前代码未使用这些注解进行实际验证 import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - +// 导入 Jackson 注解，可用于忽略 JSON 序列化和反序列化时的某些属性，当前代码未使用 import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口，使该类的对象可以进行序列化和反序列化操作 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表集合类，当前代码未使用 import java.util.List; - +// 导入 Spring 框架用于日期格式化的注解，用于将字符串日期转换为 Date 对象 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** * 健康教育 * - * @author + * @author * @email */ +// 指定该类对应数据库中的 jiankangjiaoyu 表 @TableName("jiankangjiaoyu") +// 定义泛型类，实现 Serializable 接口 public class JiankangjiaoyuEntity implements Serializable { + // 序列化版本号，确保序列化和反序列化的兼容性 private static final long serialVersionUID = 1L; + // 无参构造函数，方便创建 JiankangjiaoyuEntity 类的实例 + public JiankangjiaoyuEntity() { - public JiankangjiaoyuEntity() { - - } - - public JiankangjiaoyuEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参构造函数，接收一个泛型对象 t，将其属性复制到当前 JiankangjiaoyuEntity 对象 + public JiankangjiaoyuEntity(T t) { + try { + // 使用 BeanUtils 工具类复制属性 + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // 若复制属性过程中出现异常，打印异常堆栈信息 + e.printStackTrace(); + } + } /** * 主键 */ + // 指定该字段为主键，且主键生成策略为自增 @TableId(type = IdType.AUTO) + // 指定该字段对应数据库表中的 id 字段 @TableField(value = "id") - + // 主键，用于唯一标识一条健康教育记录 private Integer id; - /** * 健康教育标题 */ + // 指定该字段对应数据库表中的 jiankangjiaoyu_name 字段 @TableField(value = "jiankangjiaoyu_name") - + // 健康教育的标题 private String jiankangjiaoyuName; - /** * 健康教育类型 */ + // 指定该字段对应数据库表中的 jiankangjiaoyu_types 字段 @TableField(value = "jiankangjiaoyu_types") - + // 健康教育的类型，用整数表示不同类型 private Integer jiankangjiaoyuTypes; - /** * 健康教育图片 */ + // 指定该字段对应数据库表中的 jiankangjiaoyu_photo 字段 @TableField(value = "jiankangjiaoyu_photo") - + // 健康教育相关图片的存储路径 private String jiankangjiaoyuPhoto; - /** * 健康教育时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "insert_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 指定该字段对应数据库表中的 insert_time 字段，且在插入数据时自动填充 + @TableField(value = "insert_time", fill = FieldFill.INSERT) + // 健康教育的时间 private Date insertTime; - /** * 健康教育详情 */ + // 指定该字段对应数据库表中的 jiankangjiaoyu_content 字段 @TableField(value = "jiankangjiaoyu_content") - + // 健康教育的详细内容 private String jiankangjiaoyuContent; - /** * 假删 */ + // 指定该字段对应数据库表中的 jiankangjiaoyu_delete 字段 @TableField(value = "jiankangjiaoyu_delete") - + // 假删除标记，用整数表示是否删除，如 0 表示未删除，1 表示已删除 private Integer jiankangjiaoyuDelete; - /** * 创建时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 指定该字段对应数据库表中的 create_time 字段，且在插入数据时自动填充 + @TableField(value = "create_time", fill = FieldFill.INSERT) + // 该条健康教育记录的创建时间 private Date createTime; - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 获取主键的方法 public Integer getId() { return id; } - /** - * 获取：主键 - */ - + * 获取：主键 + */ + // 设置主键的方法 public void setId(Integer id) { this.id = id; } + /** - * 设置：健康教育标题 - */ + * 设置：健康教育标题 + */ + // 获取健康教育标题的方法 public String getJiankangjiaoyuName() { return jiankangjiaoyuName; } - /** - * 获取：健康教育标题 - */ - + * 获取：健康教育标题 + */ + // 设置健康教育标题的方法 public void setJiankangjiaoyuName(String jiankangjiaoyuName) { this.jiankangjiaoyuName = jiankangjiaoyuName; } + /** - * 设置：健康教育类型 - */ + * 设置：健康教育类型 + */ + // 获取健康教育类型的方法 public Integer getJiankangjiaoyuTypes() { return jiankangjiaoyuTypes; } - /** - * 获取：健康教育类型 - */ - + * 获取：健康教育类型 + */ + // 设置健康教育类型的方法 public void setJiankangjiaoyuTypes(Integer jiankangjiaoyuTypes) { this.jiankangjiaoyuTypes = jiankangjiaoyuTypes; } + /** - * 设置：健康教育图片 - */ + * 设置：健康教育图片 + */ + // 获取健康教育图片路径的方法 public String getJiankangjiaoyuPhoto() { return jiankangjiaoyuPhoto; } - /** - * 获取：健康教育图片 - */ - + * 获取：健康教育图片 + */ + // 设置健康教育图片路径的方法 public void setJiankangjiaoyuPhoto(String jiankangjiaoyuPhoto) { this.jiankangjiaoyuPhoto = jiankangjiaoyuPhoto; } + /** - * 设置：健康教育时间 - */ + * 设置：健康教育时间 + */ + // 获取健康教育时间的方法 public Date getInsertTime() { return insertTime; } - /** - * 获取：健康教育时间 - */ - + * 获取：健康教育时间 + */ + // 设置健康教育时间的方法 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + /** - * 设置：健康教育详情 - */ + * 设置：健康教育详情 + */ + // 获取健康教育详情的方法 public String getJiankangjiaoyuContent() { return jiankangjiaoyuContent; } - /** - * 获取：健康教育详情 - */ - + * 获取：健康教育详情 + */ + // 设置健康教育详情的方法 public void setJiankangjiaoyuContent(String jiankangjiaoyuContent) { this.jiankangjiaoyuContent = jiankangjiaoyuContent; } + /** - * 设置：假删 - */ + * 设置：假删 + */ + // 获取假删除标记的方法 public Integer getJiankangjiaoyuDelete() { return jiankangjiaoyuDelete; } - /** - * 获取：假删 - */ - + * 获取：假删 + */ + // 设置假删除标记的方法 public void setJiankangjiaoyuDelete(Integer jiankangjiaoyuDelete) { this.jiankangjiaoyuDelete = jiankangjiaoyuDelete; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 获取创建时间的方法 public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ - + * 获取：创建时间 + */ + // 设置创建时间的方法 public void setCreateTime(Date createTime) { this.createTime = createTime; } + // 重写 toString 方法，方便打印对象信息 @Override public String toString() { return "Jiankangjiaoyu{" + - "id=" + id + - ", jiankangjiaoyuName=" + jiankangjiaoyuName + - ", jiankangjiaoyuTypes=" + jiankangjiaoyuTypes + - ", jiankangjiaoyuPhoto=" + jiankangjiaoyuPhoto + - ", insertTime=" + insertTime + - ", jiankangjiaoyuContent=" + jiankangjiaoyuContent + - ", jiankangjiaoyuDelete=" + jiankangjiaoyuDelete + - ", createTime=" + createTime + - "}"; - } -} + "id=" + id + + ", jiankangjiaoyuName=" + jiankangjiaoyuName + + ", jiankangjiaoyuTypes=" + jiankangjiaoyuTypes + + ", jiankangjiaoyuPhoto=" + jiankangjiaoyuPhoto + + ", insertTime=" + insertTime + + ", jiankangjiaoyuContent=" + jiankangjiaoyuContent + + ", jiankangjiaoyuDelete=" + jiankangjiaoyuDelete + + ", createTime=" + createTime + + "}"; + } +} \ No newline at end of file diff --git a/src/main/java/com/entity/NewsEntity.java b/src/main/java/com/entity/NewsEntity.java index 50e42be..7c61650 100644 --- a/src/main/java/com/entity/NewsEntity.java +++ b/src/main/java/com/entity/NewsEntity.java @@ -1,227 +1,256 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解（当前未实际使用） import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - +// 导入 Jackson 用于忽略属性的注解（当前未实际使用） import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表类（当前未实际使用） import java.util.List; - +// 导入 Spring 用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** * 公告信息 * - * @author + * @author * @email */ +// 使用 TableName 注解指定该类对应的数据库表名为 "news" @TableName("news") +// 定义泛型类 NewsEntity，实现 Serializable 接口，用于对象的序列化和反序列化 public class NewsEntity implements Serializable { + // 定义序列化版本号，保证序列化和反序列化的兼容性 private static final long serialVersionUID = 1L; + // 无参构造函数，用于创建 NewsEntity 对象 + public NewsEntity() { - public NewsEntity() { - - } - - public NewsEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参构造函数，接受一个泛型对象 t，通过 BeanUtils.copyProperties 方法 + // 将对象 t 的属性复制到当前 NewsEntity 对象中 + public NewsEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // 如果在复制属性过程中出现异常，打印异常堆栈信息 + e.printStackTrace(); + } + } /** * 主键 */ + // 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（IdType.AUTO） @TableId(type = IdType.AUTO) + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "id" @TableField(value = "id") - + // 存储公告信息记录的主键值，用于唯一标识一条公告记录 private Integer id; - /** * 公告名称 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_name" @TableField(value = "news_name") - + // 存储公告的名称 private String newsName; - /** * 公告图片 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_photo" @TableField(value = "news_photo") - + // 存储公告相关图片的路径或标识 private String newsPhoto; - /** * 公告类型 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_types" @TableField(value = "news_types") - + // 存储公告的类型，用整数表示不同的公告类型，如通知、公告等 private Integer newsTypes; - /** * 公告发布时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "insert_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "insert_time"， + // 并设置在插入数据时自动填充当前时间 + @TableField(value = "insert_time", fill = FieldFill.INSERT) + // 存储公告的发布时间 private Date insertTime; - /** * 公告详情 */ + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "news_content" @TableField(value = "news_content") - + // 存储公告的详细内容 private String newsContent; - /** * 创建时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + // 设置 JSON 序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + // 用于 Spring MVC 接收表单数据时将日期字符串转换为 Date 对象 + @DateTimeFormat + // 使用 TableField 注解指定该字段在数据库表中对应的字段名为 "create_time"， + // 并设置在插入数据时自动填充当前时间 + @TableField(value = "create_time", fill = FieldFill.INSERT) + // 存储公告记录的创建时间，用于记录数据的创建时间戳 private Date createTime; - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 获取主键值的方法 public Integer getId() { return id; } - /** - * 获取：主键 - */ - + * 获取：主键 + */ + // 设置主键值的方法 public void setId(Integer id) { this.id = id; } + /** - * 设置：公告名称 - */ + * 设置：公告名称 + */ + // 获取公告名称值的方法 public String getNewsName() { return newsName; } - /** - * 获取：公告名称 - */ - + * 获取：公告名称 + */ + // 设置公告名称值的方法 public void setNewsName(String newsName) { this.newsName = newsName; } + /** - * 设置：公告图片 - */ + * 设置：公告图片 + */ + // 获取公告图片路径值的方法 public String getNewsPhoto() { return newsPhoto; } - /** - * 获取：公告图片 - */ - + * 获取：公告图片 + */ + // 设置公告图片路径值的方法 public void setNewsPhoto(String newsPhoto) { this.newsPhoto = newsPhoto; } + /** - * 设置：公告类型 - */ + * 设置：公告类型 + */ + // 获取公告类型值的方法 public Integer getNewsTypes() { return newsTypes; } - /** - * 获取：公告类型 - */ - + * 获取：公告类型 + */ + // 设置公告类型值的方法 public void setNewsTypes(Integer newsTypes) { this.newsTypes = newsTypes; } + /** - * 设置：公告发布时间 - */ + * 设置：公告发布时间 + */ + // 获取公告发布时间值的方法 public Date getInsertTime() { return insertTime; } - /** - * 获取：公告发布时间 - */ - + * 获取：公告发布时间 + */ + // 设置公告发布时间值的方法 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + /** - * 设置：公告详情 - */ + * 设置：公告详情 + */ + // 获取公告详情值的方法 public String getNewsContent() { return newsContent; } - /** - * 获取：公告详情 - */ - + * 获取：公告详情 + */ + // 设置公告详情值的方法 public void setNewsContent(String newsContent) { this.newsContent = newsContent; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 获取创建时间值的方法 public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ - + * 获取：创建时间 + */ + // 设置创建时间值的方法 public void setCreateTime(Date createTime) { this.createTime = createTime; } + // 重写 toString 方法，返回对象的字符串表示，方便调试和日志记录 @Override public String toString() { return "News{" + - "id=" + id + - ", newsName=" + newsName + - ", newsPhoto=" + newsPhoto + - ", newsTypes=" + newsTypes + - ", insertTime=" + insertTime + - ", newsContent=" + newsContent + - ", createTime=" + createTime + - "}"; - } -} + "id=" + id + + ", newsName=" + newsName + + ", newsPhoto=" + newsPhoto + + ", newsTypes=" + newsTypes + + ", insertTime=" + insertTime + + ", newsContent=" + newsContent + + ", createTime=" + createTime + + "}"; + } +} \ No newline at end of file diff --git a/src/main/java/com/entity/TokenEntity.java b/src/main/java/com/entity/TokenEntity.java index bdc0824..4f95c1d 100644 --- a/src/main/java/com/entity/TokenEntity.java +++ b/src/main/java/com/entity/TokenEntity.java @@ -1,122 +1,156 @@ package com.entity; +// 导入序列化接口，使该类的对象可以进行序列化和反序列化 import java.io.Serializable; +// 导入日期类，用于处理日期相关的操作 import java.util.Date; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; -/** +/** * token表 */ +// 使用 TableName 注解指定该类对应的数据库表名为 "token" @TableName("token") +//定义 TokenEntity 类，实现 Serializable 接口，以支持对象的序列化和反序列化 public class TokenEntity implements Serializable { + // 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; - + + // 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO） @TableId(type = IdType.AUTO) + // 存储记录的主键值，用于唯一标识一条 token 记录 private Integer id; - + /** * 用户id */ + // 存储与该 token 相关联的用户 ID private Integer userid; - + /** * 用户名 */ + // 存储与该 token 相关联的用户名 private String username; - + /** * 表名 */ + // 存储与该 token 相关的表名（具体用途可能根据业务需求而定） private String tablename; - + /** * 角色 */ + // 存储用户的角色信息，用于权限控制等 private String role; - + /** * token */ + // 存储具体的 token 值，用于身份验证和授权 private String token; - + /** * 过期时间 */ + // 存储该 token 的过期时间，用于判断 token 是否有效 private Date expiratedtime; - + /** * 新增时间 */ + // 存储该 token 记录的创建时间，用于记录数据的生成时间戳 private Date addtime; + // 获取主键值的方法 public Integer getId() { return id; } + // 设置主键值的方法 public void setId(Integer id) { this.id = id; } + // 获取用户 ID 的方法 public Integer getUserid() { return userid; } + // 设置用户 ID 的方法 public void setUserid(Integer userid) { this.userid = userid; } + // 获取角色信息的方法 public String getRole() { return role; } + // 设置角色信息的方法 public void setRole(String role) { this.role = role; } + // 获取 token 值的方法 public String getToken() { return token; } + // 获取表名的方法 public String getTablename() { return tablename; } + // 设置表名的方法 public void setTablename(String tablename) { this.tablename = tablename; } + // 设置 token 值的方法 public void setToken(String token) { this.token = token; } + // 获取过期时间的方法 public Date getExpiratedtime() { return expiratedtime; } + // 设置过期时间的方法 public void setExpiratedtime(Date expiratedtime) { this.expiratedtime = expiratedtime; } + // 获取新增时间的方法 public Date getAddtime() { return addtime; } + // 设置新增时间的方法 public void setAddtime(Date addtime) { this.addtime = addtime; } + // 获取用户名的方法 public String getUsername() { return username; } + // 设置用户名的方法 public void setUsername(String username) { this.username = username; } - public TokenEntity(Integer userid, String username, String tablename,String role, String token, Date expiratedtime) { + // 带参数的构造函数，用于初始化 TokenEntity 对象的部分属性 + public TokenEntity(Integer userid, String username, String tablename, String role, String token, Date expiratedtime) { super(); this.userid = userid; this.username = username; @@ -125,8 +159,8 @@ public class TokenEntity implements Serializable { this.token = token; this.expiratedtime = expiratedtime; } - + + // 无参构造函数，用于创建 TokenEntity 对象的实例 public TokenEntity() { } - -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/UsersEntity.java b/src/main/java/com/entity/UsersEntity.java index 99617d9..d77a5f7 100644 --- a/src/main/java/com/entity/UsersEntity.java +++ b/src/main/java/com/entity/UsersEntity.java @@ -1,77 +1,100 @@ package com.entity; +// 导入序列化接口，使该类的对象可以进行序列化和反序列化操作 import java.io.Serializable; +// 导入日期类，用于处理与日期相关的操作 import java.util.Date; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; -/** +/** * 用户 */ +// 使用 TableName 注解指定该类对应的数据库表名为 "users" @TableName("users") +// 定义 UsersEntity 类，实现 Serializable 接口，以支持对象的序列化和反序列化 public class UsersEntity implements Serializable { + // 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; - + + // 使用 TableId 注解指定该字段为主键，主键生成策略为自动增长（AUTO） @TableId(type = IdType.AUTO) + // 存储用户记录的主键值，用于唯一标识一条用户记录 private Integer id; - + /** * 用户账号 */ + // 存储用户的账号信息，用于登录等操作 private String username; - + /** * 密码 */ + // 存储用户的密码信息，用于验证用户身份 private String password; - + /** * 用户类型 */ + // 存储用户的类型信息，例如普通用户、管理员等，用于权限控制等 private String role; - + + // 存储用户记录的创建时间，用于记录数据的生成时间戳 private Date addtime; + // 获取用户账号的方法 public String getUsername() { return username; } + // 设置用户账号的方法 public void setUsername(String username) { this.username = username; } + // 获取用户密码的方法 public String getPassword() { return password; } + // 设置用户密码的方法 public void setPassword(String password) { this.password = password; } + // 获取用户类型的方法 public String getRole() { return role; } + // 设置用户类型的方法 public void setRole(String role) { this.role = role; } + // 获取用户记录创建时间的方法 public Date getAddtime() { return addtime; } + // 设置用户记录创建时间的方法 public void setAddtime(Date addtime) { this.addtime = addtime; } + // 获取用户记录主键的方法 public Integer getId() { return id; } + // 设置用户记录主键的方法 public void setId(Integer id) { this.id = id; } - -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/YishengEntity.java b/src/main/java/com/entity/YishengEntity.java index 3f81dc6..e354aec 100644 --- a/src/main/java/com/entity/YishengEntity.java +++ b/src/main/java/com/entity/YishengEntity.java @@ -1,445 +1,393 @@ package com.entity; +// 导入 MyBatis-Plus 用于指定主键的注解 import com.baomidou.mybatisplus.annotations.TableId; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 JSR 303 验证注解（在当前代码中未实际使用） import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - +// 导入 Jackson 注解（在当前代码中未实际使用） import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; - +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; +// 导入列表集合类（在当前代码中未实际使用） import java.util.List; - +// 导入 Spring 框架用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入 MyBatis-Plus 用于指定字段的注解 import com.baomidou.mybatisplus.annotations.TableField; +// 导入 MyBatis-Plus 字段填充策略枚举 import com.baomidou.mybatisplus.enums.FieldFill; +// 导入 MyBatis-Plus 主键生成策略枚举 import com.baomidou.mybatisplus.enums.IdType; /** - * 医生实体类，用于映射数据库中的医生信息表 - * 实现了 Serializable 接口，方便对象的序列化和反序列化 + * 医生 * - * @author 此处应填写作者姓名 - * @email 此处应填写作者邮箱 + * @author + * @email */ -@TableName("yisheng") // 表明该实体类对应数据库中的表名为 "yisheng" +@TableName("yisheng") public class YishengEntity implements Serializable { - // 序列化版本号，用于保证序列化和反序列化过程中对象版本的一致性 private static final long serialVersionUID = 1L; - /** - * 无参构造函数 - * 用于创建一个空的 YishengEntity 对象 - */ - public YishengEntity() { - } + public YishengEntity() { - /** - * 带参构造函数 - * 接收一个泛型对象 t，将其属性复制到当前 YishengEntity 对象中 - * - * @param t 泛型对象，其属性将被复制到当前对象 - */ - public YishengEntity(T t) { - try { - // 使用 BeanUtils 工具类将对象 t 的属性复制到当前对象 - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // 若复制属性过程中出现异常，打印异常堆栈信息 - e.printStackTrace(); - } } + public YishengEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + /** * 主键 - * 数据库表中的唯一标识字段 */ - @TableId(type = IdType.AUTO) // 表示该字段为主键，且采用自增方式生成 - @TableField(value = "id") // 表明该属性对应数据库表中的字段名为 "id" + @TableId(type = IdType.AUTO) + @TableField(value = "id") + private Integer id; /** * 医生工号 - * 用于唯一标识医生的编号 */ - @TableField(value = "yisheng_uuid_number") // 表明该属性对应数据库表中的字段名为 "yisheng_uuid_number" + @TableField(value = "yisheng_uuid_number") + private String yishengUuidNumber; /** * 账户 - * 医生登录系统使用的账户名 */ - @TableField(value = "username") // 表明该属性对应数据库表中的字段名为 "username" + @TableField(value = "username") + private String username; /** * 密码 - * 医生登录系统使用的密码 */ - @TableField(value = "password") // 表明该属性对应数据库表中的字段名为 "password" + @TableField(value = "password") + private String password; /** * 医生名称 - * 医生的真实姓名 */ - @TableField(value = "yisheng_name") // 表明该属性对应数据库表中的字段名为 "yisheng_name" + @TableField(value = "yisheng_name") + private String yishengName; /** * 科室 - * 医生所属的科室，用整数表示科室编号 */ - @TableField(value = "yisheng_types") // 表明该属性对应数据库表中的字段名为 "yisheng_types" + @TableField(value = "yisheng_types") + private Integer yishengTypes; /** * 职位 - * 医生的职位，用整数表示职位编号 */ - @TableField(value = "zhiwei_types") // 表明该属性对应数据库表中的字段名为 "zhiwei_types" + @TableField(value = "zhiwei_types") + private Integer zhiweiTypes; /** * 职称 - * 医生的职称信息 */ - @TableField(value = "yisheng_zhichneg") // 表明该属性对应数据库表中的字段名为 "yisheng_zhichneg" + @TableField(value = "yisheng_zhichneg") + private String yishengZhichneg; /** * 医生头像 - * 医生头像的存储路径或链接 */ - @TableField(value = "yisheng_photo") // 表明该属性对应数据库表中的字段名为 "yisheng_photo" + @TableField(value = "yisheng_photo") + private String yishengPhoto; /** * 联系方式 - * 医生的联系电话号码 */ - @TableField(value = "yisheng_phone") // 表明该属性对应数据库表中的字段名为 "yisheng_phone" + @TableField(value = "yisheng_phone") + private String yishengPhone; /** * 挂号须知 - * 关于该医生挂号的相关注意事项 */ - @TableField(value = "yisheng_guahao") // 表明该属性对应数据库表中的字段名为 "yisheng_guahao" + @TableField(value = "yisheng_guahao") + private String yishengGuahao; /** * 邮箱 - * 医生的电子邮箱地址 */ - @TableField(value = "yisheng_email") // 表明该属性对应数据库表中的字段名为 "yisheng_email" + @TableField(value = "yisheng_email") + private String yishengEmail; /** * 挂号价格 - * 患者挂该医生号所需支付的费用 */ - @TableField(value = "yisheng_new_money") // 表明该属性对应数据库表中的字段名为 "yisheng_new_money" + @TableField(value = "yisheng_new_money") + private Double yishengNewMoney; /** * 履历介绍 - * 医生的工作履历、专业技能等相关介绍信息 */ - @TableField(value = "yisheng_content") // 表明该属性对应数据库表中的字段名为 "yisheng_content" + @TableField(value = "yisheng_content") + private String yishengContent; /** * 创建时间 - * 该医生信息在数据库中创建的时间 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 用于将日期格式化为指定格式，方便前端展示 - @DateTimeFormat // 用于将前端传递的日期字符串解析为 Date 类型 - @TableField(value = "create_time",fill = FieldFill.INSERT) // 表明该属性对应数据库表中的字段名为 "create_time"，且在插入数据时自动填充 + @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") + @DateTimeFormat + @TableField(value = "create_time",fill = FieldFill.INSERT) + private Date createTime; /** - * 获取主键 - * - * @return 主键的值 - */ + * 设置：主键 + */ public Integer getId() { return id; } /** - * 设置主键 - * - * @param id 要设置的主键值 - */ + * 获取：主键 + */ + public void setId(Integer id) { this.id = id; } /** - * 获取医生工号 - * - * @return 医生工号的值 - */ + * 设置：医生工号 + */ public String getYishengUuidNumber() { return yishengUuidNumber; } /** - * 设置医生工号 - * - * @param yishengUuidNumber 要设置的医生工号值 - */ + * 获取：医生工号 + */ + public void setYishengUuidNumber(String yishengUuidNumber) { this.yishengUuidNumber = yishengUuidNumber; } /** - * 获取账户 - * - * @return 账户的值 - */ + * 设置：账户 + */ public String getUsername() { return username; } /** - * 设置账户 - * - * @param username 要设置的账户值 - */ + * 获取：账户 + */ + public void setUsername(String username) { this.username = username; } /** - * 获取密码 - * - * @return 密码的值 - */ + * 设置：密码 + */ public String getPassword() { return password; } /** - * 设置密码 - * - * @param password 要设置的密码值 - */ + * 获取：密码 + */ + public void setPassword(String password) { this.password = password; } /** - * 获取医生名称 - * - * @return 医生名称的值 - */ + * 设置：医生名称 + */ public String getYishengName() { return yishengName; } /** - * 设置医生名称 - * - * @param yishengName 要设置的医生名称值 - */ + * 获取：医生名称 + */ + public void setYishengName(String yishengName) { this.yishengName = yishengName; } /** - * 获取科室 - * - * @return 科室的值 - */ + * 设置：科室 + */ public Integer getYishengTypes() { return yishengTypes; } /** - * 设置科室 - * - * @param yishengTypes 要设置的科室值 - */ + * 获取：科室 + */ + public void setYishengTypes(Integer yishengTypes) { this.yishengTypes = yishengTypes; } /** - * 获取职位 - * - * @return 职位的值 - */ + * 设置：职位 + */ public Integer getZhiweiTypes() { return zhiweiTypes; } /** - * 设置职位 - * - * @param zhiweiTypes 要设置的职位值 - */ + * 获取：职位 + */ + public void setZhiweiTypes(Integer zhiweiTypes) { this.zhiweiTypes = zhiweiTypes; } /** - * 获取职称 - * - * @return 职称的值 - */ + * 设置：职称 + */ public String getYishengZhichneg() { return yishengZhichneg; } /** - * 设置职称 - * - * @param yishengZhichneg 要设置的职称值 - */ + * 获取：职称 + */ + public void setYishengZhichneg(String yishengZhichneg) { this.yishengZhichneg = yishengZhichneg; } /** - * 获取医生头像 - * - * @return 医生头像的值 - */ + * 设置：医生头像 + */ public String getYishengPhoto() { return yishengPhoto; } /** - * 设置医生头像 - * - * @param yishengPhoto 要设置的医生头像值 - */ + * 获取：医生头像 + */ + public void setYishengPhoto(String yishengPhoto) { this.yishengPhoto = yishengPhoto; } /** - * 获取联系方式 - * - * @return 联系方式的值 - */ + * 设置：联系方式 + */ public String getYishengPhone() { return yishengPhone; } /** - * 设置联系方式 - * - * @param yishengPhone 要设置的联系方式值 - */ + * 获取：联系方式 + */ + public void setYishengPhone(String yishengPhone) { this.yishengPhone = yishengPhone; } /** - * 获取挂号须知 - * - * @return 挂号须知的值 - */ + * 设置：挂号须知 + */ public String getYishengGuahao() { return yishengGuahao; } /** - * 设置挂号须知 - * - * @param yishengGuahao 要设置的挂号须知值 - */ + * 获取：挂号须知 + */ + public void setYishengGuahao(String yishengGuahao) { this.yishengGuahao = yishengGuahao; } /** - * 获取邮箱 - * - * @return 邮箱的值 - */ + * 设置：邮箱 + */ public String getYishengEmail() { return yishengEmail; } /** - * 设置邮箱 - * - * @param yishengEmail 要设置的邮箱值 - */ + * 获取：邮箱 + */ + public void setYishengEmail(String yishengEmail) { this.yishengEmail = yishengEmail; } /** - * 获取挂号价格 - * - * @return 挂号价格的值 - */ + * 设置：挂号价格 + */ public Double getYishengNewMoney() { return yishengNewMoney; } /** - * 设置挂号价格 - * - * @param yishengNewMoney 要设置的挂号价格值 - */ + * 获取：挂号价格 + */ + public void setYishengNewMoney(Double yishengNewMoney) { this.yishengNewMoney = yishengNewMoney; } /** - * 获取履历介绍 - * - * @return 履历介绍的值 - */ + * 设置：履历介绍 + */ public String getYishengContent() { return yishengContent; } /** - * 设置履历介绍 - * - * @param yishengContent 要设置的履历介绍值 - */ + * 获取：履历介绍 + */ + public void setYishengContent(String yishengContent) { this.yishengContent = yishengContent; } /** - * 获取创建时间 - * - * @return 创建时间的值 - */ + * 设置：创建时间 + */ public Date getCreateTime() { return createTime; } /** - * 设置创建时间 - * - * @param createTime 要设置的创建时间值 - */ + * 获取：创建时间 + */ + public void setCreateTime(Date createTime) { this.createTime = createTime; } - /** - * 重写 toString 方法 - * 用于将对象的属性以字符串形式输出，方便调试和日志记录 - * - * @return 包含对象属性信息的字符串 - */ @Override public String toString() { return "Yisheng{" + diff --git a/src/main/java/com/entity/YonghuEntity.java b/src/main/java/com/entity/YonghuEntity.java index a4b9ad5..3d91b1a 100644 --- a/src/main/java/com/entity/YonghuEntity.java +++ b/src/main/java/com/entity/YonghuEntity.java @@ -27,311 +27,299 @@ import com.baomidou.mybatisplus.enums.IdType; * @author * @email */ -@TableName("yonghu") // 指定对应的数据库表名 +@TableName("yonghu") public class YonghuEntity implements Serializable { - private static final long serialVersionUID = 1L; // 序列化版本UID + private static final long serialVersionUID = 1L; - /** - * 无参构造函数 - */ - public YonghuEntity() { - } + public YonghuEntity() { - /** - * 带参构造函数 - * 通过BeanUtils将传入对象的属性拷贝到当前对象 - * @param t 源对象 - */ - public YonghuEntity(T t) { - try { - BeanUtils.copyProperties(this, t); // 使用BeanUtils进行属性拷贝 - } catch (IllegalAccessException | InvocationTargetException e) { - // 打印异常堆栈 - e.printStackTrace(); - } } + public YonghuEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + /** * 主键ID * 自增类型 */ - @TableId(type = IdType.AUTO) // 主键自增 - @TableField(value = "id") // 对应数据库字段名 + @TableId(type = IdType.AUTO) + @TableField(value = "id") + private Integer id; /** * 用户名/账户 * 用于登录系统的唯一标识 */ - @TableField(value = "username") // 对应数据库字段名 + @TableField(value = "username") + private String username; /** * 密码 * 存储加密后的用户密码 */ - @TableField(value = "password") // 对应数据库字段名 + @TableField(value = "password") + private String password; /** * 用户真实姓名 */ - @TableField(value = "yonghu_name") // 对应数据库字段名 + @TableField(value = "yonghu_name") + private String yonghuName; /** * 用户头像 * 存储头像图片路径 */ - @TableField(value = "yonghu_photo") // 对应数据库字段名 + @TableField(value = "yonghu_photo") + private String yonghuPhoto; /** * 用户手机号 */ - @TableField(value = "yonghu_phone") // 对应数据库字段名 + @TableField(value = "yonghu_phone") + private String yonghuPhone; /** * 用户身份证号 */ - @TableField(value = "yonghu_id_number") // 对应数据库字段名 + @TableField(value = "yonghu_id_number") + private String yonghuIdNumber; /** * 用户邮箱 */ - @TableField(value = "yonghu_email") // 对应数据库字段名 + @TableField(value = "yonghu_email") + private String yonghuEmail; /** * 性别 * 使用数字表示，对应字典表中的性别类型 */ - @TableField(value = "sex_types") // 对应数据库字段名 + @TableField(value = "sex_types") + private Integer sexTypes; /** * 用户余额 */ - @TableField(value = "new_money") // 对应数据库字段名 + @TableField(value = "new_money") + private Double newMoney; /** * 逻辑删除标志 * 1-未删除，2-已删除 */ - @TableField(value = "yonghu_delete") // 对应数据库字段名 + @TableField(value = "yonghu_delete") + private Integer yonghuDelete; /** * 创建时间 * 自动填充，格式化为yyyy-MM-dd HH:mm:ss */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 日期格式化 - @DateTimeFormat // 日期格式 - @TableField(value = "create_time",fill = FieldFill.INSERT) // 插入时自动填充 + @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") + @DateTimeFormat + @TableField(value = "create_time",fill = FieldFill.INSERT) + private Date createTime; - // ================ getter和setter方法 ================ /** - * 获取主键ID - * @return id 主键ID - */ + * 设置：主键 + */ public Integer getId() { return id; } /** - * 设置主键ID - * @param id 主键ID - */ + * 获取：主键 + */ + public void setId(Integer id) { this.id = id; } /** - * 获取用户名/账户 - * @return username 用户名 - */ + * 设置：账户 + */ public String getUsername() { return username; } /** - * 设置用户名/账户 - * @param username 用户名 - */ + * 获取：账户 + */ + public void setUsername(String username) { this.username = username; } /** - * 获取密码 - * @return password 密码 - */ + * 设置：密码 + */ public String getPassword() { return password; } /** - * 设置密码 - * @param password 密码 - */ + * 获取：密码 + */ + public void setPassword(String password) { this.password = password; } /** - * 获取用户真实姓名 - * @return yonghuName 用户姓名 - */ + * 设置：用户姓名 + */ public String getYonghuName() { return yonghuName; } /** - * 设置用户真实姓名 - * @param yonghuName 用户姓名 - */ + * 获取：用户姓名 + */ + public void setYonghuName(String yonghuName) { this.yonghuName = yonghuName; } /** - * 获取用户头像路径 - * @return yonghuPhoto 头像路径 - */ + * 设置：头像 + */ public String getYonghuPhoto() { return yonghuPhoto; } /** - * 设置用户头像路径 - * @param yonghuPhoto 头像路径 - */ + * 获取：头像 + */ + public void setYonghuPhoto(String yonghuPhoto) { this.yonghuPhoto = yonghuPhoto; } /** - * 获取用户手机号 - * @return yonghuPhone 手机号 - */ + * 设置：用户手机号 + */ public String getYonghuPhone() { return yonghuPhone; } /** - * 设置用户手机号 - * @param yonghuPhone 手机号 - */ + * 获取：用户手机号 + */ + public void setYonghuPhone(String yonghuPhone) { this.yonghuPhone = yonghuPhone; } /** - * 获取用户身份证号 - * @return yonghuIdNumber 身份证号 - */ + * 设置：用户身份证号 + */ public String getYonghuIdNumber() { return yonghuIdNumber; } /** - * 设置用户身份证号 - * @param yonghuIdNumber 身份证号 - */ + * 获取：用户身份证号 + */ + public void setYonghuIdNumber(String yonghuIdNumber) { this.yonghuIdNumber = yonghuIdNumber; } /** - * 获取用户邮箱 - * @return yonghuEmail 邮箱地址 - */ + * 设置：邮箱 + */ public String getYonghuEmail() { return yonghuEmail; } /** - * 设置用户邮箱 - * @param yonghuEmail 邮箱地址 - */ + * 获取：邮箱 + */ + public void setYonghuEmail(String yonghuEmail) { this.yonghuEmail = yonghuEmail; } /** - * 获取性别类型 - * @return sexTypes 性别类型编码 - */ + * 设置：性别 + */ public Integer getSexTypes() { return sexTypes; } /** - * 设置性别类型 - * @param sexTypes 性别类型编码 - */ + * 获取：性别 + */ + public void setSexTypes(Integer sexTypes) { this.sexTypes = sexTypes; } /** - * 获取用户余额 - * @return newMoney 余额 - */ + * 设置：余额 + */ public Double getNewMoney() { return newMoney; } /** - * 设置用户余额 - * @param newMoney 余额 - */ + * 获取：余额 + */ + public void setNewMoney(Double newMoney) { this.newMoney = newMoney; } /** - * 获取逻辑删除标志 - * @return yonghuDelete 删除状态(1-未删除，2-已删除) - */ + * 设置：假删 + */ public Integer getYonghuDelete() { return yonghuDelete; } /** - * 设置逻辑删除标志 - * @param yonghuDelete 删除状态(1-未删除，2-已删除) - */ + * 获取：假删 + */ + public void setYonghuDelete(Integer yonghuDelete) { this.yonghuDelete = yonghuDelete; } /** - * 获取创建时间 - * @return createTime 创建时间 - */ + * 设置：创建时间 + */ public Date getCreateTime() { return createTime; } /** - * 设置创建时间 - * @param createTime 创建时间 - */ + * 获取：创建时间 + */ + public void setCreateTime(Date createTime) { this.createTime = createTime; } - /** - * 重写toString方法 - * @return 对象字符串表示 - */ @Override public String toString() { return "Yonghu{" + diff --git a/src/main/java/com/entity/model/ChatModel.java b/src/main/java/com/entity/model/ChatModel.java index c37be72..d71e147 100644 --- a/src/main/java/com/entity/model/ChatModel.java +++ b/src/main/java/com/entity/model/ChatModel.java @@ -8,7 +8,6 @@ import java.util.Date; import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - /** * 在线咨询 * 接收传参的实体类 @@ -16,196 +15,216 @@ import java.io.Serializable; * 取自ModelAndView 的model名称 */ public class ChatModel implements Serializable { + // 序列化版本号，用于保证序列化和反序列化的兼容性 private static final long serialVersionUID = 1L; - - - /** * 主键 */ + // 用于唯一标识一条在线咨询记录的主键 private Integer id; - /** * 提问用户 */ + // 发起咨询问题的用户的ID private Integer yonghuId; - /** * 问题 */ + // 用户提出的咨询问题内容 private String chatIssue; - /** * 问题时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 用户提出问题的具体时间 private Date issueTime; - /** * 回复 */ + // 针对用户咨询问题给出的回复内容 private String chatReply; - /** * 回复时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 给出回复的具体时间 private Date replyTime; - /** * 状态 */ + // 表示该在线咨询记录的状态，使用整数类型表示不同状态 private Integer zhuangtaiTypes; - /** * 数据类型 */ + // 表示该在线咨询记录的数据类型，使用整数类型表示不同类型 private Integer chatTypes; - /** * 创建时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 该在线咨询记录的创建时间 private Date insertTime; - /** - * 获取：主键 - */ + * 获取：主键 + */ + // 获取主键ID的方法 public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 设置主键ID的方法 public void setId(Integer id) { this.id = id; } + /** - * 获取：提问用户 - */ + * 获取：提问用户 + */ + // 获取提问用户ID的方法 public Integer getYonghuId() { return yonghuId; } - /** - * 设置：提问用户 - */ + * 设置：提问用户 + */ + // 设置提问用户ID的方法 public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } + /** - * 获取：问题 - */ + * 获取：问题 + */ + // 获取咨询问题内容的方法 public String getChatIssue() { return chatIssue; } - /** - * 设置：问题 - */ + * 设置：问题 + */ + // 设置咨询问题内容的方法 public void setChatIssue(String chatIssue) { this.chatIssue = chatIssue; } + /** - * 获取：问题时间 - */ + * 获取：问题时间 + */ + // 获取用户提出问题时间的方法 public Date getIssueTime() { return issueTime; } - /** - * 设置：问题时间 - */ + * 设置：问题时间 + */ + // 设置用户提出问题时间的方法 public void setIssueTime(Date issueTime) { this.issueTime = issueTime; } + /** - * 获取：回复 - */ + * 获取：回复 + */ + // 获取咨询问题回复内容的方法 public String getChatReply() { return chatReply; } - /** - * 设置：回复 - */ + * 设置：回复 + */ + // 设置咨询问题回复内容的方法 public void setChatReply(String chatReply) { this.chatReply = chatReply; } + /** - * 获取：回复时间 - */ + * 获取：回复时间 + */ + // 获取给出回复时间的方法 public Date getReplyTime() { return replyTime; } - /** - * 设置：回复时间 - */ + * 设置：回复时间 + */ + // 设置给出回复时间的方法 public void setReplyTime(Date replyTime) { this.replyTime = replyTime; } + /** - * 获取：状态 - */ + * 获取：状态 + */ + // 获取咨询记录状态的方法 public Integer getZhuangtaiTypes() { return zhuangtaiTypes; } - /** - * 设置：状态 - */ + * 设置：状态 + */ + // 设置咨询记录状态的方法 public void setZhuangtaiTypes(Integer zhuangtaiTypes) { this.zhuangtaiTypes = zhuangtaiTypes; } + /** - * 获取：数据类型 - */ + * 获取：数据类型 + */ + // 获取咨询记录数据类型的方法 public Integer getChatTypes() { return chatTypes; } - /** - * 设置：数据类型 - */ + * 设置：数据类型 + */ + // 设置咨询记录数据类型的方法 public void setChatTypes(Integer chatTypes) { this.chatTypes = chatTypes; } + /** - * 获取：创建时间 - */ + * 获取：创建时间 + */ + // 获取咨询记录创建时间的方法 public Date getInsertTime() { return insertTime; } - /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 设置咨询记录创建时间的方法 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } - - } +} \ No newline at end of file diff --git a/src/main/java/com/entity/model/DictionaryModel.java b/src/main/java/com/entity/model/DictionaryModel.java index 36483ac..4846868 100644 --- a/src/main/java/com/entity/model/DictionaryModel.java +++ b/src/main/java/com/entity/model/DictionaryModel.java @@ -1,187 +1,206 @@ package com.entity.model; +// 引入字典表实体类，可能用于与数据库实体交互或类型转换等操作 import com.entity.DictionaryEntity; +// 该注解用于指定实体类对应的数据库表名，不过在当前代码中未实际使用该功能 import com.baomidou.mybatisplus.annotations.TableName; +// 用于在将对象序列化为JSON时，对日期类型的字段进行格式化处理 import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; +// 用于在Spring MVC中，将前端传递的日期字符串绑定到Java对象的日期字段时进行格式化 import org.springframework.format.annotation.DateTimeFormat; +// 实现该接口意味着这个类的对象可以被序列化和反序列化，方便在网络传输或存储时使用 import java.io.Serializable; - /** * 字典表 * 接收传参的实体类 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 取自ModelAndView 的model名称 */ +// 定义一个名为DictionaryModel的类，实现Serializable接口，用于接收字典表相关的参数 public class DictionaryModel implements Serializable { + // 序列化版本号，用于在反序列化时验证版本一致性，避免不同版本类之间反序列化出错 private static final long serialVersionUID = 1L; - - - /** * 主键 */ + // 用于唯一标识字典表中的每一条记录，在数据库操作中常作为主键使用 private Integer id; - /** * 字段 */ + // 表示字典表中的某个字段，可能用于存储特定的数据标识 private String dicCode; - /** * 字段名 */ + // 该字段的名称，用于更直观地描述dicCode所代表的含义 private String dicName; - /** * 编码 */ + // 可能是对该字段的一种编码表示，方便数据的分类和查询 private Integer codeIndex; - /** * 编码名字 */ + // 编码对应的名称，用于更清晰地展示编码的具体含义 private String indexName; - /** * 父字段id */ + // 用于关联父字段，可能用于构建字典表的层级结构 private Integer superId; - /** * 备注 */ + // 对该条字典记录的额外说明信息，可用于记录一些特殊情况或备注 private String beizhu; - /** * 创建时间 */ + // 对日期进行JSON序列化时，指定日期的格式、语言环境和时区 @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于在Spring MVC中，将前端传递的日期字符串转换为Date类型时指定格式 + @DateTimeFormat + // 记录该条字典记录的创建时间 private Date createTime; - /** - * 获取：主键 - */ + * 获取：主键 + */ + // 定义一个公共的获取主键的方法，供外部调用获取id的值 public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 定义一个公共的设置主键的方法，供外部调用设置id的值 public void setId(Integer id) { this.id = id; } + /** - * 获取：字段 - */ + * 获取：字段 + */ + // 定义一个公共的获取字段标识的方法，供外部调用获取dicCode的值 public String getDicCode() { return dicCode; } - /** - * 设置：字段 - */ + * 设置：字段 + */ + // 定义一个公共的设置字段标识的方法，供外部调用设置dicCode的值 public void setDicCode(String dicCode) { this.dicCode = dicCode; } + /** - * 获取：字段名 - */ + * 获取：字段名 + */ + // 定义一个公共的获取字段名称的方法，供外部调用获取dicName的值 public String getDicName() { return dicName; } - /** - * 设置：字段名 - */ + * 设置：字段名 + */ + // 定义一个公共的设置字段名称的方法，供外部调用设置dicName的值 public void setDicName(String dicName) { this.dicName = dicName; } + /** - * 获取：编码 - */ + * 获取：编码 + */ + // 定义一个公共的获取编码的方法，供外部调用获取codeIndex的值 public Integer getCodeIndex() { return codeIndex; } - /** - * 设置：编码 - */ + * 设置：编码 + */ + // 定义一个公共的设置编码的方法，供外部调用设置codeIndex的值 public void setCodeIndex(Integer codeIndex) { this.codeIndex = codeIndex; } + /** - * 获取：编码名字 - */ + * 获取：编码名字 + */ + // 定义一个公共的获取编码名称的方法，供外部调用获取indexName的值 public String getIndexName() { return indexName; } - /** - * 设置：编码名字 - */ + * 设置：编码名字 + */ + // 定义一个公共的设置编码名称的方法，供外部调用设置indexName的值 public void setIndexName(String indexName) { this.indexName = indexName; } + /** - * 获取：父字段id - */ + * 获取：父字段id + */ + // 定义一个公共的获取父字段ID的方法，供外部调用获取superId的值 public Integer getSuperId() { return superId; } - /** - * 设置：父字段id - */ + * 设置：父字段id + */ + // 定义一个公共的设置父字段ID的方法，供外部调用设置superId的值 public void setSuperId(Integer superId) { this.superId = superId; } + /** - * 获取：备注 - */ + * 获取：备注 + */ + // 定义一个公共的获取备注信息的方法，供外部调用获取beizhu的值 public String getBeizhu() { return beizhu; } - /** - * 设置：备注 - */ + * 设置：备注 + */ + // 定义一个公共的设置备注信息的方法，供外部调用设置beizhu的值 public void setBeizhu(String beizhu) { this.beizhu = beizhu; } + /** - * 获取：创建时间 - */ + * 获取：创建时间 + */ + // 定义一个公共的获取创建时间的方法，供外部调用获取createTime的值 public Date getCreateTime() { return createTime; } - /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 定义一个公共的设置创建时间的方法，供外部调用设置createTime的值 public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/src/main/java/com/entity/model/GuahaoModel.java b/src/main/java/com/entity/model/GuahaoModel.java index 52938cd..198f3a1 100644 --- a/src/main/java/com/entity/model/GuahaoModel.java +++ b/src/main/java/com/entity/model/GuahaoModel.java @@ -1,229 +1,253 @@ package com.entity.model; +// 导入GuahaoEntity类，可能用于实体之间的转换或关联操作 import com.entity.GuahaoEntity; +// 导入MyBatis-Plus的TableName注解，这里可能用于指定数据库表名（但代码中未实际使用） import com.baomidou.mybatisplus.annotations.TableName; +// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时格式化日期类型字段 import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; +// 导入Spring的DateTimeFormat注解，用于在处理表单数据时格式化日期类型字段 import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - /** * 挂号 * 接收传参的实体类 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 取自ModelAndView 的model名称 */ +// 定义一个名为GuahaoModel的类，实现Serializable接口，使其对象可序列化 public class GuahaoModel implements Serializable { + // 定义序列化版本号，确保在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; - - - /** * 主键 */ + // 用于唯一标识挂号记录的主键，在数据库操作中通常作为唯一标识 private Integer id; - /** * 医生 */ + // 表示进行挂号的医生的ID，用于关联医生信息 private Integer yishengId; - /** * 用户 */ + // 表示进行挂号的用户的ID，用于关联用户信息 private Integer yonghuId; - /** * 就诊识别码 */ + // 可能是用于识别就诊记录的唯一编码，具体用途可能根据业务需求而定 private Integer guahaoUuinNumber; - /** * 挂号时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录挂号操作的具体时间 private Date guahaoTime; - /** * 时间类型 */ + // 可能用于区分不同类型的挂号时间，例如预约时间、实际挂号时间等 private Integer guahaoTypes; - /** * 挂号状态 */ + // 用于表示挂号的当前状态，例如已挂号、已取消、已就诊等 private Integer guahaoStatusTypes; - /** * 挂号审核 */ + // 用于表示挂号是否经过审核，可能是0（未审核）、1（审核通过）、2（审核不通过）等 private Integer guahaoYesnoTypes; - /** * 审核结果 */ + // 当挂号经过审核后，记录审核的具体结果信息，例如审核不通过的原因等 private String guahaoYesnoText; - /** * 创建时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录该挂号记录的创建时间 private Date createTime; - /** - * 获取：主键 - */ + * 获取：主键 + */ + // 获取主键ID的方法，供外部调用以获取该挂号记录的唯一标识 public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 设置主键ID的方法，供外部调用以设置该挂号记录的唯一标识 public void setId(Integer id) { this.id = id; } + /** - * 获取：医生 - */ + * 获取：医生 + */ + // 获取进行挂号的医生ID的方法，供外部调用以获取医生的标识 public Integer getYishengId() { return yishengId; } - /** - * 设置：医生 - */ + * 设置：医生 + */ + // 设置进行挂号的医生ID的方法，供外部调用以设置医生的标识 public void setYishengId(Integer yishengId) { this.yishengId = yishengId; } + /** - * 获取：用户 - */ + * 获取：用户 + */ + // 获取进行挂号的用户ID的方法，供外部调用以获取用户的标识 public Integer getYonghuId() { return yonghuId; } - /** - * 设置：用户 - */ + * 设置：用户 + */ + // 设置进行挂号的用户ID的方法，供外部调用以设置用户的标识 public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } + /** - * 获取：就诊识别码 - */ + * 获取：就诊识别码 + */ + // 获取就诊识别码的方法，供外部调用以获取该挂号记录的识别编码 public Integer getGuahaoUuinNumber() { return guahaoUuinNumber; } - /** - * 设置：就诊识别码 - */ + * 设置：就诊识别码 + */ + // 设置就诊识别码的方法，供外部调用以设置该挂号记录的识别编码 public void setGuahaoUuinNumber(Integer guahaoUuinNumber) { this.guahaoUuinNumber = guahaoUuinNumber; } + /** - * 获取：挂号时间 - */ + * 获取：挂号时间 + */ + // 获取挂号时间的方法，供外部调用以获取挂号操作的具体时间 public Date getGuahaoTime() { return guahaoTime; } - /** - * 设置：挂号时间 - */ + * 设置：挂号时间 + */ + // 设置挂号时间的方法，供外部调用以设置挂号操作的具体时间 public void setGuahaoTime(Date guahaoTime) { this.guahaoTime = guahaoTime; } + /** - * 获取：时间类型 - */ + * 获取：时间类型 + */ + // 获取时间类型的方法，供外部调用以获取该挂号记录的时间类型 public Integer getGuahaoTypes() { return guahaoTypes; } - /** - * 设置：时间类型 - */ + * 设置：时间类型 + */ + // 设置时间类型的方法，供外部调用以设置该挂号记录的时间类型 public void setGuahaoTypes(Integer guahaoTypes) { this.guahaoTypes = guahaoTypes; } + /** - * 获取：挂号状态 - */ + * 获取：挂号状态 + */ + // 获取挂号状态的方法，供外部调用以获取该挂号记录的当前状态 public Integer getGuahaoStatusTypes() { return guahaoStatusTypes; } - /** - * 设置：挂号状态 - */ + * 设置：挂号状态 + */ + // 设置挂号状态的方法，供外部调用以设置该挂号记录的当前状态 public void setGuahaoStatusTypes(Integer guahaoStatusTypes) { this.guahaoStatusTypes = guahaoStatusTypes; } + /** - * 获取：挂号审核 - */ + * 获取：挂号审核 + */ + // 获取挂号审核状态的方法，供外部调用以获取该挂号记录的审核状态 public Integer getGuahaoYesnoTypes() { return guahaoYesnoTypes; } - /** - * 设置：挂号审核 - */ + * 设置：挂号审核 + */ + // 设置挂号审核状态的方法，供外部调用以设置该挂号记录的审核状态 public void setGuahaoYesnoTypes(Integer guahaoYesnoTypes) { this.guahaoYesnoTypes = guahaoYesnoTypes; } + /** - * 获取：审核结果 - */ + * 获取：审核结果 + */ + // 获取审核结果的方法，供外部调用以获取该挂号记录的审核具体结果信息 public String getGuahaoYesnoText() { return guahaoYesnoText; } - /** - * 设置：审核结果 - */ + * 设置：审核结果 + */ + // 设置审核结果的方法，供外部调用以设置该挂号记录的审核具体结果信息 public void setGuahaoYesnoText(String guahaoYesnoText) { this.guahaoYesnoText = guahaoYesnoText; } + /** - * 获取：创建时间 - */ + * 获取：创建时间 + */ + // 获取创建时间的方法，供外部调用以获取该挂号记录的创建时间 public Date getCreateTime() { return createTime; } - /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ + // 设置创建时间的方法，供外部调用以设置该挂号记录的创建时间 public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/src/main/java/com/entity/model/JiankangjiaoyuModel.java b/src/main/java/com/entity/model/JiankangjiaoyuModel.java index 3c79b61..530aa3e 100644 --- a/src/main/java/com/entity/model/JiankangjiaoyuModel.java +++ b/src/main/java/com/entity/model/JiankangjiaoyuModel.java @@ -1,189 +1,209 @@ package com.entity.model; +// 导入JiankangjiaoyuEntity类，可能用于与数据库实体进行交互或数据转换等操作 import com.entity.JiankangjiaoyuEntity; +// 导入MyBatis-Plus的TableName注解，通常用于指定数据库表名（但在当前代码中未实际使用该注解） import com.baomidou.mybatisplus.annotations.TableName; +// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时对日期类型字段进行格式化处理 import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; +// 导入Spring的DateTimeFormat注解，用于在处理表单数据时对日期类型字段进行格式化 import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - /** * 健康教育 * 接收传参的实体类 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 取自ModelAndView 的model名称 */ +// 定义一个名为JiankangjiaoyuModel的类，实现Serializable接口，使该类的对象可以被序列化和反序列化 public class JiankangjiaoyuModel implements Serializable { + // 定义序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 private static final long serialVersionUID = 1L; - - - /** * 主键 */ + // 用于唯一标识健康教育记录的主键，在数据库操作中通常作为唯一标识字段 private Integer id; - /** * 健康教育标题 */ + // 存储健康教育内容的标题，用于展示和区分不同的健康教育信息 private String jiankangjiaoyuName; - /** * 健康教育类型 */ + // 表示健康教育的具体类型，可能是如疾病预防、健康生活方式等不同分类，以整数类型存储 private Integer jiankangjiaoyuTypes; - /** * 健康教育图片 */ + // 存储健康教育相关的图片路径或标识，用于展示相关的图片内容 private String jiankangjiaoyuPhoto; - /** * 健康教育时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录健康教育内容的插入时间，即该记录创建或添加到系统的时间 private Date insertTime; - /** * 健康教育详情 */ + // 存储健康教育的详细内容，如具体的健康知识、建议等文本信息 private String jiankangjiaoyuContent; - /** * 假删 */ + // 用于实现逻辑删除的字段，可能0表示未删除，1表示已删除（假删），以整数类型存储 private Integer jiankangjiaoyuDelete; - /** * 创建时间 show1 show2 nameShow */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录该健康教育记录的实际创建时间，可能与插入时间有所区别 private Date createTime; - /** - * 获取：主键 - */ + * 获取：主键 + */ + // 获取主键ID的方法，供外部调用以获取该健康教育记录的唯一标识 public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 设置主键ID的方法，供外部调用以设置该健康教育记录的唯一标识 public void setId(Integer id) { this.id = id; } + /** - * 获取：健康教育标题 - */ + * 获取：健康教育标题 + */ + // 获取健康教育标题的方法，供外部调用以获取该记录的标题信息 public String getJiankangjiaoyuName() { return jiankangjiaoyuName; } - /** - * 设置：健康教育标题 - */ + * 设置：健康教育标题 + */ + // 设置健康教育标题的方法，供外部调用以修改该记录的标题信息 public void setJiankangjiaoyuName(String jiankangjiaoyuName) { this.jiankangjiaoyuName = jiankangjiaoyuName; } + /** - * 获取：健康教育类型 - */ + * 获取：健康教育类型 + */ + // 获取健康教育类型的方法，供外部调用以获取该记录的类型信息 public Integer getJiankangjiaoyuTypes() { return jiankangjiaoyuTypes; } - /** - * 设置：健康教育类型 - */ + * 设置：健康教育类型 + */ + // 设置健康教育类型的方法，供外部调用以修改该记录的类型信息 public void setJiankangjiaoyuTypes(Integer jiankangjiaoyuTypes) { this.jiankangjiaoyuTypes = jiankangjiaoyuTypes; } + /** - * 获取：健康教育图片 - */ + * 获取：健康教育图片 + */ + // 获取健康教育图片相关信息的方法，供外部调用以获取图片路径或标识 public String getJiankangjiaoyuPhoto() { return jiankangjiaoyuPhoto; } - /** - * 设置：健康教育图片 - */ + * 设置：健康教育图片 + */ + // 设置健康教育图片相关信息的方法，供外部调用以修改图片路径或标识 public void setJiankangjiaoyuPhoto(String jiankangjiaoyuPhoto) { this.jiankangjiaoyuPhoto = jiankangjiaoyuPhoto; } + /** - * 获取：健康教育时间 - */ + * 获取：健康教育时间 + */ + // 获取健康教育内容插入时间的方法，供外部调用以获取该记录的插入时间 public Date getInsertTime() { return insertTime; } - /** - * 设置：健康教育时间 - */ + * 设置：健康教育时间 + */ + // 设置健康教育内容插入时间的方法，供外部调用以修改该记录的插入时间 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + /** - * 获取：健康教育详情 - */ + * 获取：健康教育详情 + */ + // 获取健康教育详细内容的方法，供外部调用以获取该记录的详细文本信息 public String getJiankangjiaoyuContent() { return jiankangjiaoyuContent; } - /** - * 设置：健康教育详情 - */ + * 设置：健康教育详情 + */ + // 设置健康教育详细内容的方法，供外部调用以修改该记录的详细文本信息 public void setJiankangjiaoyuContent(String jiankangjiaoyuContent) { this.jiankangjiaoyuContent = jiankangjiaoyuContent; } + /** - * 获取：假删 - */ + * 获取：假删 + */ + // 获取逻辑删除标识的方法，供外部调用以获取该记录的假删状态 public Integer getJiankangjiaoyuDelete() { return jiankangjiaoyuDelete; } - /** - * 设置：假删 - */ + * 设置：假删 + */ + // 设置逻辑删除标识的方法，供外部调用以修改该记录的假删状态 public void setJiankangjiaoyuDelete(Integer jiankangjiaoyuDelete) { this.jiankangjiaoyuDelete = jiankangjiaoyuDelete; } + /** - * 获取：创建时间 show1 show2 nameShow - */ + * 获取：创建时间 show1 show2 nameShow + */ + // 获取健康教育记录创建时间的方法，供外部调用以获取该记录的实际创建时间 public Date getCreateTime() { return createTime; } - /** - * 设置：创建时间 show1 show2 nameShow - */ + * 设置：创建时间 show1 show2 nameShow + */ + // 设置健康教育记录创建时间的方法，供外部调用以修改该记录的实际创建时间 public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/src/main/java/com/entity/model/NewsModel.java b/src/main/java/com/entity/model/NewsModel.java index 9d37e08..f683a9f 100644 --- a/src/main/java/com/entity/model/NewsModel.java +++ b/src/main/java/com/entity/model/NewsModel.java @@ -1,169 +1,188 @@ package com.entity.model; +// 导入NewsEntity类，可能用于与数据库实体交互或进行数据转换 import com.entity.NewsEntity; +// 导入MyBatis-Plus的TableName注解，通常用于指定实体类对应的数据库表名，但此代码未实际使用 import com.baomidou.mybatisplus.annotations.TableName; +// 导入Jackson的JsonFormat注解，用于在JSON序列化和反序列化时对日期类型字段进行格式化 import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; +// 导入Spring的DateTimeFormat注解，用于在处理表单数据时对日期类型字段进行格式化 import org.springframework.format.annotation.DateTimeFormat; +// 导入Serializable接口，实现该接口意味着该类的对象可以被序列化和反序列化 import java.io.Serializable; - /** * 公告信息 * 接收传参的实体类 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 取自ModelAndView 的model名称 */ +// 定义一个名为NewsModel的类，实现Serializable接口 public class NewsModel implements Serializable { + // 序列化版本号，用于保证序列化和反序列化过程中类的兼容性 private static final long serialVersionUID = 1L; - - - /** * 主键 */ + // 用于唯一标识每条公告信息的主键 private Integer id; - /** * 公告名称 */ + // 存储公告的名称，用于在列表等地方显示公告的标题 private String newsName; - /** * 公告图片 */ + // 存储公告相关图片的路径或标识 private String newsPhoto; - /** * 公告类型 */ + // 用整数表示公告的类型，不同的数值可能代表不同的公告分类 private Integer newsTypes; - /** * 公告发布时间 */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录公告发布的具体时间 private Date insertTime; - /** * 公告详情 */ + // 存储公告的详细内容，如具体的通知信息等 private String newsContent; - /** * 创建时间 show1 show2 nameShow */ + // 设置JSON序列化时日期的格式，使用中文环境，时区为东八区，格式为 "yyyy-MM-dd HH:mm:ss" @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // 用于Spring MVC接收表单数据时将日期字符串转换为Date对象 + @DateTimeFormat + // 记录该公告信息在系统中创建的时间 private Date createTime; - /** - * 获取：主键 - */ + * 获取：主键 + */ + // 获取主键ID的公共方法，供外部调用获取公告的唯一标识 public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + */ + // 设置主键ID的公共方法，供外部调用设置公告的唯一标识 public void setId(Integer id) { this.id = id; } + /** - * 获取：公告名称 - */ + * 获取：公告名称 + */ + // 获取公告名称的公共方法，供外部调用获取公告的标题 public String getNewsName() { return newsName; } - /** - * 设置：公告名称 - */ + * 设置：公告名称 + */ + // 设置公告名称的公共方法，供外部调用修改公告的标题 public void setNewsName(String newsName) { this.newsName = newsName; } + /** - * 获取：公告图片 - */ + * 获取：公告图片 + */ + // 获取公告图片路径或标识的公共方法，供外部调用获取公告的图片信息 public String getNewsPhoto() { return newsPhoto; } - /** - * 设置：公告图片 - */ + * 设置：公告图片 + */ + // 设置公告图片路径或标识的公共方法，供外部调用修改公告的图片信息 public void setNewsPhoto(String newsPhoto) { this.newsPhoto = newsPhoto; } + /** - * 获取：公告类型 - */ + * 获取：公告类型 + */ + // 获取公告类型的公共方法，供外部调用获取公告的分类信息 public Integer getNewsTypes() { return newsTypes; } - /** - * 设置：公告类型 - */ + * 设置：公告类型 + */ + // 设置公告类型的公共方法，供外部调用修改公告的分类信息 public void setNewsTypes(Integer newsTypes) { this.newsTypes = newsTypes; } + /** - * 获取：公告发布时间 - */ + * 获取：公告发布时间 + */ + // 获取公告发布时间的公共方法，供外部调用获取公告的发布时间 public Date getInsertTime() { return insertTime; } - /** - * 设置：公告发布时间 - */ + * 设置：公告发布时间 + */ + // 设置公告发布时间的公共方法，供外部调用修改公告的发布时间 public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + /** - * 获取：公告详情 - */ + * 获取：公告详情 + */ + // 获取公告详细内容的公共方法，供外部调用获取公告的具体信息 public String getNewsContent() { return newsContent; } - /** - * 设置：公告详情 - */ + * 设置：公告详情 + */ + // 设置公告详细内容的公共方法，供外部调用修改公告的具体信息 public void setNewsContent(String newsContent) { this.newsContent = newsContent; } + /** - * 获取：创建时间 show1 show2 nameShow - */ + * 获取：创建时间 show1 show2 nameShow + */ + // 获取公告创建时间的公共方法，供外部调用获取公告在系统中的创建时间 public Date getCreateTime() { return createTime; } - /** - * 设置：创建时间 show1 show2 nameShow - */ + * 设置：创建时间 show1 show2 nameShow + */ + // 设置公告创建时间的公共方法，供外部调用修改公告在系统中的创建时间 public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/src/main/java/com/entity/model/YishengModel.java b/src/main/java/com/entity/model/YishengModel.java index 97f4014..482f995 100644 --- a/src/main/java/com/entity/model/YishengModel.java +++ b/src/main/java/com/entity/model/YishengModel.java @@ -15,7 +15,10 @@ import java.io.Serializable; * 取自ModelAndView 的model名称 */ public class YishengModel implements Serializable { - private static final long serialVersionUID = 1L; // 序列化版本UID，用于版本控制 + private static final long serialVersionUID = 1L; + + + /** * 主键 @@ -97,245 +100,215 @@ public class YishengModel implements Serializable { * 使用@JsonFormat和@DateTimeFormat注解进行日期格式化 */ @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + @DateTimeFormat private Date createTime; /** - * 获取主键ID - * @return 主键ID - */ + * 获取：主键 + */ public Integer getId() { return id; } /** - * 设置主键ID - * @param id 主键ID - */ + * 设置：主键 + */ public void setId(Integer id) { this.id = id; } /** - * 获取医生工号 - * @return 医生工号 - */ + * 获取：医生工号 + */ public String getYishengUuidNumber() { return yishengUuidNumber; } /** - * 设置医生工号 - * @param yishengUuidNumber 医生工号 - */ + * 设置：医生工号 + */ public void setYishengUuidNumber(String yishengUuidNumber) { this.yishengUuidNumber = yishengUuidNumber; } /** - * 获取账户名 - * @return 账户名 - */ + * 获取：账户 + */ public String getUsername() { return username; } /** - * 设置账户名 - * @param username 账户名 - */ + * 设置：账户 + */ public void setUsername(String username) { this.username = username; } /** - * 获取密码 - * @return 密码 - */ + * 获取：密码 + */ public String getPassword() { return password; } /** - * 设置密码 - * @param password 密码 - */ + * 设置：密码 + */ public void setPassword(String password) { this.password = password; } /** - * 获取医生姓名 - * @return 医生姓名 - */ + * 获取：医生名称 + */ public String getYishengName() { return yishengName; } /** - * 设置医生姓名 - * @param yishengName 医生姓名 - */ + * 设置：医生名称 + */ public void setYishengName(String yishengName) { this.yishengName = yishengName; } /** - * 获取科室类型 - * @return 科室类型编码 - */ + * 获取：科室 + */ public Integer getYishengTypes() { return yishengTypes; } /** - * 设置科室类型 - * @param yishengTypes 科室类型编码 - */ + * 设置：科室 + */ public void setYishengTypes(Integer yishengTypes) { this.yishengTypes = yishengTypes; } /** - * 获取职位类型 - * @return 职位类型编码 - */ + * 获取：职位 + */ public Integer getZhiweiTypes() { return zhiweiTypes; } /** - * 设置职位类型 - * @param zhiweiTypes 职位类型编码 - */ + * 设置：职位 + */ public void setZhiweiTypes(Integer zhiweiTypes) { this.zhiweiTypes = zhiweiTypes; } /** - * 获取职称 - * @return 职称 - */ + * 获取：职称 + */ public String getYishengZhichneg() { return yishengZhichneg; } /** - * 设置职称 - * @param yishengZhichneg 职称 - */ + * 设置：职称 + */ public void setYishengZhichneg(String yishengZhichneg) { this.yishengZhichneg = yishengZhichneg; } /** - * 获取医生头像路径 - * @return 头像路径 - */ + * 获取：医生头像 + */ public String getYishengPhoto() { return yishengPhoto; } /** - * 设置医生头像路径 - * @param yishengPhoto 头像路径 - */ + * 设置：医生头像 + */ public void setYishengPhoto(String yishengPhoto) { this.yishengPhoto = yishengPhoto; } /** - * 获取联系方式 - * @return 联系方式 - */ + * 获取：联系方式 + */ public String getYishengPhone() { return yishengPhone; } /** - * 设置联系方式 - * @param yishengPhone 联系方式 - */ + * 设置：联系方式 + */ public void setYishengPhone(String yishengPhone) { this.yishengPhone = yishengPhone; } /** - * 获取挂号须知 - * @return 挂号须知内容 - */ + * 获取：挂号须知 + */ public String getYishengGuahao() { return yishengGuahao; } /** - * 设置挂号须知 - * @param yishengGuahao 挂号须知内容 - */ + * 设置：挂号须知 + */ public void setYishengGuahao(String yishengGuahao) { this.yishengGuahao = yishengGuahao; } /** - * 获取邮箱 - * @return 邮箱地址 - */ + * 获取：邮箱 + */ public String getYishengEmail() { return yishengEmail; } /** - * 设置邮箱 - * @param yishengEmail 邮箱地址 - */ + * 设置：邮箱 + */ public void setYishengEmail(String yishengEmail) { this.yishengEmail = yishengEmail; } /** - * 获取挂号价格 - * @return 挂号价格 - */ + * 获取：挂号价格 + */ public Double getYishengNewMoney() { return yishengNewMoney; } /** - * 设置挂号价格 - * @param yishengNewMoney 挂号价格 - */ + * 设置：挂号价格 + */ public void setYishengNewMoney(Double yishengNewMoney) { this.yishengNewMoney = yishengNewMoney; } /** - * 获取履历介绍 - * @return 履历介绍内容 - */ + * 获取：履历介绍 + */ public String getYishengContent() { return yishengContent; } /** - * 设置履历介绍 - * @param yishengContent 履历介绍内容 - */ + * 设置：履历介绍 + */ public void setYishengContent(String yishengContent) { this.yishengContent = yishengContent; } /** - * 获取创建时间 - * @return 创建时间 - */ + * 获取：创建时间 show1 show2 photoShow + */ public Date getCreateTime() { return createTime; } /** - * 设置创建时间 - * @param createTime 创建时间 - */ + * 设置：创建时间 show1 show2 photoShow + */ public void setCreateTime(Date createTime) { this.createTime = createTime; } diff --git a/src/main/java/com/entity/model/YonghuModel.java b/src/main/java/com/entity/model/YonghuModel.java index 851a493..619cfa4 100644 --- a/src/main/java/com/entity/model/YonghuModel.java +++ b/src/main/java/com/entity/model/YonghuModel.java @@ -1,14 +1,10 @@ package com.entity.model; -// 导入用户实体类 import com.entity.YonghuEntity; -// 导入MyBatis-Plus的表名注解 import com.baomidou.mybatisplus.annotations.TableName; -// 导入Jackson的日期格式化注解 import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; -// 导入Spring的日期格式化注解 import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; @@ -20,7 +16,6 @@ import java.io.Serializable; * 取自ModelAndView 的model名称 */ public class YonghuModel implements Serializable { - // 序列化版本号，用于保证序列化和反序列化的兼容性 private static final long serialVersionUID = 1L; /** @@ -82,176 +77,174 @@ public class YonghuModel implements Serializable { /** * 创建时间 */ - // 用于JSON序列化时，将日期格式化为指定的格式，这里指定为中国时区，格式为yyyy-MM-dd HH:mm:ss @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - // 用于Spring MVC接收表单数据时，将字符串类型的日期转换为Date类型 - @DateTimeFormat + @DateTimeFormat private Date createTime; /** - * 获取：主键 - */ + * 获取：主键 + */ public Integer getId() { return id; } /** - * 设置：主键 - */ + * 设置：主键 + */ public void setId(Integer id) { this.id = id; } /** - * 获取：账户 - */ + * 获取：账户 + */ public String getUsername() { return username; } /** - * 设置：账户 - */ + * 设置：账户 + */ public void setUsername(String username) { this.username = username; } /** - * 获取：密码 - */ + * 获取：密码 + */ public String getPassword() { return password; } /** - * 设置：密码 - */ + * 设置：密码 + */ public void setPassword(String password) { this.password = password; } /** - * 获取：用户姓名 - */ + * 获取：用户姓名 + */ public String getYonghuName() { return yonghuName; } /** - * 设置：用户姓名 - */ + * 设置：用户姓名 + */ public void setYonghuName(String yonghuName) { this.yonghuName = yonghuName; } /** - * 获取：头像 - */ + * 获取：头像 + */ public String getYonghuPhoto() { return yonghuPhoto; } /** - * 设置：头像 - */ + * 设置：头像 + */ public void setYonghuPhoto(String yonghuPhoto) { this.yonghuPhoto = yonghuPhoto; } /** - * 获取：用户手机号 - */ + * 获取：用户手机号 + */ public String getYonghuPhone() { return yonghuPhone; } /** - * 设置：用户手机号 - */ + * 设置：用户手机号 + */ public void setYonghuPhone(String yonghuPhone) { this.yonghuPhone = yonghuPhone; } /** - * 获取：用户身份证号 - */ + * 获取：用户身份证号 + */ public String getYonghuIdNumber() { return yonghuIdNumber; } /** - * 设置：用户身份证号 - */ + * 设置：用户身份证号 + */ public void setYonghuIdNumber(String yonghuIdNumber) { this.yonghuIdNumber = yonghuIdNumber; } /** - * 获取：邮箱 - */ + * 获取：邮箱 + */ public String getYonghuEmail() { return yonghuEmail; } /** - * 设置：邮箱 - */ + * 设置：邮箱 + */ public void setYonghuEmail(String yonghuEmail) { this.yonghuEmail = yonghuEmail; } /** - * 获取：性别 - */ + * 获取：性别 + */ public Integer getSexTypes() { return sexTypes; } /** - * 设置：性别 - */ + * 设置：性别 + */ public void setSexTypes(Integer sexTypes) { this.sexTypes = sexTypes; } /** - * 获取：余额 - */ + * 获取：余额 + */ public Double getNewMoney() { return newMoney; } /** - * 设置：余额 - */ + * 设置：余额 + */ public void setNewMoney(Double newMoney) { this.newMoney = newMoney; } /** - * 获取：假删 - */ + * 获取：假删 + */ public Integer getYonghuDelete() { return yonghuDelete; } /** - * 设置：假删 - */ + * 设置：假删 + */ public void setYonghuDelete(Integer yonghuDelete) { this.yonghuDelete = yonghuDelete; } /** - * 获取：创建时间 - */ + * 获取：创建时间 + */ public Date getCreateTime() { return createTime; } /** - * 设置：创建时间 - */ + * 设置：创建时间 + */ public void setCreateTime(Date createTime) { this.createTime = createTime; } diff --git a/src/main/java/com/entity/view/ChatView.java b/src/main/java/com/entity/view/ChatView.java index a6d3eea..2f88b67 100644 --- a/src/main/java/com/entity/view/ChatView.java +++ b/src/main/java/com/entity/view/ChatView.java @@ -14,191 +14,226 @@ import java.util.Date; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） */ +// 使用TableName注解指定该类对应的数据库表名为 "chat" @TableName("chat") +// ChatView类继承自ChatEntity类，并实现了Serializable接口，以便对象可以被序列化和反序列化 public class ChatView extends ChatEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 状态的值 - */ - private String zhuangtaiValue; - /** - * 数据类型的值 - */ - private String chatValue; - - - - //级联表 yonghu - /** - * 用户姓名 - */ - private String yonghuName; - /** - * 头像 - */ - private String yonghuPhoto; - /** - * 用户手机号 - */ - private String yonghuPhone; - /** - * 用户身份证号 - */ - private String yonghuIdNumber; - /** - * 邮箱 - */ - private String yonghuEmail; - /** - * 余额 - */ - private Double newMoney; - /** - * 假删 - */ - private Integer yonghuDelete; - + // 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 + private static final long serialVersionUID = 1L; + + /** + * 状态的值 + */ + // 用于存储在线咨询相关的状态值，可能表示咨询的状态（如进行中、已结束等） + private String zhuangtaiValue; + + /** + * 数据类型的值 + */ + // 用于存储在线咨询的数据类型相关的值，具体含义可能根据业务需求而定 + private String chatValue; + + // 级联表 yonghu + /** + * 用户姓名 + */ + // 存储与在线咨询相关联的用户的姓名信息 + private String yonghuName; + + /** + * 头像 + */ + // 存储与在线咨询相关联的用户的头像路径或标识 + private String yonghuPhoto; + + /** + * 用户手机号 + */ + // 存储与在线咨询相关联的用户的手机号码，用于联系用户 + private String yonghuPhone; + + /** + * 用户身份证号 + */ + // 存储与在线咨询相关联的用户的身份证号码，用于身份验证等业务 + private String yonghuIdNumber; + + /** + * 邮箱 + */ + // 存储与在线咨询相关联的用户的电子邮箱地址，可用于发送通知等 + private String yonghuEmail; + + /** + * 余额 + */ + // 存储与在线咨询相关联的用户的账户余额，可能与咨询费用等相关 + private Double newMoney; + + /** + * 假删 + */ + // 用于标识与在线咨询相关联的用户记录是否被逻辑删除（假删），0表示未删除，1表示已删除 + private Integer yonghuDelete; + + // 无参构造函数，用于创建ChatView对象 public ChatView() { } + // 构造函数，接受一个ChatEntity对象作为参数，通过BeanUtils.copyProperties方法 + // 将ChatEntity对象的属性值复制到当前ChatView对象中 public ChatView(ChatEntity chatEntity) { try { BeanUtils.copyProperties(this, chatEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 如果在复制属性过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } } + /** + * 获取： 状态的值 + */ + // 获取状态值的方法，外部可以通过调用该方法获取zhuangtaiValue属性的值 + public String getZhuangtaiValue() { + return zhuangtaiValue; + } + + /** + * 设置： 状态的值 + */ + // 设置状态值的方法，外部可以通过调用该方法设置zhuangtaiValue属性的值 + public void setZhuangtaiValue(String zhuangtaiValue) { + this.zhuangtaiValue = zhuangtaiValue; + } + + /** + * 获取： 数据类型的值 + */ + // 获取数据类型值的方法，外部可以通过调用该方法获取chatValue属性的值 + public String getChatValue() { + return chatValue; + } + + /** + * 设置： 数据类型的值 + */ + // 设置数据类型值的方法，外部可以通过调用该方法设置chatValue属性的值 + public void setChatValue(String chatValue) { + this.chatValue = chatValue; + } + + // 级联表的get和set yonghu + /** + * 获取： 用户姓名 + */ + // 获取用户姓名的方法，外部可以通过调用该方法获取yonghuName属性的值 + public String getYonghuName() { + return yonghuName; + } + + /** + * 设置： 用户姓名 + */ + // 设置用户姓名的方法，外部可以通过调用该方法设置yonghuName属性的值 + public void setYonghuName(String yonghuName) { + this.yonghuName = yonghuName; + } + + /** + * 获取： 头像 + */ + // 获取用户头像的方法，外部可以通过调用该方法获取yonghuPhoto属性的值 + public String getYonghuPhoto() { + return yonghuPhoto; + } + + /** + * 设置： 头像 + */ + // 设置用户头像的方法，外部可以通过调用该方法设置yonghuPhoto属性的值 + public void setYonghuPhoto(String yonghuPhoto) { + this.yonghuPhoto = yonghuPhoto; + } + + /** + * 获取： 用户手机号 + */ + // 获取用户手机号的方法，外部可以通过调用该方法获取yonghuPhone属性的值 + public String getYonghuPhone() { + return yonghuPhone; + } + /** + * 设置： 用户手机号 + */ + // 设置用户手机号的方法，外部可以通过调用该方法设置yonghuPhone属性的值 + public void setYonghuPhone(String yonghuPhone) { + this.yonghuPhone = yonghuPhone; + } - /** - * 获取： 状态的值 - */ - public String getZhuangtaiValue() { - return zhuangtaiValue; - } - /** - * 设置： 状态的值 - */ - public void setZhuangtaiValue(String zhuangtaiValue) { - this.zhuangtaiValue = zhuangtaiValue; - } - /** - * 获取： 数据类型的值 - */ - public String getChatValue() { - return chatValue; - } - /** - * 设置： 数据类型的值 - */ - public void setChatValue(String chatValue) { - this.chatValue = chatValue; - } - - - - - - - - - - - - - - - - - //级联表的get和set yonghu - /** - * 获取： 用户姓名 - */ - public String getYonghuName() { - return yonghuName; - } - /** - * 设置： 用户姓名 - */ - public void setYonghuName(String yonghuName) { - this.yonghuName = yonghuName; - } - /** - * 获取： 头像 - */ - public String getYonghuPhoto() { - return yonghuPhoto; - } - /** - * 设置： 头像 - */ - public void setYonghuPhoto(String yonghuPhoto) { - this.yonghuPhoto = yonghuPhoto; - } - /** - * 获取： 用户手机号 - */ - public String getYonghuPhone() { - return yonghuPhone; - } - /** - * 设置： 用户手机号 - */ - public void setYonghuPhone(String yonghuPhone) { - this.yonghuPhone = yonghuPhone; - } - /** - * 获取： 用户身份证号 - */ - public String getYonghuIdNumber() { - return yonghuIdNumber; - } - /** - * 设置： 用户身份证号 - */ - public void setYonghuIdNumber(String yonghuIdNumber) { - this.yonghuIdNumber = yonghuIdNumber; - } - /** - * 获取： 邮箱 - */ - public String getYonghuEmail() { - return yonghuEmail; - } - /** - * 设置： 邮箱 - */ - public void setYonghuEmail(String yonghuEmail) { - this.yonghuEmail = yonghuEmail; - } - /** - * 获取： 余额 - */ - public Double getNewMoney() { - return newMoney; - } - /** - * 设置： 余额 - */ - public void setNewMoney(Double newMoney) { - this.newMoney = newMoney; - } - /** - * 获取： 假删 - */ - public Integer getYonghuDelete() { - return yonghuDelete; - } - /** - * 设置： 假删 - */ - public void setYonghuDelete(Integer yonghuDelete) { - this.yonghuDelete = yonghuDelete; - } - - -} + /** + * 获取： 用户身份证号 + */ + // 获取用户身份证号的方法，外部可以通过调用该方法获取yonghuIdNumber属性的值 + public String getYonghuIdNumber() { + return yonghuIdNumber; + } + + /** + * 设置： 用户身份证号 + */ + // 设置用户身份证号的方法，外部可以通过调用该方法设置yonghuIdNumber属性的值 + public void setYonghuIdNumber(String yonghuIdNumber) { + this.yonghuIdNumber = yonghuIdNumber; + } + + /** + * 获取： 邮箱 + */ + // 获取用户邮箱的方法，外部可以通过调用该方法获取yonghuEmail属性的值 + public String getYonghuEmail() { + return yonghuEmail; + } + + /** + * 设置： 邮箱 + */ + // 设置用户邮箱的方法，外部可以通过调用该方法设置yonghuEmail属性的值 + public void setYonghuEmail(String yonghuEmail) { + this.yonghuEmail = yonghuEmail; + } + + /** + * 获取： 余额 + */ + // 获取用户余额的方法，外部可以通过调用该方法获取newMoney属性的值 + public Double getNewMoney() { + return newMoney; + } + + /** + * 设置： 余额 + */ + // 设置用户余额的方法，外部可以通过调用该方法设置newMoney属性的值 + public void setNewMoney(Double newMoney) { + this.newMoney = newMoney; + } + + /** + * 获取： 假删 + */ + // 获取用户假删状态的方法，外部可以通过调用该方法获取yonghuDelete属性的值 + public Integer getYonghuDelete() { + return yonghuDelete; + } + + /** + * 设置： 假删 + */ + // 设置用户假删状态的方法，外部可以通过调用该方法设置yonghuDelete属性的值 + public void setYonghuDelete(Integer yonghuDelete) { + this.yonghuDelete = yonghuDelete; + } +} \ No newline at end of file diff --git a/src/main/java/com/entity/view/DictionaryView.java b/src/main/java/com/entity/view/DictionaryView.java index 4f51785..825f709 100644 --- a/src/main/java/com/entity/view/DictionaryView.java +++ b/src/main/java/com/entity/view/DictionaryView.java @@ -14,44 +14,29 @@ import java.util.Date; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） */ +// 使用TableName注解指定该类对应的数据库表名为 "dictionary" @TableName("dictionary") +// DictionaryView类继承自DictionaryEntity类，并实现了Serializable接口， +// 使得该类的对象可以被序列化和反序列化，方便在网络传输或存储中使用 public class DictionaryView extends DictionaryEntity implements Serializable { - private static final long serialVersionUID = 1L; - - - + // 序列化版本号，用于确保在不同版本的类之间进行序列化和反序列化时的兼容性 + private static final long serialVersionUID = 1L; + // 无参构造函数，用于创建DictionaryView对象，在不需要初始化特定属性时使用 public DictionaryView() { } + // 构造函数，接受一个DictionaryEntity对象作为参数 + // 通过BeanUtils.copyProperties方法将DictionaryEntity对象的属性值复制到当前DictionaryView对象中 + // 这样可以方便地从Entity对象转换为View对象，减少手动赋值的工作量 public DictionaryView(DictionaryEntity dictionaryEntity) { try { BeanUtils.copyProperties(this, dictionaryEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 如果在复制属性过程中发生异常（例如属性访问权限问题或反射调用目标方法失败） + // 打印异常堆栈信息，以便开发人员调试和定位问题 e.printStackTrace(); } } - - - - - - - - - - - - - - - - - - - - - -} +} \ No newline at end of file diff --git a/src/main/java/com/entity/view/GuahaoView.java b/src/main/java/com/entity/view/GuahaoView.java index d5db2b2..6549895 100644 --- a/src/main/java/com/entity/view/GuahaoView.java +++ b/src/main/java/com/entity/view/GuahaoView.java @@ -14,430 +14,499 @@ import java.util.Date; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） */ +// 使用TableName注解指定该类对应的数据库表名为 "guahao" @TableName("guahao") +// GuahaoView类继承自GuahaoEntity类，并实现了Serializable接口， +// 使得该类的对象可以被序列化和反序列化，便于在网络传输或存储中使用 public class GuahaoView extends GuahaoEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 时间类型的值 - */ - private String guahaoValue; - /** - * 挂号状态的值 - */ - private String guahaoStatusValue; - /** - * 挂号审核的值 - */ - private String guahaoYesnoValue; - - - - //级联表 yisheng - /** - * 医生工号 - */ - private String yishengUuidNumber; - /** - * 医生名称 - */ - private String yishengName; - /** - * 科室 - */ - private Integer yishengTypes; - /** - * 科室的值 - */ - private String yishengValue; - /** - * 职位 - */ - private Integer zhiweiTypes; - /** - * 职位的值 - */ - private String zhiweiValue; - /** - * 职称 - */ - private String yishengZhichneg; - /** - * 医生头像 - */ - private String yishengPhoto; - /** - * 联系方式 - */ - private String yishengPhone; - /** - * 挂号须知 - */ - private String yishengGuahao; - /** - * 邮箱 - */ - private String yishengEmail; - /** - * 挂号价格 - */ - private Double yishengNewMoney; - /** - * 履历介绍 - */ - private String yishengContent; - - //级联表 yonghu - /** - * 用户姓名 - */ - private String yonghuName; - /** - * 头像 - */ - private String yonghuPhoto; - /** - * 用户手机号 - */ - private String yonghuPhone; - /** - * 用户身份证号 - */ - private String yonghuIdNumber; - /** - * 邮箱 - */ - private String yonghuEmail; - /** - * 余额 - */ - private Double newMoney; - /** - * 假删 - */ - private Integer yonghuDelete; - + // 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 + private static final long serialVersionUID = 1L; + + /** + * 时间类型的值 + */ + // 用于存储挂号相关的时间类型的值，可能表示不同的挂号时间分类等 + private String guahaoValue; + + /** + * 挂号状态的值 + */ + // 用于存储挂号状态的具体值，例如已挂号、已取消、已就诊等状态的描述 + private String guahaoStatusValue; + + /** + * 挂号审核的值 + */ + // 用于存储挂号审核结果的具体值，例如审核通过、审核不通过等描述 + private String guahaoYesnoValue; + + // 级联表 yisheng + /** + * 医生工号 + */ + // 存储与该挂号记录关联的医生的工号，用于唯一标识医生 + private String yishengUuidNumber; + + /** + * 医生名称 + */ + // 存储与该挂号记录关联的医生的姓名 + private String yishengName; + + /** + * 科室 + */ + // 用整数表示与该挂号记录关联的医生所属的科室 + private Integer yishengTypes; + + /** + * 科室的值 + */ + // 存储科室的具体描述值，可能是科室的名称等，与yishengTypes配合使用 + private String yishengValue; + + /** + * 职位 + */ + // 用整数表示与该挂号记录关联的医生的职位 + private Integer zhiweiTypes; + + /** + * 职位的值 + */ + // 存储职位的具体描述值，可能是职位的名称等，与zhiweiTypes配合使用 + private String zhiweiValue; + + /** + * 职称 + */ + // 存储与该挂号记录关联的医生的职称信息 + private String yishengZhichneg; + + /** + * 医生头像 + */ + // 存储与该挂号记录关联的医生的头像路径或标识 + private String yishengPhoto; + + /** + * 联系方式 + */ + // 存储与该挂号记录关联的医生的联系电话或其他联系方式 + private String yishengPhone; + + /** + * 挂号须知 + */ + // 存储与该医生相关的挂号注意事项和规定等信息 + private String yishengGuahao; + + /** + * 邮箱 + */ + // 存储与该挂号记录关联的医生的电子邮箱地址 + private String yishengEmail; + + /** + * 挂号价格 + */ + // 存储该医生的挂号费用金额，以Double类型表示 + private Double yishengNewMoney; + + /** + * 履历介绍 + */ + // 存储与该挂号记录关联的医生的个人履历和专业介绍等信息 + private String yishengContent; + + // 级联表 yonghu + /** + * 用户姓名 + */ + // 存储与该挂号记录关联的用户的姓名 + private String yonghuName; + + /** + * 头像 + */ + // 存储与该挂号记录关联的用户的头像路径或标识 + private String yonghuPhoto; + + /** + * 用户手机号 + */ + // 存储与该挂号记录关联的用户的手机号码，用于联系用户 + private String yonghuPhone; + + /** + * 用户身份证号 + */ + // 存储与该挂号记录关联的用户的身份证号码，用于身份验证等业务 + private String yonghuIdNumber; + + /** + * 邮箱 + */ + // 存储与该挂号记录关联的用户的电子邮箱地址，可用于发送通知等 + private String yonghuEmail; + + /** + * 余额 + */ + // 存储与该挂号记录关联的用户的账户余额，可能与挂号费用支付等相关 + private Double newMoney; + + /** + * 假删 + */ + // 用于标识与该挂号记录关联的用户记录是否被逻辑删除（假删），0表示未删除，1表示已删除 + private Integer yonghuDelete; + + // 无参构造函数，用于创建GuahaoView对象 public GuahaoView() { } + // 构造函数，接受一个GuahaoEntity对象作为参数， + // 通过BeanUtils.copyProperties方法将GuahaoEntity对象的属性值复制到当前GuahaoView对象中 public GuahaoView(GuahaoEntity guahaoEntity) { try { BeanUtils.copyProperties(this, guahaoEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 如果在复制属性过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } } + /** + * 获取： 时间类型的值 + */ + // 获取时间类型值的方法，外部可以通过调用该方法获取guahaoValue属性的值 + public String getGuahaoValue() { + return guahaoValue; + } + + /** + * 设置： 时间类型的值 + */ + // 设置时间类型值的方法，外部可以通过调用该方法设置guahaoValue属性的值 + public void setGuahaoValue(String guahaoValue) { + this.guahaoValue = guahaoValue; + } + + /** + * 获取： 挂号状态的值 + */ + // 获取挂号状态值的方法，外部可以通过调用该方法获取guahaoStatusValue属性的值 + public String getGuahaoStatusValue() { + return guahaoStatusValue; + } + + /** + * 设置： 挂号状态的值 + */ + // 设置挂号状态值的方法，外部可以通过调用该方法设置guahaoStatusValue属性的值 + public void setGuahaoStatusValue(String guahaoStatusValue) { + this.guahaoStatusValue = guahaoStatusValue; + } + + /** + * 获取： 挂号审核的值 + */ + // 获取挂号审核值的方法，外部可以通过调用该方法获取guahaoYesnoValue属性的值 + public String getGuahaoYesnoValue() { + return guahaoYesnoValue; + } + + /** + * 设置： 挂号审核的值 + */ + // 设置挂号审核值的方法，外部可以通过调用该方法设置guahaoYesnoValue属性的值 + public void setGuahaoYesnoValue(String guahaoYesnoValue) { + this.guahaoYesnoValue = guahaoYesnoValue; + } + + // 级联表的get和set yisheng + /** + * 获取： 医生工号 + */ + // 获取医生工号的方法，外部可以通过调用该方法获取yishengUuidNumber属性的值 + public String getYishengUuidNumber() { + return yishengUuidNumber; + } + + /** + * 设置： 医生工号 + */ + // 设置医生工号的方法，外部可以通过调用该方法设置yishengUuidNumber属性的值 + public void setYishengUuidNumber(String yishengUuidNumber) { + this.yishengUuidNumber = yishengUuidNumber; + } + + /** + * 获取： 医生名称 + */ + // 获取医生名称的方法，外部可以通过调用该方法获取yishengName属性的值 + public String getYishengName() { + return yishengName; + } + + /** + * 设置： 医生名称 + */ + // 设置医生名称的方法，外部可以通过调用该方法设置yishengName属性的值 + public void setYishengName(String yishengName) { + this.yishengName = yishengName; + } + + /** + * 获取： 科室 + */ + // 获取科室编号的方法，外部可以通过调用该方法获取yishengTypes属性的值 + public Integer getYishengTypes() { + return yishengTypes; + } + + /** + * 设置： 科室 + */ + // 设置科室编号的方法，外部可以通过调用该方法设置yishengTypes属性的值 + public void setYishengTypes(Integer yishengTypes) { + this.yishengTypes = yishengTypes; + } + + /** + * 获取： 科室的值 + */ + // 获取科室描述值的方法，外部可以通过调用该方法获取yishengValue属性的值 + public String getYishengValue() { + return yishengValue; + } + + /** + * 设置： 科室的值 + */ + // 设置科室描述值的方法，外部可以通过调用该方法设置yishengValue属性的值 + public void setYishengValue(String yishengValue) { + this.yishengValue = yishengValue; + } + + /** + * 获取： 职位 + */ + // 获取职位编号的方法，外部可以通过调用该方法获取zhiweiTypes属性的值 + public Integer getZhiweiTypes() { + return zhiweiTypes; + } + + /** + * 设置： 职位 + */ + // 设置职位编号的方法，外部可以通过调用该方法设置zhiweiTypes属性的值 + public void setZhiweiTypes(Integer zhiweiTypes) { + this.zhiweiTypes = zhiweiTypes; + } + + /** + * 获取： 职位的值 + */ + // 获取职位描述值的方法，外部可以通过调用该方法获取zhiweiValue属性的值 + public String getZhiweiValue() { + return zhiweiValue; + } + + /** + * 设置： 职位的值 + */ + // 设置职位描述值的方法，外部可以通过调用该方法设置zhiweiValue属性的值 + public void setZhiweiValue(String zhiweiValue) { + this.zhiweiValue = zhiweiValue; + } + + /** + * 获取： 职称 + */ + // 获取职称信息的方法，外部可以通过调用该方法获取yishengZhichneg属性的值 + public String getYishengZhichneg() { + return yishengZhichneg; + } + + /** + * 设置： 职称 + */ + // 设置职称信息的方法，外部可以通过调用该方法设置yishengZhichneg属性的值 + public void setYishengZhichneg(String yishengZhichneg) { + this.yishengZhichneg = yishengZhichneg; + } + + /** + * 获取： 医生头像 + */ + // 获取医生头像路径或标识的方法，外部可以通过调用该方法获取yishengPhoto属性的值 + public String getYishengPhoto() { + return yishengPhoto; + } + + /** + * 设置： 医生头像 + */ + // 设置医生头像路径或标识的方法，外部可以通过调用该方法设置yishengPhoto属性的值 + public void setYishengPhoto(String yishengPhoto) { + this.yishengPhoto = yishengPhoto; + } + /** + * 获取： 联系方式 + */ + // 获取医生联系方式的方法，外部可以通过调用该方法获取yishengPhone属性的值 + public String getYishengPhone() { + return yishengPhone; + } + + /** + * 设置： 联系方式 + */ + // 设置医生联系方式的方法，外部可以通过调用该方法设置yishengPhone属性的值 + public void setYishengPhone(String yishengPhone) { + this.yishengPhone = yishengPhone; + } - /** - * 获取： 时间类型的值 - */ - public String getGuahaoValue() { - return guahaoValue; - } - /** - * 设置： 时间类型的值 - */ - public void setGuahaoValue(String guahaoValue) { - this.guahaoValue = guahaoValue; - } - /** - * 获取： 挂号状态的值 - */ - public String getGuahaoStatusValue() { - return guahaoStatusValue; - } - /** - * 设置： 挂号状态的值 - */ - public void setGuahaoStatusValue(String guahaoStatusValue) { - this.guahaoStatusValue = guahaoStatusValue; - } - /** - * 获取： 挂号审核的值 - */ - public String getGuahaoYesnoValue() { - return guahaoYesnoValue; - } - /** - * 设置： 挂号审核的值 - */ - public void setGuahaoYesnoValue(String guahaoYesnoValue) { - this.guahaoYesnoValue = guahaoYesnoValue; - } - - - - - - - - - - - - - - - - - - - - //级联表的get和set yisheng - /** - * 获取： 医生工号 - */ - public String getYishengUuidNumber() { - return yishengUuidNumber; - } - /** - * 设置： 医生工号 - */ - public void setYishengUuidNumber(String yishengUuidNumber) { - this.yishengUuidNumber = yishengUuidNumber; - } - /** - * 获取： 医生名称 - */ - public String getYishengName() { - return yishengName; - } - /** - * 设置： 医生名称 - */ - public void setYishengName(String yishengName) { - this.yishengName = yishengName; - } - /** - * 获取： 科室 - */ - public Integer getYishengTypes() { - return yishengTypes; - } - /** - * 设置： 科室 - */ - public void setYishengTypes(Integer yishengTypes) { - this.yishengTypes = yishengTypes; - } - - - /** - * 获取： 科室的值 - */ - public String getYishengValue() { - return yishengValue; - } - /** - * 设置： 科室的值 - */ - public void setYishengValue(String yishengValue) { - this.yishengValue = yishengValue; - } - /** - * 获取： 职位 - */ - public Integer getZhiweiTypes() { - return zhiweiTypes; - } - /** - * 设置： 职位 - */ - public void setZhiweiTypes(Integer zhiweiTypes) { - this.zhiweiTypes = zhiweiTypes; - } - - - /** - * 获取： 职位的值 - */ - public String getZhiweiValue() { - return zhiweiValue; - } - /** - * 设置： 职位的值 - */ - public void setZhiweiValue(String zhiweiValue) { - this.zhiweiValue = zhiweiValue; - } - /** - * 获取： 职称 - */ - public String getYishengZhichneg() { - return yishengZhichneg; - } - /** - * 设置： 职称 - */ - public void setYishengZhichneg(String yishengZhichneg) { - this.yishengZhichneg = yishengZhichneg; - } - /** - * 获取： 医生头像 - */ - public String getYishengPhoto() { - return yishengPhoto; - } - /** - * 设置： 医生头像 - */ - public void setYishengPhoto(String yishengPhoto) { - this.yishengPhoto = yishengPhoto; - } - /** - * 获取： 联系方式 - */ - public String getYishengPhone() { - return yishengPhone; - } - /** - * 设置： 联系方式 - */ - public void setYishengPhone(String yishengPhone) { - this.yishengPhone = yishengPhone; - } - /** - * 获取： 挂号须知 - */ - public String getYishengGuahao() { - return yishengGuahao; - } - /** - * 设置： 挂号须知 - */ - public void setYishengGuahao(String yishengGuahao) { - this.yishengGuahao = yishengGuahao; - } - /** - * 获取： 邮箱 - */ - public String getYishengEmail() { - return yishengEmail; - } - /** - * 设置： 邮箱 - */ - public void setYishengEmail(String yishengEmail) { - this.yishengEmail = yishengEmail; - } - /** - * 获取： 挂号价格 - */ - public Double getYishengNewMoney() { - return yishengNewMoney; - } - /** - * 设置： 挂号价格 - */ - public void setYishengNewMoney(Double yishengNewMoney) { - this.yishengNewMoney = yishengNewMoney; - } - /** - * 获取： 履历介绍 - */ - public String getYishengContent() { - return yishengContent; - } - /** - * 设置： 履历介绍 - */ - public void setYishengContent(String yishengContent) { - this.yishengContent = yishengContent; - } - - - - - //级联表的get和set yonghu - /** - * 获取： 用户姓名 - */ - public String getYonghuName() { - return yonghuName; - } - /** - * 设置： 用户姓名 - */ - public void setYonghuName(String yonghuName) { - this.yonghuName = yonghuName; - } - /** - * 获取： 头像 - */ - public String getYonghuPhoto() { - return yonghuPhoto; - } - /** - * 设置： 头像 - */ - public void setYonghuPhoto(String yonghuPhoto) { - this.yonghuPhoto = yonghuPhoto; - } - /** - * 获取： 用户手机号 - */ - public String getYonghuPhone() { - return yonghuPhone; - } - /** - * 设置： 用户手机号 - */ - public void setYonghuPhone(String yonghuPhone) { - this.yonghuPhone = yonghuPhone; - } - /** - * 获取： 用户身份证号 - */ - public String getYonghuIdNumber() { - return yonghuIdNumber; - } - /** - * 设置： 用户身份证号 - */ - public void setYonghuIdNumber(String yonghuIdNumber) { - this.yonghuIdNumber = yonghuIdNumber; - } - /** - * 获取： 邮箱 - */ - public String getYonghuEmail() { - return yonghuEmail; - } - /** - * 设置： 邮箱 - */ - public void setYonghuEmail(String yonghuEmail) { - this.yonghuEmail = yonghuEmail; - } - /** - * 获取： 余额 - */ - public Double getNewMoney() { - return newMoney; - } - /** - * 设置： 余额 - */ - public void setNewMoney(Double newMoney) { - this.newMoney = newMoney; - } - /** - * 获取： 假删 - */ - public Integer getYonghuDelete() { - return yonghuDelete; - } - /** - * 设置： 假删 - */ - public void setYonghuDelete(Integer yonghuDelete) { - this.yonghuDelete = yonghuDelete; - } - - - -} + /** + * 获取： 挂号须知 + */ + // 获取挂号须知信息的方法，外部可以通过调用该方法获取yishengGuahao属性的值 + public String getYishengGuahao() { + return yishengGuahao; + } + + /** + * 设置： 挂号须知 + */ + // 设置挂号须知信息的方法，外部可以通过调用该方法设置yishengGuahao属性的值 + public void setYishengGuahao(String yishengGuahao) { + this.yishengGuahao = yishengGuahao; + } + + /** + * 获取： 邮箱 + */ + // 获取医生邮箱地址的方法，外部可以通过调用该方法获取yishengEmail属性的值 + public String getYishengEmail() { + return yishengEmail; + } + + /** + * 设置： 邮箱 + */ + // 设置医生邮箱地址的方法，外部可以通过调用该方法设置yishengEmail属性的值 + public void setYishengEmail(String yishengEmail) { + this.yishengEmail = yishengEmail; + } + + /** + * 获取： 挂号价格 + */ + // 获取挂号价格信息的方法，外部可以通过调用该方法获取yishengNewMoney属性的值 + public Double getYishengNewMoney() { + return yishengNewMoney; + } + + /** + * 设置： 挂号价格 + */ + // 设置挂号价格信息的方法，外部可以通过调用该方法设置yishengNewMoney属性的值 + public void setYishengNewMoney(Double yishengNewMoney) { + this.yishengNewMoney = yishengNewMoney; + } + + /** + * 获取： 履历介绍 + */ + // 获取医生履历介绍信息的方法，外部可以通过调用该方法获取yishengContent属性的值 + public String getYishengContent() { + return yishengContent; + } + + /** + * 设置： 履历介绍 + */ + // 设置医生履历介绍信息的方法，外部可以通过调用该方法设置yishengContent属性的值 + public void setYishengContent(String yishengContent) { + this.yishengContent = yishengContent; + } + + // 级联表的get和set yonghu + /** + * 获取： 用户姓名 + */ + // 获取用户姓名的方法，外部可以通过调用该方法获取yonghuName属性的值 + public String getYonghuName() { + return yonghuName; + } + + /** + * 设置： 用户姓名 + */ + // 设置用户姓名的方法，外部可以通过调用该方法设置yonghuName属性的值 + public void setYonghuName(String yonghuName) { + this.yonghuName = yonghuName; + } + + /** + * 获取： 头像 + */ + // 获取用户头像路径或标识的方法，外部可以通过调用该方法获取yonghuPhoto属性的值 + public String getYonghuPhoto() { + return yonghuPhoto; + } + + /** + * 设置： 头像 + */ + // 设置用户头像路径或标识的方法，外部可以通过调用该方法设置yonghuPhoto属性的值 + public void setYonghuPhoto(String yonghuPhoto) { + this.yonghuPhoto = yonghuPhoto; + } + + /** + * 获取： 用户手机号 + */ + // 获取用户手机号的方法，外部可以通过调用该方法获取yonghuPhone属性的值 + public String getYonghuPhone() { + return yonghuPhone; + } + + /** + * 设置： 用户手机号 + */ + // 设置用户手机号的方法，外部可以通过调用该方法设置yonghuPhone属性的值 + public void setYonghuPhone(String yonghuPhone) { + this.yonghuPhone = yonghuPhone; + } + + /** + * 获取： 用户身份证号 + */ + // 获取用户身份证号的方法，外部可以通过调用该方法获取yonghuIdNumber属性的值 + public String getYonghuIdNumber() { + return yonghuIdNumber; + } + + /** + * 设置： 用户身份证号 + */ + // 设置用户身份证号的方法，外部可以通过调用该方法设置yonghuIdNumber属性的值 + public void setYonghuIdNumber(String yonghuIdNumber) { + this.yonghuIdNumber = yonghuIdNumber; + } + + /** + * 获取： 邮箱 + */ + // 获取用户邮箱地址的方法，外部可以通过调用该方法获取yonghuEmail属性的值 + public String getYonghuEmail() { + return yonghuEmail; + } + +/** + * \ No newline at end of file diff --git a/src/main/java/com/entity/view/JiankangjiaoyuView.java b/src/main/java/com/entity/view/JiankangjiaoyuView.java index a6f2161..d5a1310 100644 --- a/src/main/java/com/entity/view/JiankangjiaoyuView.java +++ b/src/main/java/com/entity/view/JiankangjiaoyuView.java @@ -14,52 +14,51 @@ import java.util.Date; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） */ +// 使用TableName注解指定该类对应的数据库表名为 "jiankangjiaoyu" @TableName("jiankangjiaoyu") +// JiankangjiaoyuView类继承自JiankangjiaoyuEntity类，并实现了Serializable接口， +// 使得该类的对象可以被序列化和反序列化，方便在网络传输或存储中使用 public class JiankangjiaoyuView extends JiankangjiaoyuEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 健康教育类型的值 - */ - private String jiankangjiaoyuValue; - + // 序列化版本号，用于保证在不同版本的类之间进行序列化和反序列化时的兼容性 + private static final long serialVersionUID = 1L; + /** + * 健康教育类型的值 + */ + // 用于存储健康教育相关的类型值，可能表示不同的健康教育分类，如疾病预防、健康生活方式等 + private String jiankangjiaoyuValue; + // 无参构造函数，用于创建JiankangjiaoyuView对象，在不需要初始化特定属性时使用 public JiankangjiaoyuView() { } + // 构造函数，接受一个JiankangjiaoyuEntity对象作为参数， + // 通过BeanUtils.copyProperties方法将JiankangjiaoyuEntity对象的属性值复制到当前JiankangjiaoyuView对象中， + // 这样可以方便地从Entity对象转换为View对象，减少手动赋值的工作量 public JiankangjiaoyuView(JiankangjiaoyuEntity jiankangjiaoyuEntity) { try { BeanUtils.copyProperties(this, jiankangjiaoyuEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 如果在复制属性过程中发生异常（例如属性访问权限问题或反射调用目标方法失败）， + // 打印异常堆栈信息，以便开发人员调试和定位问题 e.printStackTrace(); } } + /** + * 获取： 健康教育类型的值 + */ + // 获取健康教育类型值的方法，外部可以通过调用该方法获取jiankangjiaoyuValue属性的值 + public String getJiankangjiaoyuValue() { + return jiankangjiaoyuValue; + } - - /** - * 获取： 健康教育类型的值 - */ - public String getJiankangjiaoyuValue() { - return jiankangjiaoyuValue; - } - /** - * 设置： 健康教育类型的值 - */ - public void setJiankangjiaoyuValue(String jiankangjiaoyuValue) { - this.jiankangjiaoyuValue = jiankangjiaoyuValue; - } - - - - - - - - - - -} + /** + * 设置： 健康教育类型的值 + */ + // 设置健康教育类型值的方法，外部可以通过调用该方法设置jiankangjiaoyuValue属性的值 + public void setJiankangjiaoyuValue(String jiankangjiaoyuValue) { + this.jiankangjiaoyuValue = jiankangjiaoyuValue; + } +} \ No newline at end of file diff --git a/src/main/java/com/entity/view/NewsView.java b/src/main/java/com/entity/view/NewsView.java index 521f42d..d0f14e1 100644 --- a/src/main/java/com/entity/view/NewsView.java +++ b/src/main/java/com/entity/view/NewsView.java @@ -1,12 +1,20 @@ package com.entity.view; +// 导入公告信息实体类，NewsView 会继承该类 import com.entity.NewsEntity; +// 导入 MyBatis-Plus 用于指定数据库表名的注解 import com.baomidou.mybatisplus.annotations.TableName; +// 导入 Apache Commons BeanUtils 工具类，用于对象属性复制 import org.apache.commons.beanutils.BeanUtils; +// 导入反射调用可能抛出的异常类 import java.lang.reflect.InvocationTargetException; +// 导入 Spring 框架用于日期格式化的注解 import org.springframework.format.annotation.DateTimeFormat; +// 导入 Jackson 用于 JSON 序列化时日期格式化的注解 import com.fasterxml.jackson.annotation.JsonFormat; +// 导入序列化接口 import java.io.Serializable; +// 导入日期类 import java.util.Date; /** @@ -14,52 +22,48 @@ import java.util.Date; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） */ +// 指定该类对应数据库中的 news 表 @TableName("news") +// NewsView 类继承自 NewsEntity 类，并实现 Serializable 接口，可进行序列化操作 public class NewsView extends NewsEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 公告类型的值 - */ - private String newsValue; - + // 序列化版本号，确保序列化和反序列化的兼容性 + private static final long serialVersionUID = 1L; + /** + * 公告类型的值 + */ + // 存储公告类型的具体描述值，例如“紧急通知”“普通公告”等 + private String newsValue; + // 无参构造函数，方便创建 NewsView 类的实例 public NewsView() { } + // 带参构造函数，接收一个 NewsEntity 对象，将其属性复制到当前 NewsView 对象 public NewsView(NewsEntity newsEntity) { try { + // 使用 BeanUtils 工具类复制属性 BeanUtils.copyProperties(this, newsEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 若复制属性过程中出现异常，打印异常堆栈信息 e.printStackTrace(); } } + /** + * 获取： 公告类型的值 + */ + // 获取公告类型值的方法 + public String getNewsValue() { + return newsValue; + } - - /** - * 获取： 公告类型的值 - */ - public String getNewsValue() { - return newsValue; - } - /** - * 设置： 公告类型的值 - */ - public void setNewsValue(String newsValue) { - this.newsValue = newsValue; - } - - - - - - - - - - -} + /** + * 设置： 公告类型的值 + */ + // 设置公告类型值的方法 + public void setNewsValue(String newsValue) { + this.newsValue = newsValue; + } +} \ No newline at end of file diff --git a/src/main/java/com/interceptor/AuthorizationInterceptor.java b/src/main/java/com/interceptor/AuthorizationInterceptor.java index 723834b..ff46fa7 100644 --- a/src/main/java/com/interceptor/AuthorizationInterceptor.java +++ b/src/main/java/com/interceptor/AuthorizationInterceptor.java @@ -29,19 +29,18 @@ public class AuthorizationInterceptor implements HandlerInterceptor { public static final String LOGIN_TOKEN_KEY = "Token"; @Autowired - private TokenService tokenService; - - @Override + private TokenService tokenService; // 注入 TokenService + @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { - String servletPath = request.getServletPath(); - if("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath()) ){//请求路径是字典表或者文件上传 直接放行 + if ("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath())) { + // 请求路径是字典表或者文件上传 直接放行 return true; } - //支持跨域请求 - response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE"); + // 支持跨域请求 + response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE"); response.setHeader("Access-Control-Max-Age", "3600"); response.setHeader("Access-Control-Allow-Credentials", "true"); response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization"); @@ -54,41 +53,41 @@ public class AuthorizationInterceptor implements HandlerInterceptor { return true; } - //从header中获取token + // 从header中获取token String token = request.getHeader(LOGIN_TOKEN_KEY); - + /** * 不需要验证权限的方法直接放过 */ - if(annotation!=null) { - return true; + if (annotation != null) { + return true; } - + TokenEntity tokenEntity = null; - if(StringUtils.isNotBlank(token)) { - tokenEntity = tokenService.getTokenEntity(token); + if (StringUtils.isNotBlank(token)) { + tokenEntity = tokenService.getTokenEntity(token); } - - if(tokenEntity != null) { - request.getSession().setAttribute("userId", tokenEntity.getUserid()); - request.getSession().setAttribute("role", tokenEntity.getRole()); - request.getSession().setAttribute("tableName", tokenEntity.getTablename()); - request.getSession().setAttribute("username", tokenEntity.getUsername()); - return true; + + if (tokenEntity != null) { + request.getSession().setAttribute("userId", tokenEntity.getUserid()); + request.getSession().setAttribute("role", tokenEntity.getRole()); + request.getSession().setAttribute("tableName", tokenEntity.getTablename()); + request.getSession().setAttribute("username", tokenEntity.getUsername()); + return true; + } + + PrintWriter writer = null; + response.setCharacterEncoding("UTF-8"); + response.setContentType("application/json; charset=utf-8"); + try { + writer = response.getWriter(); + writer.print(JSONObject.toJSONString(R.error(401, "请先登录"))); + } finally { + if (writer != null) { + writer.close(); + } } - - PrintWriter writer = null; - response.setCharacterEncoding("UTF-8"); - response.setContentType("application/json; charset=utf-8"); - try { - writer = response.getWriter(); - writer.print(JSONObject.toJSONString(R.error(401, "请先登录"))); - } finally { - if(writer != null){ - writer.close(); - } - } -// throw new EIException("请先登录", 401); - return false; +// throw new EIException("请先登录", 401); + return false; } -} +} \ No newline at end of file diff --git a/src/main/java/com/model/enums/TypeEnum.java b/src/main/java/com/model/enums/TypeEnum.java index 39061d8..e9c9de1 100644 --- a/src/main/java/com/model/enums/TypeEnum.java +++ b/src/main/java/com/model/enums/TypeEnum.java @@ -1,31 +1,39 @@ package com.model.enums; +// 导入序列化接口，使枚举对象可以进行序列化和反序列化操作 import java.io.Serializable; - +// 导入 MyBatis-Plus 的枚举接口，用于将枚举值映射到数据库字段 import com.baomidou.mybatisplus.enums.IEnum; /** * 必须现在 IEnum 配置 该包扫描自动注入，查看文件 spring-mybatis.xml 参数 typeEnumsPackage + * 这个枚举类用于表示某种状态，包含两种状态：禁用和正常 */ public enum TypeEnum implements IEnum { + // 定义枚举常量，分别表示禁用状态和正常状态 DISABLED(0, "禁用"), NORMAL(1, "正常"); + // 用于存储枚举值对应的整数值，通常与数据库中的字段值对应 private final int value; + // 用于存储枚举值对应的中文描述，方便在代码中使用和展示 private final String desc; + // 枚举类的构造函数，用于初始化枚举常量的 value 和 desc 属性 TypeEnum(final int value, final String desc) { this.value = value; this.desc = desc; } + // 实现 IEnum 接口的方法，返回枚举值对应的整数值，用于与数据库字段进行映射 @Override public Serializable getValue() { return this.value; } - // Jackson 注解为 JsonValue 返回中文 json 描述 + // 该方法用于获取枚举值的中文描述，使用 Jackson 注解时，可将该描述作为 JSON 序列化时的值 + // 这样在进行 JSON 序列化时，会返回枚举值的中文描述而不是枚举名称 public String getDesc() { return this.desc; } -} +} \ No newline at end of file diff --git a/src/main/resources/front/front/js/validate.js b/src/main/resources/front/front/js/validate.js index 6677b45..9f9bc10 100644 --- a/src/main/resources/front/front/js/validate.js +++ b/src/main/resources/front/front/js/validate.js @@ -1,74 +1,90 @@ /** - * 邮箱 - * @param {*} s + * 验证输入的字符串是否为有效的邮箱地址 + * @param {*} s - 要验证的字符串，预期为邮箱地址 + * @returns {boolean} - 如果字符串是有效的邮箱地址，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isEmail(s) { - if(s){ - return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s) + if (s) { + // 使用正则表达式匹配邮箱地址的格式 + return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s); } return true; } /** - * 手机号码 - * @param {*} s + * 验证输入的字符串是否为有效的手机号码 + * @param {*} s - 要验证的字符串，预期为手机号码 + * @returns {boolean} - 如果字符串是有效的手机号码，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isMobile(s) { - if(s){ - return /^1[0-9]{10}$/.test(s) + if (s) { + // 使用正则表达式匹配手机号码的格式（以 1 开头，后面跟着 10 位数字） + return /^1[0-9]{10}$/.test(s); } return true; } /** - * 电话号码 - * @param {*} s + * 验证输入的字符串是否为有效的电话号码 + * @param {*} s - 要验证的字符串，预期为电话号码 + * @returns {boolean} - 如果字符串是有效的电话号码，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isPhone(s) { - if(s){ - return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s) + if (s) { + // 使用正则表达式匹配电话号码的格式（可以有 3 到 4 位区号，后面跟着 7 到 8 位号码，区号和号码之间用 - 分隔） + return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s); } return true; } /** - * URL地址 - * @param {*} s + * 验证输入的字符串是否为有效的 URL 地址 + * @param {*} s - 要验证的字符串，预期为 URL 地址 + * @returns {boolean} - 如果字符串是有效的 URL 地址，返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isURL(s) { - if(s){ - return /^http[s]?:\/\/.*/.test(s) + if (s) { + // 使用正则表达式匹配 URL 地址的格式（以 http 或 https 开头） + return /^http[s]?:\/\/.*/.test(s); } return true; } /** - * 匹配数字，可以是小数，不可以是负数,可以为空 - * @param {*} s + * 验证输入的字符串是否为有效的数字（可以是小数，不能是负数，可以为空） + * @param {*} s - 要验证的字符串，预期为数字 + * @returns {boolean} - 如果字符串是有效的数字（符合指定格式），返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isNumber(s) { - if(s){ + if (s) { + // 使用正则表达式匹配数字的格式，包括小数和科学计数法形式，不允许负数 return /(^-?[+-]?([0-9]*\.?[0-9]+|[0-9]+\.?[0-9]*)([eE][+-]?[0-9]+)?$)|(^$)/.test(s); } return true; } + /** - * 匹配整数，可以为空 - * @param {*} s + * 验证输入的字符串是否为有效的整数（可以为空） + * @param {*} s - 要验证的字符串，预期为整数 + * @returns {boolean} - 如果字符串是有效的整数（符合指定格式），返回 true；否则返回 false。当传入的 s 为 null 或 undefined 时，直接返回 true */ function isIntNumer(s) { - if(s){ + if (s) { + // 使用正则表达式匹配整数的格式，包括正负整数和空字符串 return /(^-?\d+$)|(^$)/.test(s); } return true; } + /** - * 身份证校验 + * 验证输入的字符串是否为有效的身份证号码 + * @param {string} idcard - 要验证的字符串，预期为身份证号码 + * @returns {boolean} - 如果字符串是有效的身份证号码（符合 15 位、18 位或 17 位加最后一位为 X 或 x 的格式），返回 true；否则返回 false。当传入的 idcard 为 null 或 undefined 时，直接返回 true */ function isIdentity(idcard) { const regIdCard = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/; - if(idcard){ + if (idcard) { return regIdCard.test(idcard); } return true; -} +} \ No newline at end of file