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 01/12] 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 02/12] =?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 03/12] =?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 04/12] =?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 05/12] 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 06/12] =?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 07/12] =?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 From d993de692388d9844f2a5da74b0b23765d742af4 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 22:23:14 +0800 Subject: [PATCH 08/12] =?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 --- .../DictionaryServletContextListener.java | 59 ++++- .../java/com/annotation/APPLoginUser.java | 20 ++ .../main/java/com/annotation/IgnoreAuth.java | 22 ++ .../main/java/com/annotation/LoginUser.java | 17 ++ .../src/main/java/com/dao/CommonDao.java | 199 ++++++++++++++++- .../src/main/java/com/entity/EIException.java | 47 +++- .../interceptor/AuthorizationInterceptor.java | 89 +++++++- .../main/java/com/model/enums/TypeEnum.java | 38 +++- .../main/java/com/service/CommonService.java | 164 ++++++++++---- .../com/service/impl/CommonServiceImpl.java | 201 +++++++++++++++--- .../com/service/impl/UsersServiceImpl.java | 49 ++++- .../com/service/impl/YonghuServiceImpl.java | 28 ++- .../main/java/com/thread/MyThreadMethod.java | 24 +++ .../src/main/java/com/utils/CommonUtil.java | 22 +- 14 files changed, 876 insertions(+), 103 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java index a74d1774..bc72710b 100644 --- a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java +++ b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java @@ -19,43 +19,98 @@ import java.util.Map; /** * 字典初始化监视器 用的是服务器监听,每次项目启动,都会调用这个类 */ + + +/** + * 这是一个字典初始化监视器类，它实现了ServletContextListener接口，利用服务器监听机制，在每次项目启动时都会被调用， + * 主要负责完成字典表数据的初始化工作以及启动一个自定义的线程（MyThreadMethod）。在项目停止时，也能相应地记录相关日志信息， + * 整体在整个项目的生命周期中，对于字典表数据的准备以及特定线程的启动管理起着关键作用，确保相关功能在合适的时机得以执行。 + */ +// 使用@WebListener注解将该类标记为一个Web监听器，使其能够被Web容器识别并在对应的生命周期事件（如项目启动、停止等）发生时被调用， +// 从而执行相应的逻辑，在这里就是进行字典初始化以及线程启动等操作。 @WebListener public class DictionaryServletContextListener implements ServletContextListener { + // 创建一个静态的Logger对象，用于记录日志信息，通过LoggerFactory.getLogger方法传入当前类的Class对象来获取， + // 后续可以使用这个logger在不同的生命周期方法中记录如项目启动、停止、字典表初始化等各个阶段的关键信息，方便排查问题以及了解程序执行情况。 private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class); + + // 声明一个MyThreadMethod类型的变量，用于存储一个自定义的线程对象，这个线程大概率执行一些与业务相关的后台任务，具体任务由MyThreadMethod类的实现决定， + // 初始化为null，会在合适的时机（项目启动时的上下文初始化阶段）进行实例化并启动。 private MyThreadMethod myThreadMethod; + + /** + * 此方法是ServletContextListener接口中定义的，在Web应用的Servlet上下文被销毁时（通常意味着项目停止）会被调用， + * 在这里主要用于记录服务器停止的相关日志信息，方便后续查看项目的关闭情况以及进行相关的日志分析等操作。 + * + * @param sce ServletContextEvent对象，包含了与Servlet上下文销毁相关的事件信息，不过在此方法中目前只是利用它来触发日志记录，未对其事件相关内容做更多处理。 + */ @Override public void contextDestroyed(ServletContextEvent sce) { logger.info("----------服务器停止----------"); } + + /** + * 此方法是ServletContextListener接口中定义的，在Web应用的Servlet上下文初始化时（也就是项目启动时）会被调用， + * 主要承担了字典表数据初始化以及启动自定义线程的重要任务，通过一系列操作将字典表数据整理并存储到Servlet上下文的属性中，方便后续在整个项目中使用， + * 同时启动特定线程来执行可能的后台持续任务等操作，并且在各个关键步骤记录相应的日志信息，便于了解初始化的执行情况。 + * + * @param sce ServletContextEvent对象，包含了与Servlet上下文初始化相关的事件信息，通过它可以获取到Servlet上下文对象，进而用于获取Spring应用上下文以及设置上下文属性等操作。 + */ @Override public void contextInitialized(ServletContextEvent sce) { + // 通过WebApplicationContextUtils工具类的getWebApplicationContext方法，传入从ServletContextEvent对象中获取的Servlet上下文对象， + // 获取整个Web应用的Spring应用上下文（ApplicationContext），后续可以基于这个上下文来获取Spring容器管理的各种Bean实例，比如获取字典服务相关的Bean。 ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext()); logger.info("----------字典表初始化开始----------"); + // 从Spring应用上下文中获取名为"dictionaryService"的Bean实例，并强制转换为DictionaryService类型， + // DictionaryService应该是一个用于处理字典表相关业务逻辑的服务层接口，通过它可以调用如查询字典表数据等方法来进行字典表初始化操作。 DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService"); + // 调用dictionaryService的selectList方法，传入一个默认的EntityWrapper对象（可能用于添加一些通用的查询条件等，具体取决于业务实现）， + + // 获取字典表中的所有字典实体数据，返回一个List类型的列表，列表中的每个DictionaryEntity对象代表一条字典表记录，包含了如字典编码、索引等相关信息。 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 创建一个HashMap对象，用于存储整理后的字典表数据，其结构是外层的键为字典编码（String类型），值为内层的一个Map， + // 内层的Map中，键为代码索引（Integer类型），值为对应的索引名称（String类型），这样的结构方便后续根据字典编码以及索引快速查找对应的名称等信息。 Map> map = new HashMap<>(); + + // 遍历从字典表中查询到的所有字典实体数据列表，对每条记录进行处理，将其按照特定的结构整理到前面创建的map对象中。 for(DictionaryEntity d :dictionaryEntities){ + + // 根据当前字典实体的字典编码（d.getDicCode()）从map中获取对应的内层Map（即代码索引和索引名称的映射关系），如果获取到的是null或者为空，说明还没有该字典编码对应的映射关系， + // 则创建一个新的HashMap作为内层Map，用于存储该字典编码下的索引和名称对应关系。 Map m = map.get(d.getDicCode()); + if(m ==null || m.isEmpty()){ m = new HashMap<>(); } + // 将当前字典实体的代码索引（d.getCodeIndex()）作为键，索引名称（d.getIndexName()）作为值，放入内层的Map（m）中，以此构建字典编码下具体的索引和名称对应关系。 m.put(d.getCodeIndex(),d.getIndexName()); + // 将整理好的内层Map（m）重新放回外层的map中，以字典编码（d.getDicCode()）作为键，完成当前字典实体数据在整体数据结构中的整理和存储。 map.put(d.getDicCode(),m); } + + // 将整理好的包含字典表数据的map对象存储到Servlet上下文的属性中，属性名为"dictionaryMap"，方便在整个Web应用的其他地方可以通过获取Servlet上下文属性来获取这些字典数据， + // 用于诸如数据展示、业务逻辑中根据字典进行数据转换等操作。 sce.getServletContext().setAttribute("dictionaryMap", map); logger.info("----------字典表初始化完成----------"); - logger.info("----------线程执行开始----------"); + // 判断myThreadMethod是否为null，如果是null，说明还没有实例化该线程对象， + // 则创建一个MyThreadMethod类的实例，用于后续启动一个自定义的线程来执行相关的后台任务（具体任务由MyThreadMethod类的实现决定）。 + if (myThreadMethod == null) { myThreadMethod = new MyThreadMethod(); - myThreadMethod.start(); // servlet 上下文初始化时启动线程myThreadMethod + // 启动前面实例化的myThreadMethod线程，在Servlet上下文初始化（项目启动）时启动这个线程，让其开始执行相应的任务， + // 比如可能是定时更新字典数据、执行一些周期性的业务逻辑等操作，具体取决于MyThreadMethod类中run方法的实现内容。 + myThreadMethod.start(); } logger.info("----------线程执行结束----------"); } } + + diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java b/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java index 21d41b90..fccf135a 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java @@ -8,8 +8,28 @@ import java.lang.annotation.Target; /** * 登录用户信息 */ + + +/** + * 这是一个自定义的注解类型，名为 @APPLoginUser，用于特定的标识用途，通常应用在程序开发中与移动端应用（APP）登录用户相关的场景里。 + * 通过 @Target(ElementType.PARAMETER) 注解设定其作用目标为方法参数，意味着该注解专门用来标记那些代表 APP 登录用户信息的方法参数。 + * 而 @Retention(RetentionPolicy.RUNTIME) 注解规定了它的保留策略是运行时，使得在程序运行阶段能够借助反射机制获取到该注解相关的信息，进而基于此执行相应的业务逻辑，比如针对 APP 登录用户进行权限验证、信息提取等操作。 + */ + + +// @Target 注解用于明确此自定义注解可以应用的元素类型，这里指定为 ElementType.PARAMETER，表明它只能被用在方法参数上， +// 以便在代码中清晰地标识出哪些参数承载了 APP 登录用户的相关信息，方便后续统一处理与 APP 登录用户相关的业务逻辑。 @Target(ElementType.PARAMETER) + + +// @Retention 注解用来定义注解的保留期限和可见性阶段，将其设置为 RetentionPolicy.RUNTIME，表示该注解在程序运行期间依然有效且可被获取， +// 这对于在运行时根据是否存在该注解以及其相关属性（若有定义）来动态地执行如权限判断、数据筛选等和 APP 登录用户紧密相关的操作是非常关键的。 @Retention(RetentionPolicy.RUNTIME) +// 定义了 @APPLoginUser 这个注解，当前它没有定义任何成员变量（属性），不过如果业务需要，可以后续添加属性来传递更多关于 APP 登录用户的详细情况， +// 例如 APP 用户的登录来源、所属平台版本等信息，以更好地适配复杂的业务场景和多样化的处理需求。 + public @interface APPLoginUser { } + + diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java b/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java index 7c3cc550..f3fea46a 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java @@ -5,9 +5,31 @@ import java.lang.annotation.*; /** * 忽略Token验证 */ + + +/** + * 这是一个自定义的注解类型，名为 @IgnoreAuth，其主要作用是用于标记在特定的业务场景下，需要忽略Token验证的方法。 + * 通过 @Target(ElementType.METHOD) 注解明确了它的作用目标是方法，也就是该注解只能应用在方法之上，用来指示对应的方法在执行时不需要进行Token验证这一常规的安全校验操作。 + * @Retention(RetentionPolicy.RUNTIME) 注解定义了它的保留策略为运行时，这意味着在程序运行阶段，仍然可以通过反射机制获取到该注解的相关信息，进而根据此信息来决定是否跳过Token验证流程，满足一些特殊情况下对接口访问的需求，比如公开的、无需登录验证即可访问的接口等情况。 + * 而 @Documented 注解则表示在生成JavaDoc文档时，会将这个注解相关的信息也包含进去，方便开发人员查看和了解该注解的存在以及作用，提高代码的可读性和可维护性，便于团队协作开发时知晓哪些方法是不需要进行Token验证的。 + */ + + +// @Target 注解用于指定此自定义注解能够应用的元素类型，这里将其设置为 ElementType.METHOD，限定了 @IgnoreAuth 注解只能被放置在方法声明处， +// 以此清晰地标识出哪些具体的方法需要忽略Token验证操作，便于代码的阅读者和维护者快速知晓方法的特殊验证要求。 @Target(ElementType.METHOD) + +// @Retention 注解规定了注解的保留策略，此处设为 RetentionPolicy.RUNTIME，表明该注解在程序运行时依然可以被获取到， +// 借助Java的反射机制，在运行期间可以检查方法上是否存在这个注解，进而依据其存在与否来决定是否执行Token验证逻辑，使其能够灵活地控制方法的验证行为。 @Retention(RetentionPolicy.RUNTIME) + +// @Documented 注解的作用是让这个自定义注解在生成JavaDoc文档时被包含进去，使得在查看文档时能够看到哪些方法使用了该注解， +// 有助于开发人员理解方法在验证方面的特殊处理情况，增强代码文档化程度，方便团队成员之间对代码功能尤其是涉及验证逻辑部分的沟通和理解。 @Documented + +// 定义了 @IgnoreAuth 这个注解，当前它没有定义自身的成员变量（属性），不过若业务场景有更复杂的需求，例如可以添加属性来指定忽略Token验证的具体条件、适用范围等信息，以更精细地控制验证的忽略情况。 public @interface IgnoreAuth { } + + diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java b/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java index 3d808d35..3e48963f 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java @@ -8,8 +8,25 @@ import java.lang.annotation.Target; /** * 登录用户信息 */ + + +/** + * 自定义的注解类型 @LoginUser，用于标记方法参数，通常在Java的Web开发等场景下有特定用途， + * 一般可用于标识某个参数代表的是当前登录用户的相关信息，方便在方法中对登录用户的信息进行获取、处理以及基于用户权限等进行相关业务逻辑操作， + * 其作用范围通过 @Target 注解指定为只能用于方法参数（ElementType.PARAMETER），生命周期通过 @Retention 注解指定为在运行时（RetentionPolicy.RUNTIME）有效， + * 这样在程序运行期间可以通过反射等机制来获取到该注解相关信息并进行相应处理。 + */ + +// @Target 注解用于指定该自定义注解可以应用的目标元素类型，这里指定为 ElementType.PARAMETER，表示此注解只能用于方法参数上， +// 意味着它可以标记那些在方法中接收登录用户信息的参数，以便框架或者其他相关代码能识别并处理这些参数。 @Target(ElementType.PARAMETER) + +// @Retention 注解用于定义该注解的保留策略，即规定注解在什么阶段是可见可用的，这里设置为 RetentionPolicy.RUNTIME，表示在运行时该注解信息仍然保留， +// 可以通过Java的反射机制在运行期间获取到该注解及其属性值等信息，常用于根据注解来动态执行一些业务逻辑的场景。 @Retention(RetentionPolicy.RUNTIME) + +// 定义了一个名为 @LoginUser 的注解，此注解本身没有定义成员变量（属性），如果后续有需要，也可以添加属性来传递更多关于登录用户相关的配置信息等，比如用户角色、权限级别等相关限定信息。 public @interface LoginUser { } + diff --git a/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java b/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java index 47300bc8..63fd8986 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java @@ -5,19 +5,61 @@ import java.util.List; import java.util.Map; /** - * 通用接口 + * 通用接口，定义了一系列通用的数据操作方法，供具体的实现类去实现这些方法以满足不同的数据处理需求。 + * 这些方法通常会涉及到数据库查询、统计等相关操作，通过传入不同的参数来控制具体的操作逻辑。 */ + public interface CommonDao{ + + /** + * 获取选项列表的方法，根据传入的参数（params）来查询并返回相应的选项列表。 + * 参数 params 是一个 Map 类型，其具体的键值对内容取决于具体的业务需求， + * 例如可能包含查询条件、筛选字段等信息，用于确定获取哪些选项数据。 + * 返回值是一个包含字符串的列表（List），每个字符串元素代表一个选项内容。 + * @param params 用于控制查询选项列表的参数集合 + * @return 符合条件的选项列表 + */ List getOption(Map params); - + + /** + * 根据传入的选项相关参数（params），查询并返回对应的关注信息（具体含义取决于业务场景），以 Map 的形式返回结果。 + * 参数 params 同样是 Map 类型，包含了用于确定关注信息查询范围、条件等的各种键值对信息。 + * 返回值是一个 Map，其中键表示关注信息的不同属性，值则是对应属性的具体内容。 + * @param params 用于控制查询关注信息的参数集合 + * @return 包含关注信息的 Map + */ Map getFollowByOption(Map params); - + + /** + * 与 getFollowByOption 类似，也是根据传入的选项相关参数（params）查询关注信息，不过返回值类型为 List。 + * 具体返回的字符串列表内容以及参数 params 的含义都取决于具体业务逻辑，可能是另一种形式的关注信息表示。 + * @param params 用于控制查询关注信息的参数集合 + * @return 符合条件的关注信息列表（以字符串形式表示） + */ List getFollowByOption2(Map params); - + + /** + * 执行某个操作（从方法名 sh 推测可能是一个特定的业务操作，具体含义需结合业务场景确定）， + * 通过传入参数（params）来控制该操作的具体行为，该方法无返回值，意味着它可能主要用于对数据进行修改、更新等操作。 + * @param params 用于控制操作执行的参数集合 + */ void sh(Map params); - + + /** + * 用于统计提醒相关的数量，根据传入的参数（params）确定统计的范围、条件等信息，返回统计得到的提醒数量。 + * 参数 params 作为 Map 类型，包含了如时间范围、提醒类型等各种影响统计结果的条件信息。 + * 返回值为整型（int），代表符合条件的提醒数量。 + * @param params 用于控制提醒数量统计的参数集合 + * @return 提醒的数量 + */ int remindCount(Map params); + /** + * 根据传入的参数（params）进行计算操作（从方法名 selectCal 推测可能是某种选择计算，具体取决于业务逻辑）， + * 返回计算后的结果，以 Map 形式呈现，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值等内容。 + * @param params 用于控制计算操作的参数集合 + * @return 包含计算结果的 Map + */ Map selectCal(Map params); /** tableName 查询表 @@ -25,26 +67,77 @@ public interface CommonDao{ condition1Value 条件1值 average 计算平均评分 * */ + + /** + * 查询评分相关信息的方法，根据传入的参数（params）确定查询的表（tableName）、条件（condition1 及 condition1Value）等信息， + * 可能还涉及到平均评分（average）相关的计算或筛选逻辑，最终返回包含评分相关信息的 Map。 + * 参数 params 中各键值对具体含义如注释中所描述，用于精确控制评分信息的查询操作。 + * @param params 用于控制评分信息查询的参数集合，包含查询表名、条件及相关计算控制等信息 + * @return 包含评分相关信息的 Map + */ Map queryScore(Map params); + /** + * 执行分组查询操作，根据传入的参数（params）确定分组的依据、查询的数据表等信息， + * 返回一个包含多个 Map 的列表（List>），每个内层的 Map 可能表示一组分组查询后的结果信息， + * 例如包含分组字段以及对应分组下的其他相关数据等内容，具体取决于业务逻辑的设计。 + * @param params 用于控制分组查询操作的参数集合 + * @return 分组查询后的结果列表，每个元素为一组分组相关的信息 Map + */ List> selectGroup(Map params); - - List> selectValue(Map params); + /** + * 根据传入的参数（params）进行按值查询操作（具体按什么值以及查询逻辑取决于业务场景）， + * 返回一个包含多个 Map 的列表（List>），每个内层的 Map 对应按值查询后的一组结果信息， + * 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定。 + * @param params 用于控制按值查询操作的参数集合 + * @return 按值查询后的结果列表，每个元素为一组按值相关的信息 Map + */ + List> selectValue(Map params); + /** + * 用于进行图表相关的综合查询操作（从方法名 chartBoth 推测可能涉及到多方面图表数据生成相关逻辑）， + * 根据传入的参数（params）来确定具体的查询条件、涉及的数据表等信息， + * 返回一个包含多个 Map 的列表（List>），该列表包含了图表生成所需的各种数据信息， + * 具体每个 Map 中的键值对内容以及整体列表结构取决于图表的类型和业务需求，例如可能包含图表的系列数据、坐标轴数据等。 + * @param params 用于控制图表综合查询操作的参数集合 + * @return 图表相关综合查询后的结果列表，用于后续图表生成等操作 + */ List> chartBoth(Map params); + /** + * 进行图表相关的某种单一查询操作（与 chartBoth 相对，可能只涉及图表某一方面的数据查询，具体取决于业务逻辑）， + * 依据传入的参数（params）确定查询范围和条件，返回一个包含多个 Map 的列表（List>）， + * 列表中的每个 Map 包含了此次单一图表查询相关的结果信息，具体内容由业务逻辑决定，例如可能是图表某一数据系列的数据等。 + * @param params 用于控制图表单一查询操作的参数集合 + * @return 图表相关单一查询后的结果列表，用于特定图表部分的数据展示等操作 + */ List> chartOne(Map params); /** * 下面为新加的 */ + /** + * 此接口（推测所在接口定义了一系列与数据统计相关的方法，这里是其中部分方法，具体需结合完整接口来看）用于提供不同条件下的数据统计功能， + * 涉及到新的级联字典表以及普通表按日期分组等多种统计场景，通过传入不同的参数来控制具体的统计逻辑，返回相应的统计结果数据结构。 + */ + /** * 新的级联字典表的 分组求和方法 * @param params * @return */ + + /** + * 新的级联字典表的分组求和方法。 + * 该方法接收一个参数 params，它是一个 Map 类型，其中包含了执行分组求和操作所需要的各种条件信息、配置参数等， + * 例如可能包含要操作的数据表名称、分组的字段、求和的字段以及其他相关筛选条件等内容（具体取决于业务逻辑和实际应用场景）。 + * 返回值是一个 List> 类型的列表，列表中的每个 Map 表示一组分组求和后的统计结果信息， + * 其内部的键值对可以是分组字段以及对应的求和结果等内容，方便后续对分组求和数据进行处理和展示等操作。 + * @param params 用于控制新的级联字典表分组求和操作的参数集合 + * @return 新的级联字典表分组求和后的统计结果列表，每个元素为一组分组求和相关的信息 Map + */ List> newSelectGroupSum(Map params); /** @@ -52,6 +145,16 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 新的级联字典表的分组条数统计方法。 + * 接收参数 params（Map 类型），这个参数用于明确分组统计条数操作的具体条件， + * 像涉及的数据表、按照哪些字段进行分组、可能的筛选条件等信息都会通过 params 传递进来（具体由业务逻辑决定）。 + * 方法返回一个 List> 类型的列表，里面的每一个 Map 对应一组分组统计总条数的结果信息， + * 例如可能包含分组字段以及对应的记录条数等键值对内容，以满足不同业务场景下对分组统计条数结果的使用需求。 + * @param params 用于控制新的级联字典表分组条数统计操作的参数集合 + * @return 新的级联字典表分组条数统计后的结果列表，每个元素为一组分组统计条数相关的信息 Map + */ List> newSelectGroupCount(Map params); @@ -60,6 +163,16 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 当前表的日期分组求和方法。 + * 接收一个 Map 类型的参数 params，该参数会传入当前表进行日期分组求和操作所需要的各项设置信息， + * 比如要操作的表名、用于分组的日期字段（以及日期格式化相关配置等，可能在方法内部进一步处理）、求和的目标字段以及其他限定条件等（具体依据业务逻辑而定）。 + * 方法返回值为 List> 类型的列表，其中每个 Map 代表一组按照日期分组求和后的统计结果数据， + * 例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续基于日期分组求和结果进行数据展示或其他处理。 + * @param params 用于控制当前表日期分组求和操作的参数集合 + * @return 当前表日期分组求和后的统计结果列表，每个元素为一组日期分组求和相关的信息 Map + */ List> newSelectDateGroupSum(Map params); /** @@ -67,6 +180,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 查询字典表的分组统计总条数方法。 + * 同样以 Map 类型的 params 参数来控制具体的统计操作，params 中涵盖了诸如要查询的字典表名称、分组依据的字段以及其他相关筛选条件等信息（由业务场景决定具体内容）。 + * 该方法返回的是 List> 类型的列表，列表里的每个 Map 对应一组字典表分组统计总条数的结果情况， + * 通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行使用和展示。 + * @param params 用于控制查询字典表分组统计总条数操作的参数集合 + * @return 查询字典表分组统计总条数后的结果列表，每个元素为一组分组统计总条数相关的信息 Map + */ List> newSelectDateGroupCount(Map params); /** @@ -74,6 +196,22 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 此接口（推测所在接口定义了一系列用于对数据字段进行操作的方法，这里展示的是其中部分方法，需结合完整接口定义来综合理解）， + * 提供了针对数据字段进行值变更相关的操作功能，通过传入不同的参数来控制具体的操作逻辑以及操作的目标字段等信息， + * 并且以整型（int）返回值来表示操作的执行情况或者受影响的记录数量等（具体含义取决于各方法业务逻辑）。 + */ + + /** + * 增加字段值的方法。 + * 接收一个 Map 类型的参数 params，该参数用于指定增加字段值操作的相关条件及目标字段等信息。 + * 例如，params 中可能包含要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容， + * 具体的键值对含义取决于业务场景的具体需求。 + * 返回值为整型（int），其意义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定）。 + * @param params 用于控制增加字段值操作的参数集合 + * @return 整型值，可能表示受影响的记录数量或者操作执行的状态标识等情况 + */ int plusCloumNumber(Map params); /** @@ -81,6 +219,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 减少字段值的方法。 + * 同样接收 Map 类型的参数 params，这个参数在此处用于明确减少字段值操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过 params 传入（具体依据业务逻辑而定）。 + * 方法返回一个整型（int）值，该值的含义大概率与操作的执行结果相关，比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 + * @param params 用于控制减少字段值操作的参数集合 + * @return 整型值，可用于表示受影响的记录数量或者操作执行的状态情况 + */ int reduceCloumNumber(Map params); /** @@ -88,6 +235,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 修改字段值的方法。 + * 它以 Map 类型的 params 参数来控制具体的修改操作逻辑，params 里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 该方法返回的整型（int）值通常用于反馈修改操作的执行情况，可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 + * @param params 用于控制修改字段值操作的参数集合 + * @return 整型值，一般表示受影响的记录数量或者操作执行的状态标识等情况 + */ int updateCloumValue(Map params); @@ -138,6 +294,24 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 此接口（推测属于某个与数据统计及图表相关业务逻辑对应的接口，此处展示的是其中部分方法，需结合完整接口来全面理解）定义了用于生成柱状图相关数据的方法， + * 分别提供了柱状图求和以及柱状图统计的功能，通过接收包含不同配置信息的参数，来确定具体的统计逻辑以及生成符合柱状图展示需求的数据结构， + * 并以包含多个 Map 的列表形式返回相应的统计结果数据，方便后续用于柱状图的渲染展示等操作。 + */ + + /** + * 柱状图求和方法。 + * 接收一个 Map 类型的参数 params，该参数用于传递与柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 返回值为 List> 类型的列表，列表中的每个 Map 表示一组柱状图求和后的统计结果信息， + * 比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容，这些结果数据可用于构建柱状图中不同分组下的求和展示部分， + * 以直观呈现各分组的数据总和情况。 + * @param params 用于控制柱状图求和操作的参数集合 + * @return 柱状图求和后的统计结果列表，每个元素为一组求和相关的信息 Map，用于后续柱状图展示 + */ List> barSum(Map params); /** @@ -145,6 +319,17 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 柱状图统计方法。 + * 同样以 Map 类型的参数 params 来控制具体的统计操作逻辑，params 中涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 该方法返回的是 List> 类型的列表，其中每个 Map 对应一组柱状图统计后的结果信息， + * 像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对，这些结果数据可用于在柱状图中展示相应的统计情况， + * 帮助用户直观了解数据分布及特征等信息。 + * @param params 用于控制柱状图统计操作的参数集合 + * @return 柱状图统计后的结果列表，每个元素为一组统计相关的信息 Map，便于后续柱状图的构建展示 + */ List> barCount(Map params); diff --git a/minsu/minsuguanliw/src/main/java/com/entity/EIException.java b/minsu/minsuguanliw/src/main/java/com/entity/EIException.java index 2ebfb566..2fbd129e 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/EIException.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/EIException.java @@ -4,49 +4,76 @@ package com.entity; /** * 自定义异常 */ + +// 定义了一个名为EIException的自定义异常类，它继承自RuntimeException，这意味着它属于运行时异常， +// 在程序运行期间出现问题时可以抛出该异常，并且不需要在方法声明中显式地使用 throws 关键字来声明可能抛出此异常，方便处理运行阶段突发的错误情况。 + public class EIException extends RuntimeException { + // 序列化版本号，用于在对象序列化和反序列化过程中保证版本的一致性和兼容性。 + // 此处定义为1L，一般在类结构没有发生改变的情况下保持不变，若类的成员变量等结构有变动，可能需要相应地更新该版本号。 private static final long serialVersionUID = 1L; - - private String msg; - private int code = 500; - - public EIException(String msg) { + + // 用于存储异常的详细描述信息，也就是具体的错误消息内容，通过不同的构造方法进行赋值，后续可通过对应的get方法获取该消息，以知晓具体的异常原因。 + private String msg; + + // 用于表示该异常对应的错误代码，默认值被初始化为500，可用于在系统中区分不同类型的异常情况， + // 例如在与前端交互或者日志记录时，依据这个代码能快速定位和辨别具体的异常类别，进而采取相应的处理措施。 + private int code = 500; + + // 构造方法，接受一个字符串类型的msg参数，用于创建EIException异常实例。 + // 此构造方法调用父类（RuntimeException）的构造函数，将传入的msg传递给父类，同时将该msg赋值给当前类的msg属性， + // 便于后续获取具体的异常消息，适用于只需简单传递异常消息的场景。 + public EIException(String msg) { super(msg); this.msg = msg; } - + + // 构造方法，接受一个字符串类型的msg参数和一个Throwable类型的e参数。 + // 它调用父类（RuntimeException）的对应构造函数，把msg和e传递给父类，并且将msg赋值给当前类的msg属性， + // 这样既能传递详细的异常消息，又能关联引发当前异常的其他异常（通过e传入），有助于在异常链中追溯异常产生的根源。 public EIException(String msg, Throwable e) { super(msg, e); this.msg = msg; } - + + // 构造方法，接受一个字符串类型的msg参数和一个整型的code参数。 + // 调用父类（RuntimeException）的构造函数传递msg，然后将msg赋值给当前类的msg属性，同时将传入的code赋值给当前类的code属性， + // 以此创建一个带有自定义错误代码的异常实例，方便更精准地标识异常类型，除传递异常消息外，通过错误代码可做进一步的区分和处理。 public EIException(String msg, int code) { super(msg); this.msg = msg; this.code = code; } - + + // 构造方法，接受一个字符串类型的msg参数、一个整型的code参数以及一个Throwable类型的e参数。 + // 调用父类（RuntimeException）的对应构造函数，传递msg、e给父类，同时将msg赋值给当前类的msg属性，把code赋值给当前类的code属性， + // 综合了传递异常消息、设置自定义错误代码以及关联引发异常的其他异常等功能，提供了一种较为全面的异常创建方式。 public EIException(String msg, int code, Throwable e) { super(msg, e); this.msg = msg; this.code = code; } + // 获取异常消息的方法，外部代码可以调用此方法来获取在创建EIException实例时设置的异常消息内容，从而了解具体的异常详情。 public String getMsg() { return msg; } + // 设置异常消息的方法，可用于在某些特定场景下（虽然相对不常见）动态修改异常消息的内容，比如根据后续的业务逻辑调整异常提示信息等。 public void setMsg(String msg) { this.msg = msg; } + // 获取异常对应的错误代码的方法，外部代码通过调用此方法能获取当前EIException实例所代表的异常对应的错误代码， + // 便于根据该代码实施不同的错误处理逻辑，例如向客户端返回不同的错误提示等操作。 public int getCode() { return code; } + // 设置异常对应的错误代码的方法，可用于在需要根据运行时条件等因素动态调整错误代码的情况下，对错误代码进行重新设定。 public void setCode(int code) { this.code = code; } - - + + } diff --git a/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java b/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java index 723834ba..e2aa4563 100644 --- a/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java +++ b/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java @@ -23,52 +23,112 @@ import com.utils.R; /** * 权限(Token)验证 */ + +/** + * 这是一个用于权限（Token）验证的拦截器类，实现了HandlerInterceptor接口，在Web应用中可以拦截请求，对请求进行权限相关的验证处理， + * 通过检查请求携带的Token来判断用户是否有权限访问相应资源，同时还处理了一些跨域相关的设置以及对特定无需验证的请求路径进行放行等操作，是保障系统安全访问控制的重要组成部分。 + * 此类被标记为Spring的组件（通过@Component注解），以便能被Spring容器管理并在合适的时机参与到请求处理流程中。 + * + * 其主要职责包括：判断请求路径是否属于特定的无需验证的路径直接放行、设置跨域请求相关的响应头信息、检查方法上是否有忽略验证的注解（@IgnoreAuth）以及从请求头中获取Token用于后续的验证操作等。 + */ + +// 使用@Component注解将该类标记为Spring框架中的一个组件，意味着Spring容器会对其进行管理， +// 可以自动扫描并实例化这个类，使其能够在整个Web应用的请求处理流程中发挥作用，参与到权限验证等相关环节。 @Component public class AuthorizationInterceptor implements HandlerInterceptor { + // 定义了一个公共的静态常量字符串，用于表示在请求头中存放Token的键名，方便在整个类中统一使用该名称来获取请求头中的Token信息，保持代码的一致性和可读性。 public static final String LOGIN_TOKEN_KEY = "Token"; + // 使用@Autowired注解进行依赖注入，将TokenService的实例注入到当前类中， + // TokenService大概率是用于处理与Token相关的业务逻辑，比如验证Token的有效性、解析Token获取用户信息等操作，以此来辅助完成权限验证的功能。 @Autowired private TokenService tokenService; - + + + /** + * 此方法是HandlerInterceptor接口中的一个回调方法，在请求处理之前被调用，用于进行预处理操作， + * 主要在这里实现权限验证以及跨域相关的设置等逻辑，根据验证结果决定是否放行请求继续后续的处理流程，返回值为布尔类型，true表示放行，false表示拦截。 + * + * @param request 当前的HttpServletRequest对象，包含了请求相关的所有信息，如请求路径、请求头、请求参数等，可以从中获取进行权限验证等操作所需的数据。 + * @param response 当前的HttpServletResponse对象，用于设置响应相关的信息，例如在这里设置跨域请求的响应头信息，来控制浏览器对跨域请求的处理方式。 + * @param handler 表示被拦截的请求对应的处理器对象，其具体类型可能不同，通过判断其类型来获取方法上的相关注解等信息，以确定是否需要进行权限验证等操作。 + * @throws Exception 如果在处理过程中出现异常，可以抛出，由上层的异常处理机制进行统一处理，例如在验证Token等操作出现错误时可以抛出异常。 + * @return 返回一个布尔值，true表示请求可以继续往后传递进行后续的处理（即放行请求），false表示拦截该请求，不允许其继续执行后续的业务逻辑。 + */ + @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { - + // 获取当前请求的Servlet路径，用于后续判断请求是否属于特定的不需要进行权限验证的路径，通过与已知的特定路径进行对比来决定是否直接放行请求。 String servletPath = request.getServletPath(); + // 判断请求路径是否为字典表相关页面（"/dictionary/page"）、文件上传（"/file/upload"）或者用户注册（"/yonghu/register"）路径， + // 如果是这些特定的路径之一，则直接放行请求，不需要进行后续的权限验证操作，返回true表示允许请求继续执行后续的业务逻辑。 if("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath()) ){//请求路径是字典表或者文件上传 直接放行 return true; } - //支持跨域请求 + + + // 设置跨域请求相关的响应头信息，以下这些设置用于支持浏览器的跨域请求操作，使得不同域名下的前端应用能够正常访问当前后端服务提供的接口。 + + // 设置允许的请求方法，这里允许POST、GET、OPTIONS、DELETE等常见的请求方法进行跨域请求，告知浏览器本服务端支持这些跨域请求方式。 response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE"); + + // 设置跨域请求的缓存时间（单位：秒），这里设置为3600秒，意味着在这个时间段内，浏览器对于相同的跨域请求可以直接使用缓存结果，减少不必要的重复请求，提高性能。 response.setHeader("Access-Control-Max-Age", "3600"); + + // 设置是否允许跨域请求携带凭证（如Cookie等），这里设置为true，表示允许跨域请求携带相关凭证信息，方便进行基于用户登录状态等的跨域交互。 response.setHeader("Access-Control-Allow-Credentials", "true"); + + // 设置允许的请求头信息，这里列举了一系列常见的请求头以及本应用中用于权限验证等相关的特定请求头（如Token等），告知浏览器跨域请求时可以携带这些请求头信息， + // 以便服务端能够正确获取到相关的请求参数进行后续的业务处理，比如验证权限、获取请求来源等操作。 response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization"); + + // 设置允许的跨域请求来源，通过获取请求头中的Origin信息并设置到响应头中，允许来自该来源的跨域请求，实现了根据实际请求来源动态配置跨域允许的功能。 response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin")); + // 声明一个IgnoreAuth类型的注解变量，用于后续判断被拦截的请求对应的方法上是否标注了 @IgnoreAuth 注解， + // 如果标注了该注解，则意味着该方法对应的请求不需要进行权限验证，可直接放行。 IgnoreAuth annotation; + + // 判断handler对象是否是HandlerMethod类型，HandlerMethod表示的是一个被Spring MVC解析后的处理请求的方法对象， + // 如果是这种类型，说明可以获取到方法上的注解信息，进而判断是否有 @IgnoreAuth 注解；如果不是这种类型，说明可能不是常规的方法处理请求，直接放行请求。 if (handler instanceof HandlerMethod) { annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class); } else { return true; } - //从header中获取token + // 从请求的Header中获取名为Token的信息，该Token是后续进行权限验证的关键依据，会传递给注入的TokenService进行有效性验证等相关操作， + // 以此来判断当前请求是否来自合法的、已登录并有权限的用户。 String token = request.getHeader(LOGIN_TOKEN_KEY); /** * 不需要验证权限的方法直接放过 */ + + + // 判断当前请求对应的方法上是否标注了 @IgnoreAuth 注解，如果 annotation 不为空，说明该方法被标记为无需进行权限验证， + // 那么直接放行该请求，允许其继续执行后续的业务逻辑，返回 true 表示放行。 if(annotation!=null) { return true; } - + + + // 声明一个 TokenEntity 类型的变量 tokenEntity，并初始化为 null，后续会根据获取到的 token 信息尝试从 tokenService 中获取对应的 Token 实体信息， + // TokenEntity 大概率包含了与用户登录状态、权限等相关的属性，比如用户ID、角色、所属表名、用户名等，用于进一步判断用户的合法性及权限情况。 TokenEntity tokenEntity = null; + + // 检查从请求头中获取到的 token 字符串是否不为空（通过 StringUtils.isNotBlank 方法判断），如果不为空，说明请求携带了 Token 信息， + // 则调用注入的 tokenService 的 getTokenEntity 方法，尝试根据这个 token 去获取对应的 Token 实体对象，以便后续进行更多的验证及用户信息设置操作。 if(StringUtils.isNotBlank(token)) { tokenEntity = tokenService.getTokenEntity(token); } - + + // 判断获取到的 TokenEntity 是否不为空，若不为空，说明通过 Token 验证成功获取到了对应的用户相关信息， + // 此时将用户的关键信息（如用户ID、角色、表名、用户名等）设置到当前请求的 Session 中，方便在后续的请求处理过程中可以直接从 Session 里获取这些用户信息， + // 例如在其他业务逻辑中用于权限判断、数据筛选等操作，设置完相关信息后，放行该请求，返回 true 表示允许请求继续执行后续的业务逻辑。 if(tokenEntity != null) { request.getSession().setAttribute("userId", tokenEntity.getUserid()); request.getSession().setAttribute("role", tokenEntity.getRole()); @@ -76,19 +136,34 @@ public class AuthorizationInterceptor implements HandlerInterceptor { request.getSession().setAttribute("username", tokenEntity.getUsername()); return true; } - + + // 创建一个 PrintWriter 对象，用于向客户端（通常是浏览器）输出响应内容，这里后续会输出一个表示未登录的错误提示信息，以 JSON 格式返回给客户端，告知用户需要先登录才能访问相应资源。 PrintWriter writer = null; + // 设置响应的字符编码为 "UTF-8"，确保返回给客户端的中文等字符信息能够正确显示，避免出现乱码问题，这是处理响应内容编码的常见设置。 response.setCharacterEncoding("UTF-8"); + // 设置响应的内容类型为 "application/json; charset=utf-8"，表明返回给客户端的数据格式是 JSON 格式，并且字符编码采用 "UTF-8"， + // 这样客户端（如前端应用中的 JavaScript 代码等）在接收到响应后可以按照 JSON 格式进行解析处理，获取到相应的错误提示信息。 response.setContentType("application/json; charset=utf-8"); + try { + // 获取响应的输出流对象 writer，用于向客户端写入响应内容，通过调用 response.getWriter() 方法来获取，后续可以使用这个 writer 对象输出相应的 JSON 格式的错误提示信息。 writer = response.getWriter(); + // 使用 JSONObject.toJSONString 方法将一个表示错误信息的对象（通过 R.error(401, "请先登录") 创建，推测 R 是一个用于统一封装返回结果的工具类）转换为 JSON 字符串， + // 然后通过 writer.print 方法将这个 JSON 字符串输出到客户端，向用户提示需要先登录，这里的错误码 401 通常代表未授权（在 HTTP 状态码语义中常用于表示需要用户认证的情况）。 writer.print(JSONObject.toJSONString(R.error(401, "请先登录"))); + } finally { + // 在 finally 块中进行资源释放操作，判断 writer 对象是否不为空，如果不为空，说明之前成功获取到了输出流对象， + // 则调用 writer.close() 方法关闭输出流，释放相关资源，避免出现资源泄漏等问题，确保程序的稳定性和性能。 if(writer != null){ writer.close(); } } + +// 此处原本可能是要抛出一个自定义的 EIException 异常来表示未登录情况（从注释掉的代码推测），异常信息为 "请先登录"，错误码为 401， +// 不过当前代码采用了直接向客户端返回 JSON 格式错误提示信息并返回 false 来拦截请求的方式，而不是抛出异常（可能基于不同的错误处理策略考虑）。 // throw new EIException("请先登录", 401); + // 返回 false，表示拦截该请求，不允许其继续执行后续的业务逻辑，因为前面验证发现用户未登录，没有合法的权限访问相应资源，通过返回 false 来阻断请求的进一步处理。 return false; } } diff --git a/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java b/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java index 39061d8a..ff715bb2 100644 --- a/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java +++ b/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java @@ -7,25 +7,61 @@ import com.baomidou.mybatisplus.enums.IEnum; /** * 必须现在 IEnum 配置 该包扫描自动注入，查看文件 spring-mybatis.xml 参数 typeEnumsPackage */ + +/** + * 此枚举类型（enum）用于定义特定的类型集合，在业务逻辑中可能代表不同的状态、类别等情况，并且遵循了 IEnum 接口的规范进行配置， + * 实现了相关方法以便能更好地与框架集成使用。该枚举所在的包需要在特定配置（查看文件 spring-mybatis.xml 参数 typeEnumsPackage）下进行扫描， + * 从而实现自动注入等功能，使其能在整个应用程序中方便地被使用，比如在数据库操作、数据传输等场景下用于表示特定的枚举值及对应的描述信息。 + */ + +// 定义了一个名为 TypeEnum 的枚举类型，它实现了 IEnum 接口，意味着该枚举需要遵循 IEnum 接口定义的规范来实现相关方法， +// 通常这样做是为了在某些框架（如 MyBatis 等）中能更方便地进行枚举类型的处理，例如数据库字段与枚举值的映射等操作。 public enum TypeEnum implements IEnum { + + // 定义了枚举的第一个常量 DISABLED，其对应的值为 0，描述信息为 "禁用"， + // 在业务场景中可以用于表示某个对象处于禁用状态，比如用户账号禁用、功能模块禁用等情况，通过这个枚举常量可以清晰地传达该状态含义以及对应的数值表示。 DISABLED(0, "禁用"), + + + // 定义了枚举的第二个常量 NORMAL，其对应的值为 1，描述信息为 "正常"， + // 同样在业务中可用于表示正常可用的状态，像用户账号正常、系统功能正常运行等情况，方便通过统一的枚举类型来区分不同的业务状态。 NORMAL(1, "正常"); + + // 定义了一个私有 final 类型的整型变量 value，用于存储当前枚举常量对应的整数值， + // 这个值在构造函数中进行初始化，并且在后续通过实现 IEnum 接口的 getValue 方法返回，可用于与数据库字段等进行值的映射操作。 private final int value; + + + // 定义了一个私有 final 类型的字符串变量 desc，用于存储当前枚举常量对应的中文描述信息， + // 方便在需要展示给用户或者在代码中以更直观的方式体现该枚举常量含义时使用，例如在生成 JSON 数据返回给前端时展示对应的中文描述。 private final String desc; + + // 枚举类型的构造函数，用于初始化每个枚举常量的 value 和 desc 属性， + // 通过传入的参数来为当前枚举常量赋予对应的整数值和中文描述，确保每个枚举常量都有明确的数值表示和含义描述。 TypeEnum(final int value, final String desc) { this.value = value; this.desc = desc; } + + // 实现 IEnum 接口中定义的 getValue 方法，该方法要求返回一个可序列化（Serializable）的值， + // 在这里返回的就是当前枚举常量对应的整数值（this.value），这个值可以在一些数据持久化、数据传输等场景下作为具体的枚举值进行传递和存储， + // 例如在将枚举类型数据保存到数据库字段时，会调用这个方法获取对应的数值进行存储。 @Override public Serializable getValue() { return this.value; } - // Jackson 注解为 JsonValue 返回中文 json 描述 + + // 使用了 Jackson 框架相关的注解（虽然这里没明确写出具体是哪个 Jackson 注解，但从注释“Jackson 注解为 JsonValue 返回中文 json 描述”可推测）， + // 作用是在将该枚举类型转换为 JSON 数据时，调用这个 getDesc 方法返回当前枚举常量对应的中文描述信息（this.desc）， + // 使得前端接收到的 JSON 数据中对于该枚举类型的表示是更友好、易读的中文描述，而不是默认的枚举常量名称或者其他不直观的表示形式，增强了数据展示的友好性和可读性。 public String getDesc() { return this.desc; } } + + + diff --git a/minsu/minsuguanliw/src/main/java/com/service/CommonService.java b/minsu/minsuguanliw/src/main/java/com/service/CommonService.java index 6e5ea56d..d4bd97ac 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/CommonService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/CommonService.java @@ -4,79 +4,151 @@ import java.util.List; import java.util.Map; public interface CommonService { + // 以下这些方法声明所在的类（推测是某个数据访问相关的接口或者抽象类等，需结合完整代码上下文判断），定义了一系列用于不同数据操作的方法， + // 通过接收不同的参数来控制具体的操作逻辑，并返回相应类型的数据结果（或无返回值用于执行某些操作），以满足业务中多样化的数据处理需求。 + + // 获取选项的方法，接收一个名为params的参数，其类型是Map， +// 该参数用于传递一些配置信息、查询条件等内容（具体键值对含义取决于业务场景）， +// 方法返回一个List类型的结果，即返回一个字符串列表，列表中的元素代表符合条件的选项内容， +// 例如可能是下拉框选项、可选择的配置项等，具体取决于该方法在业务中的实际用途。 List getOption(Map params); - + + // 根据选项相关参数获取关注信息的方法，接收一个Map类型的params参数， +// 此参数包含了用于确定关注信息查询范围、筛选条件等的各种配置信息（具体根据业务逻辑而定）， +// 返回值是一个Map类型，意味着返回的是一个键值对形式的映射，其中键表示关注信息的不同属性，值则对应各属性的具体内容， +// 比如可以是某个用户关注的对象信息、对应权限等相关内容，由业务场景来决定具体返回的数据结构。 Map getFollowByOption(Map params); - + + // 执行某个操作（从方法名sh较难直接明确具体操作内容，需结合业务场景确定）的方法， +// 接收一个Map类型的params参数，该参数用于传递控制此操作执行的各种条件、配置等相关信息， +// 此方法无返回值，说明该操作可能主要用于对数据进行修改、更新、执行特定业务逻辑等操作，而不需要返回具体的数据结果。 void sh(Map params); - + +// 用于统计提醒相关数量的方法，接收一个Map类型的params参数， +// 这个参数中包含了确定统计提醒数量范围、类型等条件的各种键值对信息（具体由业务逻辑规定）， +// 方法返回一个整型（int）数值，代表符合给定参数条件下统计得出的提醒数量， +// 例如可以是未读提醒数量、特定时间段内的提醒数量等，取决于业务对提醒数量统计的具体要求。 + int remindCount(Map params); - + + // 根据传入参数进行选择计算（selectCal，具体计算逻辑由业务场景定义）的方法， +// 接收Map类型的params参数，该参数用于传递计算所需的输入数据、计算规则、相关配置等信息， +// 返回一个Map类型的结果，即返回一个键值对形式的映射，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值或内容， +// 比如可以是经过某种数学运算、业务规则计算后得到的汇总数据、比率等结果信息。 Map selectCal(Map params); + // 用于获取图表相关综合数据的方法，接收一个Map类型的params参数， +// 该参数包含了确定图表数据查询条件、涉及的数据范围、图表类型相关配置等信息（具体取决于业务中图表展示的需求）， +// 返回值是一个List>类型的列表，列表中的每个Map元素代表图表的一部分数据信息， +// 例如可以是图表的系列数据、坐标轴数据等不同部分的数据集合，整体构成用于生成完整图表的数据基础，具体每个Map的结构和内容由业务逻辑决定。 List> chartBoth(Map params); + // 获取图表相关某一方面数据（相对chartBoth可能是更单一维度的数据，具体取决于业务逻辑）的方法， +// 同样接收Map类型的params参数，该参数用于控制具体的数据查询条件、范围等信息， +// 返回一个List>类型的列表，其中每个Map元素包含了此次查询得到的图表某一相关部分的数据， +// 比如可能是图表中某一个数据系列的数据，用于在构建图表时填充相应的部分，具体内容由业务场景中图表的设计和需求来决定。 List> chartOne(Map params); + // 执行分组查询操作的方法，接收Map类型的params参数， +// 该参数包含了分组依据的字段、查询的数据表、筛选条件等用于控制分组查询的相关信息（具体由业务逻辑规定）， +// 返回一个List>类型的列表，列表中的每个Map表示一组分组查询后的结果信息， +// 例如可以包含分组字段以及对应分组下的其他相关数据等内容，方便后续对分组数据进行处理、展示或进一步分析等操作。 List> selectGroup(Map params); - + + // 根据传入参数进行按值查询（selectValue，具体按什么值以及查询逻辑取决于业务场景）的方法， +// 接收Map类型的params参数，该参数用于传递按值查询所需的条件、要查询的值相关信息、数据表信息等内容， +// 返回一个List>类型的列表，其中每个Map对应按值查询后的一组结果信息， +// 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定，例如可以是符合特定数值条件的数据记录集合等情况。 List> selectValue(Map params); + /** - tableName 查询表 - condition1 条件1 - condition1Value 条件1值 - average 计算平均评分 - * */ + * 此方法用于查询评分相关信息并返回相应结果，通过接收一个Map类型的参数params来控制查询操作的具体逻辑。 + * + * 参数params中包含了多个关键信息，具体如下： + * - tableName：表示要进行查询评分操作的查询表，指明了数据来源的表名称，其具体值由业务场景决定，不同的业务模块可能对应不同的数据表来存储评分相关数据。 + * - condition1：代表条件1，是用于筛选或限定评分查询范围的一个条件字段，例如可以是某个用户ID、某个时间段等具体的筛选条件，具体含义取决于具体业务逻辑中的使用方式。 + * - condition1Value：对应条件1的值，与condition1配合使用，用于明确具体的筛选数值等内容，比如当condition1是用户ID时，此参数就是具体的用户ID数值，以此精准定位符合条件的数据记录来计算评分。 + * - average：从名称推测用于控制是否进行平均评分的计算以及相关计算规则等，可能是一个布尔值（例如true表示计算平均评分，false表示不计算）或者包含更多计算相关配置的对象（如指定计算平均评分的分组方式等，具体由业务定义）。 + * + * 方法返回值是一个Map类型，返回的这个映射中，键表示评分相关信息的不同属性，比如可以是“平均分”“总分”“评分人数”等属性名称，值则是对应属性的具体内容，例如具体的数值、其他相关对象等，方便后续根据返回结果进行相应的业务处理、展示等操作，整体的返回数据结构和具体内容取决于业务中对评分查询结果的要求和设计。 + */ Map queryScore(Map params); + /** * 下面为新加的 */ /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 以下这些方法声明所在的类（通常是某个数据处理相关的接口或者抽象类等，需结合完整代码上下文判断）定义了多种不同的数据操作方法， + * 通过接收参数params来控制具体操作的逻辑，并返回相应类型的数据结果（或返回整型表示操作执行情况等），以满足业务中不同的数据统计、字段值变更等需求。 + */ + + + /** + * 新的级联字典表的分组求和统计方法。 + * 接收一个名为params的参数，其类型为Map，该参数用于传递各种与分组求和统计相关的配置信息、筛选条件等内容（具体键值对含义取决于业务逻辑）。 + * 例如可能包含要操作的级联字典表相关信息、分组的字段、求和的目标字段以及其他限定参与求和数据范围的条件等。 + * 返回值是一个List>类型的列表，列表中的每个Map表示一组分组求和后的统计结果信息， + * 像可能包含分组字段对应的标识以及对应的求和数值等键值对内容，便于后续基于这些结果进行数据展示、进一步分析等操作，具体结构由业务场景决定。 */ List> newSelectGroupSum(Map params); + /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 新的级联字典表的分组求和统计方法（此处重复定义了同名方法，可能存在命名失误或者业务上确实需要两个同名但不同实现逻辑的情况，需结合具体代码进一步确认）。 + * 同样接收Map类型的params参数，该参数用于传递在新的级联字典表中进行分组求和统计所需的各项条件、配置信息等（具体依据业务要求而定）。 + * 返回一个List>类型的列表，其中每个元素Map对应一组分组求和统计的结果数据， + * 例如包含分组字段及对应求和值等相关信息，方便后续按业务需求对统计结果进行处理和使用。 */ List> newSelectGroupCount(Map params); + + /** - * 当前表的日期分组求和 - * @param params - * @return + * 当前表的日期分组求和方法。 + * 接收Map类型的params参数，该参数包含了当前表进行日期分组求和操作所需要的各种条件信息， + * 比如要操作的表名、用于分组的日期字段（可能还涉及日期格式相关设置等）、求和的目标字段以及其他筛选条件（用于确定哪些数据参与求和计算）等内容，具体由业务场景规定。 + * 返回值为List>类型的列表，列表中的每个Map代表一组按照日期分组求和后的统计结果数据， + * 例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续在数据展示或分析中体现不同日期分组下的求和情况。 */ List> newSelectDateGroupSum(Map params); + /** - * 查询字典表的分组统计总条数 - * @param params - * @return + * 查询字典表的分组统计总条数方法。 + * 接收Map类型的params参数，该参数用于传递查询字典表分组统计总条数操作的相关配置信息、筛选条件等， + * 例如包含要查询的字典表名称、分组依据的字段以及其他限定统计范围的条件等（具体键值对含义取决于业务逻辑）。 + * 返回的是List>类型的列表，里面的每个Map对应一组字典表分组统计总条数的结果情况， + * 通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行展示、对比等操作。 */ List> newSelectDateGroupCount(Map params); + + /** - * 增加字段数字 - * @param params - * @return + * 增加字段数字的方法。 + * 接收一个Map类型的params参数，该参数用于指定增加字段数字操作的相关条件及目标字段等信息， + * 比如要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容，具体由业务场景决定。 + * 返回值为整型（int），其含义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定），用于反馈操作的执行情况。 */ int plusCloumNumber(Map params); + + /** - * 减少字段数字 - * @param params - * @return + * 减少字段数字的方法。 + * 接收Map类型的params参数，此参数用于明确减少字段数字操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过params传入（具体依据业务逻辑而定）。 + * 方法返回一个整型（int）值，该值的意义大概率与操作的执行结果相关，比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 */ int reduceCloumNumber(Map params); + + /** - * 修改字段数字 - * @param params - * @return + * 修改字段数字的方法。 + * 以Map类型的params参数来控制具体的修改操作逻辑，params里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 该方法返回的整型（int）值通常用于反馈修改操作的执行情况，可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 */ int updateCloumValue(Map params); @@ -123,17 +195,35 @@ public interface CommonService { -- 【日期，字符串，下拉框】 */ + + /** + * 以下这两个方法所在的类（通常是与数据统计及图表展示相关业务逻辑对应的类，需结合完整代码上下文进一步明确）， + * 主要用于生成柱状图相关的数据统计结果，通过接收包含不同配置信息的参数params来确定具体的统计逻辑， + * 并返回相应格式的数据结构，方便后续用于柱状图的构建及展示等操作。 + */ + + /** - * 柱状图求和 - * @param params - * @return + * 柱状图求和方法。 + * 接收一个Map类型的参数params，该参数用于传递和柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 返回值是一个List>类型的列表，列表中的每个Map表示一组柱状图求和后的统计结果信息， + * 比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容，这些结果数据可用于构建柱状图中不同分组下的求和展示部分， + * 以直观呈现各分组的数据总和情况，便于用户查看不同类别或时间段等维度下数据的总体量对比。 */ List> barSum(Map params); + + /** - * 柱状图统计 - * @param params - * @return + * 柱状图统计方法。 + * 同样接收一个Map类型的参数params，该参数涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 此方法返回的是List>类型的列表，其中每个Map对应一组柱状图统计后的结果信息， + * 像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对，这些结果数据可用于在柱状图中展示相应的统计情况， + * 帮助用户直观了解数据分布及特征等信息，辅助进行数据分析和决策等操作。 */ List> barCount(Map params); + } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java index cb42f901..6db1e592 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java @@ -17,17 +17,41 @@ import com.service.CommonService; * @author * @date */ +/** + * 该类表示系统用户相关的服务实现类，用于实现CommonService接口中定义的一系列业务方法， + * 通过依赖注入CommonDao来调用底层的数据访问操作，进而完成各项具体的业务逻辑处理， + * 这里实现的方法大多是与获取不同类型的数据、操作结果等相关，为上层应用提供相应的服务支持。 + * + * @author 此处应填写该类的作者姓名，用于标识代码的编写者，方便代码维护和追溯责任等情况。 + * @date 此处应填写该类的创建日期或者最近一次修改日期等，有助于了解代码的版本历史和更新情况。 + */ +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定了其在容器中的bean名称为"commonService"， +// 方便在其他组件中通过该名称进行依赖注入来使用这个服务类所提供的功能。 @Service("commonService") public class CommonServiceImpl implements CommonService { - + + // 使用@Autowired注解进行依赖注入，将CommonDao接口的某个实现类实例注入到当前类中， + // 这样就能通过这个实例调用CommonDao中定义的数据访问方法，实现与数据库等数据源的交互操作，完成具体业务逻辑对数据的需求。 @Autowired private CommonDao commonDao; + /** + * 实现了CommonService接口中定义的getOption方法，功能是获取选项信息。 + * 该方法接收一个Map类型的参数params，params用于传递查询选项信息所需要的相关条件、配置等信息（具体键值对含义取决于业务逻辑）。 + * 通过调用注入的commonDao的getOption方法，将参数params传递下去，获取并返回符合条件的选项信息列表，返回值类型为List， + * 列表中的每个字符串元素代表一个具体的选项内容，例如可能是下拉列表的选项、配置项等，具体取决于业务场景中对选项的定义。 + */ @Override public List getOption(Map params) { return commonDao.getOption(params); } - + + /** + * 实现了CommonService接口中定义的getFollowByOption方法，用于获取与选项相关的关注信息。 + * 接收一个Map类型的参数params，该参数包含了确定关注信息查询范围、筛选条件等的各种配置信息（具体依据业务逻辑而定）。 + * 调用commonDao的getFollowByOption方法并传递params参数，获取并返回相应的关注信息，返回值是一个Map类型， + * 即返回的是一个键值对形式的映射，其中键表示关注信息的不同属性，值则对应各属性的具体内容，比如可以是用户关注的对象详情、对应权限等相关信息，由业务场景决定具体返回的数据结构。 + */ @Override public Map getFollowByOption(Map params) { return commonDao.getFollowByOption(params); @@ -40,50 +64,126 @@ public class CommonServiceImpl implements CommonService { condition1Value 条件1值 average 计算平均评分 * */ + /** + * 以下这些方法是实现某个服务接口（从类实现了接口以及方法的命名推测，可能是与数据查询、统计、图表相关操作等业务逻辑对应的服务接口，需结合完整代码上下文判断）的具体实现方法， + * 它们大多是通过调用注入的commonDao对象的对应方法来完成具体的业务操作，将参数传递给底层的数据访问层（由commonDao代表），并返回相应的结果或者执行相应的无返回值操作， + * 以此来实现服务层与数据访问层的交互，为上层应用提供数据相关的服务支持。 + * + * 参数params在各个方法中都用于传递控制对应操作的相关条件、配置等信息，其内部具体的键值对含义取决于不同业务场景下各方法的功能需求，例如包含要操作的表名、筛选条件、计算规则等不同的内容。 + * + * 其中queryScore方法相关的参数params中包含以下几个关键信息（从注释中可看出）： + * - tableName：表示要进行查询评分操作的查询表，指明了数据来源的表名称，其具体值由业务场景决定，不同的业务模块可能对应不同的数据表来存储评分相关数据。 + * - condition1：代表条件1，是用于筛选或限定评分查询范围的一个条件字段，例如可以是某个用户ID、某个时间段等具体的筛选条件，具体含义取决于具体业务逻辑中的使用方式。 + * - condition1Value：对应条件1的值，与condition1配合使用，用于明确具体的筛选数值等内容，比如当condition1是用户ID时，此参数就是具体的用户ID数值，以此精准定位符合条件的数据记录来计算评分。 + * - average：从名称推测用于控制是否进行平均评分的计算以及相关计算规则等，可能是一个布尔值（例如true表示计算平均评分，false表示不计算）或者包含更多计算相关配置的对象（如指定计算平均评分的分组方式等，具体由业务定义）。 + */ + + /** + * 查询评分相关信息的方法，通过调用注入的commonDao的queryScore方法来获取评分数据。 + * 接收一个Map类型的参数params，该参数传递了查询评分操作所需的各种配置信息（如上述提到的查询表名、条件、计算规则等）。 + * 返回值是一个Map类型，返回的这个映射中，键表示评分相关信息的不同属性，比如可以是“平均分”“总分”“评分人数”等属性名称，值则是对应属性的具体内容，例如具体的数值、其他相关对象等， + * 方便后续根据返回结果进行相应的业务处理、展示等操作，整体的返回数据结构和具体内容取决于业务中对评分查询结果的要求和设计。 + */ public Map queryScore(Map params){ return commonDao.queryScore(params); } - + + /** + * 执行某个操作（从方法名sh较难直接明确具体操作内容，需结合业务场景确定）的方法， + * 通过调用commonDao的sh方法来执行具体操作，接收一个Map类型的参数params，该参数用于传递控制此操作执行的各种条件、配置等相关信息， + * 此方法无返回值，说明该操作可能主要用于对数据进行修改、更新、执行特定业务逻辑等操作，而不需要返回具体的数据结果，具体的操作行为由commonDao的sh方法实现逻辑决定。 + */ @Override public void sh(Map params) { - commonDao.sh(params); + commonDao.sh(params); } + + /** + * 用于统计提醒相关数量的方法，通过调用commonDao的remindCount方法来获取提醒数量统计结果。 + * 接收一个Map类型的参数params，这个参数中包含了确定统计提醒数量范围、类型等条件的各种键值对信息（具体由业务逻辑规定）。 + * 方法返回一个整型（int）数值，代表符合给定参数条件下统计得出的提醒数量，例如可以是未读提醒数量、特定时间段内的提醒数量等，取决于业务对提醒数量统计的具体要求。 + */ @Override public int remindCount(Map params) { return commonDao.remindCount(params); } + + /** + * 根据传入参数进行选择计算（selectCal，具体计算逻辑由业务场景定义）的方法， + * 通过调用commonDao的selectCal方法来执行相应的计算操作，接收Map类型的参数params，该参数用于传递计算所需的输入数据、计算规则、相关配置等信息。 + * 返回一个Map类型的结果，即返回一个键值对形式的映射，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值或内容， + * 比如可以是经过某种数学运算、业务规则计算后得到的汇总数据、比率等结果信息，具体的计算结果结构取决于业务逻辑中对selectCal操作的定义。 + */ @Override public Map selectCal(Map params) { return commonDao.selectCal(params); } - + + + /** + * 执行分组查询操作的方法，通过调用commonDao的selectGroup方法来获取分组查询结果。 + * 接收Map类型的参数params，该参数包含了分组依据的字段、查询的数据表、筛选条件等用于控制分组查询的相关信息（具体由业务逻辑规定）。 + * 返回一个List>类型的列表，列表中的每个Map表示一组分组查询后的结果信息， + * 例如可以包含分组字段以及对应分组下的其他相关数据等内容，方便后续对分组数据进行处理、展示或进一步分析等操作，具体的分组查询结果结构取决于业务逻辑中对selectGroup操作的定义。 + */ @Override public List> selectGroup(Map params) { return commonDao.selectGroup(params); } - + + + /** + * 根据传入参数进行按值查询（selectValue，具体按什么值以及查询逻辑取决于业务场景）的方法， + * 通过调用commonDao的selectValue方法来获取按值查询的结果，接收Map类型的参数params，该参数用于传递按值查询所需的条件、要查询的值相关信息、数据表信息等内容。 + * 返回一个List>类型的列表，其中每个Map对应按值查询后的一组结果信息， + * 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定，例如可以是符合特定数值条件的数据记录集合等情况。 + */ @Override public List> selectValue(Map params) { return commonDao.selectValue(params); } + + /** + * 用于获取图表相关综合数据的方法，通过调用commonDao的chartBoth方法来获取图表综合数据。 + * 接收一个Map类型的参数params，该参数包含了确定图表数据查询条件、涉及的数据范围、图表类型相关配置等信息（具体取决于业务中图表展示的需求）。 + * 返回值是一个List>类型的列表，列表中的每个Map元素代表图表的一部分数据信息， + * 例如可以是图表的系列数据、坐标轴数据等不同部分的数据集合，整体构成用于生成完整图表的数据基础，具体每个Map的结构和内容由业务逻辑决定。 + */ @Override public List> chartBoth(Map params) { return commonDao.chartBoth(params); } + + /** + * 获取图表相关某一方面数据（相对chartBoth可能是更单一维度的数据，具体取决于业务逻辑）的方法， + * 通过调用commonDao的chartOne方法来获取图表某一方面的数据，同样接收Map类型的params参数，该参数用于控制具体的数据查询条件、范围等信息。 + * 返回一个List>类型的列表，其中每个Map元素包含了此次查询得到的图表某一相关部分的数据， + * 比如可能是图表中某一个数据系列的数据，用于在构建图表时填充相应的部分，具体内容由业务场景中图表的设计和需求来决定。 + */ @Override public List> chartOne(Map params) { return commonDao.chartOne(params); } + + /** + * 以下这些方法均为实现某个服务接口（从代码结构及方法命名推测，可能是与数据统计、字段值操作等业务逻辑相关的服务接口，需结合完整代码上下文进一步明确）中的具体方法， + * 它们主要的功能是调用注入的commonDao对象对应的方法来完成相应的业务操作，将接收到的参数params传递给底层的数据访问层（通过commonDao实现交互），并返回对应的数据结果或者执行相应操作后返回相应的状态标识（整型返回值情况）， + * 以此实现服务层与数据访问层的协作，为上层应用提供多样化的数据处理服务。 + * 参数params在各个方法中都起着传递操作相关配置信息、条件等关键作用，其内部具体的键值对含义因不同方法所对应的业务功能而有所差异，例如包含操作的数据表、分组字段、条件值、计算规则等不同内容。 + */ + /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 新的级联字典表的分组求和统计方法，实现了对应接口方法的具体逻辑。 + * 接收一个Map类型的参数params，该参数用于传递各种与在新的级联字典表中进行分组求和统计相关的配置信息、筛选条件等内容（具体键值对含义取决于业务逻辑）， + * 例如可能包含要操作的级联字典表相关信息、分组的字段、求和的目标字段以及其他限定参与求和数据范围的条件等。 + * 通过调用commonDao的newSelectGroupSum方法，并将params参数传递过去，获取并返回分组求和统计后的结果数据，返回值是一个List>类型的列表， + * 列表中的每个Map表示一组分组求和后的统计结果信息，像可能包含分组字段对应的标识以及对应的求和数值等键值对内容，便于后续基于这些结果进行数据展示、进一步分析等操作，具体结构由业务场景决定。 */ @Override public List> newSelectGroupSum(Map params) { @@ -91,20 +191,26 @@ public class CommonServiceImpl implements CommonService { } + /** - * 新的级联字典表的 分组条数统计 - * @param params - * @return + * 新的级联字典表的分组条数统计方法，用于实现接口中定义的相应功能。 + * 同样接收Map类型的params参数，该参数用于传递在新的级联字典表中进行分组条数统计所需的各项条件、配置信息等（具体依据业务要求而定）， + * 例如涉及要操作的表信息、分组依据的字段以及限定统计范围的其他条件等。 + * 调用commonDao的newSelectGroupCount方法并传递params参数，获取并返回相应的分组条数统计结果，返回值为List>类型的列表， + * 其中每个元素Map对应一组分组统计总条数的结果数据，例如包含分组字段及对应统计的条数等相关信息，方便后续按业务需求对统计结果进行处理和使用。 */ @Override public List> newSelectGroupCount(Map params) { return commonDao.newSelectGroupCount(params); } + /** - * 当前表的日期分组求和 - * @param params - * @return + * 当前表的日期分组求和方法，实现了对应接口方法的业务逻辑。 + * 接收Map类型的params参数，该参数包含了当前表进行日期分组求和操作所需要的各种条件信息， + * 比如要操作的表名、用于分组的日期字段（可能还涉及日期格式相关设置等）、求和的目标字段以及其他筛选条件（用于确定哪些数据参与求和计算）等内容，具体由业务场景规定。 + * 调用commonDao的newSelectDateGroupSum方法并传递params参数，获取并返回按照日期分组求和后的统计结果数据，返回值为List>类型的列表， + * 列表中的每个Map代表一组按照日期分组求和后的统计结果数据，例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续在数据展示或分析中体现不同日期分组下的求和情况。 */ @Override public List> newSelectDateGroupSum(Map params) { @@ -113,28 +219,56 @@ public class CommonServiceImpl implements CommonService { /** - * 查询字典表的分组统计总条数 - * @param params - * @return + * 查询字典表的分组统计总条数方法，负责实现接口中对应的功能。 + * 接收Map类型的params参数，该参数用于传递查询字典表分组统计总条数操作的相关配置信息、筛选条件等， + * 例如包含要查询的字典表名称、分组依据的字段以及其他限定统计范围的条件等（具体键值对含义取决于业务逻辑）。 + * 通过调用commonDao的newSelectDateGroupCount方法并传递params参数，获取并返回相应的分组统计总条数结果，返回的是List>类型的列表， + * 里面的每个Map对应一组字典表分组统计总条数的结果情况，通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行展示、对比等操作。 */ @Override public List> newSelectDateGroupCount(Map params) { return commonDao.newSelectDateGroupCount(params); } + + /** + * 增加字段数字的方法，实现了对应接口中定义的增加字段值的功能逻辑。 + * 接收一个Map类型的params参数，该参数用于指定增加字段数字操作的相关条件及目标字段等信息， + * 比如要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容，具体由业务场景决定。 + * 调用commonDao的plusCloumNumber方法并传递params参数，获取并返回操作的执行情况，返回值为整型（int），其含义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定），用于反馈操作的执行情况。 + */ @Override public int plusCloumNumber(Map params) { return commonDao.plusCloumNumber(params); } + + + /** + * 减少字段数字的方法，实现接口中相应的减少字段值的功能。 + * 接收Map类型的params参数，此参数用于明确减少字段数字操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过params传入（具体依据业务逻辑而定）。 + * 通过调用commonDao的reduceCloumNumber方法并传递params参数，获取并返回操作的执行结果，方法返回一个整型（int）值，该值的意义大概率与操作的执行结果相关， + * 比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 + */ @Override public int reduceCloumNumber(Map params) { return commonDao.reduceCloumNumber(params); } + + + /** + * 修改字段数字的方法，用于完成接口中定义的修改字段值的相关业务逻辑。 + * 以Map类型的params参数来控制具体的修改操作逻辑，params里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 调用commonDao的updateCloumValue方法并传递params参数，获取并返回修改操作的执行情况，该方法返回的整型（int）值通常用于反馈修改操作的执行情况， + * 可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 + */ @Override public int updateCloumValue(Map params) { return commonDao.updateCloumValue(params); } + /** * 饼状图 * -- 饼状图 查询当前表 @@ -176,22 +310,41 @@ public class CommonServiceImpl implements CommonService { -- 求和 -- 【日期，字符串，下拉框】 */ + + /** - * 柱状图求和 - * @param params - * @return + * 以下这两个方法用于实现柱状图相关的数据处理操作，通过调用注入的commonDao对象对应的方法来获取相应的统计结果数据， + * 进而为上层应用提供构建柱状图所需的数据支持，它们在整个业务逻辑中承担着与柱状图数据生成密切相关的功能，具体的数据操作细节由commonDao中对应的实现来完成。 + * 参数params在这两个方法中都起着传递控制柱状图相关操作的具体条件、配置等关键信息的作用，其内部具体的键值对含义取决于不同的业务场景以及柱状图的具体展示需求， + * 例如包含要统计的数据表信息、分组依据、筛选条件以及涉及的计算字段等内容。 + */ + + + /** + * 柱状图求和方法，用于获取柱状图求和相关的数据结果。 + * 接收一个Map类型的参数params，该参数用于传递和柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 通过调用commonDao的barSum方法，并将params参数传递过去，获取并返回柱状图求和后的统计结果数据，返回值是一个List>类型的列表， + * 列表中的每个Map表示一组柱状图求和后的统计结果信息，比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容， + * 这些结果数据可用于构建柱状图中不同分组下的求和展示部分，以直观呈现各分组的数据总和情况，便于用户查看不同类别或时间段等维度下数据的总体量对比。 */ public List> barSum(Map params){ return commonDao.barSum(params); } + /** - * 柱状图统计 - * @param params - * @return + * 柱状图统计方法，旨在获取柱状图统计相关的数据信息。 + * 同样接收一个Map类型的参数params，该参数涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 调用commonDao的barCount方法并传递params参数，获取并返回柱状图统计后的结果数据，此方法返回的是List>类型的列表， + * 其中每个Map对应一组柱状图统计后的结果信息，像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对， + * 这些结果数据可用于在柱状图中展示相应的统计情况，帮助用户直观了解数据分布及特征等信息，辅助进行数据分析和决策等操作。 */ public List> barCount(Map params){ return commonDao.barCount(params); } + } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java index 786bf53d..a6f717e3 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java @@ -22,29 +22,60 @@ import com.utils.Query; * 系统用户 * @author */ + +/** + * 此类代表系统用户相关的服务实现类，用于处理与系统用户相关的业务逻辑，实现了UsersService接口中定义的多个方法， + * 通过继承ServiceImpl类并关联对应的UsersDao和UsersEntity，能够便捷地使用一些基础的数据操作方法，同时为上层应用提供更贴合业务需求的用户相关服务功能。 + * + * @author 此处应填写该类的作者姓名，用于明确代码的编写者，方便后续代码维护以及追溯代码相关问题的责任人等情况。 + */ + +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定了其在容器中的bean名称为"userService"， +// 这样其他组件就可以通过该名称在Spring容器中获取到此服务类的实例，进而使用它所提供的各种方法来处理业务逻辑。 @Service("userService") public class UsersServiceImpl extends ServiceImpl implements UsersService { + /** + * 实现UsersService接口中定义的queryPage方法，用于查询用户信息并进行分页处理。 + * 接收一个Map类型的参数params，该参数用于传递分页查询相关的各种条件信息，例如查询的页码、每页显示的记录数、筛选条件等（具体键值对含义取决于业务逻辑）。 + * 首先通过this.selectPage方法创建一个Page类型的分页对象page，在创建过程中，使用传入的params参数构建Query对象来获取分页相关配置， + * 并结合一个默认的EntityWrapper对象（此处可能用于添加一些通用的查询条件或者关联关系等，具体取决于业务实现）来确定最终的查询条件。 + * 最后将构建好的分页对象page封装到PageUtils对象中并返回，以便上层应用可以方便地获取分页后的用户数据以及分页相关的元数据（如总页数、总记录数等）。 + */ @Override public PageUtils queryPage(Map params) { Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() - ); - return new PageUtils(page); + new Query(params).getPage(), + new EntityWrapper() + ); + return new PageUtils(page); } + + /** + * 实现UsersService接口中定义的selectListView方法，用于按照特定的查询条件（通过Wrapper封装）查询用户列表信息。 + * 接收一个Wrapper类型的参数wrapper，该参数用于封装各种灵活的查询条件，例如可以指定具体的筛选字段、排序规则、关联查询等条件（具体取决于业务中对用户查询的需求）。 + * 通过调用baseMapper的selectListView方法并传入wrapper参数，获取符合条件的用户实体列表并返回，返回值类型为List，即返回一个包含多个用户实体对象的列表，这些对象代表了满足查询条件的用户信息。 + */ @Override public List selectListView(Wrapper wrapper) { return baseMapper.selectListView(wrapper); } + + /** + * 实现UsersService接口中另一个重载的queryPage方法，此方法在分页查询用户信息的基础上，还可以根据传入的Wrapper对象来进一步定制查询条件。 + * 接收两个参数，一个是Map类型的params，用于传递分页相关的通用条件信息（如页码、每页记录数等），另一个是Wrapper类型的wrapper，用于传递更具体的、个性化的查询条件。 + * 首先创建一个Page类型的分页对象page，通过传入的params参数构建Query对象来获取分页相关配置。 + * 然后调用baseMapper的selectListView方法，传入page和wrapper参数，将查询到的符合条件的用户记录设置到page对象的records属性中，以此实现根据定制条件进行分页查询用户数据的功能。 + * 最后将包含查询结果的page对象封装到PageUtils对象中并返回，方便上层应用获取带有详细分页信息和符合条件的用户数据列表，便于进行后续的数据展示、处理等操作。 + */ @Override public PageUtils queryPage(Map params, - Wrapper wrapper) { - Page page =new Query(params).getPage(); - page.setRecords(baseMapper.selectListView(page,wrapper)); - PageUtils pageUtil = new PageUtils(page); - return pageUtil; + Wrapper wrapper) { + Page page =new Query(params).getPage(); + page.setRecords(baseMapper.selectListView(page,wrapper)); + PageUtils pageUtil = new PageUtils(page); + return pageUtil; } } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java index ccdd5bcf..7df6a066 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java @@ -20,20 +20,44 @@ import com.entity.view.YonghuView; /** * 用户 服务实现类 */ + + +/** + * 这是用户相关的服务实现类，用于实现具体的用户业务逻辑，继承自ServiceImpl类并关联了YonghuDao和YonghuEntity，实现了YonghuService接口， + * 通过一系列操作来处理用户数据的分页查询等功能，同时使用了Spring的事务管理机制（通过@Transactional注解体现），保证相关操作在事务环境下执行，确保数据的一致性和完整性。 + * 该类主要向外提供了针对用户数据的服务方法，方便其他模块调用以满足业务中对用户数据操作的需求。 + */ + +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定其在容器中的bean名称为"yonghuService"， +// 这样在Spring容器中可以通过该名称来获取此服务类的实例，进而调用其提供的业务方法进行相关的用户业务逻辑处理。 +// @Transactional注解用于声明该类中的方法（如果没有特殊配置，默认是所有方法）都将在事务环境下执行， +// 如果方法执行过程中出现异常，事务将会自动回滚，以保证数据的一致性，常用于涉及数据库操作等需要保证原子性的业务场景。 @Service("yonghuService") @Transactional public class YonghuServiceImpl extends ServiceImpl implements YonghuService { + /** + * 实现了YonghuService接口中定义的queryPage方法，用于对用户数据进行分页查询并返回相应的分页结果信息。 + * 接收一个Map类型的参数params，该参数用于传递分页查询相关的各种条件信息，例如页码、每页显示的记录数、筛选条件等（具体键值对含义取决于业务逻辑）。 + * 首先会进行参数的合法性判断，如果params不为空，并且其中的"limit"（每页记录数）或者"page"（页码）参数为空，说明可能没有传入分页相关的关键参数， + * 则默认设置"page"为"1"，表示查询第一页数据，设置"limit"为"10"，表示每页显示10条记录，以此确保分页查询能有合理的默认参数进行。 + * 接着通过new Query(params).getPage()创建一个Page类型的分页对象page，该对象包含了分页相关的配置信息以及后续会存放查询到的用户数据记录。 + * 然后调用baseMapper的selectListView方法，传入page和params参数，将查询到的符合条件的用户记录设置到page对象的records属性中，完成基于传入参数的用户数据分页查询操作。 + * 最后将包含查询结果以及分页相关信息的page对象封装到PageUtils对象中并返回，使得调用该方法的上层应用能够方便地获取分页后的用户数据以及如总页数、总记录数等分页相关的元数据，便于进行后续的数据展示、处理等操作。 + */ + @Override public PageUtils queryPage(Map params) { - if(params != null && (params.get("limit") == null || params.get("page") == null)){ + if(params!= null && (params.get("limit") == null || params.get("page") == null)){ params.put("page","1"); params.put("limit","10"); } - Page page =new Query(params).getPage(); + + Page page = new Query(params).getPage(); page.setRecords(baseMapper.selectListView(page,params)); return new PageUtils(page); } } + diff --git a/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java b/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java index 37063119..b978ba48 100644 --- a/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java +++ b/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java @@ -3,7 +3,24 @@ package com.thread; /** * 线程执行方法（做一些项目启动后 一直要执行的操作，比如根据时间自动更改订单状态，比如订单签收30天自动收货功能，比如根据时间来更改状态） */ + + +/** + * 这是一个自定义的线程类，继承自Thread类，用于定义线程执行的具体逻辑。 + * 该线程主要承担在项目启动后持续执行一些特定业务操作的任务，例如根据时间条件自动更改订单状态（像订单签收30天后自动收货等基于时间来变更状态的功能）， + * 通过在run方法中的循环逻辑以及设置的休眠时间来周期性地执行相应操作，直到线程被中断为止。 + */ + + public class MyThreadMethod extends Thread { + + + /** + * 重写了Thread类中的run方法，此方法定义了线程启动后具体要执行的逻辑内容。 + * 在这个方法中，通过一个while循环来持续执行相关操作，只要线程未被中断（通过判断this.isInterrupted()为false来确定），就会一直循环下去。 + * 循环内部通过让线程休眠一定时间（当前设置为每隔5000毫秒，即5秒执行一次，通过Thread.sleep(5000)实现）来控制操作执行的频率， + * 在实际的业务场景中，可以在休眠后的位置添加具体的业务逻辑代码，以实现诸如根据时间自动更改订单状态等功能。 + */ public void run() { while (!this.isInterrupted()) {// 线程未中断执行循环 try { @@ -12,8 +29,15 @@ public class MyThreadMethod extends Thread { e.printStackTrace(); } + + // ------------------ 开始执行 --------------------------- +// 此处原本可以添加具体的业务逻辑代码，例如实现根据当前时间去数据库查询满足特定时间条件的订单，然后修改其状态等操作， +// 当前只是简单地输出了一个表示线程正在执行的信息以及当前时间戳（通过System.currentTimeMillis()获取当前时间的毫秒数）， +// 实际应用中需要根据具体的业务需求替换此处的代码来完成相应的定时业务功能。 // System.out.println("线程执行中:" + System.currentTimeMillis()); + } } } + diff --git a/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java b/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java index f6cfb86b..311f0d5d 100644 --- a/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java +++ b/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java @@ -3,21 +3,35 @@ package com.utils; import java.util.Random; public class CommonUtil { - /** - * 获取随机字符串 + + /** + * 此静态方法用于生成一个指定长度的随机字符串，可应用于需要生成随机标识、临时验证码等场景，通过传入参数来控制生成字符串的长度。 * - * @param num - * @return + * @param num 用于指定要生成的随机字符串的长度，参数类型为Integer，即传入一个整数，该整数决定了最终生成的随机字符串包含多少个字符。 + * @return 返回值类型为String，即返回一个按照特定规则生成的随机字符串，其字符内容来源于预定义的字符集合，长度由传入的参数num决定。 */ + public static String getRandomString(Integer num) { + // 定义一个包含所有可用字符的基础字符串，这里包含了小写英文字母和数字，后续将从这些字符中随机选取来组成最终的随机字符串。 String base = "abcdefghijklmnopqrstuvwxyz0123456789"; + + // 创建一个Random类的实例，用于生成伪随机数，它将作为选取字符的随机索引依据，通过其nextInt方法来获取在指定范围内的随机整数。 Random random = new Random(); + + // 创建一个StringBuffer对象，用于高效地拼接字符，相比于直接使用字符串相加操作，StringBuffer在频繁拼接字符时性能更好，将逐步把随机选取的字符添加到这里来构建最终的随机字符串。 StringBuffer sb = new StringBuffer(); + + // 通过循环来控制生成的随机字符串的长度，循环次数由传入的参数num决定，每次循环向字符串中添加一个随机字符。 for (int i = 0; i < num; i++) { + // 生成一个随机索引，其范围是从0到base字符串的长度减1（通过调用Random类的nextInt方法实现），该索引将用于从base字符串中选取一个字符。 int number = random.nextInt(base.length()); + + // 根据生成的随机索引，从base字符串中获取对应的字符，并添加到StringBuffer对象sb中，逐步构建随机字符串。 sb.append(base.charAt(number)); } + // 将StringBuffer对象转换为字符串并返回，得到最终生成的随机字符串，其长度和字符内容都符合随机生成的要求，由上述逻辑决定。 return sb.toString(); + } } -- 2.34.1 From 6d9a5088f8bc538f90d63256c1da5a3b1ae639ed Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 22:35:55 +0800 Subject: [PATCH 09/12] =?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/annotation/APPLoginUser.java | 20 ++ .../main/java/com/annotation/IgnoreAuth.java | 22 ++ .../main/java/com/annotation/LoginUser.java | 17 ++ .../src/main/java/com/dao/CommonDao.java | 199 ++++++++++++++++- .../src/main/java/com/entity/EIException.java | 47 +++- .../interceptor/AuthorizationInterceptor.java | 89 +++++++- .../main/java/com/model/enums/TypeEnum.java | 38 +++- .../main/java/com/service/CommonService.java | 164 ++++++++++---- .../com/service/impl/CommonServiceImpl.java | 201 +++++++++++++++--- .../com/service/impl/UsersServiceImpl.java | 49 ++++- .../com/service/impl/YonghuServiceImpl.java | 28 ++- .../main/java/com/thread/MyThreadMethod.java | 24 +++ .../src/main/java/com/utils/CommonUtil.java | 22 +- 13 files changed, 819 insertions(+), 101 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java b/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java index 21d41b90..fccf135a 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/APPLoginUser.java @@ -8,8 +8,28 @@ import java.lang.annotation.Target; /** * 登录用户信息 */ + + +/** + * 这是一个自定义的注解类型，名为 @APPLoginUser，用于特定的标识用途，通常应用在程序开发中与移动端应用（APP）登录用户相关的场景里。 + * 通过 @Target(ElementType.PARAMETER) 注解设定其作用目标为方法参数，意味着该注解专门用来标记那些代表 APP 登录用户信息的方法参数。 + * 而 @Retention(RetentionPolicy.RUNTIME) 注解规定了它的保留策略是运行时，使得在程序运行阶段能够借助反射机制获取到该注解相关的信息，进而基于此执行相应的业务逻辑，比如针对 APP 登录用户进行权限验证、信息提取等操作。 + */ + + +// @Target 注解用于明确此自定义注解可以应用的元素类型，这里指定为 ElementType.PARAMETER，表明它只能被用在方法参数上， +// 以便在代码中清晰地标识出哪些参数承载了 APP 登录用户的相关信息，方便后续统一处理与 APP 登录用户相关的业务逻辑。 @Target(ElementType.PARAMETER) + + +// @Retention 注解用来定义注解的保留期限和可见性阶段，将其设置为 RetentionPolicy.RUNTIME，表示该注解在程序运行期间依然有效且可被获取， +// 这对于在运行时根据是否存在该注解以及其相关属性（若有定义）来动态地执行如权限判断、数据筛选等和 APP 登录用户紧密相关的操作是非常关键的。 @Retention(RetentionPolicy.RUNTIME) +// 定义了 @APPLoginUser 这个注解，当前它没有定义任何成员变量（属性），不过如果业务需要，可以后续添加属性来传递更多关于 APP 登录用户的详细情况， +// 例如 APP 用户的登录来源、所属平台版本等信息，以更好地适配复杂的业务场景和多样化的处理需求。 + public @interface APPLoginUser { } + + diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java b/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java index 7c3cc550..f3fea46a 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/IgnoreAuth.java @@ -5,9 +5,31 @@ import java.lang.annotation.*; /** * 忽略Token验证 */ + + +/** + * 这是一个自定义的注解类型，名为 @IgnoreAuth，其主要作用是用于标记在特定的业务场景下，需要忽略Token验证的方法。 + * 通过 @Target(ElementType.METHOD) 注解明确了它的作用目标是方法，也就是该注解只能应用在方法之上，用来指示对应的方法在执行时不需要进行Token验证这一常规的安全校验操作。 + * @Retention(RetentionPolicy.RUNTIME) 注解定义了它的保留策略为运行时，这意味着在程序运行阶段，仍然可以通过反射机制获取到该注解的相关信息，进而根据此信息来决定是否跳过Token验证流程，满足一些特殊情况下对接口访问的需求，比如公开的、无需登录验证即可访问的接口等情况。 + * 而 @Documented 注解则表示在生成JavaDoc文档时，会将这个注解相关的信息也包含进去，方便开发人员查看和了解该注解的存在以及作用，提高代码的可读性和可维护性，便于团队协作开发时知晓哪些方法是不需要进行Token验证的。 + */ + + +// @Target 注解用于指定此自定义注解能够应用的元素类型，这里将其设置为 ElementType.METHOD，限定了 @IgnoreAuth 注解只能被放置在方法声明处， +// 以此清晰地标识出哪些具体的方法需要忽略Token验证操作，便于代码的阅读者和维护者快速知晓方法的特殊验证要求。 @Target(ElementType.METHOD) + +// @Retention 注解规定了注解的保留策略，此处设为 RetentionPolicy.RUNTIME，表明该注解在程序运行时依然可以被获取到， +// 借助Java的反射机制，在运行期间可以检查方法上是否存在这个注解，进而依据其存在与否来决定是否执行Token验证逻辑，使其能够灵活地控制方法的验证行为。 @Retention(RetentionPolicy.RUNTIME) + +// @Documented 注解的作用是让这个自定义注解在生成JavaDoc文档时被包含进去，使得在查看文档时能够看到哪些方法使用了该注解， +// 有助于开发人员理解方法在验证方面的特殊处理情况，增强代码文档化程度，方便团队成员之间对代码功能尤其是涉及验证逻辑部分的沟通和理解。 @Documented + +// 定义了 @IgnoreAuth 这个注解，当前它没有定义自身的成员变量（属性），不过若业务场景有更复杂的需求，例如可以添加属性来指定忽略Token验证的具体条件、适用范围等信息，以更精细地控制验证的忽略情况。 public @interface IgnoreAuth { } + + diff --git a/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java b/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java index 3d808d35..3e48963f 100644 --- a/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java +++ b/minsu/minsuguanliw/src/main/java/com/annotation/LoginUser.java @@ -8,8 +8,25 @@ import java.lang.annotation.Target; /** * 登录用户信息 */ + + +/** + * 自定义的注解类型 @LoginUser，用于标记方法参数，通常在Java的Web开发等场景下有特定用途， + * 一般可用于标识某个参数代表的是当前登录用户的相关信息，方便在方法中对登录用户的信息进行获取、处理以及基于用户权限等进行相关业务逻辑操作， + * 其作用范围通过 @Target 注解指定为只能用于方法参数（ElementType.PARAMETER），生命周期通过 @Retention 注解指定为在运行时（RetentionPolicy.RUNTIME）有效， + * 这样在程序运行期间可以通过反射等机制来获取到该注解相关信息并进行相应处理。 + */ + +// @Target 注解用于指定该自定义注解可以应用的目标元素类型，这里指定为 ElementType.PARAMETER，表示此注解只能用于方法参数上， +// 意味着它可以标记那些在方法中接收登录用户信息的参数，以便框架或者其他相关代码能识别并处理这些参数。 @Target(ElementType.PARAMETER) + +// @Retention 注解用于定义该注解的保留策略，即规定注解在什么阶段是可见可用的，这里设置为 RetentionPolicy.RUNTIME，表示在运行时该注解信息仍然保留， +// 可以通过Java的反射机制在运行期间获取到该注解及其属性值等信息，常用于根据注解来动态执行一些业务逻辑的场景。 @Retention(RetentionPolicy.RUNTIME) + +// 定义了一个名为 @LoginUser 的注解，此注解本身没有定义成员变量（属性），如果后续有需要，也可以添加属性来传递更多关于登录用户相关的配置信息等，比如用户角色、权限级别等相关限定信息。 public @interface LoginUser { } + diff --git a/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java b/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java index 47300bc8..63fd8986 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/CommonDao.java @@ -5,19 +5,61 @@ import java.util.List; import java.util.Map; /** - * 通用接口 + * 通用接口，定义了一系列通用的数据操作方法，供具体的实现类去实现这些方法以满足不同的数据处理需求。 + * 这些方法通常会涉及到数据库查询、统计等相关操作，通过传入不同的参数来控制具体的操作逻辑。 */ + public interface CommonDao{ + + /** + * 获取选项列表的方法，根据传入的参数（params）来查询并返回相应的选项列表。 + * 参数 params 是一个 Map 类型，其具体的键值对内容取决于具体的业务需求， + * 例如可能包含查询条件、筛选字段等信息，用于确定获取哪些选项数据。 + * 返回值是一个包含字符串的列表（List），每个字符串元素代表一个选项内容。 + * @param params 用于控制查询选项列表的参数集合 + * @return 符合条件的选项列表 + */ List getOption(Map params); - + + /** + * 根据传入的选项相关参数（params），查询并返回对应的关注信息（具体含义取决于业务场景），以 Map 的形式返回结果。 + * 参数 params 同样是 Map 类型，包含了用于确定关注信息查询范围、条件等的各种键值对信息。 + * 返回值是一个 Map，其中键表示关注信息的不同属性，值则是对应属性的具体内容。 + * @param params 用于控制查询关注信息的参数集合 + * @return 包含关注信息的 Map + */ Map getFollowByOption(Map params); - + + /** + * 与 getFollowByOption 类似，也是根据传入的选项相关参数（params）查询关注信息，不过返回值类型为 List。 + * 具体返回的字符串列表内容以及参数 params 的含义都取决于具体业务逻辑，可能是另一种形式的关注信息表示。 + * @param params 用于控制查询关注信息的参数集合 + * @return 符合条件的关注信息列表（以字符串形式表示） + */ List getFollowByOption2(Map params); - + + /** + * 执行某个操作（从方法名 sh 推测可能是一个特定的业务操作，具体含义需结合业务场景确定）， + * 通过传入参数（params）来控制该操作的具体行为，该方法无返回值，意味着它可能主要用于对数据进行修改、更新等操作。 + * @param params 用于控制操作执行的参数集合 + */ void sh(Map params); - + + /** + * 用于统计提醒相关的数量，根据传入的参数（params）确定统计的范围、条件等信息，返回统计得到的提醒数量。 + * 参数 params 作为 Map 类型，包含了如时间范围、提醒类型等各种影响统计结果的条件信息。 + * 返回值为整型（int），代表符合条件的提醒数量。 + * @param params 用于控制提醒数量统计的参数集合 + * @return 提醒的数量 + */ int remindCount(Map params); + /** + * 根据传入的参数（params）进行计算操作（从方法名 selectCal 推测可能是某种选择计算，具体取决于业务逻辑）， + * 返回计算后的结果，以 Map 形式呈现，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值等内容。 + * @param params 用于控制计算操作的参数集合 + * @return 包含计算结果的 Map + */ Map selectCal(Map params); /** tableName 查询表 @@ -25,26 +67,77 @@ public interface CommonDao{ condition1Value 条件1值 average 计算平均评分 * */ + + /** + * 查询评分相关信息的方法，根据传入的参数（params）确定查询的表（tableName）、条件（condition1 及 condition1Value）等信息， + * 可能还涉及到平均评分（average）相关的计算或筛选逻辑，最终返回包含评分相关信息的 Map。 + * 参数 params 中各键值对具体含义如注释中所描述，用于精确控制评分信息的查询操作。 + * @param params 用于控制评分信息查询的参数集合，包含查询表名、条件及相关计算控制等信息 + * @return 包含评分相关信息的 Map + */ Map queryScore(Map params); + /** + * 执行分组查询操作，根据传入的参数（params）确定分组的依据、查询的数据表等信息， + * 返回一个包含多个 Map 的列表（List>），每个内层的 Map 可能表示一组分组查询后的结果信息， + * 例如包含分组字段以及对应分组下的其他相关数据等内容，具体取决于业务逻辑的设计。 + * @param params 用于控制分组查询操作的参数集合 + * @return 分组查询后的结果列表，每个元素为一组分组相关的信息 Map + */ List> selectGroup(Map params); - - List> selectValue(Map params); + /** + * 根据传入的参数（params）进行按值查询操作（具体按什么值以及查询逻辑取决于业务场景）， + * 返回一个包含多个 Map 的列表（List>），每个内层的 Map 对应按值查询后的一组结果信息， + * 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定。 + * @param params 用于控制按值查询操作的参数集合 + * @return 按值查询后的结果列表，每个元素为一组按值相关的信息 Map + */ + List> selectValue(Map params); + /** + * 用于进行图表相关的综合查询操作（从方法名 chartBoth 推测可能涉及到多方面图表数据生成相关逻辑）， + * 根据传入的参数（params）来确定具体的查询条件、涉及的数据表等信息， + * 返回一个包含多个 Map 的列表（List>），该列表包含了图表生成所需的各种数据信息， + * 具体每个 Map 中的键值对内容以及整体列表结构取决于图表的类型和业务需求，例如可能包含图表的系列数据、坐标轴数据等。 + * @param params 用于控制图表综合查询操作的参数集合 + * @return 图表相关综合查询后的结果列表，用于后续图表生成等操作 + */ List> chartBoth(Map params); + /** + * 进行图表相关的某种单一查询操作（与 chartBoth 相对，可能只涉及图表某一方面的数据查询，具体取决于业务逻辑）， + * 依据传入的参数（params）确定查询范围和条件，返回一个包含多个 Map 的列表（List>）， + * 列表中的每个 Map 包含了此次单一图表查询相关的结果信息，具体内容由业务逻辑决定，例如可能是图表某一数据系列的数据等。 + * @param params 用于控制图表单一查询操作的参数集合 + * @return 图表相关单一查询后的结果列表，用于特定图表部分的数据展示等操作 + */ List> chartOne(Map params); /** * 下面为新加的 */ + /** + * 此接口（推测所在接口定义了一系列与数据统计相关的方法，这里是其中部分方法，具体需结合完整接口来看）用于提供不同条件下的数据统计功能， + * 涉及到新的级联字典表以及普通表按日期分组等多种统计场景，通过传入不同的参数来控制具体的统计逻辑，返回相应的统计结果数据结构。 + */ + /** * 新的级联字典表的 分组求和方法 * @param params * @return */ + + /** + * 新的级联字典表的分组求和方法。 + * 该方法接收一个参数 params，它是一个 Map 类型，其中包含了执行分组求和操作所需要的各种条件信息、配置参数等， + * 例如可能包含要操作的数据表名称、分组的字段、求和的字段以及其他相关筛选条件等内容（具体取决于业务逻辑和实际应用场景）。 + * 返回值是一个 List> 类型的列表，列表中的每个 Map 表示一组分组求和后的统计结果信息， + * 其内部的键值对可以是分组字段以及对应的求和结果等内容，方便后续对分组求和数据进行处理和展示等操作。 + * @param params 用于控制新的级联字典表分组求和操作的参数集合 + * @return 新的级联字典表分组求和后的统计结果列表，每个元素为一组分组求和相关的信息 Map + */ List> newSelectGroupSum(Map params); /** @@ -52,6 +145,16 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 新的级联字典表的分组条数统计方法。 + * 接收参数 params（Map 类型），这个参数用于明确分组统计条数操作的具体条件， + * 像涉及的数据表、按照哪些字段进行分组、可能的筛选条件等信息都会通过 params 传递进来（具体由业务逻辑决定）。 + * 方法返回一个 List> 类型的列表，里面的每一个 Map 对应一组分组统计总条数的结果信息， + * 例如可能包含分组字段以及对应的记录条数等键值对内容，以满足不同业务场景下对分组统计条数结果的使用需求。 + * @param params 用于控制新的级联字典表分组条数统计操作的参数集合 + * @return 新的级联字典表分组条数统计后的结果列表，每个元素为一组分组统计条数相关的信息 Map + */ List> newSelectGroupCount(Map params); @@ -60,6 +163,16 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 当前表的日期分组求和方法。 + * 接收一个 Map 类型的参数 params，该参数会传入当前表进行日期分组求和操作所需要的各项设置信息， + * 比如要操作的表名、用于分组的日期字段（以及日期格式化相关配置等，可能在方法内部进一步处理）、求和的目标字段以及其他限定条件等（具体依据业务逻辑而定）。 + * 方法返回值为 List> 类型的列表，其中每个 Map 代表一组按照日期分组求和后的统计结果数据， + * 例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续基于日期分组求和结果进行数据展示或其他处理。 + * @param params 用于控制当前表日期分组求和操作的参数集合 + * @return 当前表日期分组求和后的统计结果列表，每个元素为一组日期分组求和相关的信息 Map + */ List> newSelectDateGroupSum(Map params); /** @@ -67,6 +180,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 查询字典表的分组统计总条数方法。 + * 同样以 Map 类型的 params 参数来控制具体的统计操作，params 中涵盖了诸如要查询的字典表名称、分组依据的字段以及其他相关筛选条件等信息（由业务场景决定具体内容）。 + * 该方法返回的是 List> 类型的列表，列表里的每个 Map 对应一组字典表分组统计总条数的结果情况， + * 通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行使用和展示。 + * @param params 用于控制查询字典表分组统计总条数操作的参数集合 + * @return 查询字典表分组统计总条数后的结果列表，每个元素为一组分组统计总条数相关的信息 Map + */ List> newSelectDateGroupCount(Map params); /** @@ -74,6 +196,22 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 此接口（推测所在接口定义了一系列用于对数据字段进行操作的方法，这里展示的是其中部分方法，需结合完整接口定义来综合理解）， + * 提供了针对数据字段进行值变更相关的操作功能，通过传入不同的参数来控制具体的操作逻辑以及操作的目标字段等信息， + * 并且以整型（int）返回值来表示操作的执行情况或者受影响的记录数量等（具体含义取决于各方法业务逻辑）。 + */ + + /** + * 增加字段值的方法。 + * 接收一个 Map 类型的参数 params，该参数用于指定增加字段值操作的相关条件及目标字段等信息。 + * 例如，params 中可能包含要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容， + * 具体的键值对含义取决于业务场景的具体需求。 + * 返回值为整型（int），其意义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定）。 + * @param params 用于控制增加字段值操作的参数集合 + * @return 整型值，可能表示受影响的记录数量或者操作执行的状态标识等情况 + */ int plusCloumNumber(Map params); /** @@ -81,6 +219,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 减少字段值的方法。 + * 同样接收 Map 类型的参数 params，这个参数在此处用于明确减少字段值操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过 params 传入（具体依据业务逻辑而定）。 + * 方法返回一个整型（int）值，该值的含义大概率与操作的执行结果相关，比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 + * @param params 用于控制减少字段值操作的参数集合 + * @return 整型值，可用于表示受影响的记录数量或者操作执行的状态情况 + */ int reduceCloumNumber(Map params); /** @@ -88,6 +235,15 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 修改字段值的方法。 + * 它以 Map 类型的 params 参数来控制具体的修改操作逻辑，params 里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 该方法返回的整型（int）值通常用于反馈修改操作的执行情况，可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 + * @param params 用于控制修改字段值操作的参数集合 + * @return 整型值，一般表示受影响的记录数量或者操作执行的状态标识等情况 + */ int updateCloumValue(Map params); @@ -138,6 +294,24 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 此接口（推测属于某个与数据统计及图表相关业务逻辑对应的接口，此处展示的是其中部分方法，需结合完整接口来全面理解）定义了用于生成柱状图相关数据的方法， + * 分别提供了柱状图求和以及柱状图统计的功能，通过接收包含不同配置信息的参数，来确定具体的统计逻辑以及生成符合柱状图展示需求的数据结构， + * 并以包含多个 Map 的列表形式返回相应的统计结果数据，方便后续用于柱状图的渲染展示等操作。 + */ + + /** + * 柱状图求和方法。 + * 接收一个 Map 类型的参数 params，该参数用于传递与柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 返回值为 List> 类型的列表，列表中的每个 Map 表示一组柱状图求和后的统计结果信息， + * 比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容，这些结果数据可用于构建柱状图中不同分组下的求和展示部分， + * 以直观呈现各分组的数据总和情况。 + * @param params 用于控制柱状图求和操作的参数集合 + * @return 柱状图求和后的统计结果列表，每个元素为一组求和相关的信息 Map，用于后续柱状图展示 + */ List> barSum(Map params); /** @@ -145,6 +319,17 @@ public interface CommonDao{ * @param params * @return */ + + /** + * 柱状图统计方法。 + * 同样以 Map 类型的参数 params 来控制具体的统计操作逻辑，params 中涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 该方法返回的是 List> 类型的列表，其中每个 Map 对应一组柱状图统计后的结果信息， + * 像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对，这些结果数据可用于在柱状图中展示相应的统计情况， + * 帮助用户直观了解数据分布及特征等信息。 + * @param params 用于控制柱状图统计操作的参数集合 + * @return 柱状图统计后的结果列表，每个元素为一组统计相关的信息 Map，便于后续柱状图的构建展示 + */ List> barCount(Map params); diff --git a/minsu/minsuguanliw/src/main/java/com/entity/EIException.java b/minsu/minsuguanliw/src/main/java/com/entity/EIException.java index 2ebfb566..2fbd129e 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/EIException.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/EIException.java @@ -4,49 +4,76 @@ package com.entity; /** * 自定义异常 */ + +// 定义了一个名为EIException的自定义异常类，它继承自RuntimeException，这意味着它属于运行时异常， +// 在程序运行期间出现问题时可以抛出该异常，并且不需要在方法声明中显式地使用 throws 关键字来声明可能抛出此异常，方便处理运行阶段突发的错误情况。 + public class EIException extends RuntimeException { + // 序列化版本号，用于在对象序列化和反序列化过程中保证版本的一致性和兼容性。 + // 此处定义为1L，一般在类结构没有发生改变的情况下保持不变，若类的成员变量等结构有变动，可能需要相应地更新该版本号。 private static final long serialVersionUID = 1L; - - private String msg; - private int code = 500; - - public EIException(String msg) { + + // 用于存储异常的详细描述信息，也就是具体的错误消息内容，通过不同的构造方法进行赋值，后续可通过对应的get方法获取该消息，以知晓具体的异常原因。 + private String msg; + + // 用于表示该异常对应的错误代码，默认值被初始化为500，可用于在系统中区分不同类型的异常情况， + // 例如在与前端交互或者日志记录时，依据这个代码能快速定位和辨别具体的异常类别，进而采取相应的处理措施。 + private int code = 500; + + // 构造方法，接受一个字符串类型的msg参数，用于创建EIException异常实例。 + // 此构造方法调用父类（RuntimeException）的构造函数，将传入的msg传递给父类，同时将该msg赋值给当前类的msg属性， + // 便于后续获取具体的异常消息，适用于只需简单传递异常消息的场景。 + public EIException(String msg) { super(msg); this.msg = msg; } - + + // 构造方法，接受一个字符串类型的msg参数和一个Throwable类型的e参数。 + // 它调用父类（RuntimeException）的对应构造函数，把msg和e传递给父类，并且将msg赋值给当前类的msg属性， + // 这样既能传递详细的异常消息，又能关联引发当前异常的其他异常（通过e传入），有助于在异常链中追溯异常产生的根源。 public EIException(String msg, Throwable e) { super(msg, e); this.msg = msg; } - + + // 构造方法，接受一个字符串类型的msg参数和一个整型的code参数。 + // 调用父类（RuntimeException）的构造函数传递msg，然后将msg赋值给当前类的msg属性，同时将传入的code赋值给当前类的code属性， + // 以此创建一个带有自定义错误代码的异常实例，方便更精准地标识异常类型，除传递异常消息外，通过错误代码可做进一步的区分和处理。 public EIException(String msg, int code) { super(msg); this.msg = msg; this.code = code; } - + + // 构造方法，接受一个字符串类型的msg参数、一个整型的code参数以及一个Throwable类型的e参数。 + // 调用父类（RuntimeException）的对应构造函数，传递msg、e给父类，同时将msg赋值给当前类的msg属性，把code赋值给当前类的code属性， + // 综合了传递异常消息、设置自定义错误代码以及关联引发异常的其他异常等功能，提供了一种较为全面的异常创建方式。 public EIException(String msg, int code, Throwable e) { super(msg, e); this.msg = msg; this.code = code; } + // 获取异常消息的方法，外部代码可以调用此方法来获取在创建EIException实例时设置的异常消息内容，从而了解具体的异常详情。 public String getMsg() { return msg; } + // 设置异常消息的方法，可用于在某些特定场景下（虽然相对不常见）动态修改异常消息的内容，比如根据后续的业务逻辑调整异常提示信息等。 public void setMsg(String msg) { this.msg = msg; } + // 获取异常对应的错误代码的方法，外部代码通过调用此方法能获取当前EIException实例所代表的异常对应的错误代码， + // 便于根据该代码实施不同的错误处理逻辑，例如向客户端返回不同的错误提示等操作。 public int getCode() { return code; } + // 设置异常对应的错误代码的方法，可用于在需要根据运行时条件等因素动态调整错误代码的情况下，对错误代码进行重新设定。 public void setCode(int code) { this.code = code; } - - + + } diff --git a/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java b/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java index 723834ba..e2aa4563 100644 --- a/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java +++ b/minsu/minsuguanliw/src/main/java/com/interceptor/AuthorizationInterceptor.java @@ -23,52 +23,112 @@ import com.utils.R; /** * 权限(Token)验证 */ + +/** + * 这是一个用于权限（Token）验证的拦截器类，实现了HandlerInterceptor接口，在Web应用中可以拦截请求，对请求进行权限相关的验证处理， + * 通过检查请求携带的Token来判断用户是否有权限访问相应资源，同时还处理了一些跨域相关的设置以及对特定无需验证的请求路径进行放行等操作，是保障系统安全访问控制的重要组成部分。 + * 此类被标记为Spring的组件（通过@Component注解），以便能被Spring容器管理并在合适的时机参与到请求处理流程中。 + * + * 其主要职责包括：判断请求路径是否属于特定的无需验证的路径直接放行、设置跨域请求相关的响应头信息、检查方法上是否有忽略验证的注解（@IgnoreAuth）以及从请求头中获取Token用于后续的验证操作等。 + */ + +// 使用@Component注解将该类标记为Spring框架中的一个组件，意味着Spring容器会对其进行管理， +// 可以自动扫描并实例化这个类，使其能够在整个Web应用的请求处理流程中发挥作用，参与到权限验证等相关环节。 @Component public class AuthorizationInterceptor implements HandlerInterceptor { + // 定义了一个公共的静态常量字符串，用于表示在请求头中存放Token的键名，方便在整个类中统一使用该名称来获取请求头中的Token信息，保持代码的一致性和可读性。 public static final String LOGIN_TOKEN_KEY = "Token"; + // 使用@Autowired注解进行依赖注入，将TokenService的实例注入到当前类中， + // TokenService大概率是用于处理与Token相关的业务逻辑，比如验证Token的有效性、解析Token获取用户信息等操作，以此来辅助完成权限验证的功能。 @Autowired private TokenService tokenService; - + + + /** + * 此方法是HandlerInterceptor接口中的一个回调方法，在请求处理之前被调用，用于进行预处理操作， + * 主要在这里实现权限验证以及跨域相关的设置等逻辑，根据验证结果决定是否放行请求继续后续的处理流程，返回值为布尔类型，true表示放行，false表示拦截。 + * + * @param request 当前的HttpServletRequest对象，包含了请求相关的所有信息，如请求路径、请求头、请求参数等，可以从中获取进行权限验证等操作所需的数据。 + * @param response 当前的HttpServletResponse对象，用于设置响应相关的信息，例如在这里设置跨域请求的响应头信息，来控制浏览器对跨域请求的处理方式。 + * @param handler 表示被拦截的请求对应的处理器对象，其具体类型可能不同，通过判断其类型来获取方法上的相关注解等信息，以确定是否需要进行权限验证等操作。 + * @throws Exception 如果在处理过程中出现异常，可以抛出，由上层的异常处理机制进行统一处理，例如在验证Token等操作出现错误时可以抛出异常。 + * @return 返回一个布尔值，true表示请求可以继续往后传递进行后续的处理（即放行请求），false表示拦截该请求，不允许其继续执行后续的业务逻辑。 + */ + @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { - + // 获取当前请求的Servlet路径，用于后续判断请求是否属于特定的不需要进行权限验证的路径，通过与已知的特定路径进行对比来决定是否直接放行请求。 String servletPath = request.getServletPath(); + // 判断请求路径是否为字典表相关页面（"/dictionary/page"）、文件上传（"/file/upload"）或者用户注册（"/yonghu/register"）路径， + // 如果是这些特定的路径之一，则直接放行请求，不需要进行后续的权限验证操作，返回true表示允许请求继续执行后续的业务逻辑。 if("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath()) ){//请求路径是字典表或者文件上传 直接放行 return true; } - //支持跨域请求 + + + // 设置跨域请求相关的响应头信息，以下这些设置用于支持浏览器的跨域请求操作，使得不同域名下的前端应用能够正常访问当前后端服务提供的接口。 + + // 设置允许的请求方法，这里允许POST、GET、OPTIONS、DELETE等常见的请求方法进行跨域请求，告知浏览器本服务端支持这些跨域请求方式。 response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE"); + + // 设置跨域请求的缓存时间（单位：秒），这里设置为3600秒，意味着在这个时间段内，浏览器对于相同的跨域请求可以直接使用缓存结果，减少不必要的重复请求，提高性能。 response.setHeader("Access-Control-Max-Age", "3600"); + + // 设置是否允许跨域请求携带凭证（如Cookie等），这里设置为true，表示允许跨域请求携带相关凭证信息，方便进行基于用户登录状态等的跨域交互。 response.setHeader("Access-Control-Allow-Credentials", "true"); + + // 设置允许的请求头信息，这里列举了一系列常见的请求头以及本应用中用于权限验证等相关的特定请求头（如Token等），告知浏览器跨域请求时可以携带这些请求头信息， + // 以便服务端能够正确获取到相关的请求参数进行后续的业务处理，比如验证权限、获取请求来源等操作。 response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization"); + + // 设置允许的跨域请求来源，通过获取请求头中的Origin信息并设置到响应头中，允许来自该来源的跨域请求，实现了根据实际请求来源动态配置跨域允许的功能。 response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin")); + // 声明一个IgnoreAuth类型的注解变量，用于后续判断被拦截的请求对应的方法上是否标注了 @IgnoreAuth 注解， + // 如果标注了该注解，则意味着该方法对应的请求不需要进行权限验证，可直接放行。 IgnoreAuth annotation; + + // 判断handler对象是否是HandlerMethod类型，HandlerMethod表示的是一个被Spring MVC解析后的处理请求的方法对象， + // 如果是这种类型，说明可以获取到方法上的注解信息，进而判断是否有 @IgnoreAuth 注解；如果不是这种类型，说明可能不是常规的方法处理请求，直接放行请求。 if (handler instanceof HandlerMethod) { annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class); } else { return true; } - //从header中获取token + // 从请求的Header中获取名为Token的信息，该Token是后续进行权限验证的关键依据，会传递给注入的TokenService进行有效性验证等相关操作， + // 以此来判断当前请求是否来自合法的、已登录并有权限的用户。 String token = request.getHeader(LOGIN_TOKEN_KEY); /** * 不需要验证权限的方法直接放过 */ + + + // 判断当前请求对应的方法上是否标注了 @IgnoreAuth 注解，如果 annotation 不为空，说明该方法被标记为无需进行权限验证， + // 那么直接放行该请求，允许其继续执行后续的业务逻辑，返回 true 表示放行。 if(annotation!=null) { return true; } - + + + // 声明一个 TokenEntity 类型的变量 tokenEntity，并初始化为 null，后续会根据获取到的 token 信息尝试从 tokenService 中获取对应的 Token 实体信息， + // TokenEntity 大概率包含了与用户登录状态、权限等相关的属性，比如用户ID、角色、所属表名、用户名等，用于进一步判断用户的合法性及权限情况。 TokenEntity tokenEntity = null; + + // 检查从请求头中获取到的 token 字符串是否不为空（通过 StringUtils.isNotBlank 方法判断），如果不为空，说明请求携带了 Token 信息， + // 则调用注入的 tokenService 的 getTokenEntity 方法，尝试根据这个 token 去获取对应的 Token 实体对象，以便后续进行更多的验证及用户信息设置操作。 if(StringUtils.isNotBlank(token)) { tokenEntity = tokenService.getTokenEntity(token); } - + + // 判断获取到的 TokenEntity 是否不为空，若不为空，说明通过 Token 验证成功获取到了对应的用户相关信息， + // 此时将用户的关键信息（如用户ID、角色、表名、用户名等）设置到当前请求的 Session 中，方便在后续的请求处理过程中可以直接从 Session 里获取这些用户信息， + // 例如在其他业务逻辑中用于权限判断、数据筛选等操作，设置完相关信息后，放行该请求，返回 true 表示允许请求继续执行后续的业务逻辑。 if(tokenEntity != null) { request.getSession().setAttribute("userId", tokenEntity.getUserid()); request.getSession().setAttribute("role", tokenEntity.getRole()); @@ -76,19 +136,34 @@ public class AuthorizationInterceptor implements HandlerInterceptor { request.getSession().setAttribute("username", tokenEntity.getUsername()); return true; } - + + // 创建一个 PrintWriter 对象，用于向客户端（通常是浏览器）输出响应内容，这里后续会输出一个表示未登录的错误提示信息，以 JSON 格式返回给客户端，告知用户需要先登录才能访问相应资源。 PrintWriter writer = null; + // 设置响应的字符编码为 "UTF-8"，确保返回给客户端的中文等字符信息能够正确显示，避免出现乱码问题，这是处理响应内容编码的常见设置。 response.setCharacterEncoding("UTF-8"); + // 设置响应的内容类型为 "application/json; charset=utf-8"，表明返回给客户端的数据格式是 JSON 格式，并且字符编码采用 "UTF-8"， + // 这样客户端（如前端应用中的 JavaScript 代码等）在接收到响应后可以按照 JSON 格式进行解析处理，获取到相应的错误提示信息。 response.setContentType("application/json; charset=utf-8"); + try { + // 获取响应的输出流对象 writer，用于向客户端写入响应内容，通过调用 response.getWriter() 方法来获取，后续可以使用这个 writer 对象输出相应的 JSON 格式的错误提示信息。 writer = response.getWriter(); + // 使用 JSONObject.toJSONString 方法将一个表示错误信息的对象（通过 R.error(401, "请先登录") 创建，推测 R 是一个用于统一封装返回结果的工具类）转换为 JSON 字符串， + // 然后通过 writer.print 方法将这个 JSON 字符串输出到客户端，向用户提示需要先登录，这里的错误码 401 通常代表未授权（在 HTTP 状态码语义中常用于表示需要用户认证的情况）。 writer.print(JSONObject.toJSONString(R.error(401, "请先登录"))); + } finally { + // 在 finally 块中进行资源释放操作，判断 writer 对象是否不为空，如果不为空，说明之前成功获取到了输出流对象， + // 则调用 writer.close() 方法关闭输出流，释放相关资源，避免出现资源泄漏等问题，确保程序的稳定性和性能。 if(writer != null){ writer.close(); } } + +// 此处原本可能是要抛出一个自定义的 EIException 异常来表示未登录情况（从注释掉的代码推测），异常信息为 "请先登录"，错误码为 401， +// 不过当前代码采用了直接向客户端返回 JSON 格式错误提示信息并返回 false 来拦截请求的方式，而不是抛出异常（可能基于不同的错误处理策略考虑）。 // throw new EIException("请先登录", 401); + // 返回 false，表示拦截该请求，不允许其继续执行后续的业务逻辑，因为前面验证发现用户未登录，没有合法的权限访问相应资源，通过返回 false 来阻断请求的进一步处理。 return false; } } diff --git a/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java b/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java index 39061d8a..ff715bb2 100644 --- a/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java +++ b/minsu/minsuguanliw/src/main/java/com/model/enums/TypeEnum.java @@ -7,25 +7,61 @@ import com.baomidou.mybatisplus.enums.IEnum; /** * 必须现在 IEnum 配置 该包扫描自动注入，查看文件 spring-mybatis.xml 参数 typeEnumsPackage */ + +/** + * 此枚举类型（enum）用于定义特定的类型集合，在业务逻辑中可能代表不同的状态、类别等情况，并且遵循了 IEnum 接口的规范进行配置， + * 实现了相关方法以便能更好地与框架集成使用。该枚举所在的包需要在特定配置（查看文件 spring-mybatis.xml 参数 typeEnumsPackage）下进行扫描， + * 从而实现自动注入等功能，使其能在整个应用程序中方便地被使用，比如在数据库操作、数据传输等场景下用于表示特定的枚举值及对应的描述信息。 + */ + +// 定义了一个名为 TypeEnum 的枚举类型，它实现了 IEnum 接口，意味着该枚举需要遵循 IEnum 接口定义的规范来实现相关方法， +// 通常这样做是为了在某些框架（如 MyBatis 等）中能更方便地进行枚举类型的处理，例如数据库字段与枚举值的映射等操作。 public enum TypeEnum implements IEnum { + + // 定义了枚举的第一个常量 DISABLED，其对应的值为 0，描述信息为 "禁用"， + // 在业务场景中可以用于表示某个对象处于禁用状态，比如用户账号禁用、功能模块禁用等情况，通过这个枚举常量可以清晰地传达该状态含义以及对应的数值表示。 DISABLED(0, "禁用"), + + + // 定义了枚举的第二个常量 NORMAL，其对应的值为 1，描述信息为 "正常"， + // 同样在业务中可用于表示正常可用的状态，像用户账号正常、系统功能正常运行等情况，方便通过统一的枚举类型来区分不同的业务状态。 NORMAL(1, "正常"); + + // 定义了一个私有 final 类型的整型变量 value，用于存储当前枚举常量对应的整数值， + // 这个值在构造函数中进行初始化，并且在后续通过实现 IEnum 接口的 getValue 方法返回，可用于与数据库字段等进行值的映射操作。 private final int value; + + + // 定义了一个私有 final 类型的字符串变量 desc，用于存储当前枚举常量对应的中文描述信息， + // 方便在需要展示给用户或者在代码中以更直观的方式体现该枚举常量含义时使用，例如在生成 JSON 数据返回给前端时展示对应的中文描述。 private final String desc; + + // 枚举类型的构造函数，用于初始化每个枚举常量的 value 和 desc 属性， + // 通过传入的参数来为当前枚举常量赋予对应的整数值和中文描述，确保每个枚举常量都有明确的数值表示和含义描述。 TypeEnum(final int value, final String desc) { this.value = value; this.desc = desc; } + + // 实现 IEnum 接口中定义的 getValue 方法，该方法要求返回一个可序列化（Serializable）的值， + // 在这里返回的就是当前枚举常量对应的整数值（this.value），这个值可以在一些数据持久化、数据传输等场景下作为具体的枚举值进行传递和存储， + // 例如在将枚举类型数据保存到数据库字段时，会调用这个方法获取对应的数值进行存储。 @Override public Serializable getValue() { return this.value; } - // Jackson 注解为 JsonValue 返回中文 json 描述 + + // 使用了 Jackson 框架相关的注解（虽然这里没明确写出具体是哪个 Jackson 注解，但从注释“Jackson 注解为 JsonValue 返回中文 json 描述”可推测）， + // 作用是在将该枚举类型转换为 JSON 数据时，调用这个 getDesc 方法返回当前枚举常量对应的中文描述信息（this.desc）， + // 使得前端接收到的 JSON 数据中对于该枚举类型的表示是更友好、易读的中文描述，而不是默认的枚举常量名称或者其他不直观的表示形式，增强了数据展示的友好性和可读性。 public String getDesc() { return this.desc; } } + + + diff --git a/minsu/minsuguanliw/src/main/java/com/service/CommonService.java b/minsu/minsuguanliw/src/main/java/com/service/CommonService.java index 6e5ea56d..d4bd97ac 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/CommonService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/CommonService.java @@ -4,79 +4,151 @@ import java.util.List; import java.util.Map; public interface CommonService { + // 以下这些方法声明所在的类（推测是某个数据访问相关的接口或者抽象类等，需结合完整代码上下文判断），定义了一系列用于不同数据操作的方法， + // 通过接收不同的参数来控制具体的操作逻辑，并返回相应类型的数据结果（或无返回值用于执行某些操作），以满足业务中多样化的数据处理需求。 + + // 获取选项的方法，接收一个名为params的参数，其类型是Map， +// 该参数用于传递一些配置信息、查询条件等内容（具体键值对含义取决于业务场景）， +// 方法返回一个List类型的结果，即返回一个字符串列表，列表中的元素代表符合条件的选项内容， +// 例如可能是下拉框选项、可选择的配置项等，具体取决于该方法在业务中的实际用途。 List getOption(Map params); - + + // 根据选项相关参数获取关注信息的方法，接收一个Map类型的params参数， +// 此参数包含了用于确定关注信息查询范围、筛选条件等的各种配置信息（具体根据业务逻辑而定）， +// 返回值是一个Map类型，意味着返回的是一个键值对形式的映射，其中键表示关注信息的不同属性，值则对应各属性的具体内容， +// 比如可以是某个用户关注的对象信息、对应权限等相关内容，由业务场景来决定具体返回的数据结构。 Map getFollowByOption(Map params); - + + // 执行某个操作（从方法名sh较难直接明确具体操作内容，需结合业务场景确定）的方法， +// 接收一个Map类型的params参数，该参数用于传递控制此操作执行的各种条件、配置等相关信息， +// 此方法无返回值，说明该操作可能主要用于对数据进行修改、更新、执行特定业务逻辑等操作，而不需要返回具体的数据结果。 void sh(Map params); - + +// 用于统计提醒相关数量的方法，接收一个Map类型的params参数， +// 这个参数中包含了确定统计提醒数量范围、类型等条件的各种键值对信息（具体由业务逻辑规定）， +// 方法返回一个整型（int）数值，代表符合给定参数条件下统计得出的提醒数量， +// 例如可以是未读提醒数量、特定时间段内的提醒数量等，取决于业务对提醒数量统计的具体要求。 + int remindCount(Map params); - + + // 根据传入参数进行选择计算（selectCal，具体计算逻辑由业务场景定义）的方法， +// 接收Map类型的params参数，该参数用于传递计算所需的输入数据、计算规则、相关配置等信息， +// 返回一个Map类型的结果，即返回一个键值对形式的映射，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值或内容， +// 比如可以是经过某种数学运算、业务规则计算后得到的汇总数据、比率等结果信息。 Map selectCal(Map params); + // 用于获取图表相关综合数据的方法，接收一个Map类型的params参数， +// 该参数包含了确定图表数据查询条件、涉及的数据范围、图表类型相关配置等信息（具体取决于业务中图表展示的需求）， +// 返回值是一个List>类型的列表，列表中的每个Map元素代表图表的一部分数据信息， +// 例如可以是图表的系列数据、坐标轴数据等不同部分的数据集合，整体构成用于生成完整图表的数据基础，具体每个Map的结构和内容由业务逻辑决定。 List> chartBoth(Map params); + // 获取图表相关某一方面数据（相对chartBoth可能是更单一维度的数据，具体取决于业务逻辑）的方法， +// 同样接收Map类型的params参数，该参数用于控制具体的数据查询条件、范围等信息， +// 返回一个List>类型的列表，其中每个Map元素包含了此次查询得到的图表某一相关部分的数据， +// 比如可能是图表中某一个数据系列的数据，用于在构建图表时填充相应的部分，具体内容由业务场景中图表的设计和需求来决定。 List> chartOne(Map params); + // 执行分组查询操作的方法，接收Map类型的params参数， +// 该参数包含了分组依据的字段、查询的数据表、筛选条件等用于控制分组查询的相关信息（具体由业务逻辑规定）， +// 返回一个List>类型的列表，列表中的每个Map表示一组分组查询后的结果信息， +// 例如可以包含分组字段以及对应分组下的其他相关数据等内容，方便后续对分组数据进行处理、展示或进一步分析等操作。 List> selectGroup(Map params); - + + // 根据传入参数进行按值查询（selectValue，具体按什么值以及查询逻辑取决于业务场景）的方法， +// 接收Map类型的params参数，该参数用于传递按值查询所需的条件、要查询的值相关信息、数据表信息等内容， +// 返回一个List>类型的列表，其中每个Map对应按值查询后的一组结果信息， +// 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定，例如可以是符合特定数值条件的数据记录集合等情况。 List> selectValue(Map params); + /** - tableName 查询表 - condition1 条件1 - condition1Value 条件1值 - average 计算平均评分 - * */ + * 此方法用于查询评分相关信息并返回相应结果，通过接收一个Map类型的参数params来控制查询操作的具体逻辑。 + * + * 参数params中包含了多个关键信息，具体如下： + * - tableName：表示要进行查询评分操作的查询表，指明了数据来源的表名称，其具体值由业务场景决定，不同的业务模块可能对应不同的数据表来存储评分相关数据。 + * - condition1：代表条件1，是用于筛选或限定评分查询范围的一个条件字段，例如可以是某个用户ID、某个时间段等具体的筛选条件，具体含义取决于具体业务逻辑中的使用方式。 + * - condition1Value：对应条件1的值，与condition1配合使用，用于明确具体的筛选数值等内容，比如当condition1是用户ID时，此参数就是具体的用户ID数值，以此精准定位符合条件的数据记录来计算评分。 + * - average：从名称推测用于控制是否进行平均评分的计算以及相关计算规则等，可能是一个布尔值（例如true表示计算平均评分，false表示不计算）或者包含更多计算相关配置的对象（如指定计算平均评分的分组方式等，具体由业务定义）。 + * + * 方法返回值是一个Map类型，返回的这个映射中，键表示评分相关信息的不同属性，比如可以是“平均分”“总分”“评分人数”等属性名称，值则是对应属性的具体内容，例如具体的数值、其他相关对象等，方便后续根据返回结果进行相应的业务处理、展示等操作，整体的返回数据结构和具体内容取决于业务中对评分查询结果的要求和设计。 + */ Map queryScore(Map params); + /** * 下面为新加的 */ /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 以下这些方法声明所在的类（通常是某个数据处理相关的接口或者抽象类等，需结合完整代码上下文判断）定义了多种不同的数据操作方法， + * 通过接收参数params来控制具体操作的逻辑，并返回相应类型的数据结果（或返回整型表示操作执行情况等），以满足业务中不同的数据统计、字段值变更等需求。 + */ + + + /** + * 新的级联字典表的分组求和统计方法。 + * 接收一个名为params的参数，其类型为Map，该参数用于传递各种与分组求和统计相关的配置信息、筛选条件等内容（具体键值对含义取决于业务逻辑）。 + * 例如可能包含要操作的级联字典表相关信息、分组的字段、求和的目标字段以及其他限定参与求和数据范围的条件等。 + * 返回值是一个List>类型的列表，列表中的每个Map表示一组分组求和后的统计结果信息， + * 像可能包含分组字段对应的标识以及对应的求和数值等键值对内容，便于后续基于这些结果进行数据展示、进一步分析等操作，具体结构由业务场景决定。 */ List> newSelectGroupSum(Map params); + /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 新的级联字典表的分组求和统计方法（此处重复定义了同名方法，可能存在命名失误或者业务上确实需要两个同名但不同实现逻辑的情况，需结合具体代码进一步确认）。 + * 同样接收Map类型的params参数，该参数用于传递在新的级联字典表中进行分组求和统计所需的各项条件、配置信息等（具体依据业务要求而定）。 + * 返回一个List>类型的列表，其中每个元素Map对应一组分组求和统计的结果数据， + * 例如包含分组字段及对应求和值等相关信息，方便后续按业务需求对统计结果进行处理和使用。 */ List> newSelectGroupCount(Map params); + + /** - * 当前表的日期分组求和 - * @param params - * @return + * 当前表的日期分组求和方法。 + * 接收Map类型的params参数，该参数包含了当前表进行日期分组求和操作所需要的各种条件信息， + * 比如要操作的表名、用于分组的日期字段（可能还涉及日期格式相关设置等）、求和的目标字段以及其他筛选条件（用于确定哪些数据参与求和计算）等内容，具体由业务场景规定。 + * 返回值为List>类型的列表，列表中的每个Map代表一组按照日期分组求和后的统计结果数据， + * 例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续在数据展示或分析中体现不同日期分组下的求和情况。 */ List> newSelectDateGroupSum(Map params); + /** - * 查询字典表的分组统计总条数 - * @param params - * @return + * 查询字典表的分组统计总条数方法。 + * 接收Map类型的params参数，该参数用于传递查询字典表分组统计总条数操作的相关配置信息、筛选条件等， + * 例如包含要查询的字典表名称、分组依据的字段以及其他限定统计范围的条件等（具体键值对含义取决于业务逻辑）。 + * 返回的是List>类型的列表，里面的每个Map对应一组字典表分组统计总条数的结果情况， + * 通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行展示、对比等操作。 */ List> newSelectDateGroupCount(Map params); + + /** - * 增加字段数字 - * @param params - * @return + * 增加字段数字的方法。 + * 接收一个Map类型的params参数，该参数用于指定增加字段数字操作的相关条件及目标字段等信息， + * 比如要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容，具体由业务场景决定。 + * 返回值为整型（int），其含义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定），用于反馈操作的执行情况。 */ int plusCloumNumber(Map params); + + /** - * 减少字段数字 - * @param params - * @return + * 减少字段数字的方法。 + * 接收Map类型的params参数，此参数用于明确减少字段数字操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过params传入（具体依据业务逻辑而定）。 + * 方法返回一个整型（int）值，该值的意义大概率与操作的执行结果相关，比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 */ int reduceCloumNumber(Map params); + + /** - * 修改字段数字 - * @param params - * @return + * 修改字段数字的方法。 + * 以Map类型的params参数来控制具体的修改操作逻辑，params里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 该方法返回的整型（int）值通常用于反馈修改操作的执行情况，可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 */ int updateCloumValue(Map params); @@ -123,17 +195,35 @@ public interface CommonService { -- 【日期，字符串，下拉框】 */ + + /** + * 以下这两个方法所在的类（通常是与数据统计及图表展示相关业务逻辑对应的类，需结合完整代码上下文进一步明确）， + * 主要用于生成柱状图相关的数据统计结果，通过接收包含不同配置信息的参数params来确定具体的统计逻辑， + * 并返回相应格式的数据结构，方便后续用于柱状图的构建及展示等操作。 + */ + + /** - * 柱状图求和 - * @param params - * @return + * 柱状图求和方法。 + * 接收一个Map类型的参数params，该参数用于传递和柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 返回值是一个List>类型的列表，列表中的每个Map表示一组柱状图求和后的统计结果信息， + * 比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容，这些结果数据可用于构建柱状图中不同分组下的求和展示部分， + * 以直观呈现各分组的数据总和情况，便于用户查看不同类别或时间段等维度下数据的总体量对比。 */ List> barSum(Map params); + + /** - * 柱状图统计 - * @param params - * @return + * 柱状图统计方法。 + * 同样接收一个Map类型的参数params，该参数涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 此方法返回的是List>类型的列表，其中每个Map对应一组柱状图统计后的结果信息， + * 像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对，这些结果数据可用于在柱状图中展示相应的统计情况， + * 帮助用户直观了解数据分布及特征等信息，辅助进行数据分析和决策等操作。 */ List> barCount(Map params); + } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java index cb42f901..6db1e592 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/CommonServiceImpl.java @@ -17,17 +17,41 @@ import com.service.CommonService; * @author * @date */ +/** + * 该类表示系统用户相关的服务实现类，用于实现CommonService接口中定义的一系列业务方法， + * 通过依赖注入CommonDao来调用底层的数据访问操作，进而完成各项具体的业务逻辑处理， + * 这里实现的方法大多是与获取不同类型的数据、操作结果等相关，为上层应用提供相应的服务支持。 + * + * @author 此处应填写该类的作者姓名，用于标识代码的编写者，方便代码维护和追溯责任等情况。 + * @date 此处应填写该类的创建日期或者最近一次修改日期等，有助于了解代码的版本历史和更新情况。 + */ +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定了其在容器中的bean名称为"commonService"， +// 方便在其他组件中通过该名称进行依赖注入来使用这个服务类所提供的功能。 @Service("commonService") public class CommonServiceImpl implements CommonService { - + + // 使用@Autowired注解进行依赖注入，将CommonDao接口的某个实现类实例注入到当前类中， + // 这样就能通过这个实例调用CommonDao中定义的数据访问方法，实现与数据库等数据源的交互操作，完成具体业务逻辑对数据的需求。 @Autowired private CommonDao commonDao; + /** + * 实现了CommonService接口中定义的getOption方法，功能是获取选项信息。 + * 该方法接收一个Map类型的参数params，params用于传递查询选项信息所需要的相关条件、配置等信息（具体键值对含义取决于业务逻辑）。 + * 通过调用注入的commonDao的getOption方法，将参数params传递下去，获取并返回符合条件的选项信息列表，返回值类型为List， + * 列表中的每个字符串元素代表一个具体的选项内容，例如可能是下拉列表的选项、配置项等，具体取决于业务场景中对选项的定义。 + */ @Override public List getOption(Map params) { return commonDao.getOption(params); } - + + /** + * 实现了CommonService接口中定义的getFollowByOption方法，用于获取与选项相关的关注信息。 + * 接收一个Map类型的参数params，该参数包含了确定关注信息查询范围、筛选条件等的各种配置信息（具体依据业务逻辑而定）。 + * 调用commonDao的getFollowByOption方法并传递params参数，获取并返回相应的关注信息，返回值是一个Map类型， + * 即返回的是一个键值对形式的映射，其中键表示关注信息的不同属性，值则对应各属性的具体内容，比如可以是用户关注的对象详情、对应权限等相关信息，由业务场景决定具体返回的数据结构。 + */ @Override public Map getFollowByOption(Map params) { return commonDao.getFollowByOption(params); @@ -40,50 +64,126 @@ public class CommonServiceImpl implements CommonService { condition1Value 条件1值 average 计算平均评分 * */ + /** + * 以下这些方法是实现某个服务接口（从类实现了接口以及方法的命名推测，可能是与数据查询、统计、图表相关操作等业务逻辑对应的服务接口，需结合完整代码上下文判断）的具体实现方法， + * 它们大多是通过调用注入的commonDao对象的对应方法来完成具体的业务操作，将参数传递给底层的数据访问层（由commonDao代表），并返回相应的结果或者执行相应的无返回值操作， + * 以此来实现服务层与数据访问层的交互，为上层应用提供数据相关的服务支持。 + * + * 参数params在各个方法中都用于传递控制对应操作的相关条件、配置等信息，其内部具体的键值对含义取决于不同业务场景下各方法的功能需求，例如包含要操作的表名、筛选条件、计算规则等不同的内容。 + * + * 其中queryScore方法相关的参数params中包含以下几个关键信息（从注释中可看出）： + * - tableName：表示要进行查询评分操作的查询表，指明了数据来源的表名称，其具体值由业务场景决定，不同的业务模块可能对应不同的数据表来存储评分相关数据。 + * - condition1：代表条件1，是用于筛选或限定评分查询范围的一个条件字段，例如可以是某个用户ID、某个时间段等具体的筛选条件，具体含义取决于具体业务逻辑中的使用方式。 + * - condition1Value：对应条件1的值，与condition1配合使用，用于明确具体的筛选数值等内容，比如当condition1是用户ID时，此参数就是具体的用户ID数值，以此精准定位符合条件的数据记录来计算评分。 + * - average：从名称推测用于控制是否进行平均评分的计算以及相关计算规则等，可能是一个布尔值（例如true表示计算平均评分，false表示不计算）或者包含更多计算相关配置的对象（如指定计算平均评分的分组方式等，具体由业务定义）。 + */ + + /** + * 查询评分相关信息的方法，通过调用注入的commonDao的queryScore方法来获取评分数据。 + * 接收一个Map类型的参数params，该参数传递了查询评分操作所需的各种配置信息（如上述提到的查询表名、条件、计算规则等）。 + * 返回值是一个Map类型，返回的这个映射中，键表示评分相关信息的不同属性，比如可以是“平均分”“总分”“评分人数”等属性名称，值则是对应属性的具体内容，例如具体的数值、其他相关对象等， + * 方便后续根据返回结果进行相应的业务处理、展示等操作，整体的返回数据结构和具体内容取决于业务中对评分查询结果的要求和设计。 + */ public Map queryScore(Map params){ return commonDao.queryScore(params); } - + + /** + * 执行某个操作（从方法名sh较难直接明确具体操作内容，需结合业务场景确定）的方法， + * 通过调用commonDao的sh方法来执行具体操作，接收一个Map类型的参数params，该参数用于传递控制此操作执行的各种条件、配置等相关信息， + * 此方法无返回值，说明该操作可能主要用于对数据进行修改、更新、执行特定业务逻辑等操作，而不需要返回具体的数据结果，具体的操作行为由commonDao的sh方法实现逻辑决定。 + */ @Override public void sh(Map params) { - commonDao.sh(params); + commonDao.sh(params); } + + /** + * 用于统计提醒相关数量的方法，通过调用commonDao的remindCount方法来获取提醒数量统计结果。 + * 接收一个Map类型的参数params，这个参数中包含了确定统计提醒数量范围、类型等条件的各种键值对信息（具体由业务逻辑规定）。 + * 方法返回一个整型（int）数值，代表符合给定参数条件下统计得出的提醒数量，例如可以是未读提醒数量、特定时间段内的提醒数量等，取决于业务对提醒数量统计的具体要求。 + */ @Override public int remindCount(Map params) { return commonDao.remindCount(params); } + + /** + * 根据传入参数进行选择计算（selectCal，具体计算逻辑由业务场景定义）的方法， + * 通过调用commonDao的selectCal方法来执行相应的计算操作，接收Map类型的参数params，该参数用于传递计算所需的输入数据、计算规则、相关配置等信息。 + * 返回一个Map类型的结果，即返回一个键值对形式的映射，其中键可以表示计算结果的不同属性，值则是对应属性的具体数值或内容， + * 比如可以是经过某种数学运算、业务规则计算后得到的汇总数据、比率等结果信息，具体的计算结果结构取决于业务逻辑中对selectCal操作的定义。 + */ @Override public Map selectCal(Map params) { return commonDao.selectCal(params); } - + + + /** + * 执行分组查询操作的方法，通过调用commonDao的selectGroup方法来获取分组查询结果。 + * 接收Map类型的参数params，该参数包含了分组依据的字段、查询的数据表、筛选条件等用于控制分组查询的相关信息（具体由业务逻辑规定）。 + * 返回一个List>类型的列表，列表中的每个Map表示一组分组查询后的结果信息， + * 例如可以包含分组字段以及对应分组下的其他相关数据等内容，方便后续对分组数据进行处理、展示或进一步分析等操作，具体的分组查询结果结构取决于业务逻辑中对selectGroup操作的定义。 + */ @Override public List> selectGroup(Map params) { return commonDao.selectGroup(params); } - + + + /** + * 根据传入参数进行按值查询（selectValue，具体按什么值以及查询逻辑取决于业务场景）的方法， + * 通过调用commonDao的selectValue方法来获取按值查询的结果，接收Map类型的参数params，该参数用于传递按值查询所需的条件、要查询的值相关信息、数据表信息等内容。 + * 返回一个List>类型的列表，其中每个Map对应按值查询后的一组结果信息， + * 其具体的键值对内容表示按值查询相关的属性及对应的值，由具体业务逻辑决定，例如可以是符合特定数值条件的数据记录集合等情况。 + */ @Override public List> selectValue(Map params) { return commonDao.selectValue(params); } + + /** + * 用于获取图表相关综合数据的方法，通过调用commonDao的chartBoth方法来获取图表综合数据。 + * 接收一个Map类型的参数params，该参数包含了确定图表数据查询条件、涉及的数据范围、图表类型相关配置等信息（具体取决于业务中图表展示的需求）。 + * 返回值是一个List>类型的列表，列表中的每个Map元素代表图表的一部分数据信息， + * 例如可以是图表的系列数据、坐标轴数据等不同部分的数据集合，整体构成用于生成完整图表的数据基础，具体每个Map的结构和内容由业务逻辑决定。 + */ @Override public List> chartBoth(Map params) { return commonDao.chartBoth(params); } + + /** + * 获取图表相关某一方面数据（相对chartBoth可能是更单一维度的数据，具体取决于业务逻辑）的方法， + * 通过调用commonDao的chartOne方法来获取图表某一方面的数据，同样接收Map类型的params参数，该参数用于控制具体的数据查询条件、范围等信息。 + * 返回一个List>类型的列表，其中每个Map元素包含了此次查询得到的图表某一相关部分的数据， + * 比如可能是图表中某一个数据系列的数据，用于在构建图表时填充相应的部分，具体内容由业务场景中图表的设计和需求来决定。 + */ @Override public List> chartOne(Map params) { return commonDao.chartOne(params); } + + /** + * 以下这些方法均为实现某个服务接口（从代码结构及方法命名推测，可能是与数据统计、字段值操作等业务逻辑相关的服务接口，需结合完整代码上下文进一步明确）中的具体方法， + * 它们主要的功能是调用注入的commonDao对象对应的方法来完成相应的业务操作，将接收到的参数params传递给底层的数据访问层（通过commonDao实现交互），并返回对应的数据结果或者执行相应操作后返回相应的状态标识（整型返回值情况）， + * 以此实现服务层与数据访问层的协作，为上层应用提供多样化的数据处理服务。 + * 参数params在各个方法中都起着传递操作相关配置信息、条件等关键作用，其内部具体的键值对含义因不同方法所对应的业务功能而有所差异，例如包含操作的数据表、分组字段、条件值、计算规则等不同内容。 + */ + /** - * 新的级联字典表的 分组求和统计 - * @param params - * @return + * 新的级联字典表的分组求和统计方法，实现了对应接口方法的具体逻辑。 + * 接收一个Map类型的参数params，该参数用于传递各种与在新的级联字典表中进行分组求和统计相关的配置信息、筛选条件等内容（具体键值对含义取决于业务逻辑）， + * 例如可能包含要操作的级联字典表相关信息、分组的字段、求和的目标字段以及其他限定参与求和数据范围的条件等。 + * 通过调用commonDao的newSelectGroupSum方法，并将params参数传递过去，获取并返回分组求和统计后的结果数据，返回值是一个List>类型的列表， + * 列表中的每个Map表示一组分组求和后的统计结果信息，像可能包含分组字段对应的标识以及对应的求和数值等键值对内容，便于后续基于这些结果进行数据展示、进一步分析等操作，具体结构由业务场景决定。 */ @Override public List> newSelectGroupSum(Map params) { @@ -91,20 +191,26 @@ public class CommonServiceImpl implements CommonService { } + /** - * 新的级联字典表的 分组条数统计 - * @param params - * @return + * 新的级联字典表的分组条数统计方法，用于实现接口中定义的相应功能。 + * 同样接收Map类型的params参数，该参数用于传递在新的级联字典表中进行分组条数统计所需的各项条件、配置信息等（具体依据业务要求而定）， + * 例如涉及要操作的表信息、分组依据的字段以及限定统计范围的其他条件等。 + * 调用commonDao的newSelectGroupCount方法并传递params参数，获取并返回相应的分组条数统计结果，返回值为List>类型的列表， + * 其中每个元素Map对应一组分组统计总条数的结果数据，例如包含分组字段及对应统计的条数等相关信息，方便后续按业务需求对统计结果进行处理和使用。 */ @Override public List> newSelectGroupCount(Map params) { return commonDao.newSelectGroupCount(params); } + /** - * 当前表的日期分组求和 - * @param params - * @return + * 当前表的日期分组求和方法，实现了对应接口方法的业务逻辑。 + * 接收Map类型的params参数，该参数包含了当前表进行日期分组求和操作所需要的各种条件信息， + * 比如要操作的表名、用于分组的日期字段（可能还涉及日期格式相关设置等）、求和的目标字段以及其他筛选条件（用于确定哪些数据参与求和计算）等内容，具体由业务场景规定。 + * 调用commonDao的newSelectDateGroupSum方法并传递params参数，获取并返回按照日期分组求和后的统计结果数据，返回值为List>类型的列表， + * 列表中的每个Map代表一组按照日期分组求和后的统计结果数据，例如可能包含日期分组标识（如具体的年、月、日等形式，取决于业务对日期的处理方式）以及对应的求和数值等键值对内容，便于后续在数据展示或分析中体现不同日期分组下的求和情况。 */ @Override public List> newSelectDateGroupSum(Map params) { @@ -113,28 +219,56 @@ public class CommonServiceImpl implements CommonService { /** - * 查询字典表的分组统计总条数 - * @param params - * @return + * 查询字典表的分组统计总条数方法，负责实现接口中对应的功能。 + * 接收Map类型的params参数，该参数用于传递查询字典表分组统计总条数操作的相关配置信息、筛选条件等， + * 例如包含要查询的字典表名称、分组依据的字段以及其他限定统计范围的条件等（具体键值对含义取决于业务逻辑）。 + * 通过调用commonDao的newSelectDateGroupCount方法并传递params参数，获取并返回相应的分组统计总条数结果，返回的是List>类型的列表， + * 里面的每个Map对应一组字典表分组统计总条数的结果情况，通常会包含分组字段以及该分组下的记录总条数等键值对，方便在不同业务需求下对字典表分组统计的结果进行展示、对比等操作。 */ @Override public List> newSelectDateGroupCount(Map params) { return commonDao.newSelectDateGroupCount(params); } + + /** + * 增加字段数字的方法，实现了对应接口中定义的增加字段值的功能逻辑。 + * 接收一个Map类型的params参数，该参数用于指定增加字段数字操作的相关条件及目标字段等信息， + * 比如要操作的数据表名称、需要增加数值的具体字段名、增加的数值大小、以及可能的筛选条件（用于确定对哪些记录的字段值进行增加操作）等内容，具体由业务场景决定。 + * 调用commonDao的plusCloumNumber方法并传递params参数，获取并返回操作的执行情况，返回值为整型（int），其含义可能是成功增加数值的记录条数，或者表示操作执行是否成功的某种状态码（具体由该方法在业务逻辑中的定义决定），用于反馈操作的执行情况。 + */ @Override public int plusCloumNumber(Map params) { return commonDao.plusCloumNumber(params); } + + + /** + * 减少字段数字的方法，实现接口中相应的减少字段值的功能。 + * 接收Map类型的params参数，此参数用于明确减少字段数字操作的具体细节， + * 像要操作的数据表、待减少数值的目标字段、减少的数值量以及相关筛选条件（限定对哪些记录执行字段值减少操作）等信息会通过params传入（具体依据业务逻辑而定）。 + * 通过调用commonDao的reduceCloumNumber方法并传递params参数，获取并返回操作的执行结果，方法返回一个整型（int）值，该值的意义大概率与操作的执行结果相关， + * 比如成功减少数值的记录数量，或者用于标识操作是否顺利完成的一个状态值（取决于具体业务对该方法返回值的定义）。 + */ @Override public int reduceCloumNumber(Map params) { return commonDao.reduceCloumNumber(params); } + + + /** + * 修改字段数字的方法，用于完成接口中定义的修改字段值的相关业务逻辑。 + * 以Map类型的params参数来控制具体的修改操作逻辑，params里面会包含诸如要操作的数据表名称、需要修改值的目标字段、修改后的新值、 + * 以及用于筛选出要修改记录的条件等关键信息（具体内容由业务场景所规定）。 + * 调用commonDao的updateCloumValue方法并传递params参数，获取并返回修改操作的执行情况，该方法返回的整型（int）值通常用于反馈修改操作的执行情况， + * 可能代表成功修改的记录条数，或者是用于指示操作是否成功完成的一个状态标识（取决于该方法在业务逻辑中的具体定义）。 + */ @Override public int updateCloumValue(Map params) { return commonDao.updateCloumValue(params); } + /** * 饼状图 * -- 饼状图 查询当前表 @@ -176,22 +310,41 @@ public class CommonServiceImpl implements CommonService { -- 求和 -- 【日期，字符串，下拉框】 */ + + /** - * 柱状图求和 - * @param params - * @return + * 以下这两个方法用于实现柱状图相关的数据处理操作，通过调用注入的commonDao对象对应的方法来获取相应的统计结果数据， + * 进而为上层应用提供构建柱状图所需的数据支持，它们在整个业务逻辑中承担着与柱状图数据生成密切相关的功能，具体的数据操作细节由commonDao中对应的实现来完成。 + * 参数params在这两个方法中都起着传递控制柱状图相关操作的具体条件、配置等关键信息的作用，其内部具体的键值对含义取决于不同的业务场景以及柱状图的具体展示需求， + * 例如包含要统计的数据表信息、分组依据、筛选条件以及涉及的计算字段等内容。 + */ + + + /** + * 柱状图求和方法，用于获取柱状图求和相关的数据结果。 + * 接收一个Map类型的参数params，该参数用于传递和柱状图求和操作相关的各种配置及数据信息， + * 例如可能包含要统计的数据表名称、用于分组的字段（比如按照不同类别、时间段等进行分组）、求和的目标字段（确定对哪些数据进行求和计算）、 + * 以及可能涉及到的其他筛选条件（限定参与求和计算的数据范围）等内容，具体的键值对含义取决于具体的业务场景和柱状图展示需求。 + * 通过调用commonDao的barSum方法，并将params参数传递过去，获取并返回柱状图求和后的统计结果数据，返回值是一个List>类型的列表， + * 列表中的每个Map表示一组柱状图求和后的统计结果信息，比如可能包含分组字段对应的标识（如具体的分类名称、日期等）以及对应的求和数值等键值对内容， + * 这些结果数据可用于构建柱状图中不同分组下的求和展示部分，以直观呈现各分组的数据总和情况，便于用户查看不同类别或时间段等维度下数据的总体量对比。 */ public List> barSum(Map params){ return commonDao.barSum(params); } + /** - * 柱状图统计 - * @param params - * @return + * 柱状图统计方法，旨在获取柱状图统计相关的数据信息。 + * 同样接收一个Map类型的参数params，该参数涵盖了诸如要操作的数据表信息、分组依据的字段、统计的具体规则（比如计数、平均值等统计方式，具体取决于业务实现）、 + * 以及其他相关的筛选条件（用于精准确定参与统计的数据范围）等关键信息，其具体内容由业务场景所决定，旨在满足不同柱状图统计需求。 + * 调用commonDao的barCount方法并传递params参数，获取并返回柱状图统计后的结果数据，此方法返回的是List>类型的列表， + * 其中每个Map对应一组柱状图统计后的结果信息，像可能包含分组标识以及对应的统计数值（例如分组下的记录条数、平均值等，具体根据统计方式而定）等键值对， + * 这些结果数据可用于在柱状图中展示相应的统计情况，帮助用户直观了解数据分布及特征等信息，辅助进行数据分析和决策等操作。 */ public List> barCount(Map params){ return commonDao.barCount(params); } + } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java index 786bf53d..a6f717e3 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/UsersServiceImpl.java @@ -22,29 +22,60 @@ import com.utils.Query; * 系统用户 * @author */ + +/** + * 此类代表系统用户相关的服务实现类，用于处理与系统用户相关的业务逻辑，实现了UsersService接口中定义的多个方法， + * 通过继承ServiceImpl类并关联对应的UsersDao和UsersEntity，能够便捷地使用一些基础的数据操作方法，同时为上层应用提供更贴合业务需求的用户相关服务功能。 + * + * @author 此处应填写该类的作者姓名，用于明确代码的编写者，方便后续代码维护以及追溯代码相关问题的责任人等情况。 + */ + +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定了其在容器中的bean名称为"userService"， +// 这样其他组件就可以通过该名称在Spring容器中获取到此服务类的实例，进而使用它所提供的各种方法来处理业务逻辑。 @Service("userService") public class UsersServiceImpl extends ServiceImpl implements UsersService { + /** + * 实现UsersService接口中定义的queryPage方法，用于查询用户信息并进行分页处理。 + * 接收一个Map类型的参数params，该参数用于传递分页查询相关的各种条件信息，例如查询的页码、每页显示的记录数、筛选条件等（具体键值对含义取决于业务逻辑）。 + * 首先通过this.selectPage方法创建一个Page类型的分页对象page，在创建过程中，使用传入的params参数构建Query对象来获取分页相关配置， + * 并结合一个默认的EntityWrapper对象（此处可能用于添加一些通用的查询条件或者关联关系等，具体取决于业务实现）来确定最终的查询条件。 + * 最后将构建好的分页对象page封装到PageUtils对象中并返回，以便上层应用可以方便地获取分页后的用户数据以及分页相关的元数据（如总页数、总记录数等）。 + */ @Override public PageUtils queryPage(Map params) { Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() - ); - return new PageUtils(page); + new Query(params).getPage(), + new EntityWrapper() + ); + return new PageUtils(page); } + + /** + * 实现UsersService接口中定义的selectListView方法，用于按照特定的查询条件（通过Wrapper封装）查询用户列表信息。 + * 接收一个Wrapper类型的参数wrapper，该参数用于封装各种灵活的查询条件，例如可以指定具体的筛选字段、排序规则、关联查询等条件（具体取决于业务中对用户查询的需求）。 + * 通过调用baseMapper的selectListView方法并传入wrapper参数，获取符合条件的用户实体列表并返回，返回值类型为List，即返回一个包含多个用户实体对象的列表，这些对象代表了满足查询条件的用户信息。 + */ @Override public List selectListView(Wrapper wrapper) { return baseMapper.selectListView(wrapper); } + + /** + * 实现UsersService接口中另一个重载的queryPage方法，此方法在分页查询用户信息的基础上，还可以根据传入的Wrapper对象来进一步定制查询条件。 + * 接收两个参数，一个是Map类型的params，用于传递分页相关的通用条件信息（如页码、每页记录数等），另一个是Wrapper类型的wrapper，用于传递更具体的、个性化的查询条件。 + * 首先创建一个Page类型的分页对象page，通过传入的params参数构建Query对象来获取分页相关配置。 + * 然后调用baseMapper的selectListView方法，传入page和wrapper参数，将查询到的符合条件的用户记录设置到page对象的records属性中，以此实现根据定制条件进行分页查询用户数据的功能。 + * 最后将包含查询结果的page对象封装到PageUtils对象中并返回，方便上层应用获取带有详细分页信息和符合条件的用户数据列表，便于进行后续的数据展示、处理等操作。 + */ @Override public PageUtils queryPage(Map params, - Wrapper wrapper) { - Page page =new Query(params).getPage(); - page.setRecords(baseMapper.selectListView(page,wrapper)); - PageUtils pageUtil = new PageUtils(page); - return pageUtil; + Wrapper wrapper) { + Page page =new Query(params).getPage(); + page.setRecords(baseMapper.selectListView(page,wrapper)); + PageUtils pageUtil = new PageUtils(page); + return pageUtil; } } diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java index ccdd5bcf..7df6a066 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/YonghuServiceImpl.java @@ -20,20 +20,44 @@ import com.entity.view.YonghuView; /** * 用户 服务实现类 */ + + +/** + * 这是用户相关的服务实现类，用于实现具体的用户业务逻辑，继承自ServiceImpl类并关联了YonghuDao和YonghuEntity，实现了YonghuService接口， + * 通过一系列操作来处理用户数据的分页查询等功能，同时使用了Spring的事务管理机制（通过@Transactional注解体现），保证相关操作在事务环境下执行，确保数据的一致性和完整性。 + * 该类主要向外提供了针对用户数据的服务方法，方便其他模块调用以满足业务中对用户数据操作的需求。 + */ + +// 使用@Service注解将该类标记为Spring框架中的一个服务层组件，并且指定其在容器中的bean名称为"yonghuService"， +// 这样在Spring容器中可以通过该名称来获取此服务类的实例，进而调用其提供的业务方法进行相关的用户业务逻辑处理。 +// @Transactional注解用于声明该类中的方法（如果没有特殊配置，默认是所有方法）都将在事务环境下执行， +// 如果方法执行过程中出现异常，事务将会自动回滚，以保证数据的一致性，常用于涉及数据库操作等需要保证原子性的业务场景。 @Service("yonghuService") @Transactional public class YonghuServiceImpl extends ServiceImpl implements YonghuService { + /** + * 实现了YonghuService接口中定义的queryPage方法，用于对用户数据进行分页查询并返回相应的分页结果信息。 + * 接收一个Map类型的参数params，该参数用于传递分页查询相关的各种条件信息，例如页码、每页显示的记录数、筛选条件等（具体键值对含义取决于业务逻辑）。 + * 首先会进行参数的合法性判断，如果params不为空，并且其中的"limit"（每页记录数）或者"page"（页码）参数为空，说明可能没有传入分页相关的关键参数， + * 则默认设置"page"为"1"，表示查询第一页数据，设置"limit"为"10"，表示每页显示10条记录，以此确保分页查询能有合理的默认参数进行。 + * 接着通过new Query(params).getPage()创建一个Page类型的分页对象page，该对象包含了分页相关的配置信息以及后续会存放查询到的用户数据记录。 + * 然后调用baseMapper的selectListView方法，传入page和params参数，将查询到的符合条件的用户记录设置到page对象的records属性中，完成基于传入参数的用户数据分页查询操作。 + * 最后将包含查询结果以及分页相关信息的page对象封装到PageUtils对象中并返回，使得调用该方法的上层应用能够方便地获取分页后的用户数据以及如总页数、总记录数等分页相关的元数据，便于进行后续的数据展示、处理等操作。 + */ + @Override public PageUtils queryPage(Map params) { - if(params != null && (params.get("limit") == null || params.get("page") == null)){ + if(params!= null && (params.get("limit") == null || params.get("page") == null)){ params.put("page","1"); params.put("limit","10"); } - Page page =new Query(params).getPage(); + + Page page = new Query(params).getPage(); page.setRecords(baseMapper.selectListView(page,params)); return new PageUtils(page); } } + diff --git a/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java b/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java index 37063119..b978ba48 100644 --- a/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java +++ b/minsu/minsuguanliw/src/main/java/com/thread/MyThreadMethod.java @@ -3,7 +3,24 @@ package com.thread; /** * 线程执行方法（做一些项目启动后 一直要执行的操作，比如根据时间自动更改订单状态，比如订单签收30天自动收货功能，比如根据时间来更改状态） */ + + +/** + * 这是一个自定义的线程类，继承自Thread类，用于定义线程执行的具体逻辑。 + * 该线程主要承担在项目启动后持续执行一些特定业务操作的任务，例如根据时间条件自动更改订单状态（像订单签收30天后自动收货等基于时间来变更状态的功能）， + * 通过在run方法中的循环逻辑以及设置的休眠时间来周期性地执行相应操作，直到线程被中断为止。 + */ + + public class MyThreadMethod extends Thread { + + + /** + * 重写了Thread类中的run方法，此方法定义了线程启动后具体要执行的逻辑内容。 + * 在这个方法中，通过一个while循环来持续执行相关操作，只要线程未被中断（通过判断this.isInterrupted()为false来确定），就会一直循环下去。 + * 循环内部通过让线程休眠一定时间（当前设置为每隔5000毫秒，即5秒执行一次，通过Thread.sleep(5000)实现）来控制操作执行的频率， + * 在实际的业务场景中，可以在休眠后的位置添加具体的业务逻辑代码，以实现诸如根据时间自动更改订单状态等功能。 + */ public void run() { while (!this.isInterrupted()) {// 线程未中断执行循环 try { @@ -12,8 +29,15 @@ public class MyThreadMethod extends Thread { e.printStackTrace(); } + + // ------------------ 开始执行 --------------------------- +// 此处原本可以添加具体的业务逻辑代码，例如实现根据当前时间去数据库查询满足特定时间条件的订单，然后修改其状态等操作， +// 当前只是简单地输出了一个表示线程正在执行的信息以及当前时间戳（通过System.currentTimeMillis()获取当前时间的毫秒数）， +// 实际应用中需要根据具体的业务需求替换此处的代码来完成相应的定时业务功能。 // System.out.println("线程执行中:" + System.currentTimeMillis()); + } } } + diff --git a/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java b/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java index f6cfb86b..311f0d5d 100644 --- a/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java +++ b/minsu/minsuguanliw/src/main/java/com/utils/CommonUtil.java @@ -3,21 +3,35 @@ package com.utils; import java.util.Random; public class CommonUtil { - /** - * 获取随机字符串 + + /** + * 此静态方法用于生成一个指定长度的随机字符串，可应用于需要生成随机标识、临时验证码等场景，通过传入参数来控制生成字符串的长度。 * - * @param num - * @return + * @param num 用于指定要生成的随机字符串的长度，参数类型为Integer，即传入一个整数，该整数决定了最终生成的随机字符串包含多少个字符。 + * @return 返回值类型为String，即返回一个按照特定规则生成的随机字符串，其字符内容来源于预定义的字符集合，长度由传入的参数num决定。 */ + public static String getRandomString(Integer num) { + // 定义一个包含所有可用字符的基础字符串，这里包含了小写英文字母和数字，后续将从这些字符中随机选取来组成最终的随机字符串。 String base = "abcdefghijklmnopqrstuvwxyz0123456789"; + + // 创建一个Random类的实例，用于生成伪随机数，它将作为选取字符的随机索引依据，通过其nextInt方法来获取在指定范围内的随机整数。 Random random = new Random(); + + // 创建一个StringBuffer对象，用于高效地拼接字符，相比于直接使用字符串相加操作，StringBuffer在频繁拼接字符时性能更好，将逐步把随机选取的字符添加到这里来构建最终的随机字符串。 StringBuffer sb = new StringBuffer(); + + // 通过循环来控制生成的随机字符串的长度，循环次数由传入的参数num决定，每次循环向字符串中添加一个随机字符。 for (int i = 0; i < num; i++) { + // 生成一个随机索引，其范围是从0到base字符串的长度减1（通过调用Random类的nextInt方法实现），该索引将用于从base字符串中选取一个字符。 int number = random.nextInt(base.length()); + + // 根据生成的随机索引，从base字符串中获取对应的字符，并添加到StringBuffer对象sb中，逐步构建随机字符串。 sb.append(base.charAt(number)); } + // 将StringBuffer对象转换为字符串并返回，得到最终生成的随机字符串，其长度和字符内容都符合随机生成的要求，由上述逻辑决定。 return sb.toString(); + } } -- 2.34.1 From d291a2370e674e1bfb6d3797d1b3817ba842123d Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 22:39:23 +0800 Subject: [PATCH 10/12] =?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 --- .../DictionaryServletContextListener.java | 59 ++++++++++++++++++- 1 file changed, 57 insertions(+), 2 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java index a74d1774..bc72710b 100644 --- a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java +++ b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java @@ -19,43 +19,98 @@ import java.util.Map; /** * 字典初始化监视器 用的是服务器监听,每次项目启动,都会调用这个类 */ + + +/** + * 这是一个字典初始化监视器类，它实现了ServletContextListener接口，利用服务器监听机制，在每次项目启动时都会被调用， + * 主要负责完成字典表数据的初始化工作以及启动一个自定义的线程（MyThreadMethod）。在项目停止时，也能相应地记录相关日志信息， + * 整体在整个项目的生命周期中，对于字典表数据的准备以及特定线程的启动管理起着关键作用，确保相关功能在合适的时机得以执行。 + */ +// 使用@WebListener注解将该类标记为一个Web监听器，使其能够被Web容器识别并在对应的生命周期事件（如项目启动、停止等）发生时被调用， +// 从而执行相应的逻辑，在这里就是进行字典初始化以及线程启动等操作。 @WebListener public class DictionaryServletContextListener implements ServletContextListener { + // 创建一个静态的Logger对象，用于记录日志信息，通过LoggerFactory.getLogger方法传入当前类的Class对象来获取， + // 后续可以使用这个logger在不同的生命周期方法中记录如项目启动、停止、字典表初始化等各个阶段的关键信息，方便排查问题以及了解程序执行情况。 private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class); + + // 声明一个MyThreadMethod类型的变量，用于存储一个自定义的线程对象，这个线程大概率执行一些与业务相关的后台任务，具体任务由MyThreadMethod类的实现决定， + // 初始化为null，会在合适的时机（项目启动时的上下文初始化阶段）进行实例化并启动。 private MyThreadMethod myThreadMethod; + + /** + * 此方法是ServletContextListener接口中定义的，在Web应用的Servlet上下文被销毁时（通常意味着项目停止）会被调用， + * 在这里主要用于记录服务器停止的相关日志信息，方便后续查看项目的关闭情况以及进行相关的日志分析等操作。 + * + * @param sce ServletContextEvent对象，包含了与Servlet上下文销毁相关的事件信息，不过在此方法中目前只是利用它来触发日志记录，未对其事件相关内容做更多处理。 + */ @Override public void contextDestroyed(ServletContextEvent sce) { logger.info("----------服务器停止----------"); } + + /** + * 此方法是ServletContextListener接口中定义的，在Web应用的Servlet上下文初始化时（也就是项目启动时）会被调用， + * 主要承担了字典表数据初始化以及启动自定义线程的重要任务，通过一系列操作将字典表数据整理并存储到Servlet上下文的属性中，方便后续在整个项目中使用， + * 同时启动特定线程来执行可能的后台持续任务等操作，并且在各个关键步骤记录相应的日志信息，便于了解初始化的执行情况。 + * + * @param sce ServletContextEvent对象，包含了与Servlet上下文初始化相关的事件信息，通过它可以获取到Servlet上下文对象，进而用于获取Spring应用上下文以及设置上下文属性等操作。 + */ @Override public void contextInitialized(ServletContextEvent sce) { + // 通过WebApplicationContextUtils工具类的getWebApplicationContext方法，传入从ServletContextEvent对象中获取的Servlet上下文对象， + // 获取整个Web应用的Spring应用上下文（ApplicationContext），后续可以基于这个上下文来获取Spring容器管理的各种Bean实例，比如获取字典服务相关的Bean。 ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext()); logger.info("----------字典表初始化开始----------"); + // 从Spring应用上下文中获取名为"dictionaryService"的Bean实例，并强制转换为DictionaryService类型， + // DictionaryService应该是一个用于处理字典表相关业务逻辑的服务层接口，通过它可以调用如查询字典表数据等方法来进行字典表初始化操作。 DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService"); + // 调用dictionaryService的selectList方法，传入一个默认的EntityWrapper对象（可能用于添加一些通用的查询条件等，具体取决于业务实现）， + + // 获取字典表中的所有字典实体数据，返回一个List类型的列表，列表中的每个DictionaryEntity对象代表一条字典表记录，包含了如字典编码、索引等相关信息。 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 创建一个HashMap对象，用于存储整理后的字典表数据，其结构是外层的键为字典编码（String类型），值为内层的一个Map， + // 内层的Map中，键为代码索引（Integer类型），值为对应的索引名称（String类型），这样的结构方便后续根据字典编码以及索引快速查找对应的名称等信息。 Map> map = new HashMap<>(); + + // 遍历从字典表中查询到的所有字典实体数据列表，对每条记录进行处理，将其按照特定的结构整理到前面创建的map对象中。 for(DictionaryEntity d :dictionaryEntities){ + + // 根据当前字典实体的字典编码（d.getDicCode()）从map中获取对应的内层Map（即代码索引和索引名称的映射关系），如果获取到的是null或者为空，说明还没有该字典编码对应的映射关系， + // 则创建一个新的HashMap作为内层Map，用于存储该字典编码下的索引和名称对应关系。 Map m = map.get(d.getDicCode()); + if(m ==null || m.isEmpty()){ m = new HashMap<>(); } + // 将当前字典实体的代码索引（d.getCodeIndex()）作为键，索引名称（d.getIndexName()）作为值，放入内层的Map（m）中，以此构建字典编码下具体的索引和名称对应关系。 m.put(d.getCodeIndex(),d.getIndexName()); + // 将整理好的内层Map（m）重新放回外层的map中，以字典编码（d.getDicCode()）作为键，完成当前字典实体数据在整体数据结构中的整理和存储。 map.put(d.getDicCode(),m); } + + // 将整理好的包含字典表数据的map对象存储到Servlet上下文的属性中，属性名为"dictionaryMap"，方便在整个Web应用的其他地方可以通过获取Servlet上下文属性来获取这些字典数据， + // 用于诸如数据展示、业务逻辑中根据字典进行数据转换等操作。 sce.getServletContext().setAttribute("dictionaryMap", map); logger.info("----------字典表初始化完成----------"); - logger.info("----------线程执行开始----------"); + // 判断myThreadMethod是否为null，如果是null，说明还没有实例化该线程对象， + // 则创建一个MyThreadMethod类的实例，用于后续启动一个自定义的线程来执行相关的后台任务（具体任务由MyThreadMethod类的实现决定）。 + if (myThreadMethod == null) { myThreadMethod = new MyThreadMethod(); - myThreadMethod.start(); // servlet 上下文初始化时启动线程myThreadMethod + // 启动前面实例化的myThreadMethod线程，在Servlet上下文初始化（项目启动）时启动这个线程，让其开始执行相应的任务， + // 比如可能是定时更新字典数据、执行一些周期性的业务逻辑等操作，具体取决于MyThreadMethod类中run方法的实现内容。 + myThreadMethod.start(); } logger.info("----------线程执行结束----------"); } } + + -- 2.34.1 From b35d250f842840990fec5264ead86009eff2c75f Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Sun, 15 Dec 2024 23:08:52 +0800 Subject: [PATCH 11/12] y --- .../DictionaryServletContextListener.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java index d1c7c5bd..3cece84c 100644 --- a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java +++ b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java @@ -16,6 +16,8 @@ import java.util.HashMap; import java.util.List; import java.util.Map; + + /** * 字典初始化监视器 * 用的是服务器监听机制，实现了 `ServletContextListener` -- 2.34.1 From b77282a55a755ac53486f720208dfbe8ad37e6b4 Mon Sep 17 00:00:00 2001 From: Yin <1605103955@qq.com> Date: Wed, 18 Dec 2024 10:05:53 +0800 Subject: [PATCH 12/12] =?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/config/InterceptorConfig.java | 44 +++++++++++++++++-- .../java/com/config/MyMetaObjectHandler.java | 23 ++++++++++ .../java/com/config/MybatisPlusConfig.java | 14 ++++++ .../java/com/minsuguanliwApplication.java | 32 +++++++++++++- 4 files changed, 109 insertions(+), 4 deletions(-) diff --git a/minsu/minsuguanliw/src/main/java/com/config/InterceptorConfig.java b/minsu/minsuguanliw/src/main/java/com/config/InterceptorConfig.java index 586ccc5a..74bf818b 100644 --- a/minsu/minsuguanliw/src/main/java/com/config/InterceptorConfig.java +++ b/minsu/minsuguanliw/src/main/java/com/config/InterceptorConfig.java @@ -8,32 +8,70 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupp import com.interceptor.AuthorizationInterceptor; + +// 该类使用了Spring的配置注解 @Configuration，表示这是一个配置类 +// 并且继承自WebMvcConfigurationSupport，用于对Spring Web MVC进行相关配置扩展 + @Configuration public class InterceptorConfig extends WebMvcConfigurationSupport{ - + + + // 使用 @Bean 注解将方法返回的对象注册为Spring容器中的一个Bean + // 这里创建并返回一个AuthorizationInterceptor实例，用于后续的拦截器相关操作 @Bean public AuthorizationInterceptor getAuthorizationInterceptor() { return new AuthorizationInterceptor(); } - + + + // 重写父类WebMvcConfigurationSupport的addInterceptors方法 + // 目的是添加自定义的拦截器到Spring MVC的拦截器链中 + // 此处添加了AuthorizationInterceptor拦截器，并设置其拦截的路径模式为"/**"（即所有路径） + // 同时排除了"/static/**"路径模式，也就是对静态资源相关的路径不进行拦截 + + @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(getAuthorizationInterceptor()).addPathPatterns("/**").excludePathPatterns("/static/**"); super.addInterceptors(registry); } - + + /** * springboot 2.0配置WebMvcConfigurationSupport之后，会导致默认配置被覆盖，要访问静态资源需要重写addResourceHandlers方法 */ + + + /** + * springboot 2.0配置WebMvcConfigurationSupport之后，会导致默认配置被覆盖， + * 要访问静态资源需要重写addResourceHandlers方法。 + * 此方法就是重写后的用于配置静态资源访问的方法，通过ResourceHandlerRegistry来注册静态资源的访问路径和对应位置。 + * 这里将多个不同的类路径下的资源位置添加进来，使得这些位置下的静态资源可以通过对应的路径被访问到。 + */ + @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { + // 为资源处理器添加路径匹配模式为"/**"，表示匹配所有请求路径 registry.addResourceHandler("/**") + + // 添加类路径下的/resources/目录作为静态资源位置，意味着可以访问该目录下的静态资源 .addResourceLocations("classpath:/resources/") + + // 添加类路径下的/static/目录作为静态资源位置 .addResourceLocations("classpath:/static/") + + // 添加类路径下的/admin/目录作为静态资源位置 .addResourceLocations("classpath:/admin/") + + // 添加类路径下的/img/目录作为静态资源位置 .addResourceLocations("classpath:/img/") + + // 添加类路径下的/front/目录作为静态资源位置 .addResourceLocations("classpath:/front/") + + // 添加类路径下的/public/目录作为静态资源位置 .addResourceLocations("classpath:/public/"); + super.addResourceHandlers(registry); } } diff --git a/minsu/minsuguanliw/src/main/java/com/config/MyMetaObjectHandler.java b/minsu/minsuguanliw/src/main/java/com/config/MyMetaObjectHandler.java index 2f9e7935..48abc754 100644 --- a/minsu/minsuguanliw/src/main/java/com/config/MyMetaObjectHandler.java +++ b/minsu/minsuguanliw/src/main/java/com/config/MyMetaObjectHandler.java @@ -9,18 +9,41 @@ import com.baomidou.mybatisplus.mapper.MetaObjectHandler; /** * 自定义填充处理器 */ + + +/** + * 这是一个自定义的填充处理器类，继承自MetaObjectHandler类， + * 主要用于在MyBatis-Plus执行数据插入和更新操作时，对特定字段进行自动填充相关的处理。 + */ public class MyMetaObjectHandler extends MetaObjectHandler { + + /** + * 重写了父类的insertFill方法，当进行数据插入操作时，会触发该方法。 + * 其功能是通过MyBatis-Plus提供的机制，使用当前时间（new Date()获取）来填充名为"ctime"的字段， + * 参数metaObject用于定位到具体要操作的对象（比如实体类对象等），从而实现插入数据时该字段的自动赋值。 + */ @Override public void insertFill(MetaObject metaObject) { this.setFieldValByName("ctime", new Date(), metaObject); } + + /** + * 重写了父类的openUpdateFill方法，该方法用于决定是否开启更新填充功能。 + * 在这里返回false，表示关闭更新填充功能，也就是在数据更新操作时，不会执行更新填充相关逻辑。 + */ @Override public boolean openUpdateFill() { return false; } + + /** + * 重写了父类的updateFill方法，正常情况下用于在数据更新时进行特定字段的填充操作。 + * 但由于在openUpdateFill方法中返回了false，关闭了更新填充功能，所以此处虽然定义了该方法， + * 但实际上在更新操作时不会执行该方法内的逻辑，也就是这里的代码不会起到实质的填充作用，仅作为重写方法的一个形式存在。 + */ @Override public void updateFill(MetaObject metaObject) { // 关闭更新填充、这里不执行 diff --git a/minsu/minsuguanliw/src/main/java/com/config/MybatisPlusConfig.java b/minsu/minsuguanliw/src/main/java/com/config/MybatisPlusConfig.java index ec2e84bb..0880f7b7 100644 --- a/minsu/minsuguanliw/src/main/java/com/config/MybatisPlusConfig.java +++ b/minsu/minsuguanliw/src/main/java/com/config/MybatisPlusConfig.java @@ -10,12 +10,26 @@ import com.baomidou.mybatisplus.plugins.PaginationInterceptor; /** * mybatis-plus配置 */ + + +/** + * 该类使用了 @Configuration 注解，表明这是一个Spring框架下的配置类， + * 其主要作用是针对Mybatis-Plus进行相关配置。 + */ + + @Configuration public class MybatisPlusConfig { /** * 分页插件 */ + + /** + * 此方法使用了 @Bean 注解，作用是将方法返回的对象注册为Spring容器中的一个Bean。 + * 这里创建并返回一个PaginationInterceptor实例，用于实现Mybatis-Plus的分页功能， + * 也就是配置Mybatis-Plus的分页插件，使得在项目中可以方便地进行数据库查询结果的分页操作。 + */ @Bean public PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor(); diff --git a/minsu/minsuguanliw/src/main/java/com/minsuguanliwApplication.java b/minsu/minsuguanliw/src/main/java/com/minsuguanliwApplication.java index 80e64375..da2d447c 100644 --- a/minsu/minsuguanliw/src/main/java/com/minsuguanliwApplication.java +++ b/minsu/minsuguanliw/src/main/java/com/minsuguanliwApplication.java @@ -7,15 +7,45 @@ import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.web.servlet.ServletComponentScan; import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; + +/** + * 这是一个Spring Boot应用的主启动类，使用了 @SpringBootApplication 注解， + * 该注解是一个组合注解，包含了如 @Configuration、@EnableAutoConfiguration、@ComponentScan 等注解的功能， + * 用于标识这是一个配置类并且开启Spring Boot的自动配置以及组件扫描等功能，使得项目能够基于Spring Boot快速启动和运行。 + */ @SpringBootApplication + + +/** + * 使用 @ServletComponentScan 注解来指定Servlet相关组件（比如Servlet、Filter、Listener等）的扫描路径， + * 这里指定扫描 "com.ServletContextListener" 包下的相关组件，使得这些Servlet组件能够被Spring容器正确识别和管理。 + */ @ServletComponentScan(value = "com.ServletContextListener") + + +/** + * 通过 @MapperScan 注解来指定MyBatis的Mapper接口所在的包路径， + * 此处告知Spring Boot去扫描 "com.dao" 包及其子包下的所有Mapper接口，方便后续与数据库交互操作时能正确找到对应的Mapper实现类（通常由MyBatis框架生成代理类等方式来实现）。 + */ @MapperScan(basePackages = {"com.dao"}) public class minsuguanliwApplication extends SpringBootServletInitializer{ + /** + * 这是Java应用的主入口方法，在启动应用时会被执行。 + * 通过调用SpringApplication.run方法，传入当前主启动类（minsuguanliwApplication.class）以及启动参数（args）， + * 来启动整个Spring Boot应用，完成一系列的初始化、配置加载、组件创建等操作，使得应用可以正常运行起来。 + */ public static void main(String[] args) { SpringApplication.run(minsuguanliwApplication.class, args); } - + + + /** + * 重写了SpringBootServletInitializer类的configure方法， + * 当应用以WAR包的形式部署到外部的Servlet容器（如Tomcat等）时，会通过这个方法来配置Spring应用上下文， + * 返回的SpringApplicationBuilder对象用于构建Spring应用，这里将当前主启动类（minsuguanliwApplication.class）设置为要加载的源， + * 以此来确保应用在外部Servlet容器中的正确启动和运行。 + */ @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder applicationBuilder) { return applicationBuilder.sources(minsuguanliwApplication.class); -- 2.34.1