From 3650f14bbab16e81e0345822664502cef34b574b Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Fri, 13 Dec 2024 19:40:41 +0800 Subject: [PATCH 1/7] 1 --- .../src/main/java/com/controller/YonghuController.java | 1 - 1 file changed, 1 deletion(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index 8b24353b..943b771e 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -36,7 +36,6 @@ import com.alibaba.fastjson.*; * 用户 * 后端接口 * @author - * @email */ @RestController @Controller -- 2.34.1 From 9ffd2e82031111ab000cd517743dbacc6619a224 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Fri, 13 Dec 2024 21:15:23 +0800 Subject: [PATCH 2/7] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20ytt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/controller/YonghuController.java | 362 ++++++++++++------ 1 file changed, 253 insertions(+), 109 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index 943b771e..b5cf9755 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -36,45 +36,61 @@ import com.alibaba.fastjson.*; * 用户 * 后端接口 * @author + * @email */ @RestController @Controller @RequestMapping("/yonghu") public class YonghuController { + + // 创建日志记录器，用于记录该类中的相关操作日志 private static final Logger logger = LoggerFactory.getLogger(YonghuController.class); + // 自动注入用户服务层接口，用于处理与用户相关的业务逻辑，如数据库操作等 @Autowired private YonghuService yonghuService; - + // 自动注入Token服务层接口，用于处理与用户Token相关的业务，例如生成、验证等操作 @Autowired private TokenService tokenService; + + // 自动注入字典服务层接口，用于处理字典数据相关的转换等操作 @Autowired private DictionaryService dictionaryService; - //级联表service - - + // 此处可能用于自动注入级联表相关的服务层接口，当前代码中未完整体现具体使用情况 /** - * 后端列表 - */ + * 后端列表 + * 用于获取用户列表数据，并进行分页、字典表数据转换等处理后返回给前端 + * @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 + * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表 + */ @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,"永不会进入"); + // 如果用户角色是"用户"，则添加当前用户ID作为查询条件，用于筛选当前用户相关的数据 else if("用户".equals(role)) params.put("yonghuId",request.getSession().getAttribute("userId")); - params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1); + // 设置默认的逻辑删除开始和结束标识，用于筛选未删除的用户数据（这里假设1表示未删除） + 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); @@ -83,16 +99,24 @@ public class YonghuController { } /** - * 后端详情 - */ + * 后端详情 + * 根据用户ID获取用户的详细信息，进行必要的数据转换后返回给前端 + * @param id 用户的唯一标识（通常是数据库中的主键ID） + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 + * @return R对象，封装了操作结果及相关数据，成功时包含用户详细信息 + */ @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 + // 创建用户视图对象，用于转换和返回给前端展示的数据格式 YonghuView view = new YonghuView(); + // 将用户实体中的数据复制到用户视图对象中，实现数据格式转换 BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 + // 对用户视图对象中的相关字典表字段进行数据转换操作 //修改对应字典表字段 dictionaryService.dictionaryConvert(view, request); @@ -104,15 +128,21 @@ public class YonghuController { } /** - * 后端保存 - */ + * 后端保存 + * 用于保存新用户信息到数据库，会先检查用户名和手机号是否已被使用 + * @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户注册等数据） + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 + * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用等错误信息 + */ @RequestMapping("/save") public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); String role = String.valueOf(request.getSession().getAttribute("role")); + // 此处条件永远为假，实际应该不会进入该分支，可能是预留逻辑待完善 if(false) return R.error(511,"永远不会进入"); + // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件 Wrapper queryWrapper = new EntityWrapper() .eq("username", yonghu.getUsername()) @@ -123,11 +153,15 @@ public class YonghuController { ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户 YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); if(yonghuEntity==null){ yonghu.setYonghuDelete(1); + // 设置用户的逻辑删除标识为未删除（这里假设1表示未删除） yonghu.setCreateTime(new Date()); + // 设置默认密码（实际应用中可能需要更安全的密码处理方式） yonghu.setPassword("123456"); + // 将新用户信息插入到数据库中 yonghuService.insert(yonghu); return R.ok(); }else { @@ -136,8 +170,12 @@ public class YonghuController { } /** - * 后端修改 - */ + * 后端修改 + * 根据传入的用户信息更新数据库中对应的用户数据，会先检查用户名和手机号是否已被其他用户使用（排除自身） + * @param yonghu 包含更新后用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户修改后的数据） + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 + * @return R对象，封装了操作结果，成功表示更新成功，失败则提示账户或者手机号已经被使用等错误信息 + */ @RequestMapping("/update") public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); @@ -157,12 +195,14 @@ public class YonghuController { ; logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询是否已存在符合条件的用户 YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); + // 如果用户的照片字段为空字符串或"null"，则将其设置为null，可能是为了符合数据库存储要求 if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){ yonghu.setYonghuPhoto(null); } if(yonghuEntity==null){ - yonghuService.updateById(yonghu);//根据id更新 + yonghuService.updateById(yonghu);// 根据用户ID更新数据库中的用户信息 return R.ok(); }else { return R.error(511,"账户或者手机号已经被使用"); @@ -170,10 +210,12 @@ public class YonghuController { } - /** - * 删除 - */ + * 删除 + * 批量将指定用户的逻辑删除标识设置为已删除（这里假设2表示已删除），实现软删除功能 + * @param ids 包含要删除的用户ID的整数数组，通过请求体传入 + * @return R对象，封装了操作结果，成功表示删除操作执行成功（实际只是更新了逻辑删除标识） + */ @RequestMapping("/delete") public R delete(@RequestBody Integer[] ids){ logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); @@ -193,34 +235,47 @@ public class YonghuController { /** * 批量上传 + * 从指定的Excel文件（仅支持后缀为.xls的文件）中读取用户数据，进行重复性检查后批量插入到数据库中 + * @param fileName 要上传的Excel文件名，从请求参数中获取 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如当前用户ID等 + * @return R对象，封装了操作结果，成功表示批量插入成功，失败则提示各种错误信息，如文件格式错误、数据重复、插入异常等 */ @RequestMapping("/batchInsert") public R save( String fileName, HttpServletRequest request){ logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + // 从会话中获取当前用户ID，并转换为整数类型 Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { List yonghuList = new ArrayList<>();//上传的东西 + // 用于存储要查询是否重复的字段及对应的值，以字段名为键，值的列表为值 Map> seachFields= new HashMap<>();//要查询的字段 Date date = new Date(); int lastIndexOf = fileName.lastIndexOf("."); + // 如果文件名没有后缀，返回错误信息 if(lastIndexOf == -1){ return R.error(511,"该文件没有后缀"); }else{ String suffix = fileName.substring(lastIndexOf); + // 如果文件后缀不是.xls，返回错误信息，表明只支持该后缀的Excel文件 if(!".xls".equals(suffix)){ return R.error(511,"只支持后缀为xls的excel文件"); }else{ + // 获取指定文件名对应的文件资源路径 URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 File file = new File(resource.getFile()); + // 如果文件不存在，返回错误信息，提示联系管理员 if(!file.exists()){ return R.error(511,"找不到上传文件，请联系管理员"); }else{ + // 使用工具类读取Excel文件中的数据，返回二维列表，每一行表示一条数据 List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 + // 删除第一行数据，通常第一行是标题行等提示信息，不需要插入数据库 dataList.remove(0);//删除第一行，因为第一行是提示 for(List data:dataList){ //循环 YonghuEntity yonghuEntity = new YonghuEntity(); + // 以下是对用户实体各字段的赋值操作，目前都被注释掉了，可能需要根据实际Excel文件中的列顺序和数据内容进行正确赋值 // yonghuEntity.setUsername(data.get(0)); //账户 要改的 // //yonghuEntity.setPassword("123456");//密码 // yonghuEntity.setYonghuName(data.get(0)); //用户姓名 要改的 @@ -234,8 +289,8 @@ public class YonghuController { yonghuList.add(yonghuEntity); - //把要查询是否重复的字段放入map中 - //账户 + // 把要查询是否重复的字段（用户名和手机号）放入seachFields中，用于后续重复性检查 + // 处理用户名字段 if(seachFields.containsKey("username")){ List username = seachFields.get("username"); username.add(data.get(0));//要改的 @@ -244,7 +299,7 @@ public class YonghuController { username.add(data.get(0));//要改的 seachFields.put("username",username); } - //手机号 + // 处理手机号字段 if(seachFields.containsKey("yonghuPhone")){ List yonghuPhone = seachFields.get("yonghuPhone"); yonghuPhone.add(data.get(0));//要改的 @@ -257,93 +312,135 @@ public class YonghuController { //查询是否重复 //账户 + // 根据从Excel文件中读取的数据里的用户名，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同名用户 List yonghuEntities_username = yonghuService.selectList(new EntityWrapper().in("username", seachFields.get("username")).eq("yonghu_delete", 1)); + // 如果查询到的同名用户数量大于0，说明存在重复的用户名 if(yonghuEntities_username.size() >0 ){ ArrayList repeatFields = new ArrayList<>(); + // 遍历查询到的同名用户列表，将他们的用户名添加到repeatFields列表中 for(YonghuEntity s:yonghuEntities_username){ repeatFields.add(s.getUsername()); } + // 返回错误信息，提示数据库中该表的[账户]字段已经存在，并列出重复的用户名数据 return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString()); } - //手机号 + // 根据从Excel文件中读取的数据里的手机号，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同手机号用户 List yonghuEntities_yonghuPhone = yonghuService.selectList(new EntityWrapper().in("yonghu_phone", seachFields.get("yonghuPhone")).eq("yonghu_delete", 1)); + // 如果查询到的同手机号用户数量大于0，说明存在重复的手机号 if(yonghuEntities_yonghuPhone.size() >0 ){ ArrayList repeatFields = new ArrayList<>(); for(YonghuEntity s:yonghuEntities_yonghuPhone){ repeatFields.add(s.getYonghuPhone()); } + // 返回错误信息，提示数据库中该表的[手机号]字段已经存在，并列出重复的手机号数据 return R.error(511,"数据库的该表中的 [手机号] 字段已经存在 存在数据为:"+repeatFields.toString()); } + // 经过上述重复性检查后，如果没有重复数据，则批量将从Excel文件中读取并整理好的用户数据列表插入到数据库中 yonghuService.insertBatch(yonghuList); return R.ok(); } } } }catch (Exception e){ + // 如果在上述批量插入等操作过程中出现异常，打印异常堆栈信息方便排查问题 e.printStackTrace(); + // 返回错误信息，提示批量插入数据出现异常，并建议联系管理员处理 return R.error(511,"批量插入数据异常，请联系管理员"); } } /** - * 登录 - */ - @IgnoreAuth + * 登录 + * 用于处理用户登录逻辑，验证用户名、密码以及账户是否已被删除等情况，登录成功后生成Token并返回相关用户信息 + * @param username 用户名，从请求参数中获取 + * @param password 密码，从请求参数中获取 + * @param captcha 验证码，从请求参数中获取（当前代码中未体现验证码具体验证逻辑） + * @param request HttpServletRequest对象，用于获取当前请求相关的信息 + * @return R对象，封装了操作结果及相关数据，成功时包含用户登录后的Token、角色、用户名、所属表名、用户ID等信息，失败则返回相应错误提示 + */ + @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)) + // 如果查询到的用户为null（即用户名不存在）或者密码不匹配，返回账号或密码不正确的错误信息 + if (yonghu == null ||!yonghu.getPassword().equals(password)) return R.error("账号或密码不正确"); - else if(yonghu.getYonghuDelete() != 1) + // 如果用户的逻辑删除标识不为1（这里假设1表示未删除，即账户已被删除），返回账户已被删除的错误信息 + else if (yonghu.getYonghuDelete()!= 1) return R.error("账户已被删除"); - // // 获取监听器中的字典表 + // 以下几行代码被注释掉了，可能原本是用于获取字典表相关数据进行后续处理的逻辑，目前未生效 + // 获取当前Web应用上下文的ServletContext对象，用于获取应用范围内共享的数据（比如字典表数据等） // ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext(); - // Map> dictionaryMap= (Map>) servletContext.getAttribute("dictionaryMap"); + // 从ServletContext中获取名为"dictionaryMap"的属性，该属性可能是一个嵌套的Map结构，外层键是字典类型，内层键值对是字典代码和对应的名称等信息 + // Map> dictionaryMap = (Map>) servletContext.getAttribute("dictionaryMap"); + // 从字典表数据中获取名为"role_types"的字典类型对应的内层Map，可能是用于获取角色相关的字典信息（如角色代码和角色名称的对应关系等） // Map role_types = dictionaryMap.get("role_types"); - // role_types.get(.getRoleTypes()); - String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户"); + // 根据用户ID、用户名、用户类型等信息生成用户登录的Token（具体生成逻辑在TokenService中实现） + String token = tokenService.generateToken(yonghu.getId(), username, "yonghu", "用户"); R r = R.ok(); + // 将生成的Token放入返回结果对象中 r.put("token", token); - r.put("role","用户"); - r.put("username",yonghu.getYonghuName()); - r.put("tableName","yonghu"); - r.put("userId",yonghu.getId()); + // 将用户角色放入返回结果对象中，这里固定为"用户" + r.put("role", "用户"); + // 将用户的真实姓名（假设YonghuEntity中的YonghuName字段表示真实姓名）放入返回结果对象中 + r.put("username", yonghu.getYonghuName()); + // 将用户所属表名放入返回结果对象中，这里固定为"yonghu" + r.put("tableName", "yonghu"); + // 将用户ID放入返回结果对象中 + r.put("userId", yonghu.getId()); return r; } /** - * 注册 - */ - @IgnoreAuth + * 注册 + * 用于处理用户注册逻辑，先检查用户名和手机号是否已被使用，若未被使用则将新用户信息插入到数据库中 + * @param yonghu 包含用户注册信息的YonghuEntity对象，通过请求体传入（通常是前端提交的注册表单数据等） + * @return R对象，封装了操作结果，成功表示注册成功，失败则提示账户或者手机号已经被使用的错误信息 + */ + @IgnoreAuth // 该注解可能表示此注册接口不需要进行权限认证（具体取决于该注解的实际定义和功能） @PostMapping(value = "/register") - public R register(@RequestBody YonghuEntity yonghu){ -// ValidatorUtils.validateEntity(user); + public R register(@RequestBody YonghuEntity yonghu) { + // 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，目前未生效 + // ValidatorUtils.validateEntity(user); + // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件 Wrapper queryWrapper = new EntityWrapper() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .andNew() - .eq("yonghu_delete", 1) - ; + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .andNew() + .eq("yonghu_delete", 1); + // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户 YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); - if(yonghuEntity != null) + // 如果已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息 + if (yonghuEntity!= null) return R.error("账户或者手机号已经被使用"); + // 设置新用户的初始余额为0.0（可能根据业务需求设定的初始值） yonghu.setNewMoney(0.0); + // 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除） yonghu.setYonghuDelete(1); + // 设置新用户的创建时间为当前时间 yonghu.setCreateTime(new Date()); + // 将新用户信息插入到数据库中 yonghuService.insert(yonghu); return R.ok(); } /** * 重置密码 + * 根据传入的用户ID，将对应的用户密码重置为固定值"123456"（实际应用中可能需要更安全合理的密码重置逻辑） + * @param id 用户的唯一标识（通常是数据库中的主键ID），从请求参数中获取 + * @return R对象，封装了操作结果，成功表示密码重置成功 */ @GetMapping(value = "/resetPassword") - public R resetPassword(Integer id){ + public R resetPassword(Integer id) { YonghuEntity yonghu = new YonghuEntity(); + // 设置要重置的密码为"123456" yonghu.setPassword("123456"); + // 设置要重置密码的用户ID yonghu.setId(id); + // 根据用户ID更新数据库中对应的用户密码信息 yonghuService.updateById(yonghu); return R.ok(); } @@ -351,124 +448,171 @@ public class YonghuController { /** * 忘记密码 + * 用于处理用户忘记密码的情况，根据用户名查找对应的用户，若存在则将其密码重置为固定值“123456”（实际应用中可能需要更安全合理的重置逻辑，比如发送验证码验证等） + * @param username 用户名，从请求参数中获取，用于查找对应的用户 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，但在当前方法中未体现更多相关使用情况 + * @return R对象，封装了操作结果，成功表示密码重置成功，若用户不存在则返回账号不存在的错误信息，若更新数据库操作失败则返回相应错误信息 */ @IgnoreAuth @RequestMapping(value = "/resetPass") public R resetPass(String username, HttpServletRequest request) { + // 根据传入的用户名从数据库中查询对应的用户实体信息 YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper().eq("username", username)); - if(yonghu!=null){ + // 如果查询到对应的用户实体信息不为null，说明该用户存在 + if (yonghu!= null) { + // 将用户的密码设置为固定值“123456”，实际中这样直接设置密码不太安全，可后续优化为更安全的重置逻辑 yonghu.setPassword("123456"); + // 通过用户服务层的方法根据用户实体中的ID（已设置好）更新数据库中该用户的密码信息，并获取更新操作的结果（true表示更新成功，false表示更新失败） boolean b = yonghuService.updateById(yonghu); - if(!b){ - return R.error(); + // 如果更新操作失败（即b为false），返回相应的错误信息 + if (!b) { + return R.error(); } - }else{ - return R.error("账号不存在"); + } else { + // 如果根据用户名未查询到对应的用户，返回账号不存在的错误信息 + return R.error("账号不存在"); } + // 如果密码重置并更新数据库操作都成功，返回操作成功的结果信息 return R.ok(); } /** - * 获取用户的session用户信息 - */ + * 获取用户的session用户信息 + * 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息，经过格式转换（实体转视图）和字典表字段转换后返回给前端展示 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID + * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户视图信息，若查不到数据则返回相应错误信息 + */ @RequestMapping("/session") - public R getCurrYonghu(HttpServletRequest request){ - Integer id = (Integer)request.getSession().getAttribute("userId"); + public R getCurrYonghu(HttpServletRequest request) { + // 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息 + Integer id = (Integer) request.getSession().getAttribute("userId"); + // 根据获取到的用户ID从数据库中查询对应的用户实体信息 YonghuEntity yonghu = yonghuService.selectById(id); - if(yonghu !=null){ - //entity转view + // 如果查询到的用户实体信息不为null，说明找到了对应的用户 + if (yonghu!= null) { + // 创建一个用户视图对象，用于转换和返回适合前端展示的数据格式 YonghuView view = new YonghuView(); - BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 + // 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换 + BeanUtils.copyProperties(yonghu, view); - //修改对应字典表字段 + // 调用字典服务层的方法对用户视图对象中的相关字典表字段进行数据转换操作，使数据格式更符合前端展示需求 dictionaryService.dictionaryConvert(view, request); return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果根据用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义） + return R.error(511, "查不到数据"); } } /** - * 退出 - */ + * 退出 + * 用于处理用户退出登录的操作，通过使当前请求的会话失效来实现清除用户登录状态等相关信息的效果 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象 + * @return R对象，封装了操作结果及相关提示信息，这里返回退出成功的提示 + */ @GetMapping(value = "logout") public R logout(HttpServletRequest request) { + // 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录等相关信息 request.getSession().invalidate(); + // 返回操作成功的结果信息，并附带“退出成功”的提示内容 return R.ok("退出成功"); } - - /** - * 前端列表 - */ + * 前端列表 + * 该方法用于获取用户列表数据并返回给前端展示，支持排序参数传入，若未传入排序字段则默认按照"id"字段倒序排列，同时会对获取到的数据进行字典表数据转换操作。 + * 此接口标注了 @IgnoreAuth 注解，可能意味着该接口不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能）。 + * @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等，通过请求参数传入。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，比如可能用于后续字典表数据转换等操作获取相关上下文信息，但当前代码中未体现更多复杂使用情况。 + * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表（已经过字典表数据转换）。 + */ @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); + 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"); + // 判断传入的参数中排序字段是否为空，如果为空（即没有指定排序字段），则将排序字段设置为"id"，表示默认按照"id"字段进行倒序排序（此处未明确体现倒序逻辑，可能在PageUtils或相关数据库查询逻辑中处理）。 + if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) { + params.put("orderBy", "id"); } + // 调用用户服务层的queryPage方法，传入参数params，用于查询符合条件的分页用户数据，返回的PageUtils对象包含了分页相关信息以及用户数据列表等内容。 PageUtils page = yonghuService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(YonghuView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 + // 获取分页数据中的用户视图列表（可能是用于展示给前端的特定格式数据），这里将PageUtils中的用户数据列表取出并强转类型为List。 + List list = (List) page.getList(); + // 遍历用户视图列表，对每个用户数据进行字典表数据转换操作，调用dictionaryService的dictionaryConvert方法来处理，目的是使展示的数据符合字典表相关的业务格式要求。 + for (YonghuView c : list) + dictionaryService.dictionaryConvert(c, request); + return R.ok().put("data", page); } /** - * 前端详情 - */ + * 前端详情 + * 根据传入的用户ID获取对应的用户详细信息，将用户实体数据转换为适合前端展示的视图数据格式，并进行字典表数据转换后返回给前端。 + * @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量{id}传入，用于指定要查询详细信息的用户。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如在字典表数据转换时可能需要的一些上下文信息等，但当前代码中未体现更多复杂使用情况。 + * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户详细信息，若未查询到对应的数据则返回查不到数据的错误提示。 + */ @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) { + logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。 YonghuEntity yonghu = yonghuService.selectById(id); - if(yonghu !=null){ - + if (yonghu!= null) { - //entity转view - YonghuView view = new YonghuView(); - BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中 + // 创建一个用户视图对象，用于将从数据库查询到的用户实体数据转换为适合前端展示的数据格式。 + YonghuView view = new YonghuView(); + // 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换，比如将实体中的各个属性值对应复制到视图对象的相应属性中。 + BeanUtils.copyProperties(yonghu, 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 { + // 如果根据传入的用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义）。 + return R.error(511, "查不到数据"); + } } /** - * 前端保存 - */ + * 前端保存 + * 用于处理前端提交的新增用户信息的保存操作，会先检查用户名和手机号是否已被其他用户使用（逻辑删除标识为1表示未删除的用户），若未被使用则将新用户信息插入到数据库中。 + * @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入，通常是前端提交的新增用户表单数据等内容。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，当前代码中主要用于日志记录展示请求相关信息，但未体现更多复杂使用情况。 + * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用的错误信息。 + */ @RequestMapping("/add") - public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); + public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { + logger.debug("add方法:,,Controller:{},,yonghu:{}", this.getClass().getName(), yonghu.toString()); + // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件，通过使用EntityWrapper来方便地构建数据库查询条件。 Wrapper queryWrapper = new EntityWrapper() - .eq("username", yonghu.getUsername()) - .or() - .eq("yonghu_phone", yonghu.getYonghuPhone()) - .andNew() - .eq("yonghu_delete", 1) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .eq("username", yonghu.getUsername()) + .or() + .eq("yonghu_phone", yonghu.getYonghuPhone()) + .andNew() + .eq("yonghu_delete", 1); + + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户，调用用户服务层的selectOne方法执行查询操作，返回符合条件的用户实体对象（若存在），否则返回null。 YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); - if(yonghuEntity==null){ + if (yonghuEntity == null) { + // 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除），表示该用户数据为有效可用状态。 yonghu.setYonghuDelete(1); + // 设置新用户的创建时间为当前时间，通过创建一个新的Date对象来表示当前时刻。 yonghu.setCreateTime(new Date()); - yonghu.setPassword("123456"); - yonghuService.insert(yonghu); + // 设置新用户的默认密码为"123456"，实际应用中可能需要更安全的密码设置方式，比如密码加密等操作。 + yonghu.setPassword("123456"); + // 将包含完整信息的新用户实体对象插入到数据库中，调用用户服务层的insert方法执行插入操作。 + yonghuService.insert(yonghu); return R.ok(); - }else { - return R.error(511,"账户或者手机号已经被使用"); + } else { + // 如果查询到已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息，错误码为511（具体含义由业务定义）。 + return R.error(511, "账户或者手机号已经被使用"); } } -- 2.34.1 From 339a2beaaccb051db0a8c48369892d83789b064c Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Fri, 13 Dec 2024 23:02:45 +0800 Subject: [PATCH 3/7] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20y?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/controller/UsersController.java | 291 ++++++++++++------ .../java/com/controller/YonghuController.java | 1 + .../src/main/java/com/dao/UsersDao.java | 27 +- .../src/main/java/com/dao/YonghuDao.java | 21 +- .../src/main/java/com/entity/UsersEntity.java | 82 ++++- .../main/java/com/entity/YonghuEntity.java | 282 +++++++++-------- .../java/com/entity/model/YonghuModel.java | 202 +++++++----- .../main/java/com/entity/view/YonghuView.java | 81 ++--- .../main/java/com/service/UsersService.java | 40 ++- .../main/java/com/service/YonghuService.java | 4 + 10 files changed, 689 insertions(+), 342 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java b/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java index 2b154470..85ab4fdf 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java @@ -27,142 +27,233 @@ import com.utils.R; /** * 登录相关 + * 该类主要处理与用户登录、注册以及退出相关的操作，通过调用对应的服务层接口来实现具体业务逻辑，并与前端进行交互返回相应结果。 + * 类上使用了 @RequestMapping("users") 注解来指定该控制器处理的基础请求路径为 "/users"，使用 @RestController 注解表明这是一个 RESTful 风格的控制器，返回的数据会直接转换为 JSON 等格式响应给前端。 */ + @RequestMapping("users") @RestController public class UsersController { - + + // 自动注入用户服务层接口，通过该接口可以调用与用户相关的业务方法，比如查询用户、插入用户等数据库操作相关的方法，具体实现由对应的服务层类来完成。 @Autowired private UsersService usersService; - + + // 自动注入Token服务层接口，用于处理与用户Token相关的业务逻辑，例如生成用户登录后的Token等操作，具体功能在TokenService类中实现。 @Autowired private TokenService tokenService; /** * 登录 + * 处理用户登录的业务逻辑，接收用户名、密码和验证码（当前代码中验证码未做完整验证逻辑）作为参数，验证用户信息是否正确，若正确则生成Token并返回相关用户信息给前端。 + * 该方法使用了 @IgnoreAuth 注解，意味着此登录接口可能不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），使用 @PostMapping 注解指定该接口处理的是POST请求，请求路径为 "/login"，即完整路径为 "/users/login"。 + * @param username 用户名，从前端请求中传入，用于查找对应的用户信息。 + * @param password 密码，从前端请求中传入，用于和数据库中存储的用户密码进行比对验证。 + * @param captcha 验证码，从前端请求中传入，当前代码未对其进行完整的验证逻辑处理（比如与缓存中的验证码比对等操作）。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，不过在当前登录方法中未体现更多复杂的使用情况。 + * @return R对象，封装了操作结果及相关数据，若登录成功则包含生成的Token、用户角色、用户ID等信息，若登录失败则返回账号或密码不正确的错误信息。 */ + @IgnoreAuth @PostMapping(value = "/login") public R login(String username, String password, String captcha, HttpServletRequest request) { + + // 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件，根据传入的用户名从数据库中查询对应的用户实体信息。 + // 这里的查询条件是查找用户名与传入的username相等的用户记录，返回符合条件的UsersEntity对象（若存在），若不存在则返回null。 UsersEntity user = usersService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null || !user.getPassword().equals(password)) { + // 如果查询到的用户为null（即用户名不存在）或者密码不匹配（通过调用user对象的getPassword方法获取存储的密码并与传入的password比对），则返回账号或密码不正确的错误信息给前端。 + if (user == null ||!user.getPassword().equals(password)) { return R.error("账号或密码不正确"); } - String token = tokenService.generateToken(user.getId(),username, "users", user.getRole()); + // 如果用户信息验证通过，调用Token服务层的generateToken方法，根据用户的ID、用户名、用户类型（这里固定为"users"）以及用户的角色信息生成一个用于标识用户登录状态的Token字符串。 + String token = tokenService.generateToken(user.getId(), username, "users", user.getRole()); R r = R.ok(); + // 将生成的Token放入返回结果对象R中，以便前端接收并后续用于验证用户登录状态等操作。 r.put("token", token); - r.put("role",user.getRole()); - r.put("userId",user.getId()); + // 将用户的角色信息放入返回结果对象R中，方便前端知晓当前登录用户的角色权限等情况。 + r.put("role", user.getRole()); + // 将用户的ID信息放入返回结果对象R中，前端可能会根据此ID进行一些与用户相关的后续操作。 + r.put("userId", user.getId()); return r; } - + /** * 注册 + * 处理用户注册的业务逻辑，接收包含用户信息的UsersEntity对象作为参数，先检查用户名是否已被使用，若未被使用则将新用户信息插入到数据库中。 + * 该方法同样使用了 @IgnoreAuth 注解，可能表示此注册接口不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），使用 @PostMapping 注解指定该接口处理的是POST请求，请求路径为 "/register"，即完整路径为 "/users/register"。 + * @param user 包含用户注册信息的UsersEntity对象，通过请求体传入，通常是前端提交的注册表单数据等内容，包含了用户名、密码等各种用户相关信息。 + * @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); + // 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件，根据传入的用户实体中的用户名去数据库中查询是否已存在相同用户名的用户记录，若存在则返回对应的UsersEntity对象，若不存在则返回null。 + if (usersService.selectOne(new EntityWrapper().eq("username", user.getUsername()))!= null) { + return R.error("用户已存在"); + } + // 如果用户名未被使用，调用用户服务层的insert方法将包含新用户信息的user对象插入到数据库中，完成用户注册操作。 + usersService.insert(user); + return R.ok(); + } /** * 退出 + * 处理用户退出登录的业务逻辑，通过使当前请求的会话（Session）失效来清除用户登录状态等相关信息，返回退出成功的提示信息给前端。 + * 使用 @GetMapping 注解指定该接口处理的是GET请求，请求路径为 "/logout"，即完整路径为 "/users/logout"。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象来实现会话失效操作。 + * @return R对象，封装了操作结果及相关提示信息，这里返回包含"退出成功"提示内容的成功信息给前端，表示用户已成功退出登录。 */ + @GetMapping(value = "logout") public R logout(HttpServletRequest request) { + // 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录凭证、用户相关属性等信息，达到退出登录的效果。 request.getSession().invalidate(); return R.ok("退出成功"); } - - /** - * 密码重置 - */ - @IgnoreAuth +} + +/** + * 密码重置 + * 用于处理用户忘记密码后重置密码的业务逻辑，根据传入的用户名查找对应的用户，若用户存在则将其密码重置为固定值“123456”，并返回相应提示信息。 + * 该方法使用了 @IgnoreAuth 注解，意味着此接口可能不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），通过 @RequestMapping 注解指定其处理的请求路径为 "/resetPass"，完整路径为 "/users/resetPass"（结合类上的@RequestMapping("users") 注解）。 + * @param username 用户名，从前端请求中传入，用于查找对应的用户，以便后续重置密码操作。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，不过在当前方法中未体现更多复杂使用情况。 + * @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"); - } - - /** - * 列表 - */ - @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); - } + public R resetPass(String username, HttpServletRequest request) { + // 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件（查找用户名与传入的username相等的用户记录），从数据库中查询对应的用户实体信息。 + UsersEntity user = usersService.selectOne(new EntityWrapper().eq("username", username)); + // 如果查询到的用户为null，即用户名对应的用户不存在，返回账号不存在的错误信息给前端。 + if (user == null) { + return R.error("账号不存在"); + } + // 如果用户存在，将用户的密码设置为固定值“123456”，实际应用中这样直接设置密码不太安全，可后续优化为更安全合理的密码重置逻辑，比如通过发送验证码验证等方式。 + user.setPassword("123456"); + // 调用用户服务层的update方法，传入更新后的user对象以及null（可能表示不需要其他额外的更新条件，具体取决于update方法的参数定义），将用户的密码更新到数据库中。 + usersService.update(user, null); + // 返回操作成功的结果信息，并附带密码已重置为“123456”的提示内容，告知前端密码重置操作已完成。 + return R.ok("密码已重置为：123456"); +} - /** - * 列表 - */ - @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(); - } +/** + * 列表（分页查询） + * 用于获取用户列表数据，并进行分页以及根据传入的用户对象构建查询条件等相关处理后返回给前端，返回结果包含分页相关信息以及符合条件的用户数据列表。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/page"，完整路径为 "/users/page"。 + * @param params 包含查询参数的Map，例如分页参数（如每页条数、当前页码等）、筛选条件等，通过请求参数传入，用于构建数据库查询条件以及分页相关设置。 + * @param user 包含用户相关信息的UsersEntity对象，可能用于进一步构建查询条件，比如根据用户对象中的某些属性来筛选特定用户数据等，具体取决于业务逻辑和相关工具类（如MPUtil）的使用方式。 + * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表信息（通过PageUtils对象承载）。 + */ +@RequestMapping("/page") +public R page(@RequestParam Map params, UsersEntity user) { + // 创建一个EntityWrapper对象，用于构建数据库查询条件，它可以方便地拼接各种查询条件语句，例如等于、大于、小于等条件，初始时为空，后续会根据业务逻辑添加相应条件。 + EntityWrapper ew = new EntityWrapper(); + // 调用用户服务层的queryPage方法进行分页查询，传入params参数用于分页相关设置以及通过MPUtil相关工具方法构建的查询条件。 + // MPUtil.sort方法可能用于对查询结果进行排序设置，MPUtil.between方法可能用于构建范围查询条件，MPUtil.allLike方法可能用于构建模糊查询条件等，具体功能取决于MPUtil工具类的实现。 + PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); + return R.ok().put("data", page); +} + +/** + * 列表（另一种查询方式） + * 根据传入的用户对象构建查询条件，从数据库中查询符合条件的用户数据列表并返回给前端，返回结果包含查询到的用户数据列表信息。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/list"，完整路径为 "/users/list"。 + * @param user 包含用户相关信息的UsersEntity对象，用于构建查询条件，通过MPUtil工具类的allEq方法将用户对象中的属性转换为相等查询条件，以便从数据库中筛选出符合条件的用户数据。 + * @return R对象，封装了操作结果及相关数据，成功时包含查询到的用户数据列表（通过调用usersService.selectListView方法查询得到）。 + */ + @RequestMapping("/list") + public R list(UsersEntity user) { + // 创建一个EntityWrapper对象，用于构建数据库查询条件，方便后续添加具体的查询条件语句。 + EntityWrapper ew = new EntityWrapper(); + // 使用MPUtil工具类的allEq方法，将用户对象中的属性按照指定前缀（这里是"user"）转换为相等查询条件，添加到EntityWrapper对象中，用于构建查询符合该用户对象属性值的所有用户记录的条件语句。 + ew.allEq(MPUtil.allEQMapPre(user, "user")); + return R.ok().put("data", usersService.selectListView(ew)); +} + +/** + * 信息 + * 根据传入的用户ID，从数据库中查询对应的用户详细信息并返回给前端，若查询到则将用户信息封装在R对象中返回，若未查询到则返回相应错误信息（当前代码未做错误处理，实际可能需要完善）。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/info/{id}"，完整路径为 "/users/info/{id}"，其中{id}是路径变量，用于接收要查询信息的用户的唯一标识（通常是数据库中的主键ID）。 + * @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量传入，用于指定要查询详细信息的用户。 + * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。 + */ + @RequestMapping("/info/{id}") + public R info(@PathVariable("id") String id) { + // 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。 + UsersEntity user = usersService.selectById(id); + return R.ok().put("data", user); +} + +/** + * 获取用户的session用户信息 + * 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息并返回给前端，若获取到用户ID则进行查询并返回用户信息，若未获取到用户ID（比如会话中不存在该属性等情况）则可能返回相应错误信息（当前代码未做完善处理）。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/session"，完整路径为 "/users/session"。 + * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID属性值，用于后续查询用户信息操作。 + * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。 + */ + @RequestMapping("/session") + public R getCurrUser(HttpServletRequest request) { + // 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息。 + Integer id = (Integer) request.getSession().getAttribute("userId"); + // 通过用户服务层的selectById方法，根据获取到的用户ID从数据库中查询对应的用户实体信息。 + UsersEntity user = usersService.selectById(id); + return R.ok().put("data", user); +} + +/** + * 保存 + * 处理新增用户信息的保存操作，先检查用户名是否已被使用，若未被使用则将新用户信息插入到数据库中，同时设置默认密码为“123456”（实际应用中密码设置可优化），并返回相应操作结果给前端。 + * 通过 @PostMapping 注解指定该方法处理的是POST请求，请求路径为 "/save"，完整路径为 "/users/save"，表示用于接收前端提交的新增用户信息并进行保存操作。 + * @param user 包含用户信息的UsersEntity对象，通过请求体传入，通常是前端提交的新增用户表单数据等内容，包含了用户名、密码等各种用户相关信息。 + * @return R对象，封装了操作结果，若用户名已存在则返回用户已存在的错误信息，若保存成功则返回成功信息。 + */ + @PostMapping("/save") + public R save(@RequestBody UsersEntity user) { + // 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证用户名、密码是否符合格式要求等，目前未生效。 + // ValidatorUtils.validateEntity(user); + // 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件（查找用户名与传入的user.getUsername()相等的用户记录），从数据库中查询是否已存在相同用户名的用户，若存在则返回对应的UsersEntity对象，若不存在则返回null。 + if (usersService.selectOne(new EntityWrapper().eq("username", user.getUsername()))!= null) { + return R.error("用户已存在"); + } + // 设置新用户的密码为固定值“123456”，实际应用中这样直接设置密码不太安全，可后续优化为更安全合理的密码设置方式，比如进行密码加密等操作。 + user.setPassword("123456"); + // 调用用户服务层的insert方法将包含新用户信息的user对象插入到数据库中，完成用户新增保存操作。 + usersService.insert(user); + return R.ok(); +} + +/** + * 修改 + * 处理用户信息修改的业务逻辑，接收包含更新后用户信息的UsersEntity对象，将其全部更新到数据库中对应的用户记录（具体更新方式取决于updateById方法的实现，可能是根据ID进行匹配更新等），并返回操作成功的结果给前端。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/update"，完整路径为 "/users/update"，表示用于接收前端提交的更新后的用户信息并进行数据库更新操作。 + * @param user 包含更新后用户信息的UsersEntity对象，通过请求体传入，通常是前端提交的修改后的用户表单数据等内容，包含了需要更新的各种用户相关信息。 + * @return R对象，封装了操作结果，成功则返回操作成功的信息，表示用户信息已更新到数据库中。 + */ + @RequestMapping("/update") + public R update(@RequestBody UsersEntity user) { + // 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证更新后的用户信息是否符合格式要求等，目前未生效。 + // ValidatorUtils.validateEntity(user); + // 调用用户服务层的updateById方法，根据传入的user对象中的ID（通常是数据库中的主键ID）找到对应的用户记录，并将user对象中的所有属性值更新到数据库中对应的字段上，完成用户信息更新操作。 + usersService.updateById(user); + return R.ok(); +} + +/** + * 删除 + * 处理批量删除用户的业务逻辑，接收包含要删除的用户ID的数组，调用用户服务层的方法批量删除数据库中对应的用户记录，并返回操作成功的结果给前端。 + * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/delete"，完整路径为 "/users/delete"，表示用于接收前端提交的要删除的用户ID列表并进行批量删除操作。 + * @param ids 包含要删除的用户ID的Long类型数组，通过请求体传入，用于指定要删除的多个用户记录在数据库中的唯一标识。 + * @return R对象，封装了操作结果，成功则返回操作成功的信息，表示批量删除操作已完成。 + */ + @RequestMapping("/delete") + public R delete(@RequestBody Long[] ids) { + // 调用用户服务层的deleteBatchIds方法，传入要删除的用户ID列表（通过Arrays.asList方法将数组转换为List集合形式，具体取决于deleteBatchIds方法的参数要求），执行批量删除数据库中对应用户记录的操作。 + usersService.deleteBatchIds(Arrays.asList(ids)); + return R.ok(); +} } diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index b5cf9755..c95ce630 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -78,6 +78,7 @@ public class YonghuController { // 如果用户角色是"用户"，则添加当前用户ID作为查询条件，用于筛选当前用户相关的数据 else if("用户".equals(role)) params.put("yonghuId",request.getSession().getAttribute("userId")); + params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1); // 设置默认的逻辑删除开始和结束标识，用于筛选未删除的用户数据（这里假设1表示未删除） params.put("yonghuDeleteStart",1); params.put("yonghuDeleteEnd",1); diff --git a/minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java b/minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java index a6336bc1..e2922981 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java @@ -12,11 +12,34 @@ import com.entity.UsersEntity; /** * 用户 + * 这是一个接口定义，用于定义与用户数据访问相关的方法，该接口继承自BaseMapper， + * 意味着它会继承BaseMapper中提供的一些基础的数据库操作方法（例如根据ID查询、插入、更新、删除等操作方法）， + * 同时在此基础上又自定义了一些针对用户数据查询的特定方法，方便在具体的数据访问层实现类中去实现这些方法逻辑， + * 以满足业务中对用户数据不同查询需求的操作。 */ public interface UsersDao extends BaseMapper { - + + /** + * 选择列表视图（简单查询版本） + * 定义了一个用于查询用户数据列表的方法，该方法接收一个Wrapper类型的参数， + * 这个Wrapper通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等），通过它可以灵活地定义查询用户数据的具体逻辑， + * 返回的是一个UsersEntity类型的列表，即符合查询条件的用户数据集合。 + * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件， + * 以此来精确地控制从数据库中获取哪些用户的数据。 + * @return 符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。 + */ List selectListView(@Param("ew") Wrapper wrapper); + /** + * 选择列表视图（带分页查询版本） + * 定义了另一个用于查询用户数据列表的方法，此方法在简单查询版本的基础上增加了分页功能， + * 它接收一个Pagination类型的分页参数对象和一个用于构建查询条件的Wrapper类型的参数， + * 通过分页参数可以指定每页显示的数据条数、当前页码等信息，结合查询条件包装器一起实现带分页功能的用户数据查询操作， + * 返回的同样是一个UsersEntity类型的列表，即当前页符合查询条件的用户数据集合。 + * @param page 用于设置分页相关参数的对象，比如可以指定每页的数据量、当前是第几页等，以便从数据库中获取对应分页的数据。 + * @param wrapper 用于构建查询条件的包装器对象，和上面的方法类似，用于精确控制查询哪些用户的数据，只是这里配合分页参数共同作用。 + * @return 当前页中符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。 + */ List selectListView(Pagination page, @Param("ew") Wrapper wrapper); - + } diff --git a/minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java b/minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java index eddd8751..4de0c9fe 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java @@ -11,11 +11,28 @@ import com.entity.view.YonghuView; /** * 用户 Dao 接口 + * 此接口用于定义针对用户数据进行持久化操作（通常是与数据库交互）相关的方法声明，它继承自BaseMapper， + * 也就继承了BaseMapper中提供的如按主键查询、插入、更新、删除等基础数据库操作方法，在此基础上又自定义了特定的查询方法， + * 以满足业务中对用户数据更复杂查询需求，方便后续通过对应的实现类来具体实现这些方法逻辑，从而与数据库进行交互获取相应数据。 * - * @author + * @author + * 这里标注了作者信息（具体作者名未填写完整），通常用于代码的归属及溯源等情况。 */ public interface YonghuDao extends BaseMapper { - List selectListView(Pagination page,@Param("params")Map params); + /** + * 选择列表视图 + * 该方法用于从数据库中查询用户数据列表，并且支持分页功能，它接收一个Pagination类型的分页参数对象以及一个Map类型的参数对象， + * 分页参数用于控制每页显示的数据量、当前页码等分页相关信息，而params参数则可以用于传递各种灵活的查询条件（例如筛选条件、排序条件等）， + * 返回的是一个YonghuView类型的列表，YonghuView可能是专门用于展示给前端或者在业务逻辑中使用的用户数据视图对象， + * 即符合传入的分页及其他查询条件的用户数据集合（以视图对象形式呈现）。 + * + * @param page 用于指定分页相关设置的对象，比如每页的记录条数、当前所在页码等信息，通过这个参数来实现分页查询功能， + * 使得可以按照指定的分页规则从数据库中获取相应的数据。 + * @param params 用于传递各种查询条件的Map对象，键值对形式，其中键可以是自定义的表示不同查询条件的字符串（如"nameLike"表示按用户名模糊查询等）， + * 值则是对应条件的具体内容（如模糊查询的关键字等），以此可以灵活构建出多样化的查询逻辑，从数据库中获取想要的用户数据子集。 + * @return 符合传入的分页条件以及其他查询条件的用户视图对象列表，每个YonghuView对象代表一条符合要求的用户数据记录，方便后续在业务中展示或处理。 + */ + List selectListView(Pagination page, @Param("params") Map params); } diff --git a/minsu/minsuguanliw/src/main/java/com/entity/UsersEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/UsersEntity.java index 99617d9e..17827682 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/UsersEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/UsersEntity.java @@ -10,68 +10,140 @@ import com.baomidou.mybatisplus.enums.IdType; /** * 用户 */ +// 通过 @TableName 注解指定该实体类对应的数据库表名为 "users"，表明这个实体类与数据库中名为 "users" 的表存在映射关系， +// 在使用一些持久化框架（如 MyBatis-Plus 等）时，框架会依据这个映射关系进行数据库操作，例如将该实体类的对象持久化到对应表中，或者从表中查询数据填充到该类的对象里。 @TableName("users") +// 定义一个名为 UsersEntity 的类，实现了 Serializable 接口，意味着该类的对象可以被序列化和反序列化， +// 常用于在网络传输、对象持久化存储等场景中保证对象状态的保存和恢复，方便数据的传递与存储操作。 public class UsersEntity implements Serializable { private static final long serialVersionUID = 1L; - + + // 通过 @TableId 注解指定了主键的生成策略为自动增长（IdType.AUTO），即数据库会自动为该字段分配唯一的整数值， + // 这里的主键字段用于唯一标识数据库表中的每一条用户记录，方便后续对特定用户数据进行精准的查询、更新、删除等操作。 @TableId(type = IdType.AUTO) private Integer id; - + /** * 用户账号 + * 用于存储用户登录系统所使用的账号信息，是用户登录时的重要标识，在用户注册、登录以及相关业务逻辑中会频繁涉及对该字段的操作， + // 通常具有唯一性，以区分不同的用户个体。 */ private String username; - + /** * 密码 + * 存储用户登录系统时需要提供的密码内容，由于密码涉及用户隐私安全，在实际应用中通常需要对其进行加密存储等额外的安全处理， + // 而不只是简单的文本存储，在用户登录验证、修改密码等业务场景中会重点使用该字段。 */ private String password; - + /** * 用户类型 + * 用于区分不同角色或者权限的用户，例如可以是 "普通用户"、"管理员" 等不同的取值（具体由业务定义）， + // 系统可以根据该字段来判断用户具备哪些操作权限，进而控制用户对不同功能模块的访问，在权限管理相关的业务逻辑中起到关键作用。 */ private String role; - + + // 用于记录用户相关数据添加到系统中的时间，比如在统计用户增长趋势、查询某个时间段内新增的用户等业务场景下会用到该时间信息， + // 具体的时间格式和处理方式可能会根据业务需求以及相关的时间格式化注解来确定（当前代码中未展示相关格式化处理，但实际应用中可能会有）。 private Date addtime; + /** + * 获取用户账号的方法（getter 方法） + * 按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 UsersEntity 对象的用户账号信息时调用，返回存储的用户账号字符串值。 + * @return 返回存储的用户账号字符串。 + */ public String getUsername() { return username; } + /** + * 设置用户账号的方法（setter 方法） + * 按照 Java 的 JavaBean 规范定义，用于在创建或修改用户对象时为用户账号字段赋值，比如用户注册或者修改账号时会用到， + * 传入要设置的用户账号字符串值，用于更新用户对象的用户账号字段内容。 + * @param username 要设置的用户账号字符串值。 + */ public void setUsername(String username) { this.username = username; } + /** + * 获取密码的方法（getter 方法） + * 用于获取用户密码字段值的公共访问方法，不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值， + // 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。 + * @return 返回存储的用户密码字符串值。 + */ public String getPassword() { return password; } + /** + * 设置密码的方法（setter 方法） + * 用于在用户注册、修改密码等业务场景下为密码字段赋值，同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作， + // 传入要设置的用户密码字符串值，用于更新用户对象的密码字段内容。 + * @param password 要设置的用户密码字符串值。 + */ public void setPassword(String password) { this.password = password; } + /** + * 获取用户类型的方法（getter 方法） + * 方便其他类在需要了解该 UsersEntity 对象所代表用户的类型信息时调用，返回存储的用户类型字符串值，其具体取值由业务中对用户类型的定义决定。 + * @return 返回存储的用户类型字符串值。 + */ public String getRole() { return role; } + /** + * 设置用户类型的方法（setter 方法） + * 用于在创建或修改用户对象时设置用户的类型信息，比如在系统后台为用户分配角色、修改用户权限等场景下会调用该方法， + // 传入要设置的用户类型字符串值，用于更新用户对象的用户类型字段内容。 + * @param role 要设置的用户类型字符串值。 + */ public void setRole(String role) { this.role = role; } + /** + * 获取添加时间的方法（getter 方法） + * 用于获取用户数据添加到系统中的时间信息，在需要查看用户创建时间或者基于时间进行相关统计、查询等业务操作时会调用该方法， + // 返回存储的 Date 类型的添加时间对象。 + * @return 返回存储的 Date 类型的添加时间对象。 + */ public Date getAddtime() { return addtime; } + /** + * 设置添加时间的方法（setter 方法） + * 用于在创建用户对象或者更新用户相关时间信息时为添加时间字段赋值，传入要设置的 Date 类型的添加时间值，用于更新用户对象的添加时间字段内容， + // 比如在数据从其他数据源导入到系统中时，需要准确设置该时间信息等场景下会用到。 + * @param addtime 要设置的 Date 类型的添加时间值。 + */ public void setAddtime(Date addtime) { this.addtime = addtime; } + /** + * 获取主键的方法（getter 方法） + * 按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 UsersEntity 对象的主键值（即唯一标识）时调用，返回存储的主键整数值。 + * @return 返回存储的主键整数值。 + */ public Integer getId() { return id; } + /** + * 设置主键的方法（setter 方法） + * 用于在创建或修改用户对象时为其主键字段赋值，通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法， + // 传入要设置的主键整数值，用于更新用户对象的主键字段内容。 + * @param id 要设置的主键整数值。 + */ public void setId(Integer id) { this.id = id; } +} } diff --git a/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java index 70b7b5d5..800fff66 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java @@ -26,274 +26,314 @@ import com.baomidou.mybatisplus.enums.IdType; * @author * @email */ +// 通过 @TableName 注解指定该实体类对应的数据库表名为 "yonghu"，表明这个实体类与数据库中名为 "yonghu" 的表存在映射关系， +// 在使用一些持久化框架（如 MyBatis-Plus 等）时，框架会依据这个映射关系进行数据库操作，例如将该实体类的对象持久化到对应表中，或者从表中查询数据填充到该类的对象里。 @TableName("yonghu") +// 定义一个名为 YonghuEntity 的泛型类，实现了 Serializable 接口，意味着该类的对象可以被序列化和反序列化， +// 常用于在网络传输、对象持久化存储等场景中保证对象状态的保存和恢复，方便数据的传递与存储操作。 public class YonghuEntity implements Serializable { private static final long serialVersionUID = 1L; + // 默认构造函数，用于创建一个空的 YonghuEntity 对象实例，在某些初始化场景（如通过反射创建对象等情况）下会被调用， + // 此时对象的各个属性会被赋予默认的初始值（例如基本数据类型会有对应的默认值，引用类型为 null 等）。 + public YonghuEntity() { - public YonghuEntity() { - - } - - public YonghuEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 带参数的构造函数，接受一个泛型参数 T，尝试使用 BeanUtils.copyProperties 方法（通常来自 Spring 等相关框架提供的工具类） + // 将传入的参数对象 t 的属性值复制到当前的 YonghuEntity 对象中，实现基于已有对象来初始化当前对象的功能。 + // 如果在属性复制过程中出现异常（比如属性没有对应的访问权限或者复制方法调用出现问题等），会打印异常堆栈信息方便排查问题， + // 不过当前只是简单打印，实际应用中可根据需求完善异常处理逻辑。 + public YonghuEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } /** * 主键 + * 用于唯一标识数据库表中的每一条用户记录，通过 @TableId 注解指定了主键的生成策略为自动增长（IdType.AUTO）， + * 即数据库会自动为该字段分配唯一的整数值，同时通过 @TableField 注解明确了该字段在数据库表中对应的列名为 "id"， + * 这样持久化框架就能准确地将实体类中的这个属性与数据库表中的相应列进行映射关联。 */ @TableId(type = IdType.AUTO) @TableField(value = "id") - private Integer id; - /** * 账户 + * 用于存储用户登录系统所使用的账户信息，通过 @TableField 注解指定该属性对应数据库表中的 "username" 列， + // 保证了实体类与数据库表之间在该字段上的映射关系，方便数据的读写操作，在用户登录、注册等业务场景中会频繁涉及对该字段的操作。 */ @TableField(value = "username") - private String username; - /** * 密码 + * 存储用户登录系统时需要提供的密码内容，通过 @TableField 注解与数据库表中的 "password" 列建立映射关系， + // 由于密码涉及用户隐私安全，在实际应用中通常需要对其进行加密存储等额外的安全处理，而不只是简单的文本存储。 */ @TableField(value = "password") - private String password; - /** * 用户姓名 + * 用于记录用户的真实姓名，通过 @TableField 注解对应数据库表中的 "yonghu_name" 列， + // 方便在系统中展示用户的个人信息，比如在用户资料页面、用户列表展示等地方呈现给用户或者管理员查看。 */ @TableField(value = "yonghu_name") - private String yonghuName; - /** * 头像 + * 存放用户头像相关的信息，可能是头像文件的存储路径或者头像的标识等内容（具体取决于系统的实现方式）， + // 通过 @TableField 注解与数据库表中的 "yonghu_photo" 列关联，以便在需要展示用户头像的界面或者相关业务逻辑中进行数据操作。 */ @TableField(value = "yonghu_photo") - private String yonghuPhoto; - /** * 手机号 + * 存储用户的手机号码，通过 @TableField 注解与数据库表中的 "yonghu_phone" 列对应， + // 在诸多业务场景中都有重要作用，例如身份验证、短信通知、找回密码等操作时作为与用户联系的关键方式。 */ @TableField(value = "yonghu_phone") - private String yonghuPhone; - /** * 电子邮箱 + * 保存用户的电子邮箱地址，通过 @TableField 注解与数据库表中的 "yonghu_email" 列相映射， + // 同样可用于系统与用户之间的沟通交流，像发送重要通知、密码重置链接等业务场景都会用到该字段存储的邮箱信息。 */ @TableField(value = "yonghu_email") - private String yonghuEmail; - /** * 性别 + * 用于记录用户的性别信息，可能取值为特定的代码（如 0 表示男，1 表示女等，具体由业务定义）， + // 通过 @TableField 注解与数据库表中的 "sex_types" 列关联，便于系统根据性别进行相关的统计、展示或者业务逻辑处理。 */ @TableField(value = "sex_types") - private Integer sexTypes; - /** * 余额 + * 存储用户在系统中的账户余额数据，在涉及支付、消费、充值等业务功能的系统中，该字段记录着用户当前可支配的金额数量， + // 通过 @TableField 注解与数据库表中的 "new_money" 列建立映射关系，以保证余额数据在实体类与数据库之间的正确读写。 */ @TableField(value = "new_money") - private Double newMoney; - /** * 假删 + * 这是一个用于实现软删除功能的字段，通过设置不同的值来表示用户数据是否被删除，例如可以设定某个特定值（如 1 表示未删除，0 表示已删除等，具体由业务规则确定）， + // 借助 @TableField 注解与数据库表中的 "yonghu_delete" 列相对应，相比于直接从数据库中物理删除数据，软删除便于数据的恢复以及相关业务逻辑的处理，同时可以保留数据的历史记录等信息。 */ @TableField(value = "yonghu_delete") - private Integer yonghuDelete; - /** * 创建时间 + * 用于记录用户数据在系统中被创建的具体时间点，通过 @JsonFormat 注解可以指定该时间在序列化（比如转换为 JSON 格式返回给前端时）的格式， + // @DateTimeFormat 注解则可能用于在接收前端传入的时间格式数据时进行格式化处理，以便正确地将数据绑定到该字段上， + // 并且通过 @TableField 注解与数据库表中的 "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) - + @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 方法），按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 YonghuEntity 对象的主键值时调用， + * 返回存储的主键整数值，即用户记录的唯一标识。 + * @return 返回存储的主键整数值。 + */ public Integer getId() { return id; } - /** - * 获取：主键 - */ + /** + * 设置：主键 + * 这是一个用于设置主键字段值的公共设置方法（setter 方法），按照 Java 的 JavaBean 规范定义，用于在创建或修改用户对象时为其主键字段赋值， + * 通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法。 + * @param id 要设置的主键整数值，用于更新用户对象的主键字段内容。 + */ public void setId(Integer id) { this.id = id; } + /** - * 设置：账户 - */ + * 获取：账户 + * 用于获取用户账户字段值的公共访问方法（getter 方法），方便其他类获取该 YonghuEntity 对象的账户信息，返回存储的用户账户字符串值，即用户登录所使用的账户名。 + * @return 返回存储的用户账户字符串值。 + */ public String getUsername() { return username; } - /** - * 获取：账户 - */ + /** + * 设置：账户 + * 用于设置用户账户字段值的公共设置方法（setter 方法），在创建或修改用户对象时可通过该方法为账户字段赋值，比如用户注册或者修改账户名时会用到， + * 传入要设置的用户账户字符串值，用于更新用户对象的账户字段内容。 + * @param username 要设置的用户账户字符串值。 + */ public void setUsername(String username) { this.username = username; } + /** - * 设置：密码 - */ + * 获取：密码 + * 用于获取用户密码字段值的公共访问方法（getter 方法），不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值， + * 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。 + * @return 返回存储的用户密码字符串值。 + */ public String getPassword() { return password; } - /** - * 获取：密码 - */ + /** + * 设置：密码 + * 用于设置用户密码字段值的公共设置方法（setter 方法），在用户注册、修改密码等业务场景下会调用该方法为密码字段赋值， + * 同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作，传入要设置的用户密码字符串值，用于更新用户对象的密码字段内容。 + * @param password 要设置的用户密码字符串值。 + */ public void setPassword(String password) { this.password = password; } + /** - * 设置：用户姓名 - */ + * 获取：用户姓名 + * 用于获取用户姓名字段值的公共访问方法（getter 方法），方便在需要展示用户姓名的地方调用该方法获取相应信息，返回存储的用户姓名字符串值，即用户的真实姓名内容。 + * @return 返回存储的用户姓名字符串值。 + */ public String getYonghuName() { return yonghuName; } - /** - * 获取：用户姓名 - */ + /** + * 设置：用户姓名 + * 用于设置用户姓名字段值的公共设置方法（setter 方法），例如在用户完善个人资料、修改姓名等场景下会使用该方法更新用户对象的姓名字段内容， + * 传入要设置的用户姓名字符串值，用于更新用户对象的姓名字段内容。 + * @param yonghuName 要设置的用户姓名字符串值。 + */ public void setYonghuName(String yonghuName) { this.yonghuName = yonghuName; } + /** - * 设置：头像 - */ + * 获取：头像 + * 用于获取用户头像字段值的公共访问方法（getter 方法），在需要展示用户头像的界面或者相关业务逻辑中，可通过该方法获取头像相关信息， + * 返回存储的用户头像字符串值，可能是头像文件的路径或者头像的标识等内容（具体取决于系统实现）。 + * @return 返回存储的用户头像字符串值。 + */ public String getYonghuPhoto() { return yonghuPhoto; } - /** - * 获取：头像 - */ + /** + * 设置：头像 + * 用于设置用户头像字段值的公共设置方法（setter 方法），比如用户上传新头像、修改头像等业务场景下会调用该方法更新用户对象的头像字段内容， + * 传入要设置的用户头像字符串值，用于更新用户对象的头像字段内容。 + * @param yonghuPhoto 要设置的用户头像字符串值。 + */ public void setYonghuPhoto(String yonghuPhoto) { this.yonghuPhoto = yonghuPhoto; } + /** - * 设置：手机号 - */ + * 获取：手机号 + * 用于获取用户手机号字段值的公共访问方法（getter 方法），在涉及手机号相关的业务操作（如短信验证、联系用户等）时可通过该方法获取相应信息， + * 返回存储的用户手机号字符串值，即用户的手机号码内容。 + * @return 返回存储的用户手机号字符串值。 + */ public String getYonghuPhone() { return yonghuPhone; } - /** - * 获取：手机号 - */ + /** + * 设置：手机号 + * 用于设置用户手机号字段值的公共设置方法（setter 方法），在用户注册、修改手机号等场景下会调用该方法更新用户对象的手机号字段内容， + * 传入要设置的用户手机号字符串值，用于更新用户对象的手机号字段内容。 + * @param yonghuPhone 要设置的用户手机号字符串值。 + */ public void setYonghuPhone(String yonghuPhone) { this.yonghuPhone = yonghuPhone; } + /** - * 设置：电子邮箱 - */ + * 获取：电子邮箱 + * 用于获取用户电子邮箱字段值的公共访问方法（getter 方法），在需要通过邮箱与用户进行沟通、发送通知等业务场景下可通过该方法获取相应信息， + * 返回存储的用户电子邮箱字符串值，即用户的邮箱地址内容。 + * @return 返回存储的用户电子邮箱字符串值。 + */ public String getYonghuEmail() { return yonghuEmail; } - /** - * 获取：电子邮箱 - */ + /** + * 设置：电子邮箱 + * 用于设置用户电子邮箱字段值的公共设置方法（setter 方法），在用户注册、修改邮箱地址等场景下会调用该方法更新用户对象的电子邮箱字段内容， + * 传入要设置的用户电子邮箱字符串值，用于更新用户对象的电子邮箱字段内容。 + * @param yonghuEmail 要设置的用户电子邮箱字符串值。 + */ public void setYonghuEmail(String yonghuEmail) { this.yonghuEmail = yonghuEmail; } + /** - * 设置：性别 - */ + * 获取：性别 + * 用于获取用户性别字段值的公共访问方法（getter 方法），在需要根据性别进行统计、展示或者业务逻辑处理时可通过该方法获取相应信息， + * 返回存储的用户性别整数值，其具体含义由业务中对性别的代码定义决定（如 0 表示男，1 表示女等）。 + * @return 返回存储的用户性别整数值。 + */ public Integer getSexTypes() { return sexTypes; } - /** - * 获取：性别 - */ + /** + * 设置：性别 + * 用于设置用户性别字段值的公共设置方法（setter 方法），在用户完善个人资料、修改性别等场景下会调用该方法更新用户对象的性别字段内容， + * 同样要依据业务定义的性别代码规则来进行赋值操作，传入要设置的用户性别整数值，用于更新用户对象的性别字段内容。 + * @param sexTypes 要设置的用户性别整数值。 + */ public void setSexTypes(Integer sexTypes) { this.sexTypes = sexTypes; } + /** - * 设置：余额 - */ + * 获取：余额 + * 用于获取用户余额字段值的公共访问方法（getter 方法），在涉及用户账户余额相关的业务操作（如消费、充值、查询余额等）时可通过该方法获取相应信息， + * 返回存储的用户余额双精度浮点数值，即用户当前账户中的金额数量。 + * @return 返回存储的用户余额双精度浮点数值。 + */ public Double getNewMoney() { return newMoney; } - /** - * 获取：余额 - */ + /** + * 设置：余额 + * 用于设置用户余额字段值的公共设置方法（setter 方法），在用户充值、消费等业务场景下会调用该方法更新用户对象的余额字段内容， + * 要注意余额的计算和更新逻辑需符合业务规则以及数据的准确性要求，传入要设置的用户余额双精度浮点数值，用于更新用户对象的余额字段内容。 + * @param newMoney 要设置的用户余额双精度浮点数值。 + */ public void setNewMoney(Double newMoney) { this.newMoney = newMoney; } + /** - * 设置：假删 - */ + * 获取：假删 + * 用于获取用户假删字段值的公共访问方法（getter 方法），在涉及数据删除状态判断、数据恢复等业务逻辑中可通过该方法获取相应信息， + * 根据其取值来确定用户数据是否已被标记为删除状态（按照业务定义的取值规则），返回存储的用户假删整数值。 + * @return 返回存储的用户假删整数值。 + */ 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; - } - @Override - public String toString() { - return "Yonghu{" + - "id=" + id + - ", username=" + username + - ", password=" + password + - ", yonghuName=" + yonghuName + - ", yonghuPhoto=" + yonghuPhoto + - ", yonghuPhone=" + yonghuPhone + - ", yonghuEmail=" + yonghuEmail + - ", sexTypes=" + sexTypes + - ", newMoney=" + newMoney + - ", yonghuDelete=" + yonghuDelete + - ", createTime=" + createTime + - "}"; - } -} +/** + * 设置：假 diff --git a/minsu/minsuguanliw/src/main/java/com/entity/model/YonghuModel.java b/minsu/minsuguanliw/src/main/java/com/entity/model/YonghuModel.java index 92a9c90b..36f04918 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/model/YonghuModel.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/model/YonghuModel.java @@ -12,236 +12,290 @@ import java.io.Serializable; /** * 用户 * 接收传参的实体类 - *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） + * 此实体类用于接收与用户相关的数据参数，在实际的业务流程中，比如前端向后端传递用户信息或者后端内部不同模块间传递用户相关数据时会用到该类来承载数据。 + * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） + * 这里说明了在实际开发场景下，根据移动端接口开发的具体需求，可能会对该类中的字段进行调整，去除一些不必要的字段，并且通常后端直接使用对应的实体类（可能指的是更纯粹与数据库表结构对应的实体类）就可以满足大部分需求了，此处在特定场景下有其存在的意义。 * 取自ModelAndView 的model名称 + * 表明这个类的命名可能与ModelAndView中的model相关概念有关联，或许是用于类似的在视图与数据传递间起作用的实体对象。 */ public class YonghuModel implements Serializable { private static final long serialVersionUID = 1L; - - - /** * 主键 + * 用于唯一标识一条用户记录，在数据库中通常对应着表的主键字段，通过该字段可以准确地定位、操作某一个特定用户的数据。 */ private Integer id; - /** * 账户 + * 用于存储用户的登录账户信息，是用户登录系统时所使用的标识之一，通常具有唯一性，方便系统区分不同的用户。 */ private String username; - /** * 密码 + * 存储用户登录系统时需要提供的密码信息，用于验证用户身份的合法性，保证只有知道正确密码的用户才能登录成功并访问相应权限内的功能。 */ private String password; - /** * 用户姓名 + * 用于记录用户的真实姓名，便于在系统中更友好地展示用户信息，比如在用户个人资料页面、用户列表展示等场景下呈现给用户或者管理员查看。 */ private String yonghuName; - /** * 头像 + * 用于存放用户头像对应的文件路径或者头像相关的标识信息（具体取决于系统的实现方式），以在系统界面上展示用户的个性化头像，增强用户体验和辨识度。 */ private String yonghuPhoto; - /** * 手机号 + * 存储用户的手机号码信息，可用于多种业务场景，比如身份验证、短信通知、找回密码等操作时与用户进行联系的重要方式。 */ private String yonghuPhone; - /** * 电子邮箱 + * 保存用户的电子邮箱地址，同样可用于系统与用户之间的沟通交流，例如发送重要通知、密码重置链接等，也是用户在系统中重要的联系方式之一。 */ private String yonghuEmail; - /** * 性别 + * 用于记录用户的性别信息，可能取值为特定的代码（如0表示男，1表示女等，具体由业务定义），方便系统根据性别进行相关的统计、展示或者业务逻辑处理。 */ private Integer sexTypes; - /** * 余额 + * 用于存储用户在系统中的账户余额信息，比如在涉及支付、消费、充值等业务功能的系统中，该字段记录着用户当前可支配的金额数量。 */ private Double newMoney; - /** * 假删 + * 这是一个用于实现软删除功能的字段，通过设置不同的值来表示用户数据是否被删除，例如可以设定某个特定值（如1表示未删除，0表示已删除等，具体由业务规则确定）， + * 相比于直接从数据库中物理删除数据，软删除便于数据的恢复以及相关业务逻辑的处理，同时可以保留数据的历史记录等信息。 */ private Integer yonghuDelete; - /** * 创建时间 + * 用于记录用户数据在系统中被创建的具体时间点，通过@JsonFormat注解可以指定该时间在序列化（比如转换为JSON格式返回给前端时）的格式， + * @DateTimeFormat注解可能用于在接收前端传入的时间格式数据时进行格式化处理，以便正确地将数据绑定到该字段上， + * 该时间信息在很多业务场景中都有作用，比如按照创建时间排序、查询某个时间段内创建的用户等。 */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date createTime; - /** - * 获取：主键 - */ + * 获取：主键 + * 这是一个用于获取主键字段值的公共访问方法（getter方法），按照Java的JavaBean规范定义，方便其他类在需要获取该用户对象的主键值时调用。 + * @return 返回存储的主键整数值，即用户记录的唯一标识。 + */ public Integer getId() { return id; } - /** - * 设置：主键 - */ + * 设置：主键 + * 这是一个用于设置主键字段值的公共设置方法（setter方法），按照Java的JavaBean规范定义，用于在创建或修改用户对象时为其主键字段赋值， + * 通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法。 + * @param id 要设置的主键整数值，用于更新用户对象的主键字段内容。 + */ public void setId(Integer id) { this.id = id; } + /** - * 获取：账户 - */ + * 获取：账户 + * 用于获取用户账户字段值的公共访问方法（getter方法），方便其他类获取该用户对象的账户信息。 + * @return 返回存储的用户账户字符串值，即用户登录所使用的账户名。 + */ public String getUsername() { return username; } - /** - * 设置：账户 - */ + * 设置：账户 + * 用于设置用户账户字段值的公共设置方法（setter方法），在创建或修改用户对象时可通过该方法为账户字段赋值，比如用户注册或者修改账户名时会用到。 + * @param username 要设置的用户账户字符串值，用于更新用户对象的账户字段内容。 + */ public void setUsername(String username) { this.username = username; } + /** - * 获取：密码 - */ + * 获取：密码 + * 用于获取用户密码字段值的公共访问方法（getter方法），不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值， + * 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。 + * @return 返回存储的用户密码字符串值，即用户登录时需提供的密码内容。 + */ public String getPassword() { return password; } - /** - * 设置：密码 - */ + * 设置：密码 + * 用于设置用户密码字段值的公共设置方法（setter方法），在用户注册、修改密码等业务场景下会调用该方法为密码字段赋值， + * 同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作。 + * @param password 要设置的用户密码字符串值，用于更新用户对象的密码字段内容。 + */ public void setPassword(String password) { this.password = password; } + /** - * 获取：用户姓名 - */ + * 获取：用户姓名 + * 用于获取用户姓名字段值的公共访问方法（getter方法），方便在需要展示用户姓名的地方调用该方法获取相应信息。 + * @return 返回存储的用户姓名字符串值，即用户的真实姓名内容。 + */ public String getYonghuName() { return yonghuName; } - /** - * 设置：用户姓名 - */ + * 设置：用户姓名 + * 用于设置用户姓名字段值的公共设置方法（setter方法），例如在用户完善个人资料、修改姓名等场景下会使用该方法更新用户对象的姓名字段内容。 + * @param yonghuName 要设置的用户姓名字符串值，用于更新用户对象的姓名字段内容。 + */ public void setYonghuName(String yonghuName) { this.yonghuName = yonghuName; } + /** - * 获取：头像 - */ + * 获取：头像 + * 用于获取用户头像字段值的公共访问方法（getter方法），在需要展示用户头像的界面或者相关业务逻辑中，可通过该方法获取头像相关信息。 + * @return 返回存储的用户头像字符串值，可能是头像文件的路径或者头像的标识等内容（具体取决于系统实现）。 + */ public String getYonghuPhoto() { return yonghuPhoto; } - /** - * 设置：头像 - */ + * 设置：头像 + * 用于设置用户头像字段值的公共设置方法（setter方法），比如用户上传新头像、修改头像等业务场景下会调用该方法更新用户对象的头像字段内容。 + * @param yonghuPhoto 要设置的用户头像字符串值，用于更新用户对象的头像字段内容。 + */ public void setYonghuPhoto(String yonghuPhoto) { this.yonghuPhoto = yonghuPhoto; } + /** - * 获取：手机号 - */ + * 获取：手机号 + * 用于获取用户手机号字段值的公共访问方法（getter方法），在涉及手机号相关的业务操作（如短信验证、联系用户等）时可通过该方法获取相应信息。 + * @return 返回存储的用户手机号字符串值，即用户的手机号码内容。 + */ public String getYonghuPhone() { return yonghuPhone; } - /** - * 设置：手机号 - */ + * 设置：手机号 + * 用于设置用户手机号字段值的公共设置方法（setter方法），在用户注册、修改手机号等场景下会调用该方法更新用户对象的手机号字段内容。 + * @param yonghuPhone 要设置的用户手机号字符串值，用于更新用户对象的手机号字段内容。 + */ public void setYonghuPhone(String yonghuPhone) { this.yonghuPhone = yonghuPhone; } + /** - * 获取：电子邮箱 - */ + * 获取：电子邮箱 + * 用于获取用户电子邮箱字段值的公共访问方法（getter方法），在需要通过邮箱与用户进行沟通、发送通知等业务场景下可通过该方法获取相应信息。 + * @return 返回存储的用户电子邮箱字符串值，即用户的邮箱地址内容。 + */ public String getYonghuEmail() { return yonghuEmail; } - /** - * 设置：电子邮箱 - */ + * 设置：电子邮箱 + * 用于设置用户电子邮箱字段值的公共设置方法（setter方法），在用户注册、修改邮箱地址等场景下会调用该方法更新用户对象的电子邮箱字段内容。 + * @param yonghuEmail 要设置的用户电子邮箱字符串值，用于更新用户对象的电子邮箱字段内容。 + */ public void setYonghuEmail(String yonghuEmail) { this.yonghuEmail = yonghuEmail; } + /** - * 获取：性别 - */ + * 获取：性别 + * 用于获取用户性别字段值的公共访问方法（getter方法），在需要根据性别进行统计、展示或者业务逻辑处理时可通过该方法获取相应信息。 + * @return 返回存储的用户性别整数值，其具体含义由业务中对性别的代码定义决定（如0表示男，1表示女等）。 + */ public Integer getSexTypes() { return sexTypes; } - /** - * 设置：性别 - */ + * 设置：性别 + * 用于设置用户性别字段值的公共设置方法（setter方法），在用户完善个人资料、修改性别等场景下会调用该方法更新用户对象的性别字段内容， + * 同样要依据业务定义的性别代码规则来进行赋值操作。 + * @param sexTypes 要设置的用户性别整数值，用于更新用户对象的性别字段内容。 + */ public void setSexTypes(Integer sexTypes) { this.sexTypes = sexTypes; } + /** - * 获取：余额 - */ + * 获取：余额 + * 用于获取用户余额字段值的公共访问方法（getter方法），在涉及用户账户余额相关的业务操作（如消费、充值、查询余额等）时可通过该方法获取相应信息。 + * @return 返回存储的用户余额双精度浮点数值，即用户当前账户中的金额数量。 + */ public Double getNewMoney() { return newMoney; } - /** - * 设置：余额 - */ + * 设置：余额 + * 用于设置用户余额字段值的公共设置方法（setter方法），在用户充值、消费等业务场景下会调用该方法更新用户对象的余额字段内容， + * 要注意余额的计算和更新逻辑需符合业务规则以及数据的准确性要求。 + * @param newMoney 要设置的用户余额双精度浮点数值，用于更新用户对象的余额字段内容。 + */ public void setNewMoney(Double newMoney) { this.newMoney = newMoney; } + /** - * 获取：假删 - */ + * 获取：假删 + * 用于获取用户假删字段值的公共访问方法（getter方法），在涉及数据删除状态判断、数据恢复等业务逻辑中可通过该方法获取相应信息， + * 根据其取值来确定用户数据是否已被标记为删除状态（按照业务定义的取值规则）。 + * @return 返回存储的用户假删整数值，其具体含义由业务中对假删状态的代码定义决定（如1表示未删除，0表示已删除等）。 + */ public Integer getYonghuDelete() { return yonghuDelete; } - /** - * 设置：假删 - */ + * 设置：假删 + * 用于设置用户假删字段值的公共设置方法（setter方法），在进行数据删除（软删除操作）或者恢复已删除数据等业务场景下会调用该方法更新用户对象的假删字段内容， + * 要依据业务定义的假删状态代码规则来进行赋值操作。 + * @param yonghuDelete 要设置的用户假删整数值，用于更新用户对象的假删字段内容。 + */ public void setYonghuDelete(Integer yonghuDelete) { this.yonghuDelete = yonghuDelete; } + /** - * 获取：创建时间 - */ + * 获取：创建时间 + * 用于获取用户创建时间字段值的公共访问方法（getter方法），在需要按照创建时间进行数据排序、查询某个时间段内创建的用户等业务场景下可通过该方法获取相应信息， + * 并且通过相关注解（@JsonFormat和@DateTimeFormat）保证了时间数据在序列化和反序列化过程中的格式正确处理。 + * @return 返回存储的用户创建时间Date对象，即用户数据在系统中被创建的具体时间点。 + */ public Date getCreateTime() { return createTime; } - /** - * 设置：创建时间 - */ + * 设置：创建时间 + * 用于设置用户创建时间字段值的公共设置方法（setter方法），在创建用户对象或者从数据库查询数据后填充对象等场景下会调用该方法更新用户对象的创建时间字段内容， + * 要注意传入的时间值需符合@DateTimeFormat注解定义的格式要求（如果有相应的反序列化处理逻辑），以保证数据能正确绑定到该字段上。 + * @param createTime 要设置的用户创建时间Date对象，用于更新用户对象的创建时间字段内容。 + */ public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} diff --git a/minsu/minsuguanliw/src/main/java/com/entity/view/YonghuView.java b/minsu/minsuguanliw/src/main/java/com/entity/view/YonghuView.java index 22d27233..037839ea 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/view/YonghuView.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/view/YonghuView.java @@ -12,54 +12,65 @@ import java.util.Date; /** * 用户 * 后端返回视图实体辅助类 - * （通常后端关联的表或者自定义的字段需要返回使用） + * 此实体类作为后端返回给前端视图相关的辅助类存在，用于承载一些特定的数据，特别是那些后端关联的表中的数据或者自定义的额外字段，这些数据往往是需要展示给前端使用的， + * 它在业务中扮演着对后端数据进行整合、包装后再传递给前端的角色，方便前端获取并展示符合业务要求的完整用户相关信息。 */ @TableName("yonghu") +// 通过 @TableName 注解指定了该实体类对应的数据库表名为 "yonghu"，通常在与数据库交互的框架（如 MyBatis-Plus 等）中， +// 用于建立实体类与数据库表之间的映射关系，框架可以根据这个注解来确定操作的具体表。 public class YonghuView extends YonghuEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 性别的值 - */ - private String sexValue; - - - + private static final long serialVersionUID = 1L; + + /** + * 性别的值 + * 用于存储性别的具体值（可能是具体的文字描述，比如 "男"、"女" 等，区别于 YonghuEntity 中可能只是用代码表示性别的字段）， + * 方便直接展示给前端更直观的性别信息，而不是原始的代码形式，增强了数据展示的友好性和可读性。 + */ + private String sexValue; + + /** + * 默认构造函数 + * 用于创建一个空的 YonghuView 对象实例，在一些场景下（如通过反射等方式创建对象）可能会用到，初始化时对象的各个属性为默认值（如基本数据类型的默认初始值等）。 + */ public YonghuView() { } + /** + * 构造函数（基于 YonghuEntity 进行初始化） + * 该构造函数接受一个 YonghuEntity 对象作为参数，目的是将 YonghuEntity 中的属性值复制到当前的 YonghuView 对象中， + * 通过使用 BeanUtils.copyProperties 方法（可能来自 Spring 等相关框架提供的工具类）实现属性的拷贝， + * 这样可以方便地基于已有的 YonghuEntity 对象来创建 YonghuView 对象，减少了手动逐个设置属性的繁琐操作， + * 并且保证了大部分基础属性的一致性，同时在此基础上可以额外处理 YonghuView 中特有的属性（如 sexValue 字段）。 + * @param yonghuEntity 用于提供基础数据的 YonghuEntity 对象，其属性值将被复制到当前创建的 YonghuView 对象中。 + */ public YonghuView(YonghuEntity yonghuEntity) { try { BeanUtils.copyProperties(this, yonghuEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 如果在属性复制过程中出现异常（比如属性没有对应的访问权限或者复制方法调用出现问题等）， + // 则会打印异常堆栈信息，方便开发人员排查问题所在，当前只是简单地将异常打印出来，实际应用中可根据需求进行更完善的异常处理逻辑。 e.printStackTrace(); } } + /** + * 获取： 性别的值 + * 这是一个用于获取 sexValue 属性值的公共访问方法（getter 方法），按照 Java 的 JavaBean 规范定义， + * 方便其他类在需要获取该 YonghuView 对象的性别值时调用，返回存储的性别值字符串内容（如 "男"、"女" 等）。 + * @return 返回存储的性别的值字符串，即代表具体性别的文字描述信息。 + */ + public String getSexValue() { + return sexValue; + } - - /** - * 获取： 性别的值 - */ - public String getSexValue() { - return sexValue; - } - /** - * 设置： 性别的值 - */ - public void setSexValue(String sexValue) { - this.sexValue = sexValue; - } - - - - - - - - - - -} + /** + * 设置： 性别的值 + * 这是一个用于设置 sexValue 属性值的公共设置方法（setter 方法），按照 Java 的 JavaBean 规范定义， + * 用于在需要更新 YonghuView 对象的性别值时调用，比如根据后端业务逻辑处理后得到的具体性别文字描述来更新该字段内容。 + * @param sexValue 要设置的性别的值字符串，用于更新 YonghuView 对象的 sexValue 字段内容。 + */ + public void setSexValue(String sexValue) { + this.sexValue = sexValue; + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/UsersService.java b/minsu/minsuguanliw/src/main/java/com/service/UsersService.java index 1af066ba..7b7fb5b8 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/UsersService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/UsersService.java @@ -15,11 +15,45 @@ import com.utils.PageUtils; * @author yangliyuan * @date 2019年10月10日 上午9:18:20 */ +// 定义了一个名为 UsersService 的接口，该接口继承自 IService，意味着它会继承 IService 接口中针对 UsersEntity 类型的一系列通用的服务层方法， +// 比如常见的根据主键查询、插入、更新、删除等基础业务操作方法，在此基础上又自定义了一些特定于用户业务相关的方法，用于满足更复杂的业务需求。 +// 通常会有对应的实现类来具体实现这些方法逻辑，以实现与数据库或其他数据源交互来完成相应的业务功能。 public interface UsersService extends IService { + + /** + * 查询分页数据 + * 此方法用于根据传入的参数（以 Map 形式传递各种查询相关的条件、分页信息等）查询用户数据，并返回分页后的结果信息，封装在 PageUtils 类中。 + * PageUtils 类可能包含了分页相关的属性，如总记录数、每页记录数、当前页码以及具体的分页数据列表等内容，方便前端进行分页展示以及其他相关业务处理。 + * 该方法主要应用在需要按照一定条件分页展示用户列表的业务场景中，比如在用户管理页面，管理员查看众多用户信息时按页进行展示。 + * + * @param params 包含查询条件及分页相关参数的 Map 对象，键为参数名称（如 "pageNum" 表示当前页码，"pageSize" 表示每页记录数等，也可以包含自定义的筛选条件等）， + * 值为对应的参数值，通过这个参数可以灵活控制查询的具体逻辑以及分页设置。 + * @return 返回 PageUtils 对象，其中包含了符合查询条件的分页后的用户数据信息，可用于前端展示或后续的业务操作。 + */ + PageUtils queryPage(Map params); - + + /** + * 选择列表视图 + * 定义了一个用于查询用户数据列表的方法，该方法接收一个 Wrapper 类型的参数，这个 Wrapper 通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等）， + * 通过它可以灵活地定义查询用户数据的具体逻辑，返回的是一个 UsersEntity 类型的列表，即符合查询条件的用户数据集合，方便在业务中获取特定条件下的用户数据列表， + * 例如在查询满足某些特定属性（如特定角色、特定时间段内注册等）的用户列表场景下会用到该方法。 + * + * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件，以此来精确地控制从数据库中获取哪些用户的数据。 + * @return 符合查询条件的用户实体对象列表，列表中的每个 UsersEntity 对象代表一条用户数据记录。 + */ + List selectListView(Wrapper wrapper); - + /** + * 查询分页数据（带条件） + * 与前面的 queryPage(Map params) 方法类似，也是用于查询分页的用户数据，但此方法额外接收一个 Wrapper 类型的参数， + * 用于构建更复杂、更精确的查询条件，结合传入的 params 参数（包含分页相关设置及其他可能的通用查询条件），可以实现带特定条件的分页查询功能， + * 比如在用户管理中按照特定角色、特定状态等条件分页查看用户信息时会使用该方法。 + * + * @param params 包含查询条件及分页相关参数的 Map 对象，作用与前面 queryPage 方法中的 params 参数类似，用于设置分页相关属性以及一些基础的查询条件等。 + * @param wrapper 用于构建查询条件的包装器对象，用于添加额外的、更具体的查询条件，与 params 参数共同作用来精准控制查询哪些用户的数据以及如何分页展示这些数据。 + * @return 返回 PageUtils 对象，其中包含了符合传入的分页条件以及其他查询条件的分页后的用户数据信息，以供前端展示或后续业务操作使用。 + */ PageUtils queryPage(Map params, Wrapper wrapper); - + } diff --git a/minsu/minsuguanliw/src/main/java/com/service/YonghuService.java b/minsu/minsuguanliw/src/main/java/com/service/YonghuService.java index bdd6c320..b99d17af 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/YonghuService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/YonghuService.java @@ -15,5 +15,9 @@ public interface YonghuService extends IService { * @param params 查询参数 * @return 带分页的查询出来的数据 */ + // 定义了一个名为 `queryPage` 的方法，它接收一个 `Map` 类型的参数 `params`， + // 该方法的作用是根据传入的 `params` 参数中包含的各种查询条件及分页相关信息，查询相应的分页数据， + // 并返回一个 `PageUtils` 类型的对象，`PageUtils` 类通常用于封装分页相关的属性（如总记录数、每页记录数、当前页码以及具体的分页数据列表等）， + // 以便后续进行分页展示或者其他与分页数据相关的业务操作。例如在用户管理系统中，通过传入不同的查询条件和分页参数，获取对应分页的用户数据列表等场景会调用此方法。 PageUtils queryPage(Map params); } \ No newline at end of file -- 2.34.1 From 69333988ebabb2678919c17f169d74ab3dccc823 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Fri, 13 Dec 2024 23:25:30 +0800 Subject: [PATCH 4/7] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20ytt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/controller/UsersController.java | 4 +- .../java/com/controller/YonghuController.java | 14 +++++ .../main/java/com/entity/YonghuEntity.java | 59 ++++++++++++++++++- 3 files changed, 73 insertions(+), 4 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java b/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java index 85ab4fdf..5762282e 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/UsersController.java @@ -149,8 +149,8 @@ public class UsersController { * @param user 包含用户相关信息的UsersEntity对象，可能用于进一步构建查询条件，比如根据用户对象中的某些属性来筛选特定用户数据等，具体取决于业务逻辑和相关工具类（如MPUtil）的使用方式。 * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表信息（通过PageUtils对象承载）。 */ -@RequestMapping("/page") -public R page(@RequestParam Map params, UsersEntity user) { + @RequestMapping("/page") + public R page(@RequestParam Map params, UsersEntity user) { // 创建一个EntityWrapper对象，用于构建数据库查询条件，它可以方便地拼接各种查询条件语句，例如等于、大于、小于等条件，初始时为空，后续会根据业务逻辑添加相应条件。 EntityWrapper ew = new EntityWrapper(); // 调用用户服务层的queryPage方法进行分页查询，传入params参数用于分页相关设置以及通过MPUtil相关工具方法构建的查询条件。 diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index c95ce630..232727c6 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -106,6 +106,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 * @return R对象，封装了操作结果及相关数据，成功时包含用户详细信息 */ + @RequestMapping("/info/{id}") public R info(@PathVariable("id") Long id, HttpServletRequest request){ logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); @@ -135,6 +136,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用等错误信息 */ + @RequestMapping("/save") public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); @@ -177,6 +179,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等 * @return R对象，封装了操作结果，成功表示更新成功，失败则提示账户或者手机号已经被使用等错误信息 */ + @RequestMapping("/update") public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString()); @@ -217,6 +220,7 @@ public class YonghuController { * @param ids 包含要删除的用户ID的整数数组，通过请求体传入 * @return R对象，封装了操作结果，成功表示删除操作执行成功（实际只是更新了逻辑删除标识） */ + @RequestMapping("/delete") public R delete(@RequestBody Integer[] ids){ logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); @@ -241,6 +245,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如当前用户ID等 * @return R对象，封装了操作结果，成功表示批量插入成功，失败则提示各种错误信息，如文件格式错误、数据重复、插入异常等 */ + @RequestMapping("/batchInsert") public R save( String fileName, HttpServletRequest request){ logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); @@ -360,6 +365,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息 * @return R对象，封装了操作结果及相关数据，成功时包含用户登录后的Token、角色、用户名、所属表名、用户ID等信息，失败则返回相应错误提示 */ + @IgnoreAuth // 该注解可能表示此登录接口不需要进行权限认证（具体取决于该注解的实际定义和功能） @RequestMapping(value = "/login") public R login(String username, String password, String captcha, HttpServletRequest request) { @@ -400,6 +406,7 @@ public class YonghuController { * @param yonghu 包含用户注册信息的YonghuEntity对象，通过请求体传入（通常是前端提交的注册表单数据等） * @return R对象，封装了操作结果，成功表示注册成功，失败则提示账户或者手机号已经被使用的错误信息 */ + @IgnoreAuth // 该注解可能表示此注册接口不需要进行权限认证（具体取决于该注解的实际定义和功能） @PostMapping(value = "/register") public R register(@RequestBody YonghuEntity yonghu) { @@ -434,6 +441,7 @@ public class YonghuController { * @param id 用户的唯一标识（通常是数据库中的主键ID），从请求参数中获取 * @return R对象，封装了操作结果，成功表示密码重置成功 */ + @GetMapping(value = "/resetPassword") public R resetPassword(Integer id) { YonghuEntity yonghu = new YonghuEntity(); @@ -454,6 +462,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，但在当前方法中未体现更多相关使用情况 * @return R对象，封装了操作结果，成功表示密码重置成功，若用户不存在则返回账号不存在的错误信息，若更新数据库操作失败则返回相应错误信息 */ + @IgnoreAuth @RequestMapping(value = "/resetPass") public R resetPass(String username, HttpServletRequest request) { @@ -484,6 +493,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户视图信息，若查不到数据则返回相应错误信息 */ + @RequestMapping("/session") public R getCurrYonghu(HttpServletRequest request) { // 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息 @@ -513,6 +523,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象 * @return R对象，封装了操作结果及相关提示信息，这里返回退出成功的提示 */ + @GetMapping(value = "logout") public R logout(HttpServletRequest request) { // 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录等相关信息 @@ -530,6 +541,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，比如可能用于后续字典表数据转换等操作获取相关上下文信息，但当前代码中未体现更多复杂使用情况。 * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表（已经过字典表数据转换）。 */ + @IgnoreAuth @RequestMapping("/list") public R list(@RequestParam Map params, HttpServletRequest request) { @@ -558,6 +570,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如在字典表数据转换时可能需要的一些上下文信息等，但当前代码中未体现更多复杂使用情况。 * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户详细信息，若未查询到对应的数据则返回查不到数据的错误提示。 */ + @RequestMapping("/detail/{id}") public R detail(@PathVariable("id") Long id, HttpServletRequest request) { logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id); @@ -587,6 +600,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，当前代码中主要用于日志记录展示请求相关信息，但未体现更多复杂使用情况。 * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用的错误信息。 */ + @RequestMapping("/add") public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) { logger.debug("add方法:,,Controller:{},,yonghu:{}", this.getClass().getName(), yonghu.toString()); diff --git a/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java index 800fff66..f84e85ac 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java @@ -335,5 +335,60 @@ public class YonghuEntity implements Serializable { return yonghuDelete; } -/** - * 设置：假 + /** + * 获取：假删 + * 这是一个按照JavaBean规范定义的公共访问方法（getter方法），用于获取“假删”字段的值。 + * 在业务逻辑中，其他类可以通过调用此方法来知晓当前对象所代表的用户数据是否处于被标记为删除的状态（具体取决于“假删”字段值的定义规则，例如通常可能用特定数字表示删除与否）。 + * @return 返回存储的“假删”字段整数值，代表用户数据的删除标记状态。 + */ + + public void setYonghuDelete(Integer yonghuDelete) { + this.yonghuDelete = yonghuDelete; + } + + /** + * 获取：创建时间 + * 此为获取“创建时间”字段值的公共访问方法（getter方法），遵循JavaBean规范。 + * 在许多业务场景中，例如按照创建时间对用户数据进行排序、查询某个时间段内创建的用户等操作时，其他类可以调用该方法来获取用户数据在系统中最初被创建的具体时间点信息， + * 返回的是一个Date类型的对象，表示具体的时间值，并且该时间值的格式等相关处理可能受到类中定义的 @JsonFormat 和 @DateTimeFormat 等注解影响（若存在对应使用场景）。 + * @return 返回存储的“创建时间”Date对象，即代表用户数据被创建时的时间信息。 + */ + public Date getCreateTime() { + return createTime; + } + + /** + * 设置：创建时间 + * 按照JavaBean规范定义的用于设置“创建时间”字段值的公共设置方法（setter方法）。 + * 在创建用户对象或者从数据库查询数据后填充对象等场景下，可调用该方法来更新用户对象的“创建时间”字段内容， + * 要注意传入的时间值需符合 @DateTimeFormat 注解定义的格式要求（如果有相应的反序列化处理逻辑），以保证数据能正确绑定到该字段上，确保时间数据的准确性和一致性。 + * @param createTime 要设置的“创建时间”Date对象，用于更新当前对象的“创建时间”字段内容。 + */ + public void setCreateTime(Date createTime) { + this.createTime = createTime; + } + + /** + * 重写toString方法 + * toString方法在Java中用于将对象以字符串的形式表示出来，方便在调试、日志记录以及一些需要直观展示对象内容的场景下使用。 + * 这里重写了该方法，按照自定义的格式将对象中的各个重要属性（包括主键、用户名、密码、用户姓名、头像、手机号、电子邮箱、性别、余额、假删状态、创建时间等）拼接成一个字符串返回， + * 使得在查看该对象的字符串表示时，能够清晰地了解对象内部各关键属性的具体值情况，便于开发人员快速知晓对象的状态信息。 + * @return 返回一个包含对象关键属性信息的字符串，格式为 "Yonghu{" + 各属性键值对拼接 + "}"，其中属性值按照实际存储的值进行展示。 + */ + @Override + public String toString() { + return "Yonghu{" + + "id=" + id + + ", username=" + username + + ", password=" + password + + ", yonghuName=" + yonghuName + + ", yonghuPhoto=" + yonghuPhoto + + ", yonghuPhone=" + yonghuPhone + + ", yonghuEmail=" + yonghuEmail + + ", sexTypes=" + sexTypes + + ", newMoney=" + newMoney + + ", yonghuDelete=" + yonghuDelete + + ", createTime=" + createTime + + "}"; + } +} -- 2.34.1 From d811411e76e6a044362be60423b72b258ed5c75d Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 00:45:39 +0800 Subject: [PATCH 5/7] y --- .../src/main/java/com/controller/YonghuController.java | 1 + 1 file changed, 1 insertion(+) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index 232727c6..95cabb2a 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -442,6 +442,7 @@ public class YonghuController { * @return R对象，封装了操作结果，成功表示密码重置成功 */ + @GetMapping(value = "/resetPassword") public R resetPassword(Integer id) { YonghuEntity yonghu = new YonghuEntity(); -- 2.34.1 From ba9585072641aa4077cf86943ab16244fe61df82 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 11:19:12 +0800 Subject: [PATCH 6/7] =?UTF-8?q?=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/java/com/controller/YonghuController.java | 1 - 1 file changed, 1 deletion(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java index 95cabb2a..232727c6 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java @@ -442,7 +442,6 @@ public class YonghuController { * @return R对象，封装了操作结果，成功表示密码重置成功 */ - @GetMapping(value = "/resetPassword") public R resetPassword(Integer id) { YonghuEntity yonghu = new YonghuEntity(); -- 2.34.1 From e4261ae2ef86d9c90f48ef548f894ee7efbeb6e7 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 20:32:26 +0800 Subject: [PATCH 7/7] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20ytt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/controller/CommonController.java | 612 +++++++++++++++--- 1 file changed, 528 insertions(+), 84 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/controller/CommonController.java b/minsu/minsuguanliw/src/main/java/com/controller/CommonController.java index d388dcf3..f1991a8c 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/CommonController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/CommonController.java @@ -38,118 +38,171 @@ import com.utils.R; /** * 通用接口 */ +// 该类被标注为RestController，意味着这个类中的方法返回值会直接以JSON等格式响应给客户端，常用于构建RESTful API @RestController public class CommonController{ + // 创建一个日志记录器，用于记录该类中的相关日志信息，方便调试和问题排查 private static final Logger logger = LoggerFactory.getLogger(CommonController.class); + + // 自动注入CommonService，通过依赖注入的方式获取对应的业务逻辑处理类实例 @Autowired private CommonService commonService; - + // 自动注入ConfigService，用于获取配置相关的服务，可能用来读取系统配置信息等 @Autowired private ConfigService configService; - + // 用于百度人脸识别的客户端实例，初始化为null，后续会根据配置进行初始化 private static AipFace client = null; - + // 存储百度地图AK（Access Key），初始化为null，会从配置中读取 private static String BAIDU_DITU_AK = null; - + // 处理获取位置信息的请求映射，接收经度（lng）和纬度（lat）参数，用于根据经纬度获取对应的城市等位置信息 @RequestMapping("/location") public R location(String lng,String lat) { + // 如果百度地图AK为空，则尝试从配置中获取 if(BAIDU_DITU_AK==null) { + // 通过ConfigService根据配置名称（"baidu_ditu_ak"）查询对应的配置实体，并获取其值作为百度地图AK BAIDU_DITU_AK = configService.selectOne(new EntityWrapper().eq("name", "baidu_ditu_ak")).getValue(); + // 如果获取到的百度地图AK仍然为空，说明配置有误，返回错误信息给客户端 if(BAIDU_DITU_AK==null) { return R.error("请在配置管理中正确配置baidu_ditu_ak"); } } + // 调用BaiduUtil的方法，根据百度地图AK以及传入的经度和纬度获取对应的位置信息（以Map形式返回） Map map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat); + // 将获取到的位置信息封装到响应结果中，以"data"为键，返回成功响应给客户端 return R.ok().put("data", map); } - + /** - * 人脸比对 - * - * @param face1 人脸1 - * @param face2 人脸2 - * @return + * 人脸比对方法，用于比对两张人脸图片是否相似。 + * @param face1 人脸1对应的文件名（可能是存储在服务器特定位置的文件名称） + * @param face2 人脸2对应的文件名 + * @param request HttpServletRequest对象，用于获取服务器相关上下文信息等 + * @return 返回包含比对结果的响应信息给客户端 */ + @RequestMapping("/matchFace") public R matchFace(String face1, String face2, HttpServletRequest request) { + // 如果百度人脸识别客户端实例为空，则进行初始化操作 if(client==null) { + // 以下代码被注释掉，可能原本是打算获取AppID的配置值，但目前未使用 /*String AppID = configService.selectOne(new EntityWrapper().eq("name", "AppID")).getValue();*/ + // 获取APIKey配置值，用于百度人脸识别的认证等操作 String APIKey = configService.selectOne(new EntityWrapper().eq("name", "APIKey")).getValue(); + // 获取SecretKey配置值，同样用于百度人脸识别的相关认证操作 String SecretKey = configService.selectOne(new EntityWrapper().eq("name", "SecretKey")).getValue(); + // 通过BaiduUtil的方法，使用获取到的APIKey和SecretKey获取访问令牌（token），用于后续与百度人脸识别服务交互的认证 String token = BaiduUtil.getAuth(APIKey, SecretKey); + // 如果获取到的令牌为空，说明配置的APIKey和SecretKey有问题，返回错误信息给客户端 if(token==null) { return R.error("请在配置管理中正确配置APIKey和SecretKey"); } + // 创建百度人脸识别客户端实例，传入相关认证参数（此处AppID传入null，实际可能需要正确配置） client = new AipFace(null, APIKey, SecretKey); + // 设置连接超时时间为2000毫秒 client.setConnectionTimeoutInMillis(2000); + // 设置套接字超时时间为60000毫秒 client.setSocketTimeoutInMillis(60000); } + JSONObject res = null; try { + // 根据服务器上下文获取文件1的完整路径，该文件对应人脸1的图片 File file1 = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+face1); + // 根据服务器上下文获取文件2的完整路径，该文件对应人脸2的图片 File file2 = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+face2); + // 将文件1转换为字节数组，再进行Base64编码，得到图片的Base64编码字符串 String img1 = Base64Util.encode(FileUtil.FileToByte(file1)); + // 同样对文件2进行操作，得到其Base64编码字符串 String img2 = Base64Util.encode(FileUtil.FileToByte(file2)); + // 创建一个MatchRequest对象，用于封装人脸1的图片Base64编码及编码格式信息 MatchRequest req1 = new MatchRequest(img1, "BASE64"); + // 创建一个MatchRequest对象，用于封装人脸2的图片Base64编码及编码格式信息 MatchRequest req2 = new MatchRequest(img2, "BASE64"); + // 创建一个ArrayList来存放MatchRequest对象，用于批量提交人脸比对请求 ArrayList requests = new ArrayList(); + // 将人脸1的MatchRequest对象添加到列表中 requests.add(req1); + // 将人脸2的MatchRequest对象添加到列表中 requests.add(req2); + // 调用百度人脸识别客户端的match方法，传入封装好的请求列表，进行人脸比对操作，获取比对结果 res = client.match(requests); + // 打印比对结果中的"result"部分，可能用于调试查看比对详情（此处可以考虑更合理的日志记录方式） System.out.println(res.get("result")); } catch (FileNotFoundException e) { + // 如果文件不存在，打印堆栈信息方便排查问题，并返回文件不存在的错误信息给客户端 e.printStackTrace(); return R.error("文件不存在"); } catch (IOException e) { + // 如果发生IO异常，打印堆栈信息方便排查问题 e.printStackTrace(); - } + } + // 将比对结果解析后封装到响应结果中，以"data"为键，返回成功响应给客户端 return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString())); } - - /** - * 获取table表中的column列表(联动接口) - * @return - */ + + +// 此方法用于获取指定数据表（table）中指定列（column）的列表数据，设计为一个联动接口，可能用于前端界面上如下拉菜单等组件的联动数据获取场景 +// 通过接收表名、列名以及可选的层级（level）和父级（parent）参数，来灵活查询满足条件的数据列表，并将结果返回给客户端 +// 该接口标注了 @RequestMapping 注解，指定了访问路径的格式，其中 {tableName} 和 {columnName} 是路径变量，会在请求时被实际的值替换 +// 同时标注了 @IgnoreAuth 注解，可能意味着此接口访问不需要进行权限认证（具体取决于项目中对该注解的定义和实现） +// @return 返回一个 R 类型的对象，通常用于封装响应结果（成功时包含查询到的数据列表等信息） @RequestMapping("/option/{tableName}/{columnName}") @IgnoreAuth public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,String level,String parent) { + // 创建一个用于存储查询参数的 Map，键为字符串类型，值为 Object 类型，后续将传递给服务层（commonService）的方法用于查询操作 Map params = new HashMap(); + // 将表名参数放入 params 这个参数 Map 中，键为 "table"，方便服务层方法知晓要操作的是哪个数据表 params.put("table", tableName); + // 将列名参数放入 params 这个参数 Map 中，键为 "column"，用于指定要从数据表中获取哪一列的数据 params.put("column", columnName); + // 判断传入的 level 参数是否不为空字符串（即有实际的值传入），如果是，则将其放入参数 Map 中，键为 "level" + // 这个 level 参数可能用于在查询数据时按照某种层级关系进行筛选，比如在具有层级结构的数据表中筛选出特定层级的数据 if(StringUtils.isNotBlank(level)) { params.put("level", level); } + // 判断传入的 parent 参数是否不为空字符串（即有实际的值传入），如果是，则将其放入参数 Map 中，键为 "parent" + // 该参数可能用于在查询数据时基于某个父级元素进行筛选，例如获取某个父分类下的子项数据等场景 if(StringUtils.isNotBlank(parent)) { params.put("parent", parent); } + // 调用 commonService 的 getOption 方法，传递组装好的参数 Map，获取满足条件的数据列表，此处假设 commonService 是已经注入并实现了相应业务逻辑的服务类 List data = commonService.getOption(params); + // 使用 R 类型对象（可能是项目自定义的用于统一响应格式的类）封装查询到的数据列表，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过 R.ok() 表示） return R.ok().put("data", data); } - - /** - * 根据table中的column获取单条记录 - * @return - */ + + +// 此方法用于根据指定数据表（table）中的指定列（column）以及该列的具体值（columnValue）来获取单条记录数据 +// 接口同样标注了 @RequestMapping 注解定义访问路径格式，{tableName} 和 {columnName} 为路径变量，并且标注了 @IgnoreAuth 注解，可能不需要权限认证即可访问 +// @return 返回一个 R 类型的对象，在成功时会包含查询到的单条记录数据（以 Map 形式返回，具体结构取决于数据表的字段情况） @RequestMapping("/follow/{tableName}/{columnName}") @IgnoreAuth public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) { + // 创建一个用于存储查询参数的 Map，用于传递给服务层（commonService）的方法来执行具体的查询操作 Map params = new HashMap(); + // 将表名参数放入 params 这个参数 Map 中，键为 "table"，用于明确操作的是哪一个数据表 params.put("table", tableName); + // 将列名参数放入 params 这个参数 Map 中，键为 "column"，用于指定依据哪一列的数据来查找记录 params.put("column", columnName); + // 将列的具体值参数放入 params 这个参数 Map 中，键为 "columnValue"，这个值将用于在数据表中匹配相应的记录，比如根据某个唯一标识列的值来获取对应的记录 params.put("columnValue", columnValue); + // 调用 commonService 的 getFollowByOption 方法，传递组装好的参数 Map，获取满足条件的单条记录数据，假设 commonService 已经正确实现了对应的业务逻辑方法 Map result = commonService.getFollowByOption(params); + // 使用 R 类型对象封装查询到的单条记录数据，以 "data" 作为键值对中的键，将结果返回给客户端，返回状态为成功状态（通过 R.ok() 表示） return R.ok().put("data", result); } - - /** - * 修改table表的sfsh状态 - * @param map - * @return - */ + +// 此方法用于修改指定数据表（table）的 sfsh 状态，接收表名作为路径变量以及一个包含修改相关数据的 Map 参数（可能包含具体要修改的记录标识、新的状态值等信息） +// 通过调用 commonService 的 sh 方法来执行实际的修改操作，具体修改逻辑在 commonService.sh 方法中实现（此处未展示具体代码） +// @param map 包含修改 sfsh 状态相关数据的 Map，具体内容由客户端传入，其结构和内容取决于业务需求以及数据表的设计情况 +// @return 返回一个 R 类型的对象，表示操作成功的响应结果（这里没有返回具体修改后的详细数据等，仅表示操作成功） @RequestMapping("/sh/{tableName}") public R sh(@PathVariable("tableName") String tableName, @RequestBody Map map) { + // 将表名添加到传入的 map 参数中，键为 "table"，以便在服务层（commonService）的 sh 方法中能准确知道要修改的是哪个数据表的 sfsh 状态 map.put("table", tableName); + // 调用 commonService 的 sh 方法，传递包含表名等信息的 map 参数，执行实际的修改 sfsh 状态的操作，具体的修改逻辑在 commonService.sh 方法内部实现 commonService.sh(map); + // 返回一个表示操作成功的 R 类型对象，给客户端反馈修改操作已经顺利完成 return R.ok(); } @@ -161,88 +214,149 @@ public class CommonController{ * @param map * @return */ + + // 此方法用于获取提醒相关的数量统计信息，通过接收表名、列名、类型以及其他相关查询参数（以Map形式接收）来确定统计范围和条件 + // @RequestMapping注解指定了访问此接口的路径格式，其中 {tableName}、{columnName}、{type} 为路径变量，会在请求时被实际的值替换 + // @IgnoreAuth注解表示该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现） + // @param tableName 表示要操作的数据表名称 + // @param columnName 表示数据表中相关的列名称，可能和提醒业务逻辑相关的某个字段 + // @param type 表示提醒的类型，不同类型可能对应不同的统计逻辑 + // @param map 包含其他额外的查询参数，例如在特定类型下可能包含提醒的起止时间等信息 + // @return 返回一个R类型的对象，用于封装响应结果，在成功时包含统计得到的提醒数量（以 "count" 作为键值对中的键） @RequestMapping("/remind/{tableName}/{columnName}/{type}") @IgnoreAuth - public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, - @PathVariable("type") String type,@RequestParam Map map) { + public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @PathVariable("type") String type, @RequestParam Map map) { + // 将表名添加到传入的map参数中，键为 "table"，方便后续在服务层（commonService）的方法中明确操作的数据表 map.put("table", tableName); + // 将列名添加到传入的map参数中，键为 "column"，用于指定和提醒业务相关的列字段 map.put("column", columnName); + // 将提醒类型添加到传入的map参数中，键为 "type"，服务层方法可根据此类型执行不同的统计逻辑 map.put("type", type); - + // 如果提醒类型等于 "2"，则进行以下时间相关的处理逻辑，可能是针对类型为 "2" 的提醒设置特定的时间范围查询条件 if(type.equals("2")) { + // 创建一个SimpleDateFormat对象，用于格式化日期为 "yyyy-MM-dd" 的格式，方便后续在查询参数中设置日期格式统一的时间范围 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + // 获取一个Calendar实例，用于进行日期的计算操作，例如增加或减少天数等 Calendar c = Calendar.getInstance(); Date remindStartDate = null; Date remindEndDate = null; + + // 判断传入的查询参数中是否包含 "remindstart"（可能表示提醒开始时间的参数），如果有则进行以下处理 if(map.get("remindstart")!=null) { + // 将 "remindstart" 参数的值转换为整数类型，可能表示相对于当前日期要增加的天数等含义 Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); + // 将Calendar实例的时间设置为当前日期 + c.setTime(new Date()); + // 在当前日期基础上增加指定的天数，此处根据 "remindstart" 的值来调整日期 c.add(Calendar.DAY_OF_MONTH,remindStart); + // 获取调整后的日期对象，即提醒开始日期 remindStartDate = c.getTime(); + // 将提醒开始日期按照指定格式进行格式化后，重新放入map参数中，替换原来的值，以便后续传递给服务层方法时日期格式符合要求 map.put("remindstart", sdf.format(remindStartDate)); } + + // 判断传入的查询参数中是否包含 "remindend"（可能表示提醒结束时间的参数），如果有则进行以下处理 if(map.get("remindend")!=null) { + // 将 "remindend" 参数的值转换为整数类型，类似 "remindstart"，可能表示相对于当前日期要增加的天数等含义 Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + // 将Calendar实例的时间设置为当前日期 c.setTime(new Date()); + // 在当前日期基础上增加指定的天数，此处根据 "remindend" 的值来调整日期 c.add(Calendar.DAY_OF_MONTH,remindEnd); + // 获取调整后的日期对象，即提醒结束日期 remindEndDate = c.getTime(); + // 将提醒结束日期按照指定格式进行格式化后，重新放入map参数中，替换原来的值，以便后续传递给服务层方法时日期格式符合要求 map.put("remindend", sdf.format(remindEndDate)); } } - + + // 调用commonService的remindCount方法，传递处理好的查询参数map，获取满足条件的提醒数量统计结果 int count = commonService.remindCount(map); + // 使用R类型对象封装统计得到的提醒数量，以 "count" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("count", count); } - /** - * 圖表统计 - */ + // 此方法用于进行图表相关的统计操作，可能是根据指定数据表中的数据生成图表所需的数据统计结果 + // 接口标注了 @IgnoreAuth 注解，意味着该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现） + // @RequestMapping注解指定了访问此接口的访问路径，其中 {tableName} 为路径变量，会被实际传入的表名替换 + // @param tableName 表示要操作的数据表名称，是图表统计数据的来源表 + // @param params 包含其他额外的图表统计相关的查询参数（以Map形式传入），具体参数内容取决于图表统计的业务需求和设计 + // @return 返回一个R类型的对象，用于封装响应结果，在成功时包含图表统计得到的数据结果（以 "data" 作为键值对中的键） @IgnoreAuth @RequestMapping("/group/{tableName}") public R group1(@PathVariable("tableName") String tableName, @RequestParam Map params) { + // 将表名添加到传入的params参数中，键为 "table1"，方便服务层（commonService）的方法知晓操作的数据表，此处键为 "table1" 可能是服务层方法内部约定的参数名 params.put("table1", tableName); + // 调用commonService的chartBoth方法，传递包含表名等信息的查询参数params，获取图表统计相关的数据结果，假设commonService已经正确实现了对应的业务逻辑方法 List> result = commonService.chartBoth(params); + // 使用R类型对象封装图表统计得到的数据结果，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("data", result); } - - /** - * 单列求和 - */ + // 此方法用于对指定数据表中的单列数据进行求和操作，获取该列数据的总和统计值 + // @RequestMapping注解指定了访问此接口的路径格式，其中 {tableName}、{columnName} 为路径变量，会在请求时被实际的值替换 + // @IgnoreAuth注解表示该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现） + // @param tableName 表示要操作的数据表名称，即包含要进行求和操作列的数据表 + // @param columnName 表示数据表中要进行求和的列名称 + // @return 返回一个R类型的对象，用于封装响应结果，在成功时包含单列求和得到的结果数据（以 "data" 作为键值对中的键） @RequestMapping("/cal/{tableName}/{columnName}") @IgnoreAuth public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { - Map params = new HashMap(); + // 创建一个用于存储查询参数的Map，用于传递给服务层（commonService）的方法来执行单列求和操作 + Map params = new HashMap<>(); + // 将表名参数放入params这个参数Map中，键为 "table"，方便服务层方法明确操作的数据表 params.put("table", tableName); + // 将列名参数放入params这个参数Map中，键为 "column"，用于指定要进行求和操作的列 params.put("column", columnName); + // 调用commonService的selectCal方法，传递组装好的参数Map，获取单列求和的结果数据，假设commonService已经正确实现了对应的业务逻辑方法 Map result = commonService.selectCal(params); + // 使用R类型对象封装单列求和得到的结果数据，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("data", result); } - - /** - * 分组统计 - */ + + // 此方法用于进行分组统计操作，根据指定数据表（tableName）中的指定列（columnName）来进行分组统计分析 + // @RequestMapping注解指定了访问此接口的路径格式，其中 {tableName} 和 {columnName} 为路径变量，会在请求时被实际传入的表名和列名替换 + // @IgnoreAuth注解表示该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现） + // @param tableName 表示要操作的数据表名称，是进行分组统计的数据来源表 + // @param columnName 表示数据表中用于分组的列名称，依据该列的值将数据进行分组后再做统计相关操作 + // @return 返回一个R类型的对象，用于封装响应结果，在成功时包含分组统计得到的数据结果（以 "data" 作为键值对中的键） @RequestMapping("/group/{tableName}/{columnName}") @IgnoreAuth public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) { - Map params = new HashMap(); + // 创建一个用于存储查询参数的Map，键为字符串类型，值为Object类型，后续将传递给服务层（commonService）的方法用于分组统计操作 + Map params = new HashMap<>(); + // 将表名参数放入params这个参数Map中，键为 "table"，方便服务层方法知晓要操作的是哪个数据表 params.put("table", tableName); + // 将用于分组的列名参数放入params这个参数Map中，键为 "column"，服务层方法将依据此列进行分组统计 params.put("column", columnName); + // 调用commonService的selectGroup方法，传递组装好的参数Map，获取分组统计相关的数据结果，假设commonService已经正确实现了对应的业务逻辑方法 List> result = commonService.selectGroup(params); + // 使用R类型对象封装分组统计得到的数据结果，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("data", result); } - - /** - * （按值统计） - */ + + // 此方法用于进行按值统计操作，根据指定数据表（tableName）中的指定的X列（xColumnName）和Y列（yColumnName）来进行相关统计分析，具体统计逻辑由服务层方法决定 + // @RequestMapping注解指定了访问此接口的路径格式，其中 {tableName}、{xColumnName}、{yColumnName} 为路径变量，会在请求时被实际传入的表名、X列名和Y列名替换 + // @IgnoreAuth注解表示该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现） + // @param tableName 表示要操作的数据表名称，是进行按值统计的数据来源表 + // @param yColumnName 表示数据表中作为Y维度（具体维度含义取决于业务逻辑）的列名称，用于统计相关操作中的一个关键列 + // @param xColumnName 表示数据表中作为X维度（与Y维度共同构成统计维度关系，具体由业务逻辑确定）的列名称，也是用于统计相关操作的关键列 + // @return 返回一个R类型的对象，用于封装响应结果，在成功时包含按值统计得到的数据结果（以 "data" 作为键值对中的键） @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}") @IgnoreAuth - public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) { - Map params = new HashMap(); + public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, + @PathVariable("xColumnName") String xColumnName) { + // 创建一个用于存储查询参数的Map，用于传递给服务层（commonService）的方法来执行按值统计操作 + Map params = new HashMap<>(); + // 将表名参数放入params这个参数Map中，键为 "table"，便于服务层方法明确操作的数据表 params.put("table", tableName); + // 将X列名参数放入params这个参数Map中，键为 "xColumn"，用于指定按值统计中X维度对应的列，服务层方法将依据此列进行相应统计逻辑 params.put("xColumn", xColumnName); + // 将Y列名参数放入params这个参数Map中，键为 "yColumn"，用于指定按值统计中Y维度对应的列，与X列共同参与统计分析 params.put("yColumn", yColumnName); + // 调用commonService的selectValue方法，传递组装好的参数Map，获取按值统计相关的数据结果，假设commonService已经正确实现了对应的业务逻辑方法 List> result = commonService.selectValue(params); + // 使用R类型对象封装按值统计得到的数据结果，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("data", result); } @@ -261,10 +375,18 @@ public class CommonController{ * sumCloum 统计字段 * @return */ + + // 此方法用于执行一种新的分组求和统计操作，接收一个包含各种查询参数的Map对象，参数具体内容由客户端传入，根据这些参数进行相应的统计计算 +// @RequestMapping注解指定了访问此接口的路径，客户端通过访问该路径来触发此方法执行相应的业务逻辑 +// @param params 一个包含各种统计相关查询参数的Map，键为字符串类型，值为Object类型，其具体的键值对内容取决于业务需求和统计逻辑，例如可能包含数据表名、要分组的列名、求和的列名等信息 +// @return 返回一个R类型的对象，用于封装响应结果，在成功时会将新的分组求和统计得到的数据结果以 "data" 作为键值对中的键进行封装并返回给客户端，表示操作成功 @RequestMapping("/newSelectGroupSum") public R newSelectGroupSum(@RequestParam Map params) { + // 使用日志记录器记录DEBUG级别的日志信息，输出当前执行的方法名称（通过 this.getClass().getName() 获取类名）以及传入的参数信息，方便在调试时查看方法的调用情况和参数情况 logger.debug("newSelectGroupSum:,,Controller:{},,params:{}",this.getClass().getName(),params); + // 调用commonService的newSelectGroupSum方法，传递接收到的包含查询参数的Map对象，获取新的分组求和统计相关的数据结果，假设commonService已经正确实现了对应的业务逻辑方法 List> result = commonService.newSelectGroupSum(params); + // 使用R类型对象封装新的分组求和统计得到的数据结果，以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过R.ok()表示） return R.ok().put("data", result); } @@ -279,11 +401,23 @@ public class CommonController{ 有值 Number(res.data.value.toFixed(1)) 无值 if(res.data){} * */ + + // 标注了 @IgnoreAuth 注解，意味着该接口访问可能不需要进行权限认证（具体取决于项目中对该注解的定义和实现）。 @IgnoreAuth + // @RequestMapping 注解用于将 HTTP 请求映射到对应的处理方法上，这里指定了访问此接口的路径为 "/queryScore"， + // 当客户端发起对应路径的请求时，该方法就会被调用执行相应的业务逻辑。 @RequestMapping("/queryScore") + // 定义了一个名为 queryScore 的公共方法，用于查询分数相关的数据，接收一个包含各种查询参数的 Map 对象。 public R queryScore(@RequestParam Map params) { + // 创建一个日志记录器，用于记录该类中的相关日志信息，此处使用 DEBUG 级别记录日志，方便调试和排查问题。 + // 这条日志语句会输出当前执行的方法名称（通过 this.getClass().getName() 获取类名）以及传入的参数信息， + // 便于在调试过程中查看该方法被调用时具体传入了哪些参数。 logger.debug("queryScore:,,Controller:{},,params:{}",this.getClass().getName(),params); + // 调用 commonService 的 queryScore 方法，传递接收到的包含查询参数的 Map 对象，获取查询分数相关的数据结果， + // 这里假设 commonService 是已经注入并且正确实现了对应业务逻辑的服务类，能够根据传入的参数执行具体的查询操作并返回相应结果。 Map queryScore = commonService.queryScore(params); + // 使用 R 类型对象（可能是项目自定义的用于统一响应格式的类）封装查询得到的分数相关数据结果， + // 以 "data" 作为键值对中的键，将结果返回给客户端，返回的状态为成功状态（通过 R.ok() 表示）。 return R.ok().put("data", queryScore); } @@ -293,10 +427,24 @@ public class CommonController{ * groupColumn 分组字段 * @return */ + + // @RequestMapping注解用于将HTTP请求路径映射到对应的处理方法上，这里指定了此方法对应的请求路径为"/newSelectGroupCount"， + // 意味着当客户端发起访问该路径的请求时，此方法将会被调用执行相应的业务逻辑操作。 @RequestMapping("/newSelectGroupCount") + // 定义了一个公共方法newSelectGroupCount，它用于执行一种新的分组计数统计操作，接收一个包含各种统计相关参数的Map对象， + // 这些参数由客户端传入，用于明确具体的统计范围、条件等内容，其键为字符串类型，值可以是各种Java对象类型。 public R newSelectGroupCount(@RequestParam Map params) { + // 创建了一个日志记录器logger，用于记录该方法执行过程中的相关日志信息，此处使用DEBUG级别来记录日志，方便在调试阶段查看详细的执行情况。 + // 通过下面这行日志语句，会在日志中输出当前正在执行的方法名称（通过this.getClass().getName()获取类的全限定名来表示方法所在类） + // 以及传入该方法的参数信息，有助于排查在调用此方法时参数是否符合预期等问题。 logger.debug("newSelectGroupCount:,,Controller:{},,params:{}",this.getClass().getName(),params); + // 调用commonService（此处应是已经通过依赖注入获取到的业务服务类实例，并且假设其内部已经正确实现了相应的业务逻辑方法）的 + // newSelectGroupCount方法，将接收到的包含统计参数的Map对象传递进去，以获取新的分组计数统计操作的结果数据， + // 返回的数据类型是一个包含多个Map的List集合，每个内层的Map可能表示一组统计结果相关的信息，具体取决于业务逻辑的设计。 List> result = commonService.newSelectGroupCount(params); + // 使用R类型的对象（大概率是项目自定义的用于统一封装响应结果的类，例如包含了响应状态码、消息以及具体数据等信息）来封装统计结果， + // 以"data"作为键值对中的键，将获取到的分组计数统计结果放入其中，然后将整个封装好的R对象返回给客户端， + // 通过R.ok()表示此次操作执行成功，客户端接收到返回结果后可根据约定的格式解析并获取相应的统计数据信息。 return R.ok().put("data", result); } @@ -309,47 +457,86 @@ public class CommonController{ * dateFormatType 日期格式化类型 1:年 2:月 3:日 * @return */ + + // 此方法用于对当前表按照日期进行分组求和统计操作，根据传入的不同参数来确定具体的统计逻辑和日期格式化方式等内容。 + // 通过接收一个包含多个参数的Map对象，从其中获取必要的信息进行相应处理，并调用服务层方法完成统计功能，最后将结果返回给客户端。 + // @RequestMapping注解指定了访问此接口的请求路径为"/newSelectDateGroupSum"，当客户端发起对应路径的请求时，该方法会被触发执行。 @RequestMapping("/newSelectDateGroupSum") public R newSelectDateGroupSum(@RequestParam Map params) { + // 使用日志记录器记录DEBUG级别的日志信息，输出当前执行的方法名称（通过 this.getClass().getName() 获取类名）以及传入的参数信息， + // 方便在调试时查看方法的调用情况以及传入参数是否符合预期等情况。 logger.debug("newSelectDateGroupSum:,,Controller:{},,params:{}",this.getClass().getName(),params); + + // 从传入的参数Map中获取日期格式化类型（dateFormatType）参数的值，并转换为字符串类型进行后续判断处理。 + // 该参数用于决定对日期进行何种程度的格式化，进而影响分组统计的逻辑，例如按照年、月或日来分组求和。 String dateFormatType = String.valueOf(params.get("dateFormatType")); + + // 根据获取到的日期格式化类型进行判断，如果为 "1"，表示按照年份进行日期格式化及分组求和统计。 if("1".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y"，这是一种日期格式化的占位符表示形式，用于后续在数据库查询等操作中 + // 将日期格式化为只保留年份信息，以便按照年份进行分组求和统计。 params.put("dateFormat", "%Y"); + // 如果日期格式化类型为 "2"，表示按照月份进行日期格式化及分组求和统计。 }else if("2".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y-%m"，用于将日期格式化为包含年份和月份的信息，满足按月分组求和统计的需求。 params.put("dateFormat", "%Y-%m"); + // 如果日期格式化类型为 "3"，表示按照日期（天）进行日期格式化及分组求和统计。 }else if("3".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y-%m-%d"，用于将日期格式化为包含完整的年、月、日信息，便于按日进行分组求和统计。 params.put("dateFormat", "%Y-%m-%d"); + // 如果日期格式化类型不是上述预定义的 "1"、"2"、"3" 中的任何一个，则表示传入的日期格式化类型不正确，不符合业务逻辑要求。 }else{ - R.error("日期格式化不正确"); + // 返回一个表示错误状态的R对象，其中包含了错误提示信息 "日期格式化不正确"，用于告知客户端请求参数有误，无法正常执行统计操作。 + return R.error("日期格式化不正确"); } + + // 调用commonService（假设是已经注入并正确实现了对应业务逻辑的服务类）的newSelectDateGroupSum方法，传递处理好的包含各种参数的Map对象， + // 获取按照日期分组求和统计后的结果数据，返回的数据类型是一个包含多个Map的List集合，每个内层的Map可能对应一组分组求和的统计结果信息。 List> result = commonService.newSelectDateGroupSum(params); + + // 使用R类型对象（通常是项目自定义用于统一响应格式的类）封装统计得到的结果数据，以 "data" 作为键值对中的键，将结果返回给客户端， + // 通过R.ok()表示此次操作执行成功，客户端可根据约定的格式解析返回结果获取相应的分组求和统计数据。 return R.ok().put("data", result); } - /** - * - * 查询字典表的分组统计总条数 - * tableName 表名 - * groupColumn 分组字段 - * dateFormatType 日期格式化类型 1:年 2:月 3:日 - * @return - */ + // 此方法用于查询字典表的分组统计总条数，同样依据传入的参数来确定具体的统计逻辑以及日期格式化方式等，与上面的方法类似但功能是统计总条数。 + // 通过接收包含相关参数的Map对象，对日期格式化类型进行判断处理后，调用服务层相应方法完成统计功能，并将结果返回给客户端。 + // @RequestMapping注解指定了访问此接口的请求路径为"/newSelectDateGroupCount"，客户端访问该路径时会触发此方法执行。 @RequestMapping("/newSelectDateGroupCount") public R newSelectDateGroupCount(@RequestParam Map params) { + // 记录DEBUG级别的日志信息，输出当前执行的方法名称以及传入的参数情况，方便调试过程中查看方法调用及参数相关情况。 logger.debug("newSelectDateGroupCount:,,Controller:{},,params:{}",this.getClass().getName(),params); + + // 获取传入参数Map中的日期格式化类型（dateFormatType）参数的值，并转换为字符串类型，用于后续的条件判断操作。 String dateFormatType = String.valueOf(params.get("dateFormatType")); + + // 判断日期格式化类型是否为 "1"，如果是，则表示按照年份进行日期格式化及分组统计总条数的操作。 if("1".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y"，用于将日期格式化为只保留年份信息，以满足按年分组统计总条数的需求。 params.put("dateFormat", "%Y"); + // 如果日期格式化类型为 "2"，表示按照月份进行日期格式化及分组统计总条数的操作。 }else if("2".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y-%m"，用于将日期格式化为包含年份和月份的信息，便于按月分组统计总条数。 params.put("dateFormat", "%Y-%m"); + // 如果日期格式化类型为 "3"，表示按照日期（天）进行日期格式化及分组统计总条数的操作。 }else if("3".equals(dateFormatType)){ + // 在参数Map中添加 "dateFormat" 键值对，其值为 "%Y-%m-%d"，用于将日期格式化为包含完整的年、月、日信息，以实现按日分组统计总条数。 params.put("dateFormat", "%Y-%m-%d"); + // 如果日期格式化类型不是上述定义的 "1"、"2"、"3" 中的任何一个，说明传入的日期格式化类型不符合业务要求，是不正确的。 }else{ + // 返回一个表示错误状态的R对象，其中包含错误提示信息 "日期格式化类型不正确"，告知客户端请求参数有误，无法正常执行统计操作。 R.error("日期格式化类型不正确"); } + + // 调用commonService的newSelectDateGroupCount方法，传递处理好的包含各种参数的Map对象，获取字典表按照日期分组统计总条数的结果数据， + // 返回的数据是一个包含多个Map的List集合，每个内层的Map可能对应一组分组统计总条数的相关信息。 List> result = commonService.newSelectDateGroupCount(params); + + // 使用R类型对象封装统计得到的结果数据，以 "data" 作为键值对中的键，将结果返回给客户端，通过R.ok()表示此次操作执行成功， + // 客户端接收到返回结果后可按照约定格式解析获取相应的分组统计总条数数据。 return R.ok().put("data", result); } + /** * 饼状图 * -- 饼状图 查询当前表 @@ -395,36 +582,70 @@ public class CommonController{ /** * 柱状图求和 */ + + // 此方法用于进行柱状图相关的数据求和操作，接收一个包含各种参数的Map对象，这些参数用于确定求和的具体条件、涉及的数据表等信息。 + // 在方法内部会对参数进行一系列处理，包括解析JSON字符串为Map、对特定字段按逗号进行分割处理等，为后续的求和操作做准备。 + // @RequestMapping注解指定了访问此接口的请求路径为"/barSum"，当客户端发起对应路径的请求时，该方法会被触发执行相应的业务逻辑。 @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 = "";//第二优先 + // 使用日志记录器记录DEBUG级别的日志信息，输出当前执行的方法名称（通过 this.getClass().getName() 获取类名）以及传入参数转换为JSON字符串后的内容， + // 方便在调试时查看方法的调用情况以及传入参数的具体情况，此处将参数转换为JSON字符串是为了更清晰完整地展示参数结构和内容。 + logger.debug("barSum方法:,,Controller:{},,params:{}",this.getClass().getName(),com.alibaba.fastjson.JSONObject.toJSONString(params)); + // 定义一个布尔变量，用于标记是否存在级联表相关的情况，初始化为false，表示默认没有级联表相关操作。 + Boolean isJoinTableFlag = false;//是否有级联表相关 + // 定义一个字符串变量，用于记录第一优先处理的字段相关标识，初始化为空字符串，后续会根据具体情况赋值。 + String one = "";//第一优先 + // 定义一个字符串变量，用于记录第二优先处理的字段相关标识，初始化为空字符串，同样会根据具体情况进行赋值。 + String two = "";//第二优先 - //处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组 - //当前表 + // 以下开始处理当前表（thisTable）和级联表（joinTable）相关的参数内容，主要操作是将JSON字符串形式的参数转换为Map类型，并对带有逗号的特定字段进行切割处理，转化为数组形式。 + + // 处理当前表（thisTable）相关参数。 + // 从传入的参数Map中获取名为 "thisTable" 的参数值（其原本为JSON字符串形式），将其转换为Map类型，以便后续方便操作其中的各个字段信息。 Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class); + // 将转换后的当前表相关的Map对象重新放回参数Map中，覆盖原来的JSON字符串形式，方便后续统一基于Map形式进行操作。 params.put("thisTable",thisTable); //级联表 + // 处理级联表（joinTable）相关参数。 + // 从传入的参数Map中获取名为 "joinTable" 的参数值（其为JSON字符串形式），并转换为字符串类型进行后续判断处理。 String joinTableString = String.valueOf(params.get("joinTable")); + // 判断级联表的字符串表示是否不为空（即存在级联表相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(joinTableString)) { + // 将级联表的JSON字符串形式的参数转换为Map类型，以便后续操作其中的字段信息。 Map joinTable = JSON.parseObject(joinTableString, Map.class); + // 将转换后的级联表相关的Map对象重新放回参数Map中，覆盖原来的JSON字符串形式，便于后续统一处理。 params.put("joinTable", joinTable); + // 将表示存在级联表相关的标志变量置为true，用于后续其他逻辑判断，表明当前操作涉及级联表。 isJoinTableFlag = true; } + // 以下是根据当前表（thisTable）和级联表（joinTable）中不同字段的情况，对相关字段进行处理，并确定第一优先和第二优先处理的字段标识。 + + // 处理当前表日期字段（date）相关情况。 + // 判断当前表的 "date" 字段值是否不为空（即有日期相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期 + // 将当前表的 "date" 字段值（原本为字符串形式，可能包含逗号分隔的多个日期值）按逗号进行分割，转化为字符串数组形式， + // 以便后续在求和等操作中能更方便地处理多个日期相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("date",String.valueOf(thisTable.get("date")).split(",")); + // 将第一优先处理的字段标识设置为 "thisDate0"，表示当前表日期字段在后续操作中可能具有第一优先级（具体优先级作用取决于整体业务逻辑）。 one = "thisDate0"; } + + // 处理级联表日期字段（date）相关情况，前提是存在级联表相关（即 isJoinTableFlag 为true）。 if(isJoinTableFlag){//级联表日期 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的日期字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "date" 字段值是否不为空（即有日期相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){ + // 将级联表的 "date" 字段值按逗号进行分割，转化为字符串数组形式，便于后续处理多个日期相关的数据情况， + // 然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("date",String.valueOf(joinTable.get("date")).split(",")); + // 判断第一优先处理的字段标识是否为空，如果为空，则表示当前级联表日期字段在这种情况下具有第一优先级，将其标识设置为 "joinDate0"。 if(StringUtil.isEmpty(one)){ one ="joinDate0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识是否为空， + // 如果为空，则表示当前级联表日期字段在这种情况下具有第二优先级，将其标识设置为 "joinDate0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinDate0"; @@ -432,22 +653,38 @@ public class CommonController{ } } } + + // 处理当前表字符串字段（string）相关情况。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串 + // 将当前表的 "string" 字段值（原本为字符串形式，可能包含逗号分隔的多个字符串值）按逗号进行分割，转化为字符串数组形式， + // 方便后续在求和等操作中处理多个字符串相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("string",String.valueOf(thisTable.get("string")).split(",")); + // 判断第一优先处理的字段标识是否为空，如果为空，则表示当前表字符串字段在这种情况下具有第一优先级，将其标识设置为 "thisString0"。 if(StringUtil.isEmpty(one)){ one ="thisString0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识是否为空， + // 如果为空，则表示当前表字符串字段在这种情况下具有第二优先级，将其标识设置为 "thisString0"。 }else{ if(StringUtil.isEmpty(two)){ two ="thisString0"; } } } + + // 处理级联表字符串字段（string）相关情况，前提是存在级联表相关（即 isJoinTableFlag 为true）。 if(isJoinTableFlag){//级联表字符串 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的字符串字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "string" 字段值是否不为空（即有字符串相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){ + // 将级联表的 "string" 字段值按逗号进行分割，转化为字符串数组形式，便于后续处理多个字符串相关的数据情况， + // 然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("string",String.valueOf(joinTable.get("string")).split(",")); + // 判断第一优先处理的字段标识是否为空，如果为空，则表示当前级联表字符串字段在这种情况下具有第一优先级，将其标识设置为 "joinString0"。 if(StringUtil.isEmpty(one)){ one ="joinString0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识是否为空， + // 如果为空，则表示当前级联表字符串字段在这种情况下具有第二优先级，将其标识设置为 "joinString0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinString0"; @@ -455,22 +692,40 @@ public class CommonController{ } } } + + + // 处理当前表（thisTable）类型（types）字段相关情况。 + // 判断当前表的 "types" 字段值是否不为空（即有类型相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型 + // 将当前表的 "types" 字段值（原本为字符串形式，可能包含逗号分隔的多个类型值）按逗号进行分割，转化为字符串数组形式， + // 方便后续在柱状图相关操作（比如数据分类展示等）中能更好地处理多个类型相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("types",String.valueOf(thisTable.get("types")).split(",")); + // 判断第一优先处理的字段标识（one）是否为空，如果为空，则表示当前表类型字段在这种情况下具有第一优先级，将其标识设置为 "thisTypes0"。 if(StringUtil.isEmpty(one)){ one ="thisTypes0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识（two）是否为空， + // 如果为空，则表示当前表类型字段在这种情况下具有第二优先级，将其标识设置为 "thisTypes0"。 }else{ if(StringUtil.isEmpty(two)){ two ="thisTypes0"; } } } + + // 处理级联表（joinTable）类型（types）字段相关情况，前提是存在级联表相关（即 isJoinTableFlag 为true）。 if(isJoinTableFlag){//级联表类型 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的类型字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "types" 字段值是否不为空（即有类型相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){ + // 将级联表的 "types" 字段值按逗号进行分割，转化为字符串数组形式，便于后续处理多个类型相关的数据情况， + // 然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("types",String.valueOf(joinTable.get("types")).split(",")); + // 判断第一优先处理的字段标识（one）是否为空，如果为空，则表示当前级联表类型字段在这种情况下具有第一优先级，将其标识设置为 "joinTypes0"。 if(StringUtil.isEmpty(one)){ one ="joinTypes0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识（two）是否为空， + // 如果为空，则表示当前级联表类型字段在这种情况下具有第二优先级，将其标识设置为 "joinTypes0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinTypes0"; @@ -480,103 +735,198 @@ public class CommonController{ } } + // 调用 commonService（假设是已经注入并正确实现了对应业务逻辑的服务类）的 barSum 方法，传递处理好的包含各种参数的Map对象， + // 获取柱状图求和相关的结果数据，返回的数据类型是一个包含多个Map的List集合，每个内层的Map可能对应一组求和相关的统计结果信息，具体取决于业务逻辑的设计。 List> result = commonService.barSum(params); + // 创建一个用于存储报表 x 轴数据的 ArrayList，后续会将相应的数据添加到该列表中，用于在柱状图中展示 x 轴相关内容（比如分类名称等）。 List xAxis = new ArrayList<>();//报表x轴 + // 创建一个用于存储报表 y 轴数据的 ArrayList，由于 y 轴数据可能有多层结构（比如不同分组下对应不同的数据值等情况），所以这里的元素类型也是ArrayList， + // 后续会根据具体情况构建并添加相应的数据，用于在柱状图中展示 y 轴相关内容（比如不同分类对应的数值等）。 List> yAxis = new ArrayList<>();//y轴 + // 创建一个用于存储报表标题（legend，通常在图表中用于标识不同数据系列的名称）的 ArrayList，后续会将相应的标题名称添加到该列表中，用于在柱状图中展示图例相关内容。 List legend = new ArrayList<>();//标题 + // 判断第二优先处理的字段标识（two）是否为空，以此来区分数据是否包含第二列相关情况，进而采用不同的逻辑来处理结果数据并构建用于柱状图展示的数据结构。 + + // 如果不包含第二列（即 two 为空），表示数据结构相对简单，只有单一维度的数据情况，进行以下处理。 if(StringUtil.isEmpty(two)){//不包含第二列 + // 创建一个用于存储 y 轴单层数据的 ArrayList，后续会将具体的数据值添加到该列表中，作为 y 轴数据的唯一一层数据。 List yAxis0 = new ArrayList<>(); + // 将刚创建的 y 轴单层数据列表添加到 y 轴数据的外层列表中，构建出符合柱状图数据展示要求的 y 轴数据结构（这里只有一层数据情况）。 yAxis.add(yAxis0); + // 添加一个默认的标题名称 "数值" 到 legend 列表中，用于在柱状图中作为唯一的数据系列的图例标识，表示展示的是数值相关的数据。 legend.add("数值"); + // 遍历获取到的柱状图求和结果数据列表（result），对每个结果 Map 进行处理，提取相应的数据添加到 x 轴和 y 轴数据列表中。 for(Map map :result){ + // 获取第一优先处理的字段对应的值，并转换为字符串类型，该值将作为 x 轴上的分类标识等信息添加到 x 轴数据列表中。 String oneValue = String.valueOf(map.get(one)); + // 获取名为 "value" 的字段对应的值（推测是求和得到的数值，具体取决于业务逻辑），并转换为字符串类型，该值将作为 y 轴上对应分类的数值添加到 y 轴数据列表中。 String value = String.valueOf(map.get("value")); + // 将第一优先处理的字段对应的值添加到 x 轴数据列表中，用于在柱状图的 x 轴上展示分类相关信息。 xAxis.add(oneValue); + // 将求和得到的数值添加到 y 轴的单层数据列表中，用于在柱状图的 y 轴上展示对应分类的数值情况。 yAxis0.add(value); } + // 如果包含第二列（即 two 不为空），表示数据结构相对复杂，存在多层维度的数据情况，进行以下处理。 }else{//包含第二列 + // 创建一个 LinkedHashMap，用于存储更复杂的数据结构，键为第一优先处理的字段对应的值（通常是一种分类标识）， + // 值为 HashMap，内层的 HashMap 键为第二优先处理的字段对应的值（另一种分类标识），值为具体的数值（比如求和得到的数值等）， + // 通过这种结构可以方便地对具有两层分类的数据进行整理和后续在柱状图中的展示。 Map> dataMap = new LinkedHashMap<>(); + // 判断第二优先处理的字段标识（two）是否不为空（这里其实已经在前面判断过了，只是再次确认一下逻辑完整性），如果是，则进行以下循环处理。 if(StringUtil.isNotEmpty(two)){ + // 遍历获取到的柱状图求和结果数据列表（result），对每个结果 Map 进行处理，提取相应的数据填充到 dataMap 中，构建复杂的数据结构。 for(Map map :result){ + // 获取第一优先处理的字段对应的值，并转换为字符串类型，作为外层 dataMap 的键（一种分类标识）。 String oneValue = String.valueOf(map.get(one)); + // 获取第二优先处理的字段对应的值，并转换为字符串类型，作为内层 HashMap 的键（另一种分类标识）。 String twoValue = String.valueOf(map.get(two)); + // 获取名为 "value" 的字段对应的值（推测是求和得到的数值，具体取决于业务逻辑），并转换为字符串类型，作为内层 HashMap 的值（具体的数值）。 String value = String.valueOf(map.get("value")); + // 判断 legend 列表中是否已经包含了当前的第二优先处理的字段对应的值（即判断是否已经添加过该分类标识作为图例名称）， + // 如果不包含，则将其添加到 legend 列表中，用于在柱状图中作为不同数据系列的图例标识，确保图例包含了所有的分类情况。 if(!legend.contains(twoValue)){ legend.add(twoValue);//添加完成后 就是最全的第二列的类型 } + // 判断 dataMap 中是否已经包含了当前的第一优先处理的字段对应的值（即判断是否已经有该外层分类标识对应的内层数据结构），如果包含，说明之前已经处理过同类型的外层分类，进行以下操作。 if(dataMap.containsKey(oneValue)){ + // 获取已经存在的对应外层分类标识下的内层 HashMap，然后将当前的第二优先处理的字段对应的值和数值添加到该内层 HashMap 中， + // 用于更新或补充该外层分类下不同内层分类对应的数值情况。 dataMap.get(oneValue).put(twoValue,value); + // 如果 dataMap 中不包含当前的第一优先处理的字段对应的值，说明是新的外层分类情况，进行以下操作。 }else{ + // 创建一个新的内层 HashMap，用于存储当前外层分类下不同内层分类对应的数值情况。 HashMap oneData = new HashMap<>(); + // 将当前的第二优先处理的字段对应的值和数值添加到新创建的内层 HashMap 中。 oneData.put(twoValue,value); + // 将新创建的内层 HashMap 作为值，以当前的第一优先处理的字段对应的值作为键，添加到 dataMap 中，构建出完整的两层分类数据结构。 dataMap.put(oneValue,oneData); } } } + + // 这段代码的主要目的是根据之前构建好的 legend（标题列表，用于标识不同数据系列）、dataMap（存储了不同分类对应的数据值的复杂数据结构）等数据， + // 进一步完善用于柱状图展示的 x 轴、y 轴数据结构，将其组装成最终符合要求的格式，以便后续返回给客户端用于前端展示。 + + // 根据 legend 的大小，为 y 轴数据结构（yAxis，是一个 List> 类型，外层列表对应不同的数据系列，内层列表对应每个系列的数据值）添加相应数量的内层列表。 + // 每个内层列表将用于存储对应数据系列（由 legend 中的元素标识）在各个分类（x 轴分类，后续会填充）下的数据值。 for(int i =0; i()); } + + // 获取 dataMap 的键集合（keySet），这里的键通常对应着 x 轴上的分类标识（比如不同的日期、类型等，取决于业务逻辑），用于后续遍历填充 x 轴和相应的 y 轴数据。 Set keys = dataMap.keySet(); + // 遍历 dataMap 的键集合，对每个键（即每个 x 轴分类标识）进行处理，填充 x 轴和对应的 y 轴数据。 for(String key:keys){ + // 将当前键（分类标识）添加到 x 轴数据列表（xAxis）中，用于在柱状图的 x 轴上展示分类信息。 xAxis.add(key); + // 根据当前键从 dataMap 中获取对应的内层 HashMap，该 HashMap 存储了当前分类下不同数据系列（由 legend 标识）对应的数值信息（如果有的话）。 HashMap map = dataMap.get(key); + // 遍历 legend 列表，对于每个数据系列标识（也就是 legend 中的每个元素），进行以下操作，以填充对应的 y 轴数据列表（yAxis 中的内层列表）。 for(int i =0; i data = yAxis.get(i); - if(StringUtil.isNotEmpty(map.get(legend.get(i)))){ + // 判断当前分类下（由外层循环的 key 确定）对应的数据系列（由 legend.get(i) 确定）在 map 中是否有对应的值（即是否存在相应的数值信息）， + // 如果有值，则将该值添加到对应的 y 轴数据列表中，表示该分类下该数据系列对应的数值情况。 + if (StringUtil.isNotEmpty(map.get(legend.get(i)))) { data.add(map.get(legend.get(i))); - }else{ + // 如果当前分类下对应的数据系列在 map 中没有值，说明该分类下该数据系列不存在具体数值，按照默认情况添加 "0" 到对应的 y 轴数据列表中， + // 以保证数据结构的完整性，便于前端在展示柱状图时进行统一处理（比如显示为数值为 0 的柱子等情况）。 + } else { data.add("0"); } } } + + // 输出一个空行，可能用于调试时在控制台区分不同部分的日志信息等情况（实际意义需结合具体调试场景判断），这里对整体逻辑影响不大。 System.out.println(); } + + // 创建一个新的 HashMap，用于将整理好的 x 轴、y 轴以及 legend 数据封装在一起，方便后续统一作为结果返回给客户端，符合一定的响应格式要求。 Map resultMap = new HashMap<>(); + // 将整理好的 x 轴数据列表（xAxis）添加到 resultMap 中，键为 "xAxis"，方便客户端根据键获取相应的数据用于柱状图的 x 轴展示。 resultMap.put("xAxis",xAxis); + // 将整理好的 y 轴数据结构（yAxis）添加到 resultMap 中，键为 "yAxis"，客户端可据此获取数据用于柱状图的 y 轴展示，展示不同分类下各数据系列对应的数值情况。 resultMap.put("yAxis",yAxis); + // 将整理好的 legend 数据列表（用于标识不同数据系列的标题列表）添加到 resultMap 中，键为 "legend"，客户端可利用其在柱状图中展示相应的图例信息。 resultMap.put("legend",legend); + // 使用 R 类型对象（可能是项目自定义的用于统一响应格式的类，例如包含了响应状态码、消息以及具体数据等信息）来封装最终的结果数据， + // 以 "data" 作为键值对中的键，将包含了 x 轴、y 轴和 legend 数据的 resultMap 放入其中，然后将整个封装好的 R 对象返回给客户端， + // 通过 R.ok() 表示此次操作执行成功，客户端接收到返回结果后可根据约定的格式解析并获取相应的数据用于柱状图的展示。 return R.ok().put("data", resultMap); - } - - /** - * 柱状图统计 - */ - @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并把带有,的切割为数组 - //当前表 + } + + + // 以下是另一个方法 barCount 的相关代码注释，该方法与前面的 barSum 方法在功能和部分处理逻辑上有相似之处，都是用于柱状图相关的数据处理及统计操作。 + + // 此方法用于进行柱状图相关的统计操作，接收一个包含各种参数的Map对象，这些参数用于确定统计的具体条件、涉及的数据表等信息。 + // 在方法内部会对参数进行一系列处理，包括解析JSON字符串为Map、对特定字段按逗号进行分割处理等，为后续的统计操作做准备。 + // @RequestMapping注解指定了访问此接口的请求路径为"/barCount"，当客户端发起对应路径的请求时，该方法会被触发执行相应的业务逻辑。 + @RequestMapping("/barCount") + public R barCount(@RequestParam Map params) { + // 使用日志记录器记录DEBUG级别的日志信息，输出当前执行的方法名称（通过 this.getClass().getName() 获取类名）以及传入参数转换为JSON字符串后的内容， + // 方便在调试时查看方法的调用情况以及传入参数的具体情况，此处将参数转换为JSON字符串是为了更清晰完整地展示参数结构和内容。 + logger.debug("barCount方法:,,Controller:{},,params:{}",this.getClass().getName(),com.alibaba.fastjson.JSONObject.toJSONString(params)); + + // 定义一个布尔变量，用于标记是否存在级联表相关的情况，初始化为false，表示默认没有级联表相关操作。 + Boolean isJoinTableFlag = false;//是否有级联表相关 + // 定义一个字符串变量，用于记录第一优先处理的字段相关标识，初始化为空字符串，后续会根据具体情况赋值。 + String one = "";//第一优先 + // 定义一个字符串变量，用于记录第二优先处理的字段相关标识，初始化为空字符串，同样会根据具体情况进行赋值。 + String two = "";//第二优先 + + // 以下开始处理当前表（thisTable）和级联表（joinTable）相关的参数内容，主要操作是将JSON字符串形式的参数转换为Map类型，并对带有逗号的特定字段进行切割处理，转化为数组形式。 + + // 处理当前表（thisTable）相关参数。 + // 从传入的参数Map中获取名为 "thisTable" 的参数值（其原本为JSON字符串形式），将其转换为Map类型，以便后续方便操作其中的各个字段信息。 Map thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class); + // 将转换后的当前表相关的Map对象重新放回参数Map中，覆盖原来的JSON字符串形式，方便后续统一基于Map形式进行操作。 params.put("thisTable",thisTable); - //级联表 + // 处理级联表（joinTable）相关参数。 + // 从传入的参数Map中获取名为 "joinTable" 的参数值（其为JSON字符串形式），并转换为字符串类型进行后续判断处理。 String joinTableString = String.valueOf(params.get("joinTable")); + // 判断级联表的字符串表示是否不为空（即存在级联表相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(joinTableString)) { + // 将级联表的JSON字符串形式的参数转换为Map类型，以便后续操作其中的字段信息。 Map joinTable = JSON.parseObject(joinTableString, Map.class); + // 将转换后的级联表相关的Map对象重新放回参数Map中，覆盖原来的JSON字符串形式，便于后续统一处理。 params.put("joinTable", joinTable); + // 将表示存在级联表相关的标志变量置为true，用于后续其他逻辑判断，表明当前操作涉及级联表。 isJoinTableFlag = true; } + // 以下是根据当前表（thisTable）和级联表（joinTable）中不同字段的情况，对相关字段进行处理，并确定第一优先和第二优先处理的字段标识。 + + // 处理当前表日期字段（date）相关情况。 + // 判断当前表的 "date" 字段值是否不为空（即有日期相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期 + // 将当前表的 "date" 字段值（原本为字符串形式，可能包含逗号分隔的多个日期值）按逗号进行分割，转化为字符串数组形式， + // 以便后续在统计等操作中能更方便地处理多个日期相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("date",String.valueOf(thisTable.get("date")).split(",")); + // 将第一优先处理的字段标识设置为 "thisDate0"，表示当前表日期字段在后续操作中可能具有第一优先级（具体优先级作用取决于整体业务逻辑）。 one = "thisDate0"; } + + // 处理级联表日期字段（date）相关情况，前提是存在级联表相关（即 isJoinTableFlag 为true）。 if(isJoinTableFlag){//级联表日期 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的日期字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "date" 字段值是否不为空（即有日期相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){ + // 将级联表的 "date" 字段值按逗号进行分割，转化为字符串数组形式，便于后续处理多个日期相关的数据情况， + // 然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("date",String.valueOf(joinTable.get("date")).split(",")); + // 判断第一优先处理的字段标识是否为空，如果为空，则表示当前级联表日期字段在这种情况下具有第一优先级，将其标识设置为 "joinDate0"。 if(StringUtil.isEmpty(one)){ one ="joinDate0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识是否为空， + // 如果为空，则表示当前级联表日期字段在这种情况下具有第二优先级，将其标识设置为 "joinDate0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinDate0"; @@ -584,22 +934,38 @@ public class CommonController{ } } } + // 处理当前表字符串字段（string）相关情况。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串 + // 将当前表的 "string" 字段值（原本为字符串形式，可能包含逗号分隔的多个字符串值）按逗号进行分割，转化为字符串数组形式， + // 方便后续在统计等操作中处理多个字符串相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("string",String.valueOf(thisTable.get("string")).split(",")); + // 判断第一优先处理的字段标识是否为空，如果为空，则表示当前表字符串字段在这种情况下具有第一优先级，将其标识设置为 "thisString0"。 if(StringUtil.isEmpty(one)){ one ="thisString0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识是否为空， + // 如果为空，则表示当前表字符串字段在这种情况下具有第二优先级，将其标识设置为 "thisString0"。 }else{ if(StringUtil.isEmpty(two)){ two ="thisString0"; } } } + if(isJoinTableFlag){//级联表字符串 + // 处理级联表（joinTable）字符串（string）字段相关情况，前提是存在级联表相关（即 isJoinTableFlag 为 true）。 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的字符串字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "string" 字段值是否不为空（即有字符串相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){ + + // 将级联表的 "string" 字段值（原本为字符串形式，可能包含逗号分隔的多个字符串值）按逗号进行分割，转化为字符串数组形式， + // 便于后续在柱状图相关操作（比如数据分类展示等）中能更好地处理多个字符串相关的数据情况，然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("string",String.valueOf(joinTable.get("string")).split(",")); + // 判断第一优先处理的字段标识（one）是否为空，如果为空，则表示当前级联表字符串字段在这种情况下具有第一优先级，将其标识设置为 "joinString0"。 if(StringUtil.isEmpty(one)){ one ="joinString0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识（two）是否为空， + // 如果为空，则表示当前级联表字符串字段在这种情况下具有第二优先级，将其标识设置为 "joinString0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinString0"; @@ -607,22 +973,38 @@ public class CommonController{ } } } + +// 处理当前表（thisTable）类型（types）字段相关情况。 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型 + // 将当前表的 "types" 字段值（原本为字符串形式，可能包含逗号分隔的多个类型值）按逗号进行分割，转化为字符串数组形式， + // 方便后续在柱状图相关操作（比如数据分类展示等）中能更好地处理多个类型相关的数据情况，然后将处理后的数组重新放回当前表的Map中，覆盖原来的字符串值。 thisTable.put("types",String.valueOf(thisTable.get("types")).split(",")); + // 判断第一优先处理的字段标识（one）是否为空，如果为空，则表示当前表类型字段在这种情况下具有第一优先级，将其标识设置为 "thisTypes0"。 if(StringUtil.isEmpty(one)){ one ="thisTypes0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识（two）是否为空， + // 如果为空，则表示当前表类型字段在这种情况下具有第二优先级，将其标识设置为 "thisTypes0"。 }else{ if(StringUtil.isEmpty(two)){ two ="thisTypes0"; } } } + +// 处理级联表（joinTable）类型（types）字段相关情况，前提是存在级联表相关（即 isJoinTableFlag 为 true）。 if(isJoinTableFlag){//级联表类型 + // 从参数Map中获取级联表对应的Map对象，方便后续操作其中的类型字段信息。 Map joinTable = (Map) params.get("joinTable"); + // 判断级联表的 "types" 字段值是否不为空（即有类型相关参数传入），如果是，则进行以下处理。 if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){ + // 将级联表的 "types" 字段值按逗号进行分割，转化为字符串数组形式，便于后续处理多个类型相关的数据情况， + // 然后将处理后的数组重新放回级联表的Map中，覆盖原来的字符串值。 joinTable.put("types",String.valueOf(joinTable.get("types")).split(",")); + // 判断第一优先处理的字段标识（one）是否为空，如果为空，则表示当前级联表类型字段在这种情况下具有第一优先级，将其标识设置为 "joinTypes0"。 if(StringUtil.isEmpty(one)){ one ="joinTypes0"; + // 如果第一优先处理的字段标识已经有值了，说明之前已经确定了其他更优先的字段，此时判断第二优先处理的字段标识（two）是否为空， + // 如果为空，则表示当前级联表类型字段在这种情况下具有第二优先级，将其标识设置为 "joinTypes0"。 }else{ if(StringUtil.isEmpty(two)){ two ="joinTypes0"; @@ -632,67 +1014,129 @@ public class CommonController{ } } + // 调用 commonService（假设是已经注入并正确实现了对应业务逻辑的服务类）的 barCount 方法，传递处理好的包含各种参数的Map对象， + // 获取柱状图统计相关的结果数据，返回的数据类型是一个包含多个Map的List集合，每个内层的Map可能对应一组统计相关的结果信息，具体取决于业务逻辑的设计。 List> result = commonService.barCount(params); + // 创建一个用于存储报表 x 轴数据的 ArrayList，后续会将相应的数据添加到该列表中，用于在柱状图中展示 x 轴相关内容（比如分类名称等）。 List xAxis = new ArrayList<>();//报表x轴 + // 创建一个用于存储报表 y 轴数据的 ArrayList，由于 y 轴数据可能有多层结构（比如不同分组下对应不同的数据值等情况），所以这里的元素类型也是ArrayList， + // 后续会根据具体情况构建并添加相应的数据，用于在柱状图中展示 y 轴相关内容（比如不同分类对应的数值等）。 List> yAxis = new ArrayList<>();//y轴 + // 创建一个用于存储报表标题（legend，通常在图表中用于标识不同数据系列的名称）的 ArrayList，后续会将相应的标题名称添加到该列表中，用于在柱状图中展示图例相关内容。 List legend = new ArrayList<>();//标题 +// 判断第二优先处理的字段标识（two）是否为空，以此来区分数据是否包含第二列相关情况，进而采用不同的逻辑来处理结果数据并构建用于柱状图展示的数据结构。 + +// 如果不包含第二列（即 two 为空），表示数据结构相对简单，只有单一维度的数据情况，进行以下处理。 if(StringUtil.isEmpty(two)){//不包含第二列 + // 创建一个用于存储 y 轴单层数据的 ArrayList，后续会将具体的数据值添加到该列表中，作为 y 轴数据的唯一一层数据。 List yAxis0 = new ArrayList<>(); + // 将刚创建的 y 轴单层数据列表添加到 y 轴数据的外层列表中，构建出符合柱状图数据展示要求的 y 轴数据结构（这里只有一层数据情况）。 yAxis.add(yAxis0); + // 添加一个默认的标题名称 "数值" 到 legend 列表中，用于在柱状图中作为唯一的数据系列的图例标识，表示展示的是数值相关的数据。 legend.add("数值"); + // 遍历获取到的柱状图统计结果数据列表（result），对每个结果 Map 进行处理，提取相应的数据添加到 x 轴和 y 轴数据列表中。 for(Map map :result){ + // 获取第一优先处理的字段对应的值，并转换为字符串类型，该值将作为 x 轴上的分类标识等信息添加到 x 轴数据列表中。 String oneValue = String.valueOf(map.get(one)); + // 获取名为 "value" 的字段对应的值（推测是统计得到的数值，具体取决于业务逻辑），并转换为字符串类型，该值将作为 y 轴上对应分类的数值添加到 y 轴数据列表中。 String value = String.valueOf(map.get("value")); + // 将第一优先处理的字段对应的值添加到 x 轴数据列表中，用于在柱状图的 x 轴上展示分类相关信息。 xAxis.add(oneValue); + // 将统计得到的数值添加到 y 轴的单层数据列表中，用于在柱状图的 y 轴上展示对应分类的数值情况。 yAxis0.add(value); } +// 如果包含第二列（即 two 不为空），表示数据结构相对复杂，存在多层维度的数据情况，进行以下处理。 }else{//包含第二列 + // 创建一个 LinkedHashMap，用于存储更复杂的数据结构，键为第一优先处理的字段对应的值（通常是一种分类标识）， + // 值为 HashMap，内层的 HashMap 键为第二优先处理的字段对应的值（另一种分类标识），值为具体的数值（比如统计得到的数值等）， + // 通过这种结构可以方便地对具有两层分类的数据进行整理和后续在柱状图中的展示。 Map> dataMap = new LinkedHashMap<>(); + // 判断第二优先处理的字段标识（two）是否不为空（这里其实已经在前面判断过了，只是再次确认一下逻辑完整性），如果是，则进行以下循环处理。 if(StringUtil.isNotEmpty(two)){ + // 遍历获取到的柱状图统计结果数据列表（result），对每个结果 Map 进行处理，提取相应的数据填充到 dataMap 中，构建复杂的数据结构。 for(Map map :result){ + // 获取第一优先处理的字段对应的值，并转换为字符串类型，作为外层 dataMap 的键（一种分类标识）。 String oneValue = String.valueOf(map.get(one)); + // 获取第二优先处理的字段对应的值，并转换为字符串类型，作为内层 HashMap 的键（另一种分类标识）。 String twoValue = String.valueOf(map.get(two)); + // 获取名为 "value" 的字段对应的值（推测是统计得到的数值，具体取决于业务逻辑），并转换为字符串类型，作为内层 HashMap 的值（具体的数值）。 String value = String.valueOf(map.get("value")); + // 判断 legend 列表中是否已经包含了当前的第二优先处理的字段对应的值（即判断是否已经添加过该分类标识作为图例名称）， + // 如果不包含，则将其添加到 legend 列表中，用于在柱状图中作为不同数据系列的图例标识，确保图例包含了所有的分类情况。 if(!legend.contains(twoValue)){ - legend.add(twoValue);//添加完成后 就是最全的第二列的类型 + legend.add(twoValue);//添加完成后 就是最全的第二列的类型 } + // 判断 dataMap 中是否已经包含了当前的第一优先处理的字段对应的值（即判断是否已经有该外层分类标识对应的内层数据结构），如果包含，说明之前已经处理过同类型的外层分类，进行以下操作。 if(dataMap.containsKey(oneValue)){ + // 获取已经存在的对应外层分类标识下的内层 HashMap，然后将当前的第二优先处理的字段对应的值和数值添加到该内层 HashMap 中， + // 用于更新或补充该外层分类下不同内层分类对应的数值情况。 dataMap.get(oneValue).put(twoValue,value); + // 如果 dataMap 中不包含当前的第一优先处理的字段对应的值，说明是新的外层分类情况，进行以下操作。 }else{ + // 创建一个新的内层 HashMap，用于存储当前外层分类下不同内层分类对应的数值情况。 HashMap oneData = new HashMap<>(); + // 将当前的第二优先处理的字段对应的值和数值添加到新创建的内层 HashMap 中。 oneData.put(twoValue,value); + // 将新创建的内层 HashMap 作为值，以当前的第一优先处理的字段对应的值作为键，添加到 dataMap 中，构建出完整的两层分类数据结构。 dataMap.put(oneValue,oneData); } } } + // 以下代码是基于前面已经构建好的 legend（图例相关数据列表）、dataMap（存储特定数据结构的映射表）等数据， + // 进一步完善用于柱状图展示的 x 轴（xAxis）和 y 轴（yAxis）数据结构，使其符合最终在前端展示柱状图的要求。 + + // 根据 legend 列表的大小，为 y 轴数据结构（yAxis，是一个 List> 类型，外层列表对应不同的数据系列，内层列表对应每个系列的数据值）添加相应数量的内层列表。 + // 每个内层列表将用于存储对应数据系列（由 legend 中的元素标识）在各个分类（x 轴分类，后续会填充）下的数据值，以此构建出 y 轴多层结构的初始框架。 for(int i =0; i()); } + // 获取 dataMap 的键集合（keySet），这里的键通常对应着 x 轴上的分类标识（比如不同的日期、类型等，取决于业务逻辑）， + // 后续将通过遍历这些键来填充 x 轴数据列表（xAxis）以及对应的 y 轴各内层列表数据。 Set keys = dataMap.keySet(); + + // 遍历 dataMap 的键集合，对每个键（即每个 x 轴分类标识）进行处理，填充 x 轴和对应的 y 轴数据，以构建完整的柱状图展示数据结构。 for(String key:keys){ + // 将当前键（分类标识）添加到 x 轴数据列表（xAxis）中，用于在柱状图的 x 轴上展示分类信息，使 x 轴能体现出不同的分类情况。 xAxis.add(key); + + // 根据当前键从 dataMap 中获取对应的内层 HashMap，该 HashMap 存储了当前分类下不同数据系列（由 legend 标识）对应的数值信息（如果有的话）， + // 后续将依据这个 HashMap 来填充 y 轴对应的数据。 HashMap map = dataMap.get(key); + + // 遍历 legend 列表，对于每个数据系列标识（也就是 legend 中的每个元素），进行以下操作，以填充对应的 y 轴数据列表（yAxis 中的内层列表）。 + // 这样就能确保每个数据系列在每个 x 轴分类下都有对应的数据值（若不存在实际值则按默认情况处理）。 for(int i =0; i data = yAxis.get(i); + + // 判断当前分类下（由外层循环的 key 确定）对应的数据系列（由 legend.get(i) 确定）在 map 中是否有对应的值（即是否存在相应的数值信息）， + // 如果有值，则将该值添加到对应的 y 轴数据列表中，表示该分类下该数据系列对应的数值情况，用于在柱状图中准确展示相应数据。 if(StringUtil.isNotEmpty(map.get(legend.get(i)))){ data.add(map.get(legend.get(i))); + // 如果当前分类下对应的数据系列在 map 中没有值，说明该分类下该数据系列不存在具体数值，按照默认情况添加 "0" 到对应的 y 轴数据列表中， + // 这样可以保证数据结构的完整性，便于前端在展示柱状图时进行统一处理（比如显示为数值为 0 的柱子等情况）。 }else{ data.add("0"); } } } + + // 输出一个空行，可能用于调试时在控制台区分不同部分的日志信息等情况（实际意义需结合具体调试场景判断），这里对整体逻辑影响不大。 System.out.println(); } + // 创建一个HashMap用于封装整理好的x轴、y轴以及legend数据，方便后续统一作为结果返回给客户端。 Map resultMap = new HashMap<>(); resultMap.put("xAxis",xAxis); resultMap.put("yAxis",yAxis); resultMap.put("legend",legend); + // 使用R类型对象封装最终结果数据，以"data"为键值对中的键，将包含相关数据的resultMap放入其中，返回成功响应给客户端。 return R.ok().put("data", resultMap); } } -- 2.34.1