From e8edf658a814fb5efc0754e7f700cc017c8e1a21 Mon Sep 17 00:00:00 2001 From: p4vb9jpo3 <1605103955@qq.com> Date: Sun, 15 Dec 2024 11:21:56 +0800 Subject: [PATCH 1/4] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20ytt=20(#4)?= 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 | 15 + .../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 | 301 ++++++++++++------ .../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, 740 insertions(+), 324 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..5762282e 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..232727c6 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); @@ -105,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); @@ -134,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()); @@ -176,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()); @@ -216,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()); @@ -240,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); @@ -359,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) { @@ -399,6 +406,7 @@ public class YonghuController { * @param yonghu 包含用户注册信息的YonghuEntity对象，通过请求体传入（通常是前端提交的注册表单数据等） * @return R对象，封装了操作结果，成功表示注册成功，失败则提示账户或者手机号已经被使用的错误信息 */ + @IgnoreAuth // 该注解可能表示此注册接口不需要进行权限认证（具体取决于该注解的实际定义和功能） @PostMapping(value = "/register") public R register(@RequestBody YonghuEntity yonghu) { @@ -433,6 +441,7 @@ public class YonghuController { * @param id 用户的唯一标识（通常是数据库中的主键ID），从请求参数中获取 * @return R对象，封装了操作结果，成功表示密码重置成功 */ + @GetMapping(value = "/resetPassword") public R resetPassword(Integer id) { YonghuEntity yonghu = new YonghuEntity(); @@ -453,6 +462,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，但在当前方法中未体现更多相关使用情况 * @return R对象，封装了操作结果，成功表示密码重置成功，若用户不存在则返回账号不存在的错误信息，若更新数据库操作失败则返回相应错误信息 */ + @IgnoreAuth @RequestMapping(value = "/resetPass") public R resetPass(String username, HttpServletRequest request) { @@ -483,6 +493,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户视图信息，若查不到数据则返回相应错误信息 */ + @RequestMapping("/session") public R getCurrYonghu(HttpServletRequest request) { // 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息 @@ -512,6 +523,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象 * @return R对象，封装了操作结果及相关提示信息，这里返回退出成功的提示 */ + @GetMapping(value = "logout") public R logout(HttpServletRequest request) { // 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录等相关信息 @@ -529,6 +541,7 @@ public class YonghuController { * @param request HttpServletRequest对象，用于获取当前请求相关的信息，比如可能用于后续字典表数据转换等操作获取相关上下文信息，但当前代码中未体现更多复杂使用情况。 * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表（已经过字典表数据转换）。 */ + @IgnoreAuth @RequestMapping("/list") public R list(@RequestParam Map params, HttpServletRequest request) { @@ -557,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); @@ -586,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/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..f84e85ac 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java @@ -26,274 +26,369 @@ 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; } + /** - * 获取：假删 - */ + * 获取：假删 + * 这是一个按照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 + - "}"; + "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 From c4545d0e20d435d591aa9d843b7bfb4ea1d5d9c5 Mon Sep 17 00:00:00 2001 From: pfgkalsmu Date: Sun, 15 Dec 2024 15:51:02 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E6=97=A0=20(#5)=20Co-authored-by:=20pfgkal?= =?UTF-8?q?smu=20=20Co-committed-by:=20pfgkalsmu?= =?UTF-8?q?=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- minsu/.idea/misc.xml | 2 +- .../java/com/controller/ForumController.java | 433 ++++++++------- .../java/com/controller/NewsController.java | 365 +++++++------ .../src/main/java/com/dao/ForumDao.java | 10 +- .../src/main/java/com/dao/NewsDao.java | 10 +- .../src/main/java/com/entity/ForumEntity.java | 327 +++++++----- .../src/main/java/com/entity/NewsEntity.java | 289 ++++++---- .../java/com/entity/model/ForumModel.java | 265 ++++----- .../main/java/com/entity/model/NewsModel.java | 209 ++++---- .../main/java/com/entity/view/ForumView.java | 504 +++++++++++------- .../main/java/com/entity/view/NewsView.java | 83 +-- .../main/java/com/service/ForumService.java | 30 +- .../main/java/com/service/NewsService.java | 31 +- .../main/java/com/service/TokenService.java | 95 +++- .../com/service/impl/ForumServiceImpl.java | 45 +- .../com/service/impl/NewsServiceImpl.java | 44 +- .../com/service/impl/TokenServiceImpl.java | 191 ++++++- 17 files changed, 1771 insertions(+), 1162 deletions(-) diff --git a/minsu/.idea/misc.xml b/minsu/.idea/misc.xml index 639900d1..a818314f 100644 --- a/minsu/.idea/misc.xml +++ b/minsu/.idea/misc.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/controller/ForumController.java b/minsu/minsuguanliw/src/main/java/com/controller/ForumController.java index 0c7a52b7..25318035 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/ForumController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/ForumController.java @@ -1,4 +1,3 @@ - package com.controller; import java.io.File; @@ -35,315 +34,305 @@ import com.alibaba.fastjson.*; /** * 论坛 * 后端接口 - * @author + * 该类主要作为论坛相关功能的控制层，处理各种与论坛业务相关的HTTP请求，调用对应的服务层方法来实现具体功能， + * 并与数据库进行交互以及处理返回结果等操作。 + * @author WMZ * @email -*/ + */ @RestController @Controller @RequestMapping("/forum") public class ForumController { + // 创建日志记录器， + // 用于记录该类中各个方法执行过程中的关键信息，方便调试和问题排查 private static final Logger logger = LoggerFactory.getLogger(ForumController.class); + // 通过Spring的依赖注入，自动装配ForumService， + // 用于处理论坛相关的业务逻辑，比如查询、插入、更新、删除等操作 @Autowired private ForumService forumService; - + // 自动注入TokenService， + // 可能用于处理用户认证相关的令牌操作（具体功能需看对应服务层实现） @Autowired private TokenService tokenService; + // 自动注入DictionaryService， + // 用于处理字典表相关的数据转换等操作（比如将字典表中的编码转换为对应的有意义的值等） @Autowired private DictionaryService dictionaryService; - //级联表service + // 自动注入YonghuService， + // 用于处理与用户（Yonghu，可能是具体业务中的一种用户类型）相关的级联表操作 @Autowired private YonghuService yonghuService; + // 自动注入UsersService， + // 用于处理与普通用户相关的级联表操作（比如获取用户详细信息等） @Autowired private UsersService usersService; - - /** - * 后端列表 - */ + * 后端列表功能方法 + * 接收前端传来的查询参数params以及HttpServletRequest对象，用于获取分页数据以及进行相关业务逻辑处理， + * 根据参数查询论坛信息列表，并进行字典表数据转换后返回给前端。 + * @param params 包含查询条件、分页等相关参数的Map集合 + * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的属性等） + * @return R类型的结果对象，包含操作结果状态以及查询到的数据等信息（R应该是自定义的统一返回结果类型） + */ @RequestMapping("/page") - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录page方法的调用信息， + // 包括当前类名和传入的参数， + // 方便调试查看参数情况（以JSON字符串形式记录参数） + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果传入的排序字段参数为空， + // 则默认按照"id"字段进行排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用forumService的queryPage方法， + // 根据传入的参数获取分页数据（该方法内部应该是与数据库交互获取相应的数据列表等） PageUtils page = forumService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(ForumView c:list){ - //修改对应字典表字段 + // 获取分页数据中的列表数据 + // （这里应该是ForumView类型的列表，ForumView可能是用于展示的视图对象） + List list = (List) page.getList(); + // 遍历列表数据， + // 对每条数据进行字典表数据转换操作（比如将字典表中的编码转换为对应的实际含义显示给前端） + for (ForumView c : list) { dictionaryService.dictionaryConvert(c, request); } + // 返回包含处理后数据的成功结果对象 + // （R.ok()表示操作成功，并将数据放入返回对象中返回给前端） return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情功能方法 + * 根据传入的论坛记录id，从数据库中查询对应的论坛详细信息， + * 进行相关的实体转视图、级联表数据处理以及字典表数据转换后返回给前端。 + * @param id 要查询的论坛记录的唯一标识（Long类型的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); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 通过forumService根据传入的id从数据库中查询对应的ForumEntity对象（ForumEntity可能是数据库对应的实体类） ForumEntity forum = forumService.selectById(id); - if(forum !=null){ - //entity转view + if (forum!= null) { + // 创建ForumView对象， + // 用于将查询到的实体数据转换为适合展示的视图数据（ForumView可能包含了部分需要展示给前端的字段等） ForumView view = new ForumView(); - BeanUtils.copyProperties( forum , view );//把实体数据重构到view中 - - //级联表 - YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId()); - if(yonghu != null){ - BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYonghuId(yonghu.getId()); - } - //管理员用户表做特殊处理,防止和用户表账户姓名字段冲突 - UsersEntity users = usersService.selectById(forum.getUsersId()); - if(users != null){ - view.setUsersId(users.getId()); - view.setUusername(users.getUsername()); - view.setUpassword(users.getPassword()); - view.setUrole(users.getRole()); - view.setUaddtime(users.getAddtime()); - } - //修改对应字典表字段 + // 使用Spring的BeanUtils工具， + // 将forum实体对象中的属性值复制到view视图对象中 + BeanUtils.copyProperties(forum, view); + + // 处理级联表数据， + // 获取与该论坛记录关联的YonghuEntity（用户相关的实体对象），并将部分属性复制到view中（排除一些不需要的字段） + YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId()); + if (yonghu!= null) { + BeanUtils.copyProperties(yonghu, view, new String[] { "id", "createTime", "insertTime", "updateTime" }); + view.setYonghuId(yonghu.getId()); + } + // 处理管理员用户表数据， + // 获取与该论坛记录关联的UsersEntity（管理员用户相关的实体对象），并将部分关键属性设置到view中 + UsersEntity users = usersService.selectById(forum.getUsersId()); + if (users!= null) { + view.setUsersId(users.getId()); + view.setUusername(users.getUsername()); + view.setUpassword(users.getPassword()); + view.setUrole(users.getRole()); + view.setUaddtime(users.getAddtime()); + } + // 对view视图对象进行字典表数据转换操作 + // （比如将字典表中的编码转换为对应的实际含义显示给前端） dictionaryService.dictionaryConvert(view, request); + // 返回包含处理后详细数据的成功结果对象（R.ok()表示操作成功， + // 并将数据放入返回对象中返回给前端） return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到对应的数据， + // 则返回包含错误码和错误提示信息的错误结果对象 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存功能方法 + * 接收前端传来的ForumEntity对象（包含要保存的论坛相关数据）以及HttpServletRequest对象， + * 根据当前用户角色设置相关的关联用户id，并检查数据是否重复后将数据插入到数据库中。 + * @param forum 包含要保存的论坛相关数据的ForumEntity对象 + * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色、用户id等属性） + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/save") - public R save(@RequestBody ForumEntity forum, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString()); + public R save(@RequestBody ForumEntity forum, HttpServletRequest request) { + logger.debug("save方法:,,Controller:{},,forum:{}", this.getClass().getName(), forum.toString()); + // 从HttpServletRequest的会话中获取当前用户的角色信息（这里先将获取到的Object类型强制转换为String类型） String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); - else if("用户".equals(role)) + if (false) + return R.error(511, "永远不会进入"); + else if ("用户".equals(role)) + // 如果当前用户角色是"用户"， + // 则将论坛记录的YonghuId设置为从会话中获取的当前用户的id（这里做了一些类型转换操作） forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); - else if("管理员".equals(role)) + else if ("管理员".equals(role)) + // 如果当前用户角色是"管理员"， + // 则将论坛记录的UsersId设置为从会话中获取的当前用户的id（同样进行了类型转换） forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); + // 创建EntityWrapper对象， + // 用于构建查询条件，检查数据库中是否已经存在相同的数据（根据多个字段进行等值判断） Wrapper queryWrapper = new EntityWrapper() - .eq("forum_name", forum.getForumName()) - .eq("yonghu_id", forum.getYonghuId()) - .eq("users_id", forum.getUsersId()) - .eq("super_ids", forum.getSuperIds()) - .eq("forum_state_types", forum.getForumStateTypes()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .eq("forum_name", forum.getForumName()) + .eq("yonghu_id", forum.getYonghuId()) + .eq("users_id", forum.getUsersId()) + .eq("super_ids", forum.getSuperIds()) + .eq("forum_state_types", forum.getForumStateTypes()); + + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询数据库中是否已经存在相同的数据 + // （通过selectOne方法查询一条符合条件的数据） ForumEntity forumEntity = forumService.selectOne(queryWrapper); - if(forumEntity==null){ + if (forumEntity == null) { + // 如果不存在相同数据， + // 则设置论坛记录的插入时间和创建时间为当前时间，并将该记录插入到数据库中（通过insert方法） forum.setInsertTime(new Date()); forum.setCreateTime(new Date()); forumService.insert(forum); return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果存在相同数据， + // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改功能方法 + * 接收前端传来的ForumEntity对象（包含要修改的论坛相关数据）以及HttpServletRequest对象， + * 根据字段查询是否有相同数据，若不存在则根据id更新数据库中的对应论坛记录。 + * @param forum 包含要修改的论坛相关数据的ForumEntity对象 + * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性） + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/update") - public R update(@RequestBody ForumEntity forum, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString()); + public R update(@RequestBody ForumEntity forum, HttpServletRequest request) { + logger.debug("update方法:,,Controller:{},,forum:{}", this.getClass().getName(), forum.toString()); String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); -// else if("用户".equals(role)) + + + + +// if (false) +// return R.error(511, "永远不会进入"); +// else if ("用户".equals(role)) // forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); -// else if("管理员".equals(role)) +// else if ("管理员".equals(role)) // forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); - //根据字段查询是否有相同数据 + // 创建EntityWrapper对象，用于构建查询条件，检查数据库中除了当前要修改的记录（根据id排除）外是否存在相同的数据（根据多个字段进行等值判断） + Wrapper queryWrapper = new EntityWrapper() - .notIn("id",forum.getId()) - .andNew() - .eq("forum_name", forum.getForumName()) - .eq("yonghu_id", forum.getYonghuId()) - .eq("users_id", forum.getUsersId()) - .eq("super_ids", forum.getSuperIds()) - .eq("forum_state_types", forum.getForumStateTypes()) - ; - - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + .notIn("id", forum.getId()) + .andNew() + .eq("forum_name", forum.getForumName()) + .eq("yonghu_id", forum.getYonghuId()) + .eq("users_id", forum.getUsersId()) + .eq("super_ids", forum.getSuperIds()) + .eq("forum_state_types", forum.getForumStateTypes()); + + + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据） + ForumEntity forumEntity = forumService.selectOne(queryWrapper); + // 设置论坛记录的更新时间为当前时间 + + + forum.setUpdateTime(new Date()); - if(forumEntity==null){ - forumService.updateById(forum);//根据id更新 + if (forumEntity == null) { + // 如果不存在相同数据， + // 则根据传入的forum对象的id更新数据库中的对应论坛记录（通过updateById方法） + forumService.updateById(forum); return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果存在相同数据， + // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据 + return R.error(511, "表中有相同数据"); } } - /** - * 删除 - */ + /** + * 删除功能方法 + * 接收前端传来的要删除的论坛记录的id数组，调用forumService的批量删除方法，从数据库中删除对应的数据记录， + * 并返回操作结果给前端。 + * @param ids 包含要删除的论坛记录的id的整数数组 + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + + + public R delete(@RequestBody Integer[] ids) { + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用forumService的deleteBatchIds方法， + // 批量删除数据库中对应id的论坛记录（传入的是将数组转换为List后的集合） forumService.deleteBatchIds(Arrays.asList(ids)); return R.ok(); } - /** - * 批量上传 + * 批量上传功能方法 + * 接收文件名fileName以及HttpServletRequest对象，用于将指定的Excel文件中的论坛数据批量插入到数据库中， + * 在插入前进行一些文件格式校验、数据读取以及重复数据检查等操作。 + * @param fileName 要上传的文件的名称（这里应该是位于特定目录下的文件名） + * @param request HttpServletRequest对象，用于获取请求相关的信息（如当前用户的id等属性） + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） */ + + @RequestMapping("/batchInsert") - public R save( String fileName, HttpServletRequest request){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); + public R save(String fileName, HttpServletRequest request) { + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); + // 从HttpServletRequest的会话中获取当前用户的id，并转换为Integer类型（这里做了一些强制类型转换操作） Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { - List forumList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + // 创建一个用于存储要插入数据库的ForumEntity对象列表（即从文件中读取到的多条论坛数据记录） + List forumList = new ArrayList<>(); + // 创建一个Map，用于存储要查询是否重复的字段信息（具体的使用方式需看后续代码逻辑） + Map> seachFields = new HashMap<>(); Date date = new Date(); int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 通过类加载器获取指定文件名对应的文件资源路径（这里应该是位于"static/upload/"目录下的文件） + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + // 调用PoiUtil的poiImport方法读取Excel文件中的数据（返回的是一个嵌套的List，外层List表示行，内层List表示每行中的单元格数据） + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除读取到的数据列表中的第一行（可能是表头之类的提示信息，不需要插入数据库） + dataList.remove(0); + for (List data : dataList) { + // 循环处理每一行数据，创建一个ForumEntity对象，用于存储要插入数据库的一条论坛记录信息 ForumEntity forumEntity = new ForumEntity(); // forumEntity.setForumName(data.get(0)); //帖子标题 要改的 // forumEntity.setYonghuId(Integer.valueOf(data.get(0))); //用户 要改的 // forumEntity.setUsersId(Integer.valueOf(data.get(0))); //管理员 要改的 // forumEntity.setForumContent("");//详情和图片 // forumEntity.setSuperIds(Integer.valueOf(data.get(0))); //父id 要改的 -// forumEntity.setForumStateTypes(Integer.valueOf(data.get(0))); //帖子状态 要改的 -// forumEntity.setInsertTime(date);//时间 -// forumEntity.setUpdateTime(sdf.parse(data.get(0))); //修改时间 要改的 -// forumEntity.setCreateTime(date);//时间 - forumList.add(forumEntity); - - - //把要查询是否重复的字段放入map中 - } - - //查询是否重复 - forumService.insertBatch(forumList); - return R.ok(); - } - } - } - }catch (Exception e){ - e.printStackTrace(); - return R.error(511,"批量插入数据异常，请联系管理员"); - } - } - - - - - - /** - * 前端列表 - */ - @IgnoreAuth - @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - - // 没有指定排序字段就默认id倒序 - if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ - params.put("orderBy","id"); - } - PageUtils page = forumService.queryPage(params); - - //字典表数据转换 - List list =(List)page.getList(); - for(ForumView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 - return R.ok().put("data", page); - } - - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - ForumEntity forum = forumService.selectById(id); - if(forum !=null){ - - - //entity转view - ForumView view = new ForumView(); - BeanUtils.copyProperties( forum , view );//把实体数据重构到view中 - - //级联表 - YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId()); - if(yonghu != null){ - BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段 - view.setYonghuId(yonghu.getId()); - } - UsersEntity users = usersService.selectById(forum.getUsersId()); - if(users != null){ - view.setUsersId(users.getId()); - view.setUusername(users.getUsername()); - view.setUpassword(users.getPassword()); - view.setUrole(users.getRole()); - view.setUaddtime(users.getAddtime()); - } - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } - } - - - /** - * 前端保存 - */ - @RequestMapping("/add") - public R add(@RequestBody ForumEntity forum, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString()); - Wrapper queryWrapper = new EntityWrapper() - .eq("forum_name", forum.getForumName()) - .eq("yonghu_id", forum.getYonghuId()) - .eq("users_id", forum.getUsersId()) - .eq("super_ids", forum.getSuperIds()) - .eq("forum_state_types", forum.getForumStateTypes()) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - ForumEntity forumEntity = forumService.selectOne(queryWrapper); - if(forumEntity==null){ - forum.setInsertTime(new Date()); - forum.setCreateTime(new Date()); - forumService.insert(forum); - return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } - - -} +// forumEntity.setForumStateTypes(Integer.valueOf(data.get(0))); //帖子状态 要改的 \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/controller/NewsController.java b/minsu/minsuguanliw/src/main/java/com/controller/NewsController.java index 65d2eeeb..d0e4feeb 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/NewsController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/NewsController.java @@ -1,4 +1,3 @@ - package com.controller; import java.io.File; @@ -35,178 +34,273 @@ import com.alibaba.fastjson.*; /** * 公告信息 * 后端接口 - * @author - * @email -*/ + * 该类作为公告信息相关功能的控制层，负责接收前端发送的各种HTTP请求， + * 调用对应的服务层方法来处理公告信息的查询、保存、修改、删除以及批量上传等业务操作， + * 并与数据库进行交互，对返回结果进行相应处理后返回给前端。 + * @author wangmuzi + * + */ @RestController @Controller @RequestMapping("/news") public class NewsController { + // 创建一个日志记录器，用于记录该类中各个方法执行过程中的关键信息，方便后续调试和问题排查 private static final Logger logger = LoggerFactory.getLogger(NewsController.class); + // 通过Spring的依赖注入， + // 自动装配NewsService，用于处理公告信息相关的核心业务逻辑，比如数据库操作等 @Autowired private NewsService newsService; - + // 自动注入TokenService， + // 可能用于处理与用户认证令牌相关的操作（具体功能需看对应服务层实现） @Autowired private TokenService tokenService; + // 自动注入DictionaryService， + // 用于处理字典表数据的转换操作，例如将字典表中的编码转换为有实际意义的展示值 @Autowired private DictionaryService dictionaryService; - //级联表service - + // 自动注入YonghuService， + // 可能用于处理与用户（Yonghu，可能是特定业务中的一种用户类型）相关的级联表操作（具体使用场景看后续代码逻辑） @Autowired private YonghuService yonghuService; - /** - * 后端列表 - */ + * 后端列表功能方法 + * 接收前端传来的查询参数以及HttpServletRequest对象，根据用户角色添加相应查询条件，获取公告信息的分页列表数据， + * 并对字典表相关字段进行数据转换后返回给前端。 + * @param params 包含查询条件、分页等相关参数的Map集合，例如每页显示数量、页码、排序字段等 + * @param request HttpServletRequest对象，用于获取请求相关的信息，如当前用户的角色、用户ID等，以便添加特定的查询条件 + * @return R类型的结果对象，包含操作结果状态以及查询到的分页数据等信息（R应该是自定义的统一返回结果类型） + */ @RequestMapping("/page") - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 记录page方法的调用信息， + // 包括当前类名和传入的参数（将参数转换为JSON字符串形式记录，方便查看参数详情），用于调试目的 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 从HttpServletRequest的会话中获取当前用户的角色信息， + // 并转换为String类型 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永不会进入"); - else if("用户".equals(role)) - params.put("yonghuId",request.getSession().getAttribute("userId")); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + if (false) + return R.error(511, "永不会进入"); + else if ("用户".equals(role)) + // 如果当前用户角色是"用户"， + // 则将当前用户的ID添加到查询参数中，作为查询属于该用户的公告信息的条件（这里假设数据库中有对应的关联字段） + params.put("yonghuId", request.getSession().getAttribute("userId")); + // 如果传入的排序字段参数为空，则默认按照"id"字段进行排序 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用newsService的queryPage方法， + // 根据传入的参数获取公告信息的分页数据（该方法内部应该是与数据库交互来查询相应的数据列表等） PageUtils page = newsService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(NewsView c:list){ - //修改对应字典表字段 + // 获取分页数据中的列表数据（这里应该是NewsView类型的列表，NewsView可能是用于展示的视图对象） + List list = (List) page.getList(); + // 遍历列表数据，对每条数据进行字典表数据转换操作， + // 将字典表中的编码等转换为对应的实际展示值（比如状态码转换为具体的状态文字描述） + for (NewsView c : list) { dictionaryService.dictionaryConvert(c, request); } + // 返回包含处理后数据的成功结果对象（R.ok()表示操作成功， + // 并将数据放入返回对象中返回给前端） return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情功能方法 + * 根据传入的公告信息记录的id，从数据库中查询对应的详细信息，进行实体转视图操作以及字典表数据转换后返回给前端。 + * @param id 要查询的公告信息记录的唯一标识（Long类型的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); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 通过newsService根据传入的id从数据库中查询对应的NewsEntity对象（NewsEntity可能是数据库对应的实体类） NewsEntity news = newsService.selectById(id); - if(news !=null){ - //entity转view + if (news!= null) { + // 创建NewsView对象， + // 用于将查询到的实体数据转换为适合展示的视图数据（NewsView可能包含了部分需要展示给前端的字段等） NewsView view = new NewsView(); - BeanUtils.copyProperties( news , view );//把实体数据重构到view中 + // 使用Spring的BeanUtils工具， + // 将news实体对象中的属性值复制到view视图对象中，实现实体转视图的基本数据复制 + BeanUtils.copyProperties(news, view); - //修改对应字典表字段 + // 对view视图对象进行字典表数据转换操作， + // 将字典表相关字段转换为有实际意义的展示值（比如将类型编码转换为类型名称等） dictionaryService.dictionaryConvert(view, request); + // 返回包含处理后详细数据的成功结果对象（R.ok()表示操作成功， + // 并将数据放入返回对象中返回给前端） return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到对应的数据， + // 则返回包含错误码和错误提示信息的错误结果对象 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存功能方法 + * 接收前端传来的NewsEntity对象（包含要保存的公告信息相关数据）以及HttpServletRequest对象， + * 检查数据是否重复后将数据插入到数据库中。 + * @param news 包含要保存的公告信息相关数据的NewsEntity对象，包含如公告名称、类型等各种属性信息 + * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性），不过此处暂时未体现更多使用场景 + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/save") - public R save(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); + public R save(@RequestBody NewsEntity news, HttpServletRequest request) { + logger.debug("save方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString()); String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); + if (false) + return R.error(511, "永远不会进入"); + // 创建EntityWrapper对象，用于构建查询条件， + // 检查数据库中是否已经存在相同的公告信息（根据公告名称和公告类型等字段进行等值判断） Wrapper queryWrapper = new EntityWrapper() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; + .eq("news_name", news.getNewsName()) + .eq("news_types", news.getNewsTypes()); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据） NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if(newsEntity==null){ + if (newsEntity == null) { + // 如果不存在相同数据，则设置公告信息的插入时间和创建时间为当前时间， + // 并将该公告信息插入到数据库中（通过insert方法） news.setInsertTime(new Date()); news.setCreateTime(new Date()); newsService.insert(news); return R.ok(); - }else { - return R.error(511,"表中有相同数据"); + } else { + // 如果存在相同数据，则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据 + return R.error(511, "表中有相同数据"); } } /** - * 后端修改 - */ + * 后端修改功能方法 + * 接收前端传来的NewsEntity对象（包含要修改的公告信息相关数据）以及HttpServletRequest对象， + * 根据字段查询是否有相同数据，若不存在则根据id更新数据库中的对应公告信息记录，同时对图片字段进行空值处理。 + * @param news 包含要修改的公告信息相关数据的NewsEntity对象，包含如公告名称、类型、图片等各种属性信息，且部分属性可能已被修改 + * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性），不过此处暂时未体现更多使用场景 + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/update") - public R update(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); + public R update(@RequestBody NewsEntity news, HttpServletRequest request) { + logger.debug("update方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString()); String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); - //根据字段查询是否有相同数据 +// if (false) +// return R.error(511, "永远不会进入"); + // 创建EntityWrapper对象，用于构建查询条件，检查数据库中除了当前要修改的记录（根据id排除）外是否存在相同的公告信息（根据公告名称和公告类型等字段进行等值判断） Wrapper queryWrapper = new EntityWrapper() - .notIn("id",news.getId()) - .andNew() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; + .notIn("id", news.getId()) + .andNew() + .eq("news_name", news.getNewsName()) + .eq("news_types", news.getNewsTypes()); + + logger.info("sql语句:" + queryWrapper.getSqlSegment()); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据） NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())){ - news.setNewsPhoto(null); + + // 如果公告图片字段为空字符串或者值为"null" + // （这里可能是前端传递过来的表示空值的情况），则将其设置为null，以便后续正确更新到数据库中 + if ("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())) { + news.setNewsPhoto(null); } - if(newsEntity==null){ - newsService.updateById(news);//根据id更新 + if (newsEntity == null) { + + // 如果不存在相同数据， + // 则根据传入的news对象的id更新数据库中的对应公告信息记录（通过updateById方法） + + newsService.updateById(news); return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } + } else { + // 如果存在相同数据， + // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据 + return R.error(511, "表中有相同数据"); + } + } /** - * 删除 - */ + * 删除功能方法 + * 接收前端传来的要删除的公告信息记录的id数组，调用newsService的批量删除方法，从数据库中删除对应的数据记录， + * 并返回操作结果给前端。 + * @param ids 包含要删除的公告信息记录的id的整数数组，用于指定要删除的多条公告信息 + * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息） + */ @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); + public R delete(@RequestBody Integer[] ids) { + + logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString()); + // 调用newsService的deleteBatchIds方法， + // 批量删除数据库中对应id的公告信息记录（传入的是将数组转换为List后的集合） + newsService.deleteBatchIds(Arrays.asList(ids)); return R.ok(); } - /** - * 批量上传 + * 批量上传功能方法 + * 接收文件名fileName以及HttpServletRequest对象，用于将指定的Excel文件中的公告信息数据批量插入到数据库中， + * 在插入前进行一些文件格式校验、数据读取以及重复数据检查等操作。 + * @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); + public R save(String fileName, HttpServletRequest request) { + logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName); + + // 从HttpServletRequest的会话中获取当前用户的ID， + // 并转换为Integer类型（这里做了一些强制类型转换操作） + Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { - List newsList = new ArrayList<>();//上传的东西 - Map> seachFields= new HashMap<>();//要查询的字段 + + // 创建一个用于存储要插入数据库的NewsEntity对象列表（即从文件中读取到的多条公告信息记录） + List newsList = new ArrayList<>(); + // 创建一个Map， + + // 用于存储要查询是否重复的字段信息（具体的使用方式需看后续代码逻辑，可能用于去重判断等） + Map> seachFields = new HashMap<>(); Date date = new Date(); int lastIndexOf = fileName.lastIndexOf("."); - if(lastIndexOf == -1){ - return R.error(511,"该文件没有后缀"); - }else{ + if (lastIndexOf == -1) { + return R.error(511, "该文件没有后缀"); + } else { String suffix = fileName.substring(lastIndexOf); - if(!".xls".equals(suffix)){ - return R.error(511,"只支持后缀为xls的excel文件"); - }else{ - URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径 + if (!".xls".equals(suffix)) { + return R.error(511, "只支持后缀为xls的excel文件"); + } else { + // 通过类加载器获取指定文件名对应的文件资源路径（这里应该是位于"static/upload/"目录下的文件） + URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); File file = new File(resource.getFile()); - if(!file.exists()){ - return R.error(511,"找不到上传文件，请联系管理员"); - }else{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 + if (!file.exists()) { + return R.error(511, "找不到上传文件，请联系管理员"); + } else { + + // 调用PoiUtil的poiImport方法读取Excel文件中的数据（返回的是一个嵌套的List， + // 外层List表示行，内层List表示每行中的单元格数据） + List> dataList = PoiUtil.poiImport(file.getPath()); + // 删除读取到的数据列表中的第一行（可能是表头之类的提示信息，不需要插入数据库） + dataList.remove(0); + for (List data : dataList) { + // 循环处理每一行数据，创建一个NewsEntity对象，用于存储要插入数据库的一条公告信息记录信息 NewsEntity newsEntity = new NewsEntity(); +// +// +// +// +// +// +// // newsEntity.setNewsName(data.get(0)); //公告标题 要改的 // newsEntity.setNewsTypes(Integer.valueOf(data.get(0))); //公告类型 要改的 // newsEntity.setNewsPhoto("");//详情和图片 @@ -215,91 +309,28 @@ public class NewsController { // newsEntity.setCreateTime(date);//时间 newsList.add(newsEntity); + // 把要查询是否重复的字段放入map中（此处代码未完整实现具体放入逻辑，需补充） - //把要查询是否重复的字段放入map中 } - //查询是否重复 + + // 查询是否重复（此处应该是根据放入seachFields中的字段去检查数据库中是否已存在相同记录， + // 代码可能需完善） newsService.insertBatch(newsList); + return R.ok(); } } } - }catch (Exception e){ + } catch (Exception e) { e.printStackTrace(); - return R.error(511,"批量插入数据异常，请联系管理员"); - } - } - - - - - - /** - * 前端列表 - */ - @IgnoreAuth - @RequestMapping("/list") - public R list(@RequestParam Map params, HttpServletRequest request){ - logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - - // 没有指定排序字段就默认id倒序 - if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){ - params.put("orderBy","id"); + return R.error(511, "批量插入数据异常，请联系管理员"); } - PageUtils page = newsService.queryPage(params); - - //字典表数据转换 - List list =(List)page.getList(); - for(NewsView c:list) - dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段 - return R.ok().put("data", page); } - /** - * 前端详情 - */ - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); - NewsEntity news = newsService.selectById(id); - if(news !=null){ - - - //entity转view - NewsView view = new NewsView(); - BeanUtils.copyProperties( news , view );//把实体数据重构到view中 - - //修改对应字典表字段 - dictionaryService.dictionaryConvert(view, request); - return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); - } - } - - - /** - * 前端保存 - */ - @RequestMapping("/add") - public R add(@RequestBody NewsEntity news, HttpServletRequest request){ - logger.debug("add方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString()); - Wrapper queryWrapper = new EntityWrapper() - .eq("news_name", news.getNewsName()) - .eq("news_types", news.getNewsTypes()) - ; - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - NewsEntity newsEntity = newsService.selectOne(queryWrapper); - if(newsEntity==null){ - news.setInsertTime(new Date()); - news.setCreateTime(new Date()); - newsService.insert(news); - return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } - - -} +/** + * 前端列表功能方法 + * 接收前端传来的查询参数以及HttpServletRequest对象，获取公告信息的分页列表数据， + * 并对字典表相关字段进行数据转换后返回给前端，此方法不受权限验证限制（通过@IgnoreAuth注解标识）。 + * @param params 包含查询条件、分页等相关参数的Map集合，例如每页显示数量、页码、排序字段等 + * @param request HttpServletRequest对象，用于获取请求相关的信息，如当前用户的角色、用户ID等，以便添加特定的查询 \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/dao/ForumDao.java b/minsu/minsuguanliw/src/main/java/com/dao/ForumDao.java index 86f6ab46..18850df1 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/ForumDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/ForumDao.java @@ -9,11 +9,11 @@ import com.baomidou.mybatisplus.plugins.pagination.Pagination; import org.apache.ibatis.annotations.Param; import com.entity.view.ForumView; -/** - * 论坛 Dao 接口 - * - * @author - */ +//** + //* 论坛 Dao 接口 + //* + //* @author + //*/ public interface ForumDao extends BaseMapper { List selectListView(Pagination page,@Param("params")Map params); diff --git a/minsu/minsuguanliw/src/main/java/com/dao/NewsDao.java b/minsu/minsuguanliw/src/main/java/com/dao/NewsDao.java index eeaf9176..aa94e050 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/NewsDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/NewsDao.java @@ -9,11 +9,11 @@ import com.baomidou.mybatisplus.plugins.pagination.Pagination; import org.apache.ibatis.annotations.Param; import com.entity.view.NewsView; -/** - * 公告信息 Dao 接口 - * - * @author - */ +//** + // 公告信息 Dao 接口 + //* + //* @author + //*/ public interface NewsDao extends BaseMapper { List selectListView(Pagination page,@Param("params")Map params); diff --git a/minsu/minsuguanliw/src/main/java/com/entity/ForumEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/ForumEntity.java index 1eb3fdae..58f50398 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/ForumEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/ForumEntity.java @@ -22,243 +22,292 @@ import com.baomidou.mybatisplus.enums.IdType; /** * 论坛 + * 该类定义了论坛相关的数据实体， * - * @author + * + * 对应数据库中的"forum"表，用于存储和传递论坛帖子等相关信息， + * 包含了帖子的各种属性以及对应的Getter、 + * + * Setter方法，同时实现了Serializable接口以支持对象的序列化操作。 + * @author wangmuzi * @email */ @TableName("forum") public class ForumEntity implements Serializable { + // 用于定义序列化版本号， + // 保证在对象序列化和反序列化过程中的兼容性， + // 当类的结构发生变化时可更新该版本号 private static final long serialVersionUID = 1L; + // 无参构造函数，用 + // 于创建ForumEntity对象的默认实例， + // 在一些框架或反射创建对象的场景中可能会用到 + public ForumEntity() { - public ForumEntity() { - - } - - public ForumEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 有参构造函数，接受一个泛型参数t + //// ，尝试将t对象的属性值复制到当前ForumEntity对象中， + //// 通过BeanUtils进行属性复制 + // ，若出现异常则打印堆栈信息，可用于基于已有对象来初始化该实体对象的场景。 + public ForumEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } - /** - * 主键 + //** + //* 主键 + // * 对应数据库表中记录的唯一标识符， + * 使用了MyBatis Plus的注解来指定主键的相关配置， + * 如设置主键生成策略为自增长（IdType.AUTO）， + * 并指定了数据库表中的字段名为"id"。 */ @TableId(type = IdType.AUTO) @TableField(value = "id") - private Integer id; - - /** - * 帖子标题 + // /** + // * 帖子标题 + // * 用于存储论坛帖子的标题信息， + // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_name"。 */ @TableField(value = "forum_name") - private String forumName; - /** * 用户 - */ + // * 用于存储发布该帖子的用户的唯一标识（可能关联到用户表中的用户ID）， + // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"yonghu_id"。 + // */ @TableField(value = "yonghu_id") - private Integer yonghuId; - /** - * 管理员 - */ + // * 管理员 + //* 用于存储与该帖子相关的管理员用户的唯一标识（可能在一些管理操作或权限相关场景中有作用）， + // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"users_id"。 + //*/ @TableField(value = "users_id") - private Integer usersId; - - /** - * 发布内容 - */ + // /** + //* 发布内容 + // * 用于存储论坛帖子的具体内容信息，通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_content"。 + //*/ @TableField(value = "forum_content") - private String forumContent; - - /** - * 父id - */ + // /** + // * 父id + // * 可能用于表示帖子之间的层级关系（比如回复帖子时关联到原帖子的ID等情况）， + //* 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"super_ids"。 + // */ @TableField(value = "super_ids") - private Integer superIds; - - /** - * 帖子状态 - */ + // /** + //* 帖子状态 + // * 用于存储帖子当前所处的状态信息（例如审核状态、是否可见等不同状态，具体含义由业务定义）， + //* 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_state_types"。 + //*/ @TableField(value = "forum_state_types") - private Integer forumStateTypes; - - /** - * 发帖时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "insert_time",fill = FieldFill.INSERT) - + ///** + // * 发帖时间 + //* 用于记录帖子发布的时间，使用了@JsonFormat注解来指定时间格式化的相关配置，如设置时区、格式化模式等， + // * 使其在序列化为JSON等格式时能以指定格式展示时间，同时通过@DateTimeFormat注解用于在接收前端传入时间格式数据时进行解析， + // * 并且通过@TableField注解指定了该字段在数据库表"forum"中对应的字段名为"insert_time"以及其填充策略为插入时自动填充（FieldFill.INSERT）。 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat + @TableField(value = "insert_time", fill = FieldFill.INSERT) private Date insertTime; - - /** - * 修改时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "update_time",fill = FieldFill.UPDATE) - + // /** + // * 修改时间 + //* 用于记录帖子最后一次被修改的时间，同样使用了@JsonFormat和@DateTimeFormat注解来处理时间的格式化和解析， + //* 通过@TableField注解指定了该字段在数据库表"forum"中对应的字段名为"update_time"以及其填充策略为更新时自动填充（FieldFill.UPDATE）。 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat + @TableField(value = "update_time", fill = FieldFill.UPDATE) private Date updateTime; - - /** - * 创建时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + ///** + //* 创建时间 + //* 用于记录帖子相关记录在系统中创建的时间，使用了@JsonFormat和@DateTimeFormat注解来处理时间的格式化和解析， + //* 通过@TableField注解指定了该字段在数据库表"forum"中对应的字段名为"create_time"以及其填充策略为插入时自动填充（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方法，用于获取主键id的值，外部代码可以通过该方法获取当前ForumEntity对象的主键值。 + //*/ public Integer getId() { return id; } - /** - * 获取：主键 - */ + ///** + //* 获取：主键 + //* Setter方法，用于设置主键id的值，外部代码可以通过该方法来修改当前ForumEntity对象的主键值。 + //*/ public void setId(Integer id) { this.id = id; } - /** - * 设置：帖子标题 - */ + + ///** + // * 设置：帖子标题 + //* Getter方法，用于获取帖子标题forumName的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子标题。 + // */ public String getForumName() { return forumName; } - /** - * 获取：帖子标题 - */ + ///** + // * 获取：帖子标题 + //* Setter方法，用于设置帖子标题forumName的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子标题。 + //*/ public void setForumName(String forumName) { this.forumName = forumName; } - /** - * 设置：用户 - */ + + ///** + // * 设置：用户 + //* Getter方法，用于获取用户ID（yonghuId）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的用户标识。 + //*/ + // + // + // + // public Integer getYonghuId() { return yonghuId; } - /** - * 获取：用户 - */ + // /** + //* 获取：用户 + //* Setter方法，用于设置用户ID（yonghuId）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的用户标识。 + //*/ public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } - /** - * 设置：管理员 - */ + + ///** + //* 设置：管理员 + // * Getter方法，用于获取管理员用户ID（usersId）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的管理员标识。 + //*/ public Integer getUsersId() { return usersId; } - /** - * 获取：管理员 - */ + ///** + // * 获取：管理员 + // * Setter方法，用于设置管理员用户ID（usersId）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的管理员标识。 + // */ public void setUsersId(Integer usersId) { this.usersId = usersId; } - /** - * 设置：发布内容 - */ + + ///** + //* 设置：发布内容 + //* Getter方法，用于获取帖子发布内容（forumContent）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子具体内容。 + //*/ public String getForumContent() { return forumContent; } - /** - * 获取：发布内容 - */ + // /** + //* 获取：发布内容 + //* Setter方法，用于设置帖子发布内容（forumContent）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子具体内容。 + //*/ public void setForumContent(String forumContent) { this.forumContent = forumContent; } - /** - * 设置：父id - */ + + ///** + //* 设置：父id + //* Getter方法，用于获取父ID（superIds）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的父级帖子标识（如果有层级关系的话）。 + // */ public Integer getSuperIds() { return superIds; } - /** - * 获取：父id - */ + ///** + // * 获取：父id + //* Setter方法，用于设置父ID（superIds）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的父级帖子标识（如果有层级关系的话）。 + // */ public void setSuperIds(Integer superIds) { this.superIds = superIds; } - /** - * 设置：帖子状态 - */ + + // /** + // * 设置：帖子状态 + //* Getter方法，用于获取帖子状态（forumStateTypes）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子当前状态信息。 + //*/ public Integer getForumStateTypes() { return forumStateTypes; } - /** - * 获取：帖子状态 - */ + ///** + // * 获取：帖子状态 + // * Setter方法，用于设置帖子状态（forumStateTypes）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子当前状态信息。 + //*/ public void setForumStateTypes(Integer forumStateTypes) { this.forumStateTypes = forumStateTypes; } - /** - * 设置：发帖时间 - */ + + //** + //* 设置：发帖时间 + // * Getter方法，用于获取发帖时间（insertTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子发布时间信息。 + // */ public Date getInsertTime() { return insertTime; } - /** - * 获取：发帖时间 - */ + ///** + //* 获取：发帖时间 + ////* Setter方法，用于设置发帖时间（insertTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子发布时间信息。 + //*/ public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } - /** - * 设置：修改时间 - */ + + ///** + // * 设置：修改时间 + //* Getter方法，用于获取修改时间（updateTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子最后修改时间信息。 + // */ public Date getUpdateTime() { return updateTime; } - /** - * 获取：修改时间 - */ + ///** + //* 获取：修改时间 + //* Setter方法，用于设置修改时间（updateTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子最后修改时间信息。 + // */ public void setUpdateTime(Date updateTime) { this.updateTime = updateTime; } - /** - * 设置：创建时间 - */ + + ///** + // * 设置：创建时间 + // * Getter方法，用于获取创建时间（createTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子相关记录创建时间信息。 + // */ public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ + // /** + // * 获取：创建时间 + //* Setter方法，用于设置创建时间（createTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子相关记录创建时间信息。 + // */ public void setCreateTime(Date createTime) { this.createTime = createTime; } @@ -266,16 +315,16 @@ public class ForumEntity implements Serializable { @Override public String toString() { return "Forum{" + - "id=" + id + - ", forumName=" + forumName + - ", yonghuId=" + yonghuId + - ", usersId=" + usersId + - ", forumContent=" + forumContent + - ", superIds=" + superIds + - ", forumStateTypes=" + forumStateTypes + - ", insertTime=" + insertTime + - ", updateTime=" + updateTime + - ", createTime=" + createTime + - "}"; + "id=" + id + + ", forumName=" + forumName + + ", yonghuId=" + yonghuId + + ", usersId=" + usersId + + ", forumContent=" + forumContent + + ", superIds=" + superIds + + ", forumStateTypes=" + forumStateTypes + + ", insertTime=" + insertTime + + ", updateTime=" + updateTime + + ", createTime=" + createTime + + "}"; } -} +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/NewsEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/NewsEntity.java index e1ded6a8..90dd3c40 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/NewsEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/NewsEntity.java @@ -20,180 +20,251 @@ import com.baomidou.mybatisplus.annotations.TableField; import com.baomidou.mybatisplus.enums.FieldFill; import com.baomidou.mybatisplus.enums.IdType; -/** - * 公告信息 - * - * @author - * @email - */ +///** + //* 公告信息 + // 该类定义了公告信息相关的数据实体，对应数据库中的"news"表，用于存储和传递公告相关的各种属性信息， + //* 同时实现了Serializable接口，使其能够进行序列化操作，方便在网络传输、持久化等场景中使用， + //* 类中还包含了用于属性访问的Getter和Setter方法以及重写的toString方法，便于对象的操作和信息展示。 + //* @author wangmuzi + //* @email + //*/ @TableName("news") public class NewsEntity implements Serializable { + // + // + // 定义序列化版本号，用于在对象序列化和反序列化过程中确保兼容性， + // 当类的结构发生变化（如新增、删除字段等）时， + // 可适当更新该版本号，以避免出现序列化和反序列化不一致的问题。 private static final long serialVersionUID = 1L; + // 无参构造函数，主要用于创建NewsEntity类的默认实例对象， + // 在一些框架自动实例化对象或者通过反射创建对象等场景下会被调用。 + public NewsEntity() { - public NewsEntity() { - - } - - public NewsEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // 有参构造函数，接受一个泛型参数t， + // 其目的是尝试将传入的t对象的属性值复制到当前的NewsEntity对象中。 + // 通过使用BeanUtils工具类的copyProperties方法来实现属性复制， + // 若在复制过程中出现IllegalAccessException（例如访问权限问题） + // 或者InvocationTargetException（例如被调用方法抛出异常）， + // 则会打印异常堆栈信息进行调试。 + public NewsEntity(T t) { + try { + BeanUtils.copyProperties(this, t); + } catch (IllegalAccessException | InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } - /** - * 主键 - */ + ///** + //* 主键 + //* 对应数据库中"news"表记录的唯一标识符， + // * 通过@TableId注解指定了主键的生成策略为自增长（IdType.AUTO）， + //* 并使用@TableField注解明确了在数据库表中的字段名为"id"，用于唯一标识每条公告信息记录。 + //*/ @TableId(type = IdType.AUTO) @TableField(value = "id") - private Integer id; - - /** - * 公告标题 - */ + // /** + // * 公告标题 + // * 用于存储公告的标题内容， + // * 通过@TableField注解将该属性与数据库表"news"中的"news_name"字段进行映射关联， + //// 方便在进行数据库操作时进行数据的存取。 + // */ @TableField(value = "news_name") - private String newsName; - - /** - * 公告类型 - */ + ///** + // * 公告类型 + //* 用于表示公告所属的类型（例如通知类、活动类等， + // * 具体类型由业务逻辑定义），通过@TableField注解将其与数据库表"news"中的"news_types"字段对应起来， + //* 其类型为Integer，可能在数据库中以数字编码形式存储不同的公告类型。 + // */ @TableField(value = "news_types") - private Integer newsTypes; - - - /** - * 公告图片 - */ +// + // /** + // * 公告图片 + // * 用于存放公告相关的图片路径或者图片资源的标识信息（具体取决于业务实现方式，可能是文件系统路径、URL等）， + // * 通过@TableField注解关联到数据库表"news"中的"news_photo"字段，方便进行图片相关的数据操作与存储。 + // */ @TableField(value = "news_photo") - private String newsPhoto; - - /** - * 添加时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "insert_time",fill = FieldFill.INSERT) - + // /** + // * 添加时间 + // * 用于记录公告信息添加到系统中的时间， + // * 通过@JsonFormat注解来指定时间的格式化方式，使其在序列化为JSON格式数据时能够按照指定的格式展示， + // * 例如设置了中文地区（locale="zh"）、东八区时区（timezone="GMT+8"）以及具体的时间格式（pattern="yyyy-MM-dd HH:mm:ss"）。 + // * 同时，@DateTimeFormat注解用于在接收前端传入的时间格式数据时进行解析转换，使其能正确赋值给该属性。 + // * @TableField注解指定了在数据库表中的字段名为"insert_time"，并且设置了填充策略为插入时自动填充（FieldFill.INSERT）， + //* 意味着在将该实体对象插入数据库时，该时间字段会自动被赋值为当前时间（通常由相关框架自动处理）。 + //*/ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat + @TableField(value = "insert_time", fill = FieldFill.INSERT) private Date insertTime; - - /** - * 公告详情 - */ + ///** + //* 公告详情 + //* 用于存储公告的详细内容信息， + //* 通过@TableField注解与数据库表"news"中的"news_content"字段进行关联， + // // 方便在进行数据库读写操作时传递和保存公告的详细文本内容。 + // */ @TableField(value = "news_content") - private String newsContent; - - /** - * 创建时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) - + // /** + // * 创建时间 + // * 类似于添加时间，用于记录公告相关记录在系统中创建的时间， + // * 同样使用了@JsonFormat和@DateTimeFormat注解来处理时间的格式化和解析， + //* 通过@TableField注解指定了该字段在数据库表"news"中对应的字段名为"create_time"以及其填充策略为插入时自动填充（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; - - /** - * 设置：主键 - */ + // /** + // * 设置：主键 + // * 这是属性id的Getter方法， + /// * 外部代码可以通过调用该方法获取当前NewsEntity对象的主键值，方便在业务逻辑中进行基于主键的操作， + ///* 比如查询、更新、删除等操作时使用该主键来定位特定的公告记录。 + //*/ public Integer getId() { return id; } - /** - * 获取：主键 - */ + ///** + // * 获取：主键 + // * 这是属性id的Setter方法，外部代码可以通过调用该方法来设置当前NewsEntity对象的主键值， + // * 不过通常主键在数据库中是由自增长等策略生成， + // * 手动设置的情况相对较少，但在一些特定业务场景下可能会用到，比如数据迁移等情况。 + // */ public void setId(Integer id) { this.id = id; } - /** - * 设置：公告标题 - */ + + // /** + // * 设置：公告标题 + //* 这是属性newsName的Getter方法， + //* 外部代码通过调用它可以获取当前NewsEntity对象所存储的公告标题内容， + //// 便于在展示公告信息或者进行标题相关的业务判断等场景中使用。 + // */ public String getNewsName() { return newsName; } - /** - * 获取：公告标题 - */ + // /** + // * 获取：公告标题 + // * 这是属性newsName的Setter方法， + // * 外部代码调用该方法可以修改当前NewsEntity对象的公告标题内容， + // 比如在编辑公告功能中更新公告的标题时会用到。 + // */ public void setNewsName(String newsName) { this.newsName = newsName; } - /** - * 设置：公告类型 - */ + + // /** + // * 设置：公告类型 + // * 这是属性newsTypes的Getter方法， + // * 外部代码通过调用它可以获取当前NewsEntity对象所代表的公告类型标识（数字编码形式）， + // // 便于在业务逻辑中根据公告类型进行分类处理、查询筛选等操作。 + //*/ public Integer getNewsTypes() { return newsTypes; } - /** - * 获取：公告类型 - */ + // /** + //* 获取：公告类型 + //* 这是属性newsTypes的Setter方法，外部代码调用该方法可以修改当前NewsEntity对象的公告类型标识， + //// 例如在调整公告所属分类等业务场景下会用到。 + //*/ public void setNewsTypes(Integer newsTypes) { this.newsTypes = newsTypes; } - /** - * 设置：公告图片 - */ + + // /** + // * 设置：公告图片 + // * 这是属性newsPhoto的Getter方法， + //* 外部代码通过调用它可以获取当前NewsEntity对象存储的公告图片相关信息（路径或标识等）， + // 在显示公告图片或者对图片资源进行管理等场景中会用到该方法获取相应信息。 + // */ public String getNewsPhoto() { return newsPhoto; } - /** - * 获取：公告图片 - */ + /** + * 获取：公告图片 + * 这是属性newsPhoto的Setter方法， + * 外部代码调用该方法可以修改当前NewsEntity对象的公告图片相关信息， + // 比如更新公告的配图、修改图片路径等业务操作时会用到。 + */ public void setNewsPhoto(String newsPhoto) { this.newsPhoto = newsPhoto; } + /** - * 设置：添加时间 - */ + * 设置：添加时间 + * 这是属性insertTime的Getter方法， + * 外部代码通过调用它可以获取当前NewsEntity对象记录的公告添加时间信息， + // 在查询公告历史记录、按照时间范围筛选公告等业务场景中会用到该时间信息。 + */ public Date getInsertTime() { return insertTime; } - /** - * 获取：添加时间 - */ + /** + * 获取：添加时间 + * 这是属性insertTime的Setter方法， + * 外部代码调用该方法可以修改当前NewsEntity对象的公告添加时间信息， + // 不过一般情况下该时间是由系统自动填充， + 手动修改的情况较少，特殊业务需求下可能会用到（如数据纠错等）。 + */ public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } + /** - * 设置：公告详情 - */ + * 设置：公告详情 + * 这是属性newsContent的Getter方法， + * 外部代码通过调用它可以获取当前NewsEntity对象存储的公告详细内容信息， + // 是展示公告完整内容给用户查看的关键方法，在公告详情页面等场景中会用到。 + */ public String getNewsContent() { return newsContent; } - /** - * 获取：公告详情 - */ + /** + * 获取：公告详情 + * 这是属性newsContent的Setter方法， + * 外部代码调用该方法可以修改当前NewsEntity对象的公告详细内容信息， + // 比如在编辑公告详情文本内容时会用到该方法进行更新操作。 + */ public void setNewsContent(String newsContent) { this.newsContent = newsContent; } + /** - * 设置：创建时间 - */ + * 设置：创建时间 + * 这是属性createTime的Getter方法， + * 外部代码通过调用它可以获取当前NewsEntity对象记录的公告相关记录创建时间信息， + // 在一些涉及到数据创建时间跟踪、按照创建时间排序等业务场景中会用到该时间信息。 + */ public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ + /** + * 获取：创建时间 + * 这是属性createTime的Setter方法， + * 外部代码调用该方法可以修改当前NewsEntity对象的公告相关记录创建时间信息， + // 通常该时间由系统自动填充，手动修改场景较少，特殊业务场景下（如数据迁移、时间校正等）可能会用到。 + */ public void setCreateTime(Date createTime) { this.createTime = createTime; } @@ -201,13 +272,13 @@ public class NewsEntity implements Serializable { @Override public String toString() { return "News{" + - "id=" + id + - ", newsName=" + newsName + - ", newsTypes=" + newsTypes + - ", newsPhoto=" + newsPhoto + - ", insertTime=" + insertTime + - ", newsContent=" + newsContent + - ", createTime=" + createTime + - "}"; - } -} + "id=" + id + + ", newsName=" + newsName + + ", newsTypes=" + newsTypes + + ", newsPhoto=" + newsPhoto + + ", insertTime=" + insertTime + + ", newsContent=" + newsContent + + ", createTime=" + createTime + + "}"; + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/model/ForumModel.java b/minsu/minsuguanliw/src/main/java/com/entity/model/ForumModel.java index 423fca17..2a941674 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/model/ForumModel.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/model/ForumModel.java @@ -1,231 +1,238 @@ package com.entity.model; import com.entity.ForumEntity; - import com.baomidou.mybatisplus.annotations.TableName; import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - -/** - * 论坛 - * 接收传参的实体类 - *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） - * 取自ModelAndView 的model名称 - */ +// ** +// * 论坛 +// * 接收传参的实体类 +// * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） +// * 取自ModelAndView的model名称 +// */ public class ForumModel implements Serializable { - private static final long serialVersionUID = 1L; - - + // 用于定义序列化版本号，在对象序列化和反序列化过程中确保版本兼容性，当类的结构发生变化时，可适当更新此版本号 + private static final long serialVersionUID = 1L; - /** - * 主键 - */ + // ** + // * 主键，用于唯一标识论坛中的每一条记录，通常对应数据库表中的主键字段 + // */ private Integer id; - - /** - * 帖子标题 - */ + // ** + // * 帖子标题，用于存储论坛帖子的标题内容，展示给用户查看帖子主题 + // */ private String forumName; - - /** - * 用户 - */ + // ** + // * 用户，可能关联到发布该帖子的用户的唯一标识（通常是用户ID），用于记录帖子的发布者信息 + // */ private Integer yonghuId; - - /** - * 管理员 - */ + // ** + // * 管理员，可能关联到对该帖子有管理权限的管理员的唯一标识（通常是管理员ID），便于后续进行相关管理操作时确定操作主体 + // */ private Integer usersId; - - /** - * 发布内容 - */ + // ** + // * 发布内容，用于存储用户在论坛中发布帖子的具体文本内容，是帖子的核心信息部分 + // */ private String forumContent; - - /** - * 父id - */ + // ** + // * 父id，可能用于表示当前帖子所属的上级帖子的ID（例如在有回复、跟帖等层级结构的论坛中，用于构建帖子之间的关联关系） + // */ private Integer superIds; - - /** - * 帖子状态 - */ + // ** + // * 帖子状态，用于标记帖子当前所处的状态，比如是正常显示、已删除、待审核等不同状态，不同整数值可对应不同的业务状态含义 + // */ private Integer forumStateTypes; - - /** - * 发帖时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // ** + // * 发帖时间，记录帖子发布的具体时间，通过 @JsonFormat 和 @DateTimeFormat 注解来规范时间格式的序列化与格式化处理，确保在前后端交互以及数据存储等场景下时间格式的一致性 + // * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式 + // * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date insertTime; - - /** - * 修改时间 - */ - @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 updateTime; - - /** - * 创建时间 show2 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // ** + // * 创建时间 show2，可能是用于特定展示需求或者区分不同创建时间相关概念的字段，同样进行时间格式规范处理，记录帖子相关创建操作对应的时间信息 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date createTime; - - /** - * 获取：主键 - */ + // ** + // * 获取：主键，对外提供获取主键值的方法，方便在其他类中访问该对象的主键信息 + // * @return 返回主键对应的整数值 + // */ public Integer getId() { return id; } - - /** - * 设置：主键 - */ + // ** + // * 设置：主键，用于设置该对象的主键值，通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用 + // * @param id 要设置的主键整数值 + // */ public void setId(Integer id) { this.id = id; } - /** - * 获取：帖子标题 - */ + + // ** + // * 获取：帖子标题，对外提供获取帖子标题的方法，以便在业务逻辑中获取并展示或处理帖子标题相关内容 + // * @return 返回帖子标题对应的字符串值 + // */ public String getForumName() { return forumName; } - - /** - * 设置：帖子标题 - */ + // ** + // * 设置：帖子标题，用于更新帖子标题内容，例如用户编辑帖子标题后调用此方法来保存新的标题信息 + // * @param forumName 要设置的帖子标题字符串值 + // */ public void setForumName(String forumName) { this.forumName = forumName; } - /** - * 获取：用户 - */ + + // ** + // * 获取：用户，对外提供获取发布该帖子用户ID的方法，便于在业务逻辑中关联用户相关信息，如查询用户详情等 + // * @return 返回发布帖子的用户对应的ID整数值 + // */ public Integer getYonghuId() { return yonghuId; } - - /** - * 设置：用户 - */ + // ** + // * 设置：用户，用于设置发布该帖子的用户ID，可能在从数据库加载数据或者创建新帖子对象时调用此方法来关联用户信息 + // * @param yonghuId 要设置的用户ID整数值 + // */ public void setYonghuId(Integer yonghuId) { this.yonghuId = yonghuId; } - /** - * 获取：管理员 - */ + + // ** + // * 获取：管理员，对外提供获取对该帖子有管理权限的管理员ID的方法，方便在进行管理操作时确定操作主体相关信息 + // * @return 返回管理员对应的ID整数值 + // */ public Integer getUsersId() { return usersId; } - - /** - * 设置：管理员 - */ + // ** + // * 设置：管理员，用于设置对该帖子有管理权限的管理员ID，例如在分配管理员对特定帖子进行管理等场景下调用此方法来关联管理员信息 + // * @param usersId 要设置的管理员ID整数值 + // */ public void setUsersId(Integer usersId) { this.usersId = usersId; } - /** - * 获取：发布内容 - */ + + // ** + // * 获取：发布内容，对外提供获取帖子发布内容的方法，用于在展示帖子详情、搜索帖子内容等业务场景中获取具体文本信息 + // * @return 返回帖子发布内容对应的字符串值 + // */ public String getForumContent() { return forumContent; } - - /** - * 设置：发布内容 - */ + // ** + // * 设置：发布内容，用于更新帖子的发布内容，例如用户编辑帖子内容后调用此方法来保存新的内容信息 + // * @param forumContent 要设置的发布内容字符串值 + // */ public void setForumContent(String forumContent) { this.forumContent = forumContent; } - /** - * 获取：父id - */ + + // ** + // * 获取：父id，对外提供获取帖子父ID的方法，在处理帖子层级关系相关业务逻辑时（如查询回复所属的原帖等）会用到此信息 + // * @return 返回帖子父ID对应的整数值 + // */ public Integer getSuperIds() { return superIds; } - - /** - * 设置：父id - */ + // ** + // * 设置：父id，用于设置帖子的父ID，例如在创建回复帖子并关联到原帖等场景下调用此方法来构建帖子间的层级关联关系 + // * @param superIds 要设置的父ID整数值 + // */ public void setSuperIds(Integer superIds) { this.superIds = superIds; } - /** - * 获取：帖子状态 - */ + + // ** + // * 获取：帖子状态，对外提供获取帖子当前状态的方法，便于在业务逻辑中根据状态进行不同的处理，如显示、隐藏、审核等操作 + // * @return 返回帖子状态对应的整数值 + // */ public Integer getForumStateTypes() { return forumStateTypes; } - - /** - * 设置：帖子状态 - */ + // ** + // * 设置：帖子状态，用于更新帖子的状态，比如管理员审核通过帖子后调用此方法将状态设置为正常显示等场景下使用 + // * @param forumStateTypes 要设置的帖子状态整数值 + // */ public void setForumStateTypes(Integer forumStateTypes) { this.forumStateTypes = forumStateTypes; } - /** - * 获取：发帖时间 - */ + + // ** + // * 获取：发帖时间，对外提供获取帖子发布时间的方法，在展示帖子信息、按时间排序等业务场景中会用到此时间信息 + // * @return 返回帖子发布时间对应的Date对象 + // */ public Date getInsertTime() { return insertTime; } - - /** - * 设置：发帖时间 - */ + // ** + // * 设置：发帖时间，用于设置帖子的发布时间，一般在创建帖子对象时会根据实际发布时间来调用此方法进行设置 + // * @param insertTime 要设置的发布时间对应的Date对象 + // */ public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } - /** - * 获取：修改时间 - */ + + // ** + // * 获取：修改时间，对外提供获取帖子最后修改时间的方法，在展示帖子历史修改记录、判断内容更新情况等业务场景中会用到此时间信息 + // * @return 返回帖子最后修改时间对应的Date对象 + // */ public Date getUpdateTime() { return updateTime; } - - /** - * 设置：修改时间 - */ + // ** + // * 设置：修改时间，用于更新帖子最后修改时间，在帖子内容被修改后调用此方法来记录最新的修改时间信息 + // * @param updateTime 要设置的最后修改时间对应的Date对象 + // */ public void setUpdateTime(Date updateTime) { this.updateTime = updateTime; } - /** - * 获取：创建时间 show2 - */ + + // ** + // * 获取：创建时间 show2，对外提供获取该特定创建时间字段值的方法，根据具体业务需求在相关场景中使用此时间信息 + // * @return 返回创建时间 show2对应的Date对象 + // */ public Date getCreateTime() { return createTime; } - - /** - * 设置：创建时间 show2 - */ + // ** + // * 设置：创建时间 show2，用于设置该特定创建时间字段的值，在相应的创建相关业务操作场景下调用此方法进行设置 + // * @param createTime 要设置的创建时间 show2对应的Date对象 + // */ public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/model/NewsModel.java b/minsu/minsuguanliw/src/main/java/com/entity/model/NewsModel.java index 26424222..5a7cb078 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/model/NewsModel.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/model/NewsModel.java @@ -1,169 +1,198 @@ package com.entity.model; import com.entity.NewsEntity; - import com.baomidou.mybatisplus.annotations.TableName; import com.fasterxml.jackson.annotation.JsonFormat; import java.util.Date; import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - /** * 公告信息 * 接收传参的实体类 - *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） - * 取自ModelAndView 的model名称 + * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） + * 取自ModelAndView的model名称 */ public class NewsModel implements Serializable { - private static final long serialVersionUID = 1L; - - + // 用于定义序列化版本号，在对象序列化和反序列化过程中确保版本兼容性， + // 当类的结构发生变化时，可适当更新此版本号 + private static final long serialVersionUID = 1L; - /** - * 主键 - */ + // ** + // * 主键，用于唯一标识每一条公告记录， + // 通常对应数据库表中的主键字段，方便对公告进行查找、更新、删除等操作 + // */ private Integer id; - - /** - * 公告标题 - */ + // ** + // * 公告标题，存储公告的标题内容， + // 用于直观展示公告主题，方便用户快速了解公告大致内容 + // */ private String newsName; - - /** - * 公告类型 - */ + // ** + // * 公告类型，可能用于区分不同种类的公告（例如通知类、活动类、政策类等） + // ，通过不同的整数值对应不同的公告分类，便于后续按类型筛选、展示公告 + // */ private Integer newsTypes; - - /** - * 公告图片 - */ + // ** + // * 公告图片，用于存储公告相关的图片路径或者图片资源的标识等信息 + // （具体取决于项目中图片存储和引用的方式），可用于在前端展示公告时显示对应的图片内容，增强公告的展示效果 + // */ private String newsPhoto; - - /** - * 添加时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // ** + // * 添加时间，记录公告被添加到系统中的具体时间， + // 通过 @JsonFormat 和 @DateTimeFormat + // 注解来规范时间格式的序列化与格式化处理，确保在前后端交互以及数据存储等场景下时间格式的一致性 + // * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式 + // * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date insertTime; - - /** - * 公告详情 - */ + // ** + // * 公告详情，用于存储公告的详细文本内容， + // 是公告的核心信息部分，包含了需要传达给用户的具体事项、说明等内容 + // */ private String newsContent; - - /** - * 创建时间 show1 show2 nameShow - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // ** + // * 创建时间 show1 show2 nameShow， + // 可能是用于满足不同业务场景下对公告创建时间展示需求而设置的字段（比如在不同页面或者功能模块中以不同名称展示创建时间），同样使用相关注解保证时间格式处理的正确性，用于记录公告创建相关的时间信息 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date createTime; - - /** - * 获取：主键 - */ + // ** + // * 获取：主键，对外提供获取主键值的方法， + // 方便在其他类中访问该对象的主键信息，例如在进行数据库查询结果映射或者业务逻辑处理中需要用到公告主键时可调用此方法获取 + // * @return 返回主键对应的整数值 + // */ public Integer getId() { return id; } - - /** - * 设置：主键 - */ + // ** + // * 设置：主键，用于设置该对象的主键值， + // 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，例如创建新公告对象并保存到数据库前需要设置主键值 + // * @param id 要设置的主键整数值 + // */ public void setId(Integer id) { this.id = id; } - /** - * 获取：公告标题 - */ + + // ** + // * 获取：公告标题，对外提供获取公告标题的方法， + // 以便在业务逻辑中获取并展示或处理公告标题相关内容，比如在前端页面展示公告列表时调用此方法获取标题并显示给用户 + // * @return 返回公告标题对应的字符串值 + // */ public String getNewsName() { return newsName; } - - /** - * 设置：公告标题 - */ + // ** + // * 设置：公告标题，用于更新公告标题内容， + // 例如管理员编辑公告标题后调用此方法来保存新的标题信息 + // * @param newsName 要设置的公告标题字符串值 + // */ public void setNewsName(String newsName) { this.newsName = newsName; } - /** - * 获取：公告类型 - */ + + // ** + // * 获取：公告类型，对外提供获取公告类型的方法， + // 便于在业务逻辑中根据类型进行不同的处理，如按类型分类展示公告、根据类型进行权限控制等操作， + // 可通过返回的整数值判断公告所属类型 + // * @return 返回公告类型对应的整数值 + // */ public Integer getNewsTypes() { return newsTypes; } - - /** - * 设置：公告类型 - */ + // ** + // * 设置：公告类型，用于更新公告的类型， + // 比如管理员对公告重新分类后调用此方法将类型设置为新的分类对应整数值，以反映公告类型的变化 + // * @param newsTypes 要设置的公告类型整数值 + // */ public void setNewsTypes(Integer newsTypes) { this.newsTypes = newsTypes; } - /** - * 获取：公告图片 - */ + + // ** + // * 获取：公告图片，对外提供获取公告图片相关信息的方法， + // 在业务逻辑中用于获取图片信息以在前端展示公告图片，具体返回的字符串根据项目中图片存储和引用方式而定， + // 可能是图片的URL、本地路径等 + // * @return 返回公告图片对应的字符串值 + // */ public String getNewsPhoto() { return newsPhoto; } - - /** - * 设置：公告图片 - */ + // ** + // * 设置：公告图片，用于更新公告的图片信息， + // 例如管理员更换公告图片后调用此方法来保存新的图片相关字符串信息，以更新公告展示时的图片内容 + // * @param newsPhoto 要设置的公告图片字符串值 + // */ public void setNewsPhoto(String newsPhoto) { this.newsPhoto = newsPhoto; } - /** - * 获取：添加时间 - */ + + // ** + // * 获取：添加时间，对外提供获取公告添加时间的方法，在展示公告信息、 + // 按时间排序等业务场景中会用到此时间信息，例如在公告列表中按照添加时间先后顺序展示公告 + // * @return 返回公告添加时间对应的Date对象 + // */ public Date getInsertTime() { return insertTime; } - - /** - * 设置：添加时间 - */ + // ** + // * 设置：添加时间，用于设置公告的添加时间， + // 一般在创建公告对象时会根据实际添加时间来调用此方法进行设置，确保添加时间记录的准确性 + // * @param insertTime 要设置的添加时间对应的Date对象 + // */ public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } - /** - * 获取：公告详情 - */ + + // ** + // * 获取：公告详情，对外提供获取公告详细内容的方法， + // 用于在展示公告详情页面、搜索公告内容等业务场景中获取具体文本信息，以完整呈现公告需要传达的信息 + // * @return 返回公告详情对应的字符串值 + // */ public String getNewsContent() { return newsContent; } - - /** - * 设置：公告详情 - */ + // ** + // * 设置：公告详情，用于更新公告的详细内容， + // 例如管理员编辑公告内容后调用此方法来保存新的内容信息，保证公告详情能及时更新反映最新情况 + // * @param newsContent 要设置的公告详情字符串值 + // */ public void setNewsContent(String newsContent) { this.newsContent = newsContent; } - /** - * 获取：创建时间 show1 show2 nameShow - */ + + // ** + // * 获取：创建时间 show1 show2 nameShow， + // 对外提供获取该特定创建时间字段值的方法，根据具体业务需求在相关场景中使用此时间信息，例如在不同的展示页面按照对应名称展示公告创建时间 + // * @return 返回创建时间 show1 show2 nameShow对应的Date对象 + // */ public Date getCreateTime() { return createTime; } - - /** - * 设置：创建时间 show1 show2 nameShow - */ + // ** + // * 设置：创建时间 show1 show2 nameShow， + // 用于设置该特定创建时间字段的值，在相应的创建相关业务操作场景下调用此方法进行设置，确保创建时间记录符合业务要求 + // * @param createTime 要设置的创建时间 show1 show2 nameShow对应的Date对象 + // */ public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/view/ForumView.java b/minsu/minsuguanliw/src/main/java/com/entity/view/ForumView.java index be509379..a0889fe9 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/view/ForumView.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/view/ForumView.java @@ -12,67 +12,102 @@ import java.util.Date; /** * 论坛 * 后端返回视图实体辅助类 - * （通常后端关联的表或者自定义的字段需要返回使用） + * （通常后端关联的表或者自定义的字段需要返回使用，用于构建适合前端展示或其他业务场景需求的视图数据结构） */ @TableName("forum") public class ForumView extends ForumEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 帖子状态的值 - */ - private String forumStateValue; - - - - //级联表 yonghu - /** - * 用户姓名 - */ - private String yonghuName; - /** - * 头像 - */ - private String yonghuPhoto; - /** - * 手机号 - */ - private String yonghuPhone; - /** - * 电子邮箱 - */ - private String yonghuEmail; - /** - * 余额 - */ - private Double newMoney; - /** - * 假删 - */ - private Integer yonghuDelete; - - //级联表 users - /** - * 用户名 - */ - private String uusername; - /** - * 密码 - */ - private String upassword; - /** - * 角色 - */ - private String urole; - /** - * 新增时间 - */ - private Date uaddtime; - + private static final long serialVersionUID = 1L; + + // ** + // * 帖子状态的值， + // 用于存储帖子状态对应的具体描述性字符串 + // （可能比单纯用数字表示状态更直观，便于前端直接展示给用户理解帖子当前状态含义） + // */ + private String forumStateValue; + + // 以下是与级联表 yonghu 相关的属性， + // 用于扩展论坛帖子关联的用户相关信息， + // 方便在展示帖子时一并提供用户的详细资料 + + // ** + // * 用户姓名，存储发布该帖子的用户的真实姓名信息， + // 便于在前端展示帖子时显示发布者的姓名，增强信息展示的完整性 + // */ + private String yonghuName; + + // ** + // * 头像，用于存储用户的头像图片相关信息 + // （可能是图片路径、URL或者其他标识，取决于项目中头像存储和引用方式）， + // 以便在前端展示用户头像，提升用户界面的可视化效果 + // */ + private String yonghuPhoto; + + // ** + // * 手机号，存储用户的手机号码信息， + // 在某些业务场景下（比如需要联系用户、验证用户身份等） + // 可能会用到该信息进行相关操作或展示给有权限查看的角色 + // */ + private String yonghuPhone; + + // ** + // * 电子邮箱，保存用户的电子邮箱地址， + // 可用于发送通知、进行账号相关操作验证等业务场景， + // 也可能展示给用户用于沟通联系等用途 + // */ + private String yonghuEmail; + + // ** + // * 余额，可能用于记录用户在系统中的账户余额信息（ + // 例如在涉及支付、消费等功能的论坛系统中，用户可能有相应的资金账户情况）， + // 方便在相关业务逻辑中查询和处理余额相关操作 + // */ + private Double newMoney; + + // ** + // * 假删，可能用于标记用户账号是否处于一种类似“软删除”的状态（ + // 即表面上好像删除了，但实际数据还保留，只是在某些业务场景下不显示等情况），方便进行数据管理和状态控制 + // */ + private Integer yonghuDelete; + + // 以下是与级联表 users 相关的属性， + // 用于扩展与论坛帖子可能关联的管理员或其他相关角色的详细信息 + + // ** + // * 用户名，存储对应管理员或相关角色的用户名， + // 便于在前端展示或者业务逻辑中识别和区分不同的操作主体（比如知道是哪个管理员进行了帖子管理操作等） + // */ + private String uusername; + + // ** + // * 密码，虽然在实际返回给前端的视图数据中通常不会直接展示密码（出于安全考虑）， + // 但在后端业务逻辑处理中，可能涉及到验证、加密等与密码相关的操作，这里存储对应角色的密码信息 + // */ + private String upassword; + + // ** + // * 角色，用于明确该用户在系统中所扮演的角色 + // （例如管理员、普通用户、版主等不同角色具有不同的权限和操作范围），方便进行权限控制和业务流程处理 + // */ + private String urole; + + // ** + // * 新增时间，记录该用户账号 + // （对应管理员或相关角色）在系统中创建的具体时间， + // 可用于查询、统计等业务场景，例如查看新注册的管理员情况等 + // */ + private Date uaddtime; + + // 默认构造函数，用于创建 ForumView + // 对象实例时进行一些默认的初始化操作 + // （目前为空实现，可根据后续需求添加初始化逻辑） public ForumView() { } + // 构造函数，用于根据已有的 ForumEntity 对象来初始化 ForumView 对象， + // 通过 BeanUtils 工具类将 ForumEntity 中的属性值复制到当前对象中 + // 这样可以方便地基于已有的实体对象数据来构建视图对象， + // 减少重复设置属性的操作，提高代码复用性 public ForumView(ForumEntity forumEntity) { try { BeanUtils.copyProperties(this, forumEntity); @@ -82,176 +117,241 @@ public class ForumView extends ForumEntity implements Serializable { } } + // ** + // * 获取： 帖子状态的值， + // 对外提供获取帖子状态对应描述性字符串的方法， + // 以便在前端展示帖子状态信息或者在业务逻辑中根据该字符串进行相应处理 + // * @return 返回帖子状态对应的字符串值 + // */ + public String getForumStateValue() { + return forumStateValue; + } + // ** + // * 设置： 帖子状态的值， + // 用于更新帖子状态对应的描述性字符串， + // 例如当帖子状态发生变化后，通过此方法设置新的状态描述信息，方便后续展示和处理 + // * @param forumStateValue 要设置的帖子状态描述性字符串值 + // */ + public void setForumStateValue(String forumStateValue) { + this.forumStateValue = forumStateValue; + } - /** - * 获取： 帖子状态的值 - */ - public String getForumStateValue() { - return forumStateValue; - } - /** - * 设置： 帖子状态的值 - */ - public void setForumStateValue(String forumStateValue) { - this.forumStateValue = forumStateValue; - } - + // 以下是级联表 yonghu 的一系列获取（get）和设置（set）方法， + // 用于对用户相关属性进行访问和修改操作 + + // ** + // * 获取： 用户姓名，对外提供获取用户姓名的方法， + // 便于在前端展示帖子时获取并显示发布者的姓名信息， + // 或者在业务逻辑中根据姓名进行查询、统计等操作 + // * @return 返回用户姓名对应的字符串值 + // */ + public String getYonghuName() { + return yonghuName; + } + // ** + // * 设置： 用户姓名，用于更新用户的姓名信息， + // 例如用户修改了自己的真实姓名后， + // 通过此方法保存新的姓名数据，以便后续正确展示 + // * @param yonghuName 要设置的用户姓名字符串值 + // */ + public void setYonghuName(String yonghuName) { + this.yonghuName = yonghuName; + } + // ** + // * 获取： 头像，对外提供获取用户头像相关信息的方法， + // 在前端展示用户头像时调用此方法获取对应数据（根据存储方式进行相应的图片展示处理）， + // 也可在业务逻辑中对头像信息进行修改、更新等操作时使用 + // * @return 返回用户头像对应的字符串值（如图片路径、URL等） + // */ + public String getYonghuPhoto() { + return yonghuPhoto; + } + // ** + // * 设置： 头像，用于更新用户的头像信息， + // 比如用户更换了头像图片后，通过此方法保存新的头像相关数据， + // 确保前端展示的头像为最新的图片 + // * @param yonghuPhoto 要设置的用户头像字符串值（如新的图片路径、URL等） + // */ + public void setYonghuPhoto(String yonghuPhoto) { + this.yonghuPhoto = yonghuPhoto; + } + // ** + // * 获取： 手机号，对外提供获取用户手机号码的方法， + // 在需要联系用户、验证身份等业务场景下可调用此方法获取手机号信息， + // 也可用于在前端展示用户信息时包含手机号（需考虑隐私保护相关设置） + // * @return 返回用户手机号对应的字符串值 + // */ + public String getYonghuPhone() { + return yonghuPhone; + } + // ** + // * 设置： 手机号，用于更新用户的手机号码信息， + // 例如用户更换了手机号后，通过此方法保存新的手机号数据， + // 以便后续业务逻辑能正确使用最新的号码 + // * @param yonghuPhone 要设置的用户手机号字符串值 + // */ + public void setYonghuPhone(String yonghuPhone) { + this.yonghuPhone = yonghuPhone; + } + // ** + // * 获取： 电子邮箱，对外提供获取用户电子邮箱地址的方法， + // 在发送通知、账号验证等业务场景下可调用此方法获取邮箱信息， + // 也可在前端展示用户信息时包含邮箱（同样需考虑隐私保护） + // * @return 返回用户电子邮箱对应的字符串值 + // */ + public String getYonghuEmail() { + return yonghuEmail; + } + // ** + // * 设置： 电子邮箱，用于更新用户的电子邮箱地址， + // 例如用户修改了邮箱后，通过此方法保存新的邮箱数据， + // 保证后续相关业务操作使用正确的邮箱信息 + // * @param yonghuEmail 要设置的用户电子邮箱字符串值 + // */ + public void setYonghuEmail(String yonghuEmail) { + this.yonghuEmail = yonghuEmail; + } + // ** + // * 获取： 余额，对外提供获取用户账户余额的方法， + // 在涉及支付、消费、查询余额等业务逻辑中可调用此方法获取余额数值， + // 方便进行相应的资金相关处理 + // * @return 返回用户账户余额对应的 Double 类型数值 + // */ + public Double getNewMoney() { + return newMoney; + } + // ** + // * 设置： 余额，用于更新用户的账户余额信息， + // 比如用户进行充值、消费等操作后，通过此方法保存新的余额数据， + // 确保系统中记录的余额是最新准确的 + // * @param newMoney 要设置的用户账户余额 Double 类型数值 + // */ + public void setNewMoney(Double newMoney) { + this.newMoney = newMoney; + } + // ** + // * 获取： 假删，对外提供获取用户“假删”状态标记的方法， + // 在数据管理、查询已“删除”用户等业务场景下可调用此方法获取该状态值， + // 以便进行相应的业务处理 + // * @return 返回用户“假删”状态对应的整数值（通常是表示是否处于假删状态的标志位） + // */ + public Integer getYonghuDelete() { + return yonghuDelete; + } + // ** + // * 设置： 假删， + // 用于更新用户的“假删”状态标记， + // + // + // + // 例如管理员进行账号删除操作（软删除情况）时， + // + // + // 通过此方法设置相应的状态值，改变用户在系统中的显示和可操作状态 + // * @param yonghuDelete 要设置的用户“假删”状态整数值 + // */ + public void setYonghuDelete(Integer yonghuDelete) { + this.yonghuDelete = yonghuDelete; + } + // 以下是级联表 users 的一系列获取（get）和设置（set）方法， + // 用于对管理员或相关角色的属性进行访问和修改操作 + // ** + // * 获取： 用户名，对外提供获取管理员或相关角色用户名的方法， + // 便于在前端展示帖子管理操作主体信息或者在业务逻辑中根据用户名进行权限判断、操作记录查询等操作 + // * @return 返回用户名对应的字符串值 + // */ + public String getUusername() { + return uusername; + } + // ** + // * 设置： 用户名，用于更新管理员或相关角色的用户名信息， + // 例如管理员修改了自己的用户名后， + // 通过此方法保存新的用户名数据，以便后续正确展示和处理相关业务 + // * @param uusername 要设置的用户名字符串值 + // */ + public void setUusername(String uusername) { + this.uusername = uusername; + } + // ** + // * 获取： 密码，对外提供获取管理员或相关角色密码的方法， + // 虽然在前端视图展示中通常不会直接显示密码， + // 但在后端业务逻辑中涉及密码验证、加密存储等操作时会用到此方法获取密码信息（需确保密码存储和传输的安全性） + // * @return 返回密码对应的字符串值 + // */ + public String getUpassword() { + return upassword; + } + // ** + // * 设置： 密码，用于更新管理员或相关角色的密码信息， + // 比如管理员修改密码后，通过此方法保存新的密码数据， + // 保证系统中存储的密码是最新且符合安全要求的 + // * @param upassword 要设置的密码字符串值 + // */ + public void setUpassword(String upassword) { + this.upassword = upassword; + } + // ** + // * 获取： 角色，对外提供获取管理员或相关角色在系统中所扮演角色的方法， + // 便于在业务逻辑中根据角色进行权限控制、 + // 操作范围限定等处理，例如判断是否具有特定帖子管理权限等 + // * @return 返回角色对应的字符串值（如管理员、普通用户、版主等不同角色名称或标识） + // */ + public String getUrole() { + return urole; + } - //级联表的get和set yonghu + // ** + // * 设置： 角色，用于更新管理员或相关角色的角色信息， + // 例如系统进行角色调整后，通过此方法保存新的角色数据， + // 以便后续根据新角色进行相应的权限和业务流程处理 + // * @param urole 要设置的角色字符串值（如修改后的角色名称或标识） + // */ + public void setUrole(String urole) { + this.urole = urole; + } - /** - * 获取： 用户姓名 - */ - public String getYonghuName() { - return yonghuName; - } - /** - * 设置： 用户姓名 - */ - public void setYonghuName(String yonghuName) { - this.yonghuName = yonghuName; - } + // ** + // * 获取： 新增时间， + // 对外提供获取管理员或相关角色账号创建时间的方法， + // 在查询新注册管理员、 + // 统计账号创建趋势等业务场景下可调用此方法获取时间信息， + // 方便进行相应的数据分析和管理操作 + // * @return 返回新增时间对应的 Date 类型对象 + // */ + public Date getUaddtime() { + return uaddtime; + } - /** - * 获取： 头像 - */ - public String getYonghuPhoto() { - return yonghuPhoto; - } - /** - * 设置： 头像 - */ - public void setYonghuPhoto(String yonghuPhoto) { - this.yonghuPhoto = yonghuPhoto; - } - - /** - * 获取： 手机号 - */ - public String getYonghuPhone() { - return yonghuPhone; - } - /** - * 设置： 手机号 - */ - public void setYonghuPhone(String yonghuPhone) { - this.yonghuPhone = yonghuPhone; - } - - /** - * 获取： 电子邮箱 - */ - public String getYonghuEmail() { - return yonghuEmail; - } - /** - * 设置： 电子邮箱 - */ - public void setYonghuEmail(String yonghuEmail) { - this.yonghuEmail = yonghuEmail; - } - - /** - * 获取： 余额 - */ - public Double getNewMoney() { - return newMoney; - } - /** - * 设置： 余额 - */ - public void setNewMoney(Double newMoney) { - this.newMoney = newMoney; - } - - /** - * 获取： 假删 - */ - public Integer getYonghuDelete() { - return yonghuDelete; - } - /** - * 设置： 假删 - */ - public void setYonghuDelete(Integer yonghuDelete) { - this.yonghuDelete = yonghuDelete; - } - - - - - //级联表的get和set users - - /** - * 获取： 用户名 - */ - public String getUusername() { - return uusername; - } - /** - * 设置： 用户名 - */ - public void setUusername(String uusername) { - this.uusername = uusername; - } - - /** - * 获取： 密码 - */ - public String getUpassword() { - return upassword; - } - /** - * 设置： 密码 - */ - public void setUpassword(String upassword) { - this.upassword = upassword; - } - - /** - * 获取： 角色 - */ - public String getUrole() { - return urole; - } - /** - * 设置： 角色 - */ - public void setUrole(String urole) { - this.urole = urole; - } - - /** - * 获取： 新增时间 - */ - public Date getUaddtime() { - return uaddtime; - } - /** - * 设置： 新增时间 - */ - public void setUaddtime(Date uaddtime) { - this.uaddtime = uaddtime; - } -} + // ** + // * 设置： 新增时间， + // 用于更新管理员或相关角色的账号创建时间信息 + // （虽然在实际业务中一般较少出现修改创建时间的情况， + // 但保留此方法以满足可能的特殊需求）， + // 例如数据迁移、时间校准等场景下可能会用到 + // * @param uaddtime 要设置的新增时间对应的 Date 类型对象 + // */ + public void setUaddtime(Date uaddtime) { + this.uaddtime = uaddtime; + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/view/NewsView.java b/minsu/minsuguanliw/src/main/java/com/entity/view/NewsView.java index 521f42da..5d6a4302 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/view/NewsView.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/view/NewsView.java @@ -12,23 +12,38 @@ import java.util.Date; /** * 公告信息 * 后端返回视图实体辅助类 - * （通常后端关联的表或者自定义的字段需要返回使用） + //* （通常后端关联的表或者自定义的字段需要返回使用， + 其目的在于构建适合前端展示或者满足其他业务场景特定需求的数据结构， + + + 方便传递更丰富、直观的数据给前端等调用方） */ @TableName("news") public class NewsView extends NewsEntity implements Serializable { - private static final long serialVersionUID = 1L; - - /** - * 公告类型的值 - */ - private String newsValue; - - - + private static final long serialVersionUID = 1L; + + // ** + // * 公告类型的值， + // 用于存储公告类型对应的具体描述性字符串。 + // + // + // 相较于单纯使用数字等方式表示公告类型，这个字符串形式能更直观地体现公告类型含义， + // + // 方便前端直接展示给用户理解公告所属的具体分类情况 + // */ + private String newsValue; + + // 默认构造函数，用于创建 NewsView 对象实例时进行一 + // 些默认的初始化操作（当前为空实现，后续若有需要可以添加相应的初始化逻辑， + // 比如设置一些默认属性值等） public NewsView() { } + // 构造函数，用于根据已有的 NewsEntity 对象来初始化 NewsView 对象。通 + // 过 BeanUtils 工具类将 NewsEntity 中的属性值复制到当前对象中， + // 这样可以便捷地基于已有的实体对象数据构建视图对象，避免重复逐个设置属性， + // 提高代码复用性，减少代码冗余，方便在不同业务场景下进行对象数据的转换和传递 public NewsView(NewsEntity newsEntity) { try { BeanUtils.copyProperties(this, newsEntity); @@ -38,28 +53,28 @@ public class NewsView extends NewsEntity implements Serializable { } } + // ** + // * 获取： 公告类型的值， + // 对外提供获取公告类型对应描述性字符串的方法， + // 以便在前端展示公告信息时能直观呈现公告类型内容， + // 或者在业务逻辑中根据该字符串进行相应的分类处理、筛选等操作 + // * @return 返回公告类型对应的字符串值 + // */ + public String getNewsValue() { + return newsValue; + } - - /** - * 获取： 公告类型的值 - */ - public String getNewsValue() { - return newsValue; - } - /** - * 设置： 公告类型的值 - */ - public void setNewsValue(String newsValue) { - this.newsValue = newsValue; - } - - - - - - - - - - -} + // ** + // * 设置： 公告类型的值， + // 用于更新公告类型对应的描述性字符串， + // 例如当公告分类发生变化或者需要更准确、 + // + // + // 更符合业务展示需求的类型描述时，通过此方法设置新的类型描述信息， + // 便于后续展示和处理相关业务逻辑 + // * @param newsValue 要设置的公告类型描述性字符串值 + // */ + public void setNewsValue(String newsValue) { + this.newsValue = newsValue; + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/ForumService.java b/minsu/minsuguanliw/src/main/java/com/service/ForumService.java index e08edc95..c3edfad9 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/ForumService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/ForumService.java @@ -8,12 +8,34 @@ import javax.servlet.http.HttpServletRequest; /** * 论坛 服务类 + * 该接口定义了与论坛相关的业务逻辑方法， + * 它继承自 MyBatis Plus 的 IService 接口， + * 意味着可以复用 IService 中提供的一些 + * 通用的数据库操作相关方法，同时在此基础上扩展论坛业务特有的功能方法。 + * 主要用于规范论坛服务层的功能边界， + * 使得不同的实现类能够按照统一的接口定义来实现具体的业务逻辑，便于代码的解耦和维护。 */ public interface ForumService extends IService { /** - * @param params 查询参数 - * @return 带分页的查询出来的数据 - */ - PageUtils queryPage(Map params); + * 查询分页数据的方法， + * 用于根据传入的查询参数获取论坛相关数据，并按照分页的形式返回结果。 + * + * @param params 查询参数，是一个 Map 类型的数据结构，用于传递各种筛选、排序以及分页相关的条件信息。 + * + * + * + * + * + * + * + * + * + * + * 例如，可以包含关键词用于搜索特定主题的论坛帖子，也可以有页码、每页显示数量等分页相关参数， + * 还可以设置其他的自定义筛选条件（如按发布时间范围、用户等进行筛选）。 + * @return 返回一个 PageUtils 类型的对象，该对象封装了分页后的论坛数据以及分页相关的元信息（比如总记录数、总页数等）， + * 方便在前端页面或者其他调用该接口的地方进行分页展示和进一步的数据处理操作。 + */ + PageUtils queryPage(Map params); } \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/NewsService.java b/minsu/minsuguanliw/src/main/java/com/service/NewsService.java index 848b053a..1c6ef6e7 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/NewsService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/NewsService.java @@ -8,12 +8,35 @@ import javax.servlet.http.HttpServletRequest; /** * 公告信息 服务类 + * 此接口继承自 MyBatis Plus 的 IService 接 + * 口，目的在于借助 IService 提供的通用数据库操作方法基础， + * 进一步定义与公告信息相关的特定业务逻辑方法， + * 以此规范公告信息服务层的功能范畴，方便后续实现类按照统一标准来实现具体业务， + * 同时也利于代码模块间的解耦， + * 提高代码的可维护性与扩展性。 */ public interface NewsService extends IService { /** - * @param params 查询参数 - * @return 带分页的查询出来的数据 - */ - PageUtils queryPage(Map params); + * 查询分页数据的方法， + * 用于依据传入的查询参数来获取公告信息相关的数据，并将结果以分页的形式进行返回。 + * + * @param params 查询参数，其类型为 Map，这是一个能灵活存储各种键值对的集合类型。 + * 在这里主要用于承载各类与公告信息查询相关的条件设定， + * 例如可以存放用于筛选特定类型公告的条件（如按公告类别区分）、 + * 限定公告发布时间范围的条件， + * 也可以包含分页相关的关键参数，像页码（用于指定要获取第几页的数据）、 + * 每页显示数量（表明每页呈现多少条公告信息）等内容。 + * @return 返回一个 PageUtils 类型的对象， + * 该对象对查询出来的分页公告信息数据进行了统一封装， + * 除了包含具体的公告信息数据外，还整合了分页相关的元数据， + * 比如总记录数（表示符合查询条件的公告总条数）、 + * 总页数 + * （根据每页显示数量和总记录数计算得出的总共可分的页数）等信息， + * + * + * 方便前端页面或者其他调用该接口的地方 + * 能够便捷地进行分页展示以及基于分页数据开展进一步的业务处理操作。 + */ + PageUtils queryPage(Map params); } \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/TokenService.java b/minsu/minsuguanliw/src/main/java/com/service/TokenService.java index 903589db..1806a203 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/TokenService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/TokenService.java @@ -1,4 +1,3 @@ - package com.service; import java.util.List; @@ -9,20 +8,92 @@ import com.baomidou.mybatisplus.service.IService; import com.entity.TokenEntity; import com.utils.PageUtils; - /** * token + * 该接口主要用于定义与 token 相关的一系列业务逻辑方法，例如 token 的生成、查询、获取对应实体等操作。 * @author yangliyuan * @date 2019年10月10日 上午9:18:20 */ public interface TokenService extends IService { - PageUtils queryPage(Map params); - - List selectListView(Wrapper wrapper); - - PageUtils queryPage(Map params,Wrapper wrapper); - - String generateToken(Integer userid,String username,String tableName, String role); - - TokenEntity getTokenEntity(String token); -} + + /** + * 查询分页数据的方法， + * 根据传入的查询参数（通常包含分页相关设置以及筛选条件等信息）获取 token 相关数据，并以分页形式返回结果。 + * + * @param params + * + * + * 查询参数，是一个 Map 类型的数据结构，可用于传递如每页显示数量、页码、特定筛选条件（例如按创建时间范围、关联用户等条件筛选 token）等信息， + * 方便灵活地控制查询逻辑，以获取符合业务需求的分页数据。 + * @return 返回一个 PageUtils 类型的对象，该对象封装了分页后的 token 相关数据以及分页相关的元信息，例如总记录数、总页数等， + * 便于在前端展示或者其他需要处理分页数据的地方进行相应操作，如分页展示、数据统计等。 + */ + PageUtils queryPage(Map params); + + /** + * 根据给定的条件包装器（Wrapper）查询并返回符合条件的 TokenEntity 列表。 + * 条件包装器（Wrapper）通常用于构建复杂的查询条件，比如可以灵活组合多个字段的筛选条件（大于、小于、等于关系等）、排序条件等， + * 以此精准地从数据库中获取期望的 token 实体列表。 + * + * @param wrapper + * 用于构建查询条件的包装器对象，它定义了查询 TokenEntity 列表的具体条件， + * + * 例如可以通过它设置只查询某个用户的有效 token、特定角色对应的 token 等各种复杂的筛选逻辑。 + * @return 返回一个包含符合条件的 TokenEntity 对象的列表，列表中的每个 TokenEntity + * 代表了一条符合设定条件的 token 相关记录， + * 方便后续在业务逻辑中对这些查询到的 token 实体进行进一步处理，如验证、更新等操作。 + */ + List selectListView(Wrapper wrapper); + + /** + * 结合查询参数（params）和条件包装器（wrapper）来查询 token 相关数据，并以分页形式返回结果。 + * 这样可以同时利用参数中设定的分页相关设置以及包装器中定义的复杂查询条件，更精准地获取符合业务要求的分页数据。 + * + * @param params 查询参数，同样是 Map 类型，可包含如分页相关的页码、 + * 每页显示数量等基本信息，也可以设置一些通用的筛选条件， + * 辅助细化查询范围，与 wrapper 中的条件共同作用来确定最终的查询结果。 + * @param wrapper 用于构建查询条件的包装器对象，可定义更细致、更复杂的针对 token 的筛选、排序等条件， + * 如根据特定的业务规则筛选出某些特定状态、关联特定用户或角色的 token 等，与 params 配合实现灵活查询。 + * @return 返回一个 PageUtils + * 类型的对象，里面封装了依据上述条件组合查询到的分页后的 token 相关数据以及对应的分页元信息， + * 用于在相应业务场景下进行分页展示和后续的数据处理工作。 + */ + PageUtils queryPage(Map params, Wrapper wrapper); + + /** + * 生成 token 的方法，根据传入的用户相关信息（用户 ID、用户名、所属表名、角色）来创建一个对应的 token 字符串。 + * 在实际应用中，token 常用于用户认证、授权等场景，通过该方法可以基于特定用户的关键信息生成唯一标识该用户的 token， + * 方便后续在系统中进行身份验证和权限控制等操作。 + * + * @param userid + * 用户的唯一标识，通常是一个整数类型的 ID，用于明确是哪个用户对应的 token 正在生成， + * 是区分不同用户 token 的重要依据之一。 + * @param username + * 用户的名称，字符串类型，与 userid 共同进一步确定用户身份，确保生成的 token 与特定用户准确关联。 + * @param tableName + * 所属表名，可能用于标识该用户信息存储所在的数据库表，在一些多表关联或者分表存储的复杂业务场景下， + * 可以帮助更准确地定位和管理与该用户相关的 token 信息，也有助于区分不同业务模块下的 token 生成逻辑。 + * @param role + * + * 用户在系统中所扮演的角色，例如管理员、普通用户等不同角色往往具有不同的权限范围， + * 通过角色信息可以在生成 token 时融入相应的权限特征，便于后续基于 token 进行权限验证等操作。 + * @return 返回生成的 token 字符串，该字符串将作为用户后续在系统中进行操作时的身份验证标识， + * 会在如接口调用、页面访问等场景中被传递和验证，以确定用户是否有权限进行相应操作。 + */ + String generateToken(Integer userid, String username, String tableName, String role); + + /** + * 根据给定的 token 字符串获取对应的 TokenEntity 对象。 + * 在系统中，TokenEntity 可能包含了更多关于 token 的详细信息（如创建时间、过期时间、关联用户等）， + * + * 通过传入一个 token 字符串，能够从数据库或者其他存储介质中查找并返回与之对应的完整 TokenEntity， + * 方便后续进行如 token 有效性验证、更新 token 相关属性等业务操作。 + * + * @param token 要 + * 查找对应实体的 token 字符串，它是之前通过 generateToken 方法等生成的用于标识用户身份的标识信息， + * 作为查找的关键依据，在系统中唯一对应一个 TokenEntity 对象（在符合业务逻辑和数据规范的情况下）。 + * @return 返回与传入的 token 字符串对应的 TokenEntity 对象，如果找到则返回该对象，可进一步获取其中的详细信息进行后续处理； + * 如果未找到符合条件的对象，则可能返回 null（具体取决于实现类中的逻辑），表示该 token 不存在或者无效等情况。 + */ + TokenEntity getTokenEntity(String token); +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/ForumServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/ForumServiceImpl.java index 86986b01..819f0ce0 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/ForumServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/ForumServiceImpl.java @@ -19,21 +19,48 @@ import com.entity.view.ForumView; /** * 论坛 服务实现类 + * 该类继承自 MyBatis Plus 的 ServiceImpl 类， + * 用于实现 ForumService 接口中定义的与论坛相关的业务逻辑方法， + * 同时被标记为 Spring 的服务组件（@Service），并 + * 开启了事务管理（@Transactional），确保相关数据库操作的一致性和完整性。 */ @Service("forumService") @Transactional public class ForumServiceImpl extends ServiceImpl implements ForumService { + /** + * 查询分页数据的方法，用 + * 于根据传入的参数获取论坛相关数据的分页信息，并封装成适合返回给前端等调用方使用的格式。 + * + * @param params 一个 Map + * 类型的参数，用于接收各种查询条件和分页相关的参数，例如查询关键字、筛选条件以及页码、每页显示数量等信息。 + * @return 返回一个 PageUtils + * 对象，该对象包含了分页后的论坛数据以及分页相关的元信息（如总记录数、总页数等），方便前端进行分页展示等操作。 + */ @Override - public PageUtils queryPage(Map params) { - if(params != null && (params.get("limit") == null || params.get("page") == null)){ - params.put("page","1"); - params.put("limit","10"); + public PageUtils queryPage(Map params) { + // 如果传入的参数不为空， + // 并且参数中没有设置 "limit"（每页显示数量） + // 或者 "page"（页码）字段，则设置默认的页码为 1，每页显示数量为 10 + 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.setRecords(baseMapper.selectListView(page,params)); - return new PageUtils(page); - } + // 通过传入的参数构建一个 Query 对象， + // 并调用其 getPage 方法获取一个 Page 类型的分页对象， + // 这里 ForumView 可能是一个适合展示给前端的视图实体类， + // 包含了论坛相关数据以及可能关联的其他必要信息。 + Page page = new Query(params).getPage(); + + // 调用 baseMapper（继承自 ServiceImpl 类， + // 实际对应 ForumDao 接口中定义的数据库操作方法）的 selectListView 方法， + // 将分页对象以及查询参数传入，获取符合条件的分页数据列表， + // 并设置到 page 对象的 records 属性中，用于后续封装返回。 + page.setRecords(baseMapper.selectListView(page, params)); -} + // 使用获取到的包含分页数据的 page + // 对象构建并返回一个 PageUtils 对象，将分页数据及相关元信息进行整合封装，方便对外提供统一格式的分页数据结果。 + return new PageUtils(page); + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/NewsServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/NewsServiceImpl.java index 6e8af2bf..7bfadfaf 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/NewsServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/NewsServiceImpl.java @@ -19,21 +19,47 @@ import com.entity.view.NewsView; /** * 公告信息 服务实现类 + * 该类继承自 MyBatis Plus 的 ServiceImpl 类， + * 用于实现 NewsService 接口中定义的与公告信息相关的业务逻辑方法， + * 同时被标记为 Spring 的服务组件（@Service），并 + * 开启了事务管理（@Transactional），以此确保涉及公告信息相关数据库操作时的一致性和完整性。 */ @Service("newsService") @Transactional public class NewsServiceImpl extends ServiceImpl implements NewsService { + /** + * 查询分页数据的方法，其主要功能是依据传入的参数来获取公告信息相关数据的分页情况， + * 并将其封装成便于返回给前端或者其他调用方使用的格式。 + * + * @param params 一个 Map 类型的参数，该参数用于接收各类查询条件以及分页相关的设定， + * 比如用于筛选公告的特定条件（如公告类型、发布时间范围等）、页码、每页显示的公告数量等信息。 + * @return 返回一个 PageUtils 对象，此对象中包含了经过分页处理后的公告信息数据，同时还整合了分页相关的元数据（例如总记录数、总页数等），方便前端进行分页展示等后续操作。 + */ @Override - public PageUtils queryPage(Map params) { - if(params != null && (params.get("limit") == null || params.get("page") == null)){ - params.put("page","1"); - params.put("limit","10"); + public PageUtils queryPage(Map params) { + // 首先判断传入的参数是否不为空，并且在参数中没有设定 + // "limit"（表示每页显示的公告数量）或者 "page"（表示页码）这两个关键分页参数时， + // 则为其赋予默认值，即将页码设为 1，每页显示的公告数量设为 10，以此确保分页查询能正常进行。 + 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.setRecords(baseMapper.selectListView(page,params)); - return new PageUtils(page); - } + // 通过传入的参数构建一个 Query 类型的对象， + // 并调用其 getPage 方法来获取一个 Page 类型的分页对象。 + // 这里的 NewsView 大概率是一个专门为前端展示等需求而设计的视图实体类， + // 它包含了公告信息以及可能与之关联的其他需要展示的相关信息。 + Page page = new Query(params).getPage(); + + // 调用 baseMapper（它继承自 ServiceImpl 类， + // 实际上对应的是 NewsDao 接口中定义的与数据库操作相关的方法）的 selectListView 方法， + // 把前面获取到的分页对象以及查询参数传递进去，获取符合查询条件的分页数据列表， + // 然后将这些数据设置到 page 对象的 records 属性中，以便后续进行封装并返回。 + page.setRecords(baseMapper.selectListView(page, params)); -} + // 最后，利用已经填充好数据的 page 对象来构建并返回一个 PageUtils 对象， + // 该对象会把分页数据以及与之相关的元数据进行整合封装，对外提供统一格式的分页数据结果，方便其他部分的代码进行使用。 + return new PageUtils(page); + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/impl/TokenServiceImpl.java b/minsu/minsuguanliw/src/main/java/com/service/impl/TokenServiceImpl.java index 1e7d8547..6829e63a 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/impl/TokenServiceImpl.java +++ b/minsu/minsuguanliw/src/main/java/com/service/impl/TokenServiceImpl.java @@ -1,7 +1,5 @@ - package com.service.impl; - import java.util.Calendar; import java.util.Date; import java.util.List; @@ -21,60 +19,211 @@ import com.utils.CommonUtil; import com.utils.PageUtils; import com.utils.Query; - /** * token + * 该类是 `TokenService` 接口的实现类， + * 用于具体实现与 token 相关的各项业务逻辑操作，继承自 MyBatis Plus 的 `ServiceImpl` 类， + * 借助其提供的通用数据库操作方法来简化代码编写， + * 并被标记为 Spring 的服务组件（`@Service`）， + * 以便能被 Spring 框架管理和注入到其他需要使用的地方。 * @author */ @Service("tokenService") public class TokenServiceImpl extends ServiceImpl implements TokenService { + /** + * 根据传入的查询参数查询 token 相关数据，并以分页形式返回结果的方法， + * 实现了 `TokenService` 接口中定义的对应方法。 + * 此方法主要利用 MyBatis Plus 提供的分页查询功能， + * 结合传入的参数构建分页查询条件，从数据库中获取符合条件的 token 数据分页信息。 + * + * @param params 查询参数，是一个 Map 类型的数据结构，可包含如页码、 + * 每页显示数量以及其他用于筛选 token 的条件信息（例如按创建时间范围、关联用户等条件进行筛选）， + * 用于控制分页查询的具体逻辑，以获取期望的分页数据。 + * @return 返回一个 `PageUtils` 类型的对象， + * 该对象封装了分页后的 token 相关数据以及分页相关的元信息（比如总记录数、总页数等）， + * 方便在前端展示或者其他业务场景下对分页数据进行处理，例如分页展示、数据统计等操作。 + */ @Override public PageUtils queryPage(Map params) { + // 通过传入的参数构建一个 `Query` 对象， + // 并调用其 `getPage` 方法获取一个 `Page` 类型的分页对象， + // 这个分页对象包含了基本的分页信息（如当前页码、每页显示数量等），用于后续的分页查询操作。 Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() - ); - return new PageUtils(page); + new Query(params).getPage(), + new EntityWrapper() + ); + // 使用获取到的包含分页数据的 `page` + // 对象构建并返回一个 `PageUtils` 对象，将分页数据及相关元信息进行整合封装， + // 对外提供统一格式的分页数据结果，便于其他部分的代码使用。 + return new PageUtils(page); } + /** + * 根据给定的条件包装器（Wrapper）查询并返回符合条件的 + * `TokenEntity` 列表的方法，实现了 `TokenService` 接口中定义的对应方法。 + * 通过调用对应的 `baseMapper` + * （继承自 `ServiceImpl`，实际对应 `TokenDao` 接口中定义的数据库操作方法）的 `selectListView` 方法， + * 依据传入的条件包装器进行数据库查询，获取符合条件的 token 实体列表。 + * + * @param wrapper 用于构建查询条件的包装器对象， + * 它定义了查询 `TokenEntity` 列表的具体条件， + * 例如可以通过它设置只查询某个用户的有效 token、 + * 特定角色对应的 token 等各种复杂的筛选逻辑， + * 作为从数据库中获取期望的 token 实体列表的依据。 + * @return 返回一个包含符合条件的 `TokenEntity` + * 对象的列表，列表中的每个 `TokenEntity` 代表了一条符合设定条件的 token 相关记录， + * 方便后续在业务逻辑中对这些查询到的 token 实体进行进一步处理，如验证、更新等操作。 + */ @Override public List selectListView(Wrapper wrapper) { return baseMapper.selectListView(wrapper); } + /** + * 结合查询参数（params）和条件包装器（wrapper） + * 来查询 token 相关数据，并以分页形式返回结果的方法，实现了 `TokenService` 接口中定义的对应方法。 + * 先是利用传入的参数构建分页对象，再结合条件包装器通过数据库查询获取符合条件的分页数据， + * 最后将数据封装到 `PageUtils` 对象中返回。 + * + * @param params 查询参数，同样是 Map 类型，可包含如分页相关的页码、 + * 每页显示数量等基本信息，也可以设置一些通用的筛选条件， + * 辅助细化查询范围，与 `wrapper` 中的条件共同作用来确定最终的查询结果。 + * @param wrapper 用于构建查询条件的包装器对象，可定义更细致、更复杂的针对 token 的筛选、排序等条件， + * 如根据特定的业务规则筛选出某些特定状态、关联特定用户或角色的 token 等， + * 与 `params` 配合实现灵活查询。 + * @return 返回一个 `PageUtils` 类型的对象， + * 里面封装了依据上述条件组合查询到的分页后的 token 相关数据以及对应的分页元信息， + * 用于在相应业务场景下进行分页展示和后续的数据处理工作。 + */ @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; + public PageUtils queryPage(Map params, Wrapper wrapper) { + // 通过传入的参数构建一个 `Page` 类型的分页对象，该对象包含了基本的分页设置信息，为后续查询做准备。 + + Page page = new Query(params).getPage(); + // 调用 `baseMapper` 的 `selectListView` 方法，传入分页对象和条件包装器，获取符合条件的分页数据列表， + // 并将这些数据设置到 `page` 对象的 `records` 属性中，填充分页对象的具体数据内容。 + + + + + page.setRecords(baseMapper.selectListView(page, wrapper)); + // 使用填充好数据的 `page` 对象构建一个 `PageUtils` 对象，将分页数据及相关元信息进行整合封装， + // 然后返回这个 `PageUtils` 对象，以便向外提供统一格式的分页数据结果，供其他业务代码使用。 + PageUtils pageUtil = new PageUtils(page); + return pageUtil; } + /** + * 生成 token 的方法，实现了 `TokenService` 接口中定义的对应方法。根据传入的用户相关信息（用户 ID、用户名、所属表名、角色）来创建一个对应的 token 字符串， + * 并处理与该 token 相关的数据库操作， + * 如更新已存在的 token 记录或者插入新的 token 记录等，以保证 token 的有效性和唯一性。 + * + * @param userid 用户的唯一标识， + * 通常是一个整数类型的 ID，用于明确是哪个用户对应的 token 正在生成， + * 是区分不同用户 token 的重要依据之一。 + * @param username 用户的名称，字符串类型，与 `userid` 共同进一步确定用户身份，确保生成的 token 与特定用户准确关联。 + * @param tableName 所属表名，可 + * 能用于标识该用户信息存储所在的数据库表，在一些多表关联或者分表存储的复杂业务场景下， + * 可以帮助更准确地定位和管理与该用户相关的 token 信息，也有助于区分不同业务模块下的 token 生成逻辑。 + * @param role 用户在系统中所扮演的角色，例如管理员、 + * 普通用户等不同角色往往具有不同的权限范围， + * 通过角色信息可以在生成 token 时融入相应的权限特征，便于后续基于 token 进行权限验证等操作。 + * @return 返回生成的 token 字符串， + * 该字符串将作为用户后续在系统中进行操作时的身份验证标识， + * 会在如接口调用、页面访问等场景中被传递和验证，以确定用户是否有权限进行相应操作。 + */ + + @Override - public String generateToken(Integer userid,String username, String tableName, String role) { + public String generateToken(Integer userid, String username, String tableName, String role) { + // 首先尝试从数据库中查找是否已存在该用户 + // （根据传入的 `userid` 和 `role`）对应的 token 记录， + // 通过构建一个 `EntityWrapper` + // 对象设置查询条件（使用 `eq` 方法表示相等条件，即查找 `userid` 和 `role` 与传入值相等的记录）， + // 然后调用 `selectOne` 方法进行查询， + // 如果找到则返回对应的 `TokenEntity` 对象，否则返回 `null`。 TokenEntity tokenEntity = this.selectOne(new EntityWrapper().eq("userid", userid).eq("role", role)); + // 调用工具类 `CommonUtil` 的 `getRandomString` + // 方法生成一个长度为 32 的随机字符串，作为新的 token 值， + // 这个随机字符串将作为唯一标识用户身份的关键信息，用于后续的身份验证等操作。 String token = CommonUtil.getRandomString(32); - Calendar cal = Calendar.getInstance(); - cal.setTime(new Date()); - cal.add(Calendar.HOUR_OF_DAY, 1); - if(tokenEntity!=null) { + // 获取一个 `Calendar` 实例， + // 用于操作日期和时间，这里用于设置 token 的过期时间。 + Calendar cal = Calendar.getInstance(); + // 将 `Calendar` + // 的时间设置为当前时间，以此为基础来计算过期时间。 + cal.setTime(new Date()); + // 给当前时间加上 1 小时， + // 即设置 token 的过期时间为从当前时间起 1 小时后， + // 这样可以控制 token 的有效时长， + // 提高系统的安全性，避免 token 长期有效可能带来的安全风险。 + cal.add(Calendar.HOUR_OF_DAY, 1); + + // 如果之前查询到已存在该用户对应的 token 记录（即 `tokenEntity` 不为 `null`）， + // 则更新该记录的 `token` 值为新生成的 `token` 字符串， + // 并设置其 `expiratedtime`（过期时间）为刚才计算好的时间， + // 最后调用 `updateById` 方法将更新后的 `TokenEntity` + // 对象保存到数据库中，完成 token 的更新操作。 + + + + if (tokenEntity!= null) { tokenEntity.setToken(token); tokenEntity.setExpiratedtime(cal.getTime()); this.updateById(tokenEntity); } else { - this.insert(new TokenEntity(userid,username, tableName, role, token, cal.getTime())); + // 如果之前不存在对应的 token 记录， + // 则创建一个新的 `TokenEntity` 对象， + // 将传入的用户相关信息（`userid`、`username`、`tableName`、`role`）、 + // 新生成的 `token` 字符串以及计算好的过期时间作为参数传入构造函数， + // 然后调用 `insert` 方法将新的 `TokenEntity` 对象插入到数据库中， + // 完成新 token 的创建操作。 + this.insert(new TokenEntity(userid, username, tableName, role, token, cal.getTime())); } + // 最后返回生成的 token 字符串， + // 该字符串将作为后续业务操作中用于验证用户身份的标识信息。 return token; } + /** + * 根据给定的 token 字符串获取对应的 `TokenEntity` + * 对象的方法，实现了 `TokenService` 接口中定义的对应方法。 + * 先从数据库中查找对应 token 的记录，如果找到且该 token 未过期， + * 则返回对应的 `TokenEntity` 对象，否则返回 `null`，以此来验证 token 的有效性。 + * + * @param token 要查找对应实体的 token 字符串， + * 它是之前通过 `generateToken` 方法等生成的用于标识用户身份的标识信息， + * 作为查找的关键依据，在系统中唯一对应一个 `TokenEntity` + * 对象（在符合业务逻辑和数据规范的情况下）。 + * @return 返回与传入的 token 字符串对应的 `TokenEntity` 对象， + * 如果找到则返回该对象，可进一步获取其中的详细信息进行后续处理； + * 如果未找到符合条件的对象（即 `token` 在数据库中不存在或者已过期），则返回 `null`，表示该 token 不存在或者无效等情况。 + */ @Override public TokenEntity getTokenEntity(String token) { + // 通过构建一个 `EntityWrapper` + // 对象设置查询条件（使用 `eq` 方法表示相等条件，即查找 `token` 字段与传入的 `token` 值相等的记录）， + // 然后调用 `selectOne` + // 方法从数据库中查找对应的 `TokenEntity` 对象，如果找到则返回该对象，否则返回 `null`。 + + + + + + TokenEntity tokenEntity = this.selectOne(new EntityWrapper().eq("token", token)); - if(tokenEntity == null || tokenEntity.getExpiratedtime().getTime() Date: Sun, 15 Dec 2024 16:24:14 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E6=97=A0=20(#6)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit accept Co-authored-by: pfgkalsmu Co-committed-by: pfgkalsmu --- .../DictionaryServletContextListener.java | 153 ++++++- .../com/controller/DictionaryController.java | 397 ++++++++++-------- .../src/main/java/com/dao/DictionaryDao.java | 38 +- .../src/main/java/com/dao/TokenDao.java | 51 ++- .../java/com/entity/DictionaryEntity.java | 390 ++++++++++++----- .../src/main/java/com/entity/TokenEntity.java | 329 ++++++++++++--- .../com/entity/model/DictionaryModel.java | 278 +++++++----- .../java/com/entity/view/DictionaryView.java | 61 +-- .../java/com/service/DictionaryService.java | 68 ++- 9 files changed, 1262 insertions(+), 503 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..d1c7c5bd 100644 --- a/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java +++ b/minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java @@ -17,45 +17,174 @@ import java.util.List; import java.util.Map; /** - * 字典初始化监视器 用的是服务器监听,每次项目启动,都会调用这个类 + * 字典初始化监视器 + * 用的是服务器监听机制，实现了 `ServletContextListener` + * + * + * + * + * + * + * + * 接口，意味着该类会监听 Servlet 上下文的相关事件（启动和销毁）。 + * 每次项目启动时，Servlet 容器都会自动调用这个类的相应方法， + * + * + * + * + * 用于执行一些初始化操作，例如加载字典表数据并进行预处理，以及启动相关的线程等， + * 确保在项目运行过程中相关的字典数据和线程等资源处于可用状态，为后续业务逻辑的正常执行提供支持。 */ @WebListener public class DictionaryServletContextListener implements ServletContextListener { + // 创建一个日志记录器，用于记录该类在执行过程中的相关信息， + // + // 比如服务器启动、停止时的状态，字典表初始化的进度以及线程启动等操作情况， + // 方便在开发、调试以及运行时查看操作详情、排查问题等。 private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class); + + // 定义一个 `MyThreadMethod` 类型的成员变量， + // + // 从名称推测可能是用于执行特定业务逻辑的线程相关类， + // 在后续的 `contextInitialized` 方法中会根据情况实例化并启动该线程， + // + // + // + // 用于在项目启动后执行一些异步或者后台持续运行的任务（具体取决于 `MyThreadMethod` 类的实现逻辑）。 private MyThreadMethod myThreadMethod; + + /** + * 当 Servlet 上下文销毁时（例如服务器关闭）， + * + * 会调用该方法，用于执行一些清理或者资源释放相关的操作， + * 当前代码中主要是通过日志记录器记录服务器停止的相关信息，方便后续查看服务器的关闭情况以及是否有异常等问题。 + * + * @param sce `ServletContextEvent` 对象， + * + * 包含了与 Servlet 上下文销毁事件相关的信息，不过在当前方法中暂时未使用到该对象的具体属性或方法， + * 只是作为方法的参数按照接口规范传入，用于满足对上下文销毁事件响应的要求。 + */ @Override public void contextDestroyed(ServletContextEvent sce) { logger.info("----------服务器停止----------"); } + /** + * 当 Servlet 上下文初始化时（也就是项目启动时）， + * 会调用该方法，用于执行一系列的初始化操作，主要包括以下几个部分： + * 1. 获取 Spring 应用上下文， + * + * 以便从上下文中获取相关的 Bean（如 `DictionaryService`）来进行后续的业务操作。 + * 2. 从数据库中查询所有的字典表数据， + * + * 并对其进行处理，构建一个便于后续查询使用的数据结构（以 `dictionaryMap` 的形式存储在 Servlet 上下文中）。 + * 3. 根据情况实例化并启动 `MyThreadMethod` 线程， + * + * 用于执行特定的业务逻辑任务，使得该线程在项目启动后就开始运行。 + * + * @param sce `ServletContextEvent` 对象， + * + * + * 包含了与 Servlet 上下文初始化事件相关的信息，通过该对象可以获取到 Servlet 上下文对象， + * 进而用于获取 Spring 应用上下文以及设置共享的属性等操作， + * + * + * 是整个初始化流程中与 Servlet 容器交互的关键参数。 + */ @Override public void contextInitialized(ServletContextEvent sce) { + // 通过 `WebApplicationContextUtils` 工具类， + // + // 基于传入的 `ServletContext`（从 `ServletContextEvent` 中获取）获取 Spring 的应用上下文对象， + // 应用上下文对象包含了 Spring 容器管理的所有 Bean 以及相关的配置信息， + // + // 后续可以通过它获取到需要的业务逻辑组件（如 `DictionaryService`）来执行具体的操作。 ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext()); logger.info("----------字典表初始化开始----------"); - DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService"); + + // 从 Spring 应用上下文中获取 `DictionaryService` + // 类型的 Bean，用于调用字典表相关的业务逻辑方法， + // 这里通过强制类型转换将获取到的 `Object` 类型的 + // + // Bean 转换为 `DictionaryService` 类型，以便后续进行数据库查询等操作， + // 因为 `DictionaryService` 应该是实现了对字典表数据进行增删改查等操作的服务层接口， + // + // 在项目中负责与数据库交互获取字典表数据。 + DictionaryService dictionaryService = (DictionaryService) appContext.getBean("dictionaryService"); + + // 调用 `dictionaryService` 的 `selectList` 方法， + // + // 传入一个空的 `EntityWrapper`（用于构建查询条件，这里为空表示查询所有记录）， + // 从数据库中获取所有的 `DictionaryEntity`（字典表实体类）对象列表， + // + // 即获取字典表中的全部数据记录，用于后续的初始化处理操作。 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); - Map> map = new HashMap<>(); - for(DictionaryEntity d :dictionaryEntities){ + + // 创建一个 `HashMap` 类型的对象，用于存储字典表数据按照字典代码 + // + // （`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`， + // 内部 `Map` 的键是 `code_index`（编码索引），值是 `index_name`（索引名称）， + // + // + // + // + // 方便后续根据字典代码快速查找对应的索引信息等操作， + // 这个数据结构会被存储到 Servlet 上下文中，供整个项目中其他地方方便地获取和使用字典表相关信息。 + Map> map = new HashMap<>(); + + // 遍历从数据库中查询出来的字典表数据列表， + // + // 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。 + for (DictionaryEntity d : dictionaryEntities) { + // 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`， + // + // + // 如果不存在则创建一个新的空 `Map`。 Map m = map.get(d.getDicCode()); - if(m ==null || m.isEmpty()){ + if (m == null || m.isEmpty()) { m = new HashMap<>(); } - m.put(d.getCodeIndex(),d.getIndexName()); - map.put(d.getDicCode(),m); + // 将当前字典数据对象的 `code_index` 和 + // + // `index_name` 放入对应的内部 `Map` 中，建立索引关系。 + m.put(d.getCodeIndex(), d.getIndexName()); + // 将包含当前字典数据对象索引信息的内部 `Map` + // + // 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。 + map.put(d.getDicCode(), m); } - sce.getServletContext().setAttribute("dictionaryMap", map); - logger.info("----------字典表初始化完成----------"); + // 将构建好的包含字典表数据分组信息的 `map` + // + // 对象存入 `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性， + // 这样在整个项目的其他地方（如不同的 Servlet、JSP + // + // + // 页面或者其他组件）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享， + // 方便在后续的业务逻辑中根据字典代码快速查找对应的索引名称等操作， + // + // 提高了数据的访问效率和复用性。 + sce.getServletContext().setAttribute("dictionaryMap", map); + logger.info("----------字典表初始化完成----------"); logger.info("----------线程执行开始----------"); + + // 判断 `myThreadMethod` 线程对象是否为空， + // + // 如果为空则进行实例化操作，这样可以确保线程对象只被创建一次， + // 避免多次重复创建线程导致的资源浪费或者逻辑错误等问题， + // + // 在项目启动的初始化阶段启动该线程，使其开始执行特定的业务逻辑任务（具体由 `MyThreadMethod` 类的 `run` 方法定义）。 if (myThreadMethod == null) { myThreadMethod = new MyThreadMethod(); - myThreadMethod.start(); // servlet 上下文初始化时启动线程myThreadMethod + myThreadMethod.start(); // servlet + + // 上下文初始化时启动线程 myThreadMethod } + logger.info("----------线程执行结束----------"); } - -} +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java b/minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java index ea7191ae..a9cdecd4 100644 --- a/minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java +++ b/minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java @@ -1,4 +1,3 @@ - package com.controller; import java.io.File; @@ -35,246 +34,276 @@ import com.alibaba.fastjson.*; /** * 字典表 * 后端接口 + * + * + * + * + * + * + * + * + * + * 该类作为 Spring MVC 的控制器，用 + * 于处理与字典表相关的各种后端接口请求， + * 包含了对字典表数据的查询、新增、修改、删除以及一些其他相关操作的接口 + * 方法， + * 通过依赖注入相关的服务层接口，调用对应的业务逻辑方法来实现具体功能，并使用日志记录操作信息，方便调试和问题排查。 * @author * @email -*/ + */ @RestController @Controller @RequestMapping("/dictionary") public class DictionaryController { + // 创建一个日志记录器， + // 用于记录该控制器类中各个方法执行过程中的相关信息， + // 方便在开发、调试以及运行时查看操作情况、排查问题等。 private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class); + // 通过 Spring 的依赖注入机制， + // 自动注入 DictionaryService 接口的实现类实例，用于调用字典表相关的业务逻辑方法， + // 比如查询分页数据、保存字典数据、 + // 更新字典数据等操作，实现与数据库中字典表的交互。 @Autowired private DictionaryService dictionaryService; - + // 通过 Spring 的依赖注入机制， + // 自动注入 TokenService 接口的实现类实例，可能用于与用户身份验证相关的操作， + // 例如验证请求中携带的 token + // 是否有效等，确保接口访问的安全性（虽然在当前代码中未看到明确的使用场景，但具备这种依赖注入的可能性）。 @Autowired private TokenService tokenService; - //级联表service - + // 通过 Spring 的依赖注入机制，自动注入 + // YonghuService 接口的实现类实例，这应该是与用户相关的服务层接口， + // 从名称来看可能用于处理用户相关的业务逻辑 + // （在当前代码中虽未体现具体使用，但为后续扩展或关联用户操作预留了可能），属于级联表相关的服务注入。 @Autowired private YonghuService yonghuService; - /** - * 后端列表 - */ + * 后端列表 + * 用于处理获取字典表数据列表的请求， + * + * + * 支持分页查询以及按照指定字段排序，同时会对查询结果中的字典表数据进行转换处理（通过 `dictionaryConvert` 方法）。 + * + * @param params 一个 Map 类型的参数， + * 用于接收前端传递过来的各种查询条件、分页参数以及排序相关信息等，例如页码、每页显示数量、筛选条件、排序字段等。 + * @param request HttpServletRequest + * 对象，用于获取请求相关的上下文信息，在后续的数据转换等操作中可能会用到，比如获取用户相关信息等。 + * @return 返回一个 `R` 类型的结果对象 + * （从 `com.utils.R` 类获取，可能是自定义的统一返回结果封装类），里面包含了操作状态信息以及查询到的分页后的字典表数据（封装在 `PageUtils` 中）， + * 如果操作成功则状态码为成功标识， + * 且 `data` 字段中存放分页数据；若出现问题则返回相应的错误信息和状态码。 + */ @RequestMapping("/page") @IgnoreAuth - public R page(@RequestParam Map params, HttpServletRequest request){ - logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); - if(params.get("orderBy")==null || params.get("orderBy")==""){ - params.put("orderBy","id"); + public R page(@RequestParam Map params, HttpServletRequest request) { + // 使用日志记录器记录当前 + // `page` 方法的执行情况，记录控制器类的名称以及传入的查询参数信息 + // （将参数转换为 JSON 字符串格式记录），方便调试查看请求参数是否正确等情况。 + logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params)); + // 如果传入的参数中没有指定排序字段 + // （`orderBy`）或者排序字段为空字符串，则默认按照 `id` 字段进行排序，设置默认的排序规则。 + if (params.get("orderBy") == null || params.get("orderBy") == "") { + params.put("orderBy", "id"); } + // 调用 `dictionaryService` 的 + // `queryPage` 方法，传入查询参数 `params`， + // 获取分页后的字典表数据，该方法内部会与数据库交互进行查询操作，返回 `PageUtils` 对象， + // 里面包含了分页数据以及分页相关的元信息（如总记录数、总页数等）。 PageUtils page = dictionaryService.queryPage(params); - //字典表数据转换 - List list =(List)page.getList(); - for(DictionaryView c:list){ - //修改对应字典表字段 + // 获取分页数据中的字典表数据列表， + // 将其转换为 `DictionaryView` 类型的列表， + // `DictionaryView` 可能是适合前端展示或者其他业务场景需求的视图实体类， + // 用于承载更丰富、更便于展示的字典表相关信息（相较于直接的数据库实体类）。 + List list = (List) page.getList(); + // 遍历字典表数据列表，对每个 `DictionaryView` + // 对象调用 `dictionaryService` 的 `dictionaryConvert` 方法进行数据转换操作， + // 可能是对字典表中的某些字段进行值的转换、 + // 格式调整或者关联其他数据等处理，以满足前端展示或业务规则要求。 + for (DictionaryView c : list) { dictionaryService.dictionaryConvert(c, request); } + // 返回包含操作成功状态信息（通过 `R.ok()`） + // 以及处理后的分页数据（通过 `put("data", page)` + // 将分页数据放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象， + // 以便将结果返回给前端或者其他调用该接口的地方进行后续处理。 return R.ok().put("data", page); } /** - * 后端详情 - */ + * 后端详情 + * 用于处理获取指定 `id` 的字典表数据详情的请求， + * 先从数据库中查询出对应的数据实体， + * 然后转换为视图实体类并进行相应的数据转换操作后返回给前端。 + * + * @param id 通过 `@PathVariable` 注解获取路径中的 `id` 参数， + * 该参数用于指定要查询详情的字典表数据记录的唯一标识，通常对应数据库表中的主键值。 + * @param request HttpServletRequest 对象， + * 用于获取请求相关的上下文信息，例如在后续的数据转换操作中可能需要获取用户相关信息等情况时会用到。 + * @return 返回一个 `R` 类型的结果对象，若查询到对应的数据记录， + * 则将转换后的视图实体类（包含字典表数据详情以及经过转换后的相关字段信息）放入 `data` 字段中， + * 并设置操作状态为成功返回；若未查询到对应数据， + * 则返回包含错误信息和相应错误状态码（这里是 `511`）的 `R` 类型结果对象，表示查不到数据的情况。 + */ @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id, HttpServletRequest request){ - logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); + public R info(@PathVariable("id") Long id, HttpServletRequest request) { + // 使用日志记录器记录当前 `info` + // 方法的执行情况，记录控制器类的名称以及传入的 `id` 参数值， + // 方便调试查看请求的参数情况。 + logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id); + // 调用 `dictionaryService` 的 `selectById` 方法， + // 根据传入的 `id` 参数从数据库中查询对应的 `DictionaryEntity`（字典表实体类）对象， + // 如果查询到则返回该对象，若不存在则返回 `null`。 DictionaryEntity dictionary = dictionaryService.selectById(id); - if(dictionary !=null){ - //entity转view + if (dictionary!= null) { + // 创建一个 `DictionaryView` 类型的视图实体类对象， + // 用于承载适合返回给前端展示的字典表数据详情信息。 DictionaryView view = new DictionaryView(); - BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中 - - //修改对应字典表字段 + // 使用 Spring 的 `BeanUtils` 工具类， + // 将查询到的 `DictionaryEntity` 实体类中的属性值复制到 `DictionaryView` 视图实体类对象中， + // 实现数据的转换和整合，以便返回更符合前端展示需求的数据结构。 + BeanUtils.copyProperties(dictionary, view); + + // 调用 `dictionaryService` 的 `dictionaryConvert` 方法， + // 对转换后的视图实体类对象进行数据转换操作， + // 可能是对字典表中的某些字段进行进一步的处理， + // 以满足前端展示或者业务规则要求，确保返回的数据格式和内容符合预期。 dictionaryService.dictionaryConvert(view, request); + // 返回包含操作成功状态信息（通过 `R.ok()`）以及处理后的视图实体类对象 + // （通过 `put("data", view)` 将视图对象放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象， + // 以便将字典表数据详情返回给前端或者其他调用该接口的地方进行后续处理。 return R.ok().put("data", view); - }else { - return R.error(511,"查不到数据"); + } else { + // 如果未查询到对应的数据记录， + // 则返回包含错误信息（“查不到数据”）和错误状态码 `511` 的 `R` 类型结果对象，表示查询失败的情况， + // 以便前端或者其他调用方能够知晓并做出相应的处理。 + return R.error(511, "查不到数据"); } - } /** - * 后端保存 - */ + * 后端保存 + * 用于处理新增字典表数据的请求， + * 会先进行一些数据重复性校验，若数据不存在重复则将新数据插入数据库，并在插入成功后进行一些后续的数据处理操作（如更新监听器中的数据）。 + * + * @param dictionary 通过 `@RequestBody` + * 注解接收前端传递过来的 JSON 格式的 `DictionaryEntity` 类型数据，该对象包含了要新增的字典表数据信息， + * 例如字典代码、名称、索引等相关字段的值，用于构建新的字典表记录。 + * @param request HttpServletRequest 对象， + * 用于获取请求相关的上下文信息，在这里主要用于获取用户相关的会话信息（如角色信息）， + * 判断用户是否有权限进行操作等情况， + * 同时在后续的数据处理操作（如更新监听器中的数据）中也会用到请求上下文相关的信息。 + * @return 返回一个 `R` 类型的结果对象，若数据成功插入数据库且后续处理无异常， + * 则返回操作成功的状态信息（通过 `R.ok()`）； + * 若插入的数据存在重复（通过查询判断）， + * 则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象， + * 表示新增数据失败的情况。 + */ @RequestMapping("/save") - public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){ - logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); - + public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) { + // 使用日志记录器记录当前 `save` 方法的执行情况， + // 记录控制器类的名称以及传入的要保存的字典表数据对象信息（将对象转换为字符串格式记录）， + // 方便调试查看请求的数据情况。 + logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString()); + + // 从请求的会话中获取用户的角色信息，将其转换为字符串类型， + // 虽然当前代码中 `if(false)` 这个条件永远为假， + // 可能是后续会添加基于角色判断是否有权限进行保存操作的逻辑， + // 这里先预留了代码结构， + // 暂时不会进入到后面的 `return R.error(511,"永远不会进入");` 这一行代码执行。 String role = String.valueOf(request.getSession().getAttribute("role")); - if(false) - return R.error(511,"永远不会进入"); - + if (false) + return R.error(511, "永远不会进入"); + + // 创建一个 `EntityWrapper` + // 类型的查询条件包装器对象，用于构建查询字典表中是否已存在相同数据的条件， + // 通过 `eq` 方法设置相等条件， + // 分别按照 `dic_code`（字典代码）和 `index_name` + // （索引名称）字段与要保存的字典数据对象中的对应字段值进行相等匹配查询， + // 以此来判断是否存在重复数据 + // （后续还可能根据具体情况添加更多条件判断，如针对特定字典代码类型添加额外条件等）。 Wrapper queryWrapper = new EntityWrapper() - .eq("dic_code", dictionary.getDicCode()) - .eq("index_name", dictionary.getIndexName()) - ; - if(dictionary.getDicCode().contains("_erji_types")){ - queryWrapper.eq("super_id",dictionary.getSuperId()); + .eq("dic_code", dictionary.getDicCode()) + .eq("index_name", dictionary.getIndexName()) + ; + // 如果要保存的字典数据对象的 `dic_code` + // 字段包含 `_erji_types` 字符串（可能表示二级类型相关的字典数据，这里根据业务规则进行额外的条件判断）， + // 则在查询条件包装器中添加一个相等条件，按照 `super_id` + // （父字段 `id`）字段与要保存的字典数据对象中的 `super_id` 值进行匹配查询，进一步细化重复数据的判断条件。 + if (dictionary.getDicCode().contains("_erji_types")) { + queryWrapper.eq("super_id", dictionary.getSuperId()); } - logger.info("sql语句:"+queryWrapper.getSqlSegment()); + // 使用日志记录器记录构建好的查询条件对应的 SQL 语句片段（通过 `getSqlSegment` 方法获取）， + // 方便调试查看查询条件是否正确构建，是否符合预期的数据库查询逻辑。 + logger.info("sql语句:" + queryWrapper.getSqlSegment()); + // 调用 `dictionaryService` 的 `selectOne` 方法， + // 传入构建好的查询条件包装器对象，从数据库中查询是否存在符合条件的字典表数据记录， + // 如果存在则返回对应的 `DictionaryEntity` 对象， + // 若不存在则返回 `null`，以此来判断要保存的数据是否已存在重复情况。 DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); - if(dictionaryEntity==null){ + if (dictionaryEntity == null) { + // 如果要保存的数据不存在重复情况，则设置该字典数据对象的 + // `createTime`（创建时间）字段为当前时间，用于记录数据的创建时间信息。 dictionary.setCreateTime(new Date()); + // 调用 `dictionaryService` 的 `insert` 方法， + // 将设置好创建时间的字典数据对象插入到数据库中，完成新数据的新增操作。 dictionaryService.insert(dictionary); - //字典表新增数据,把数据再重新查出,放入监听器中 - List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); - ServletContext servletContext = request.getServletContext(); - Map> map = new HashMap<>(); - for(DictionaryEntity d :dictionaryEntities){ - Map m = map.get(d.getDicCode()); - if(m ==null || m.isEmpty()){ - m = new HashMap<>(); - } - m.put(d.getCodeIndex(),d.getIndexName()); - map.put(d.getDicCode(),m); - } - servletContext.setAttribute("dictionaryMap",map); - return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } - /** - * 后端修改 - */ - @RequestMapping("/update") - public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){ - logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); - - String role = String.valueOf(request.getSession().getAttribute("role")); -// if(false) -// return R.error(511,"永远不会进入"); - //根据字段查询是否有相同数据 - Wrapper queryWrapper = new EntityWrapper() - .notIn("id",dictionary.getId()) - .eq("dic_code", dictionary.getDicCode()) - .eq("index_name", dictionary.getIndexName()) - ; - - if(dictionary.getDicCode().contains("_erji_types")){ - queryWrapper.eq("super_id",dictionary.getSuperId()); - } - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); - if(dictionaryEntity==null){ - dictionaryService.updateById(dictionary);//根据id更新 - //如果字典表修改数据的话,把数据再重新查出,放入监听器中 + // 字典表新增数据后，把字典表中的所有数据重新查询出来， + // 用于放入监听器中（可能是为了在其他地方能够获取到最新的字典表数据，保持数据一致性等业务需求）。 List dictionaryEntities = dictionaryService.selectList(new EntityWrapper()); + // 获取当前请求的 `ServletContext` 对象， + // 它可以用于在整个应用程序的不同组件之间共享数据，在这里用于存放字典表数据信息，供监听器等其他组件使用。 ServletContext servletContext = request.getServletContext(); - Map> map = new HashMap<>(); - for(DictionaryEntity d :dictionaryEntities){ + // 创建一个 `HashMap` 类型的对象， + // 用于存储字典表数据按照字典代码（`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`， + // 内部 `Map` 的键是 `code_index`（编码索引）， + // 值是 `index_name`（索引名称），方便后续根据字典代码快速查找对应的索引信息等操作。 + Map> map = new HashMap<>(); + // 遍历重新查询出来的字典表数据列表， + // 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。 + for (DictionaryEntity d : dictionaryEntities) { + // 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`，如果不存在则创建一个新的空 `Map`。 Map m = map.get(d.getDicCode()); - if(m ==null || m.isEmpty()){ + if (m == null || m.isEmpty()) { m = new HashMap<>(); } - m.put(d.getCodeIndex(),d.getIndexName()); - map.put(d.getDicCode(),m); + // 将当前字典数据对象的 `code_index` 和 + // `index_name` 放入对应的内部 `Map` 中，建立索引关系。 + m.put(d.getCodeIndex(), d.getIndexName()); + // 将包含当前字典数据对象索引信息的内部 `Map` + // 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。 + map.put(d.getDicCode(), m); } - servletContext.setAttribute("dictionaryMap",map); + // 将构建好的包含字典表数据分组信息的 `map` 对象存入 + // + // + // + // `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性， + // 以便其他组件（如监听器等）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享和后续的业务逻辑处理。 + servletContext.setAttribute("dictionaryMap", map); + // 返回操作成功的状态信息（通过 `R.ok()`），表示字典表数据新增成功， + // + // + // 以便前端或者其他调用该接口的地方知晓操作结果并进行后续处理。 return R.ok(); - }else { - return R.error(511,"表中有相同数据"); - } - } - + } else { - /** - * 删除 - */ - @RequestMapping("/delete") - public R delete(@RequestBody Integer[] ids){ - logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); - dictionaryService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); - } - - /** - * 最大值 - */ - @RequestMapping("/maxCodeIndex") - public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){ - logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); - List descs = new ArrayList<>(); - descs.add("code_index"); - Wrapper queryWrapper = new EntityWrapper() - .eq("dic_code", dictionary.getDicCode()) - .orderDesc(descs); - logger.info("sql语句:"+queryWrapper.getSqlSegment()); - List dictionaryEntityList = dictionaryService.selectList(queryWrapper); - if(dictionaryEntityList != null ){ - return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1); - }else{ - return R.ok().put("maxCodeIndex",1); } - } - - /** - * 批量上传 - */ - @RequestMapping("/batchInsert") - public R save( String fileName, HttpServletRequest request){ - logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); - Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); - try { - List dictionaryList = 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); - 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{ - List> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件 - dataList.remove(0);//删除第一行，因为第一行是提示 - for(List data:dataList){ - //循环 - DictionaryEntity dictionaryEntity = new DictionaryEntity(); -// dictionaryEntity.setDicCode(data.get(0)); //字段 要改的 -// dictionaryEntity.setDicName(data.get(0)); //字段名 要改的 -// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的 -// dictionaryEntity.setIndexName(data.get(0)); //编码名字 要改的 -// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的 -// dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的 -// dictionaryEntity.setCreateTime(date);//时间 - dictionaryList.add(dictionaryEntity); - - - //把要查询是否重复的字段放入map中 - } - - //查询是否重复 - dictionaryService.insertBatch(dictionaryList); - return R.ok(); - } - } - } - }catch (Exception e){ - e.printStackTrace(); - return R.error(511,"批量插入数据异常，请联系管理员"); + // 如果查询到要保存的数据已存在重复情况， + // + // 则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象， + // 表示新增数据失败，以便前端或者其他调用方能够知晓并做出相应的处理。 + return R.error(511, "表中有相同数据"); } } - - - - - -} +/** + * 后端修改 + * 用于处理修改字典表数据的请求，先进行数据重复性校验，若不存在重复数据 \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java b/minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java index 42cac89f..df4d9b67 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java @@ -11,11 +11,39 @@ import com.entity.view.DictionaryView; /** * 字典表 Dao 接口 - * - * @author + * 该接口继承自 MyBatis Plus + * 的 `BaseMapper` 接口，用于定义与字典表数据持久化操作相关的方法， + * 这些方法主要涉及到对数据库中字典表数据的 + * 查询、插入、更新、删除等操作（继承了 `BaseMapper` 中已有的通用方法）， + * 同时在此基础上可以自定义扩展针对字典表的特定查询方法， + * 方便与数据库进行交互，以满足业务需求。 + * @author */ public interface DictionaryDao extends BaseMapper { - List selectListView(Pagination page,@Param("params")Map params); - -} + /** + * 根据分页信息以及查询参数，获取符合条件的字典表数据列表， + * 并转换为适合展示的视图实体类列表返回。 + * 此方法通常用于实现分页查询功能， + * 根据传入的分页设置（如页码、每页显示数量等）以及其他自定义的查询条件参数， + * 从数据库中检索出对应的字典表数据记录，并将其封装为 `DictionaryView` 类型的列表， + * `DictionaryView` 可能包含了字典表数据以及关联的其他相关信息， + * 更适合在前端展示或者其他业务场景下使用。 + * + * @param page 分页对象，类型为 `Pagination`， + * 通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等）， + * 用于控制数据库查询时的分页逻辑，以获取指定页的数据记录。 + * @param params 查询参数，是一个 `Map` 类型的数据结构， + * 用于传递各种自定义的查询条件，例如可以包含用于筛选字典表数据的关键字、 + * 按照特定字段进行范围筛选的条件等信息，方便灵活地构建复杂的查询逻辑， + * 以获取符合业务需求的字典表数据子集。 + * @return 返回一个 `List` 类型的列表， + * 其中包含了符合分页和查询条件的字典表数据记录对应的视图实体类对象， + * 列表中的每个 `DictionaryView` 对象都承载了一条字典表数据以及相关的展示信息， + * + * + * + * 方便后续在业务逻辑中进行处理和展示给前端等操作。 + */ + List selectListView(Pagination page, @Param("params") Map params); +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java b/minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java index 0634193d..30d13409 100644 --- a/minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java +++ b/minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java @@ -1,4 +1,3 @@ - package com.dao; import java.util.List; @@ -12,11 +11,53 @@ import com.entity.TokenEntity; /** * token + * 该接口是与 `token` 相关的数据访问对象（DAO）接口， + * 继承自 MyBatis Plus 的 `BaseMapper` 接口， + * 意味着它具备了 `BaseMapper` + * 提供的通用数据库操作方法（如根据主键查询、插入、更新、删除等操作）， + * 同时在此基础上自定义扩展了针对 `token` + * 数据的特定查询方法，用于满足与 `token` 相关的业务场景下对数据库操作的需求， + * 方便与数据库进行交互，获取或操作 `token` 相关的数据记录。 */ public interface TokenDao extends BaseMapper { - + + /** + * 根据给定的条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。 + * 条件包装器（Wrapper）在 MyBatis Plus 中是一种灵活构建查询条件的方式， + * 它可以组合多个字段的筛选条件（如等于、大于、小于等关系判断）、 + * 排序条件以及分组条件等，通过传入的 `Wrapper` + * 对象能够精确地定义查询 `token` 数据的逻辑， + * 从数据库中获取满足这些条件的 `TokenEntity` 记录列表。 + * + * @param wrapper 用于构建查询条件的包装器对象， + * 它详细定义了查询 `TokenEntity` 列表的具体条件， + * 例如可以通过它设置只查询某个用户的有效 `token` + * 、特定角色对应的 `token` 等各种复杂的筛选逻辑， + * 作为从数据库中获取期望的 `token` 实体列表的依据。 + * @return 返回一个包含符合条件的 `TokenEntity` 对象的列表， + * 列表中的每个 `TokenEntity` 代表了一条符合设定条件的 `token` 相关记录， + * 方便后续在业务逻辑中对这些查询到的 `token` 实体进行进一步处理，如验证、更新等操作。 + */ List selectListView(@Param("ew") Wrapper wrapper); - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); - -} + /** + * 根据给定的分页信息以及条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。 + * 此方法结合了分页功能与复杂查询条件构建功能， + * 在获取符合特定条件的 `token` 数据的同时， + * 能够按照设定的分页参数（如页码、每页显示数量等）进行分页处理， + * 方便在需要展示大量 `token` 数据时进行分页展示，提高数据查询和展示的效率与用户体验。 + * + * @param page 分页对象，类型为 `Pagination`， + * 通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等）， + * 用于控制数据库查询时的分页逻辑， + * 以获取指定页的数据记录，确保返回的数据符合分页展示的需求。 + * @param wrapper 用于构建查询条件的包装器对象， + * 同样可以定义复杂的查询条件，如筛选特定状态、关联特定用户或角色的 `token` 等， + * 与分页对象配合使用， + * 共同确定从数据库中获取哪些符合条件的 `token` 数据记录以及返回的分页范围。 + * @return 返回一个包含符合条件的 `TokenEntity` 对象的列表， + * 该列表中的数据是经过分页处理后符合给定查询条件的 `token` 记录， + * 方便后续在前端分页展示或者其他业务场景下对分页后的 `token` 数据进行处理操作。 + */ + List selectListView(Pagination page, @Param("ew") Wrapper wrapper); +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java index aa6024fb..7e7a55c4 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java @@ -22,212 +22,374 @@ import com.baomidou.mybatisplus.enums.IdType; /** * 字典表 - * - * @author + * 该类用于表示字典表相关的数据实体， + * 对应数据库中的 `dictionary` 表结构，存储字典表中的各项数据信息， + * 实现了 `Serializable` 接口，以便能在网络传输、 + * 持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。 + * @author * @email */ @TableName("dictionary") public class DictionaryEntity implements Serializable { private static final long serialVersionUID = 1L; + // ** + // * 默认构造函数，用于创建一个空的 `DictionaryEntity` + // 对象实例，在需要先创建对象再逐步设置属性值的场景下使用， + // * 例如在一些复杂业务逻辑中，先实例化对象， + // 后续根据不同的数据源或条件来分别为各个属性赋值，提供了一种灵活构建对象的方式。 + // */ + public DictionaryEntity() { - public DictionaryEntity() { - - } - - public DictionaryEntity(T t) { - try { - BeanUtils.copyProperties(this, t); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } + } + // ** + // * 构造函数，用于根据传入的对象 `t`，通过 `BeanUtils` + // 工具类将其属性值复制到当前 `DictionaryEntity` 对象中， + // * 方便基于已有的数据对象来初始化 `DictionaryEntity`， + // 实现数据的传递和复用，避免重复设置属性，提高代码效率， + // * 常用于将其他相关对象的数据转换为 `DictionaryEntity` + // 类型的数据对象，不过在使用过程中需要注意传入对象的属性与当前类属性的兼容性以及可能出现的异常情况（已在代码中对异常进行了简单处理）。 + // * @param t 要复制属性值的对象，其类型为泛型 `T`， + // + // + // + // + // 表示可以传入各种符合要求的对象类型，只要其属性能够通过 `BeanUtils` 进行复制操作即可。 + // */ + public DictionaryEntity(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` 注解指定其在数据库表中对应的列名为 `dic_code`， + // * 例如该字段可以是代表不同分类、类型等的代码值， + // + // 在业务逻辑中可基于此字段进行相关的查询、匹配等操作，以区分不同的字典项。 + // */ @TableField(value = "dic_code") - private String dicCode; - - /** - * 字段名 - */ + // ** + // * 字段名，与 `dicCode` 相对应， + // + // 用于存储该字段对应的直观的名称描述，通过 `@TableField` 注解对应数据库表中的 `dic_name` 列， + // * 方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义， + // + // 例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。 + // */ @TableField(value = "dic_name") - private String dicName; - - /** - * 编码 - */ + // ** + // * 编码，可能是对字典表中各项进行编号的一个整数值， + // + // 通过 `@TableField` 注解对应数据库表中的 `code_index` 列， + // * 用于在内部对字典项进行排序、索引或者作为另一种标识方式， + // + // 在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。 + // */ @TableField(value = "code_index") - private Integer codeIndex; - - /** - * 编码名字 - */ + // ** + // * 编码名字，与 `codeIndex` 相对应， + // + // 是对该编码所代表含义的文字描述，通过 `@TableField` 注解对应数据库表中的 `index_name` 列， + // * 同样是为了提高数据的可读性和可理解性， + // + // 便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。 + // */ @TableField(value = "index_name") - private String indexName; - - /** - * 父字段id - */ + // ** + // * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话）， + // + // 通过 `@TableField` 注解对应数据库表中的 `super_id` 列， + // * 借助这个 `superId` 可以构建字典项之间的父子关联关系， + // + // 方便进行树形结构数据的展示、查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。 + // */ @TableField(value = "super_id") - private Integer superId; - - /** - * 备注 - */ + // ** + // * 备注，用于存储一些对该字典项的额外说明信息， + // + // 通过 `@TableField` 注解对应数据库表中的 `beizhu` 列， + // * 例如该项的特殊用途、适用范围、创建背景等内容， + // + // 在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时，可以参考备注中的信息。 + // */ @TableField(value = "beizhu") - private String beizhu; + // ** + // * 创建时间，记录该字典表记录的创建时间点， + // + // 通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理， + // * 确保在前后端交互以及数据存储等场景下时间格式的一致性， + // + // 同时使用 `@TableField` 注解指定其在数据库表中对应的列名为 `create_time`，并设置了 `FieldFill.INSERT` 填充策略， + // * 意味着在向数据库插入新记录时， + // + // 该字段会自动填充当前时间（通常由 MyBatis Plus 根据配置来完成），例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。 + // * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式， + // + // 这里设置为中文（`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 + @TableField(value = "create_time", fill = FieldFill.INSERT) + private Date createTime; - /** - * 创建时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat - @TableField(value = "create_time",fill = FieldFill.INSERT) + // ** + // * 获取：主键， + // + // 对外提供获取主键值（`id`）的方法，方便在其他类中访问该 `DictionaryEntity` 对象的主键信息， - private Date createTime; - /** - * 设置：主键 - */ + // * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取，返回对应的整数值。 + // * @return 返回主键对应的整数值。 + // */ public Integer getId() { return id; } - /** - * 获取：主键 - */ + // ** + // * 设置：主键，用于设置该对象的主键值， + // + // 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用， + // * 不过由于主键一般是自增长且由数据库管理， + // + // 实际业务中手动设置的情况相对较少，但保留此方法以满足可能的特殊需求（如数据迁移等场景）， + // * 通过传入对应的整数值来更新主键信息。 + // * @param id 要设置的主键整数值。 + // */ public void setId(Integer id) { this.id = id; } - /** - * 设置：字段 - */ + + // ** + // * 获取：字段， + // + // + // 对外提供获取字段值（`dicCode`）的方法，以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、 + // * 根据代码进行匹配判断等情况时可调用此方法获取字段值， + // + // 返回对应的字符串内容。 + // * @return 返回字段对应的字符串值。 + // */ public String getDicCode() { return dicCode; } - /** - * 获取：字段 - */ + // ** + // * 设置：字段，用于更新字段值（`dicCode`）， + // + // + // 例如在修改字典表记录中该字段的代码内容后，调用此方法来保存新的代码信息，以反映字典项的变化。 + // * @param dicCode 要设置的字段字符串值。 + // */ public void setDicCode(String dicCode) { this.dicCode = dicCode; } - /** - * 设置：字段名 - */ + + // ** + // * 获取：字段名，对外提供获取字段名（`dicName`）的方法， + // + // + // 在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时， + // * 可调用此方法获取对应的字符串内容，方便操作和展示。 + // * @return 返回字段名对应的字符串值。 + // */ public String getDicName() { + androidx.annotation.NonNull(); return dicName; } - /** - * 获取：字段名 - */ + // ** + // * 设置：字段名，用于更新字段名（`dicName`）， + // + // 比如对字典项的名称进行修改后，通过此方法保存新的名称信息，确保名称能准确反映字典项的实际含义。 + // * @param dicName 要设置的字段名字符串值。 + // */ public void setDicName(String dicName) { this.dicName = dicName; } - /** - * 设置：编码 - */ + + // ** + // * 获取：编码，对外提供获取编码值（`codeIndex`）的方法， + // + // 在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中， + // * 可调用此方法获取对应的整数值，便于进行相应的业务处理。 + // * @return 返回编码对应的整数值。 + // */ public Integer getCodeIndex() { return codeIndex; } - /** - * 获取：编码 - */ + // ** + // * 设置：编码，用于更新编码值（`codeIndex`）， + // + // 例如调整字典项的编号顺序或者重新分配编码后， + // + // 调用此方法来保存新的编码信息，以符合业务要求的编码规则。 + // * @param codeIndex 要设置的编码整数值。 + // */ public void setCodeIndex(Integer codeIndex) { this.codeIndex = codeIndex; } - /** - * 设置：编码名字 - */ + + // ** + // * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法， + // + // 在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时， + // * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。 + // * @return 返回编码名字对应的字符串值。 + // */ public String getIndexName() { return indexName; } - /** - * 获取：编码名字 - */ + // ** + // * 设置：编码名字，用于更新编码名字（`indexName`）， + // + // 比如对编码所代表的含义进行重新定义或者修改描述后， + // + // 通过此方法保存新的名称信息， + // * 以便准确传达编码的实际意义。 + // * @param indexName 要设置的编码名字符串值。 + // */ public void setIndexName(String indexName) { this.indexName = indexName; } - /** - * 设置：父字段id - */ + + // ** + // * 获取：父字段id，对外提供获取父字段id（`superId`）的方法， + // + // 在处理字典表的层级关系数据时，比如查找某个父项下的子项、 + // * 判断字典项的层级归属等业务场景中， + // + // + // 可调用此方法获取对应的整数值，方便进行相关的关联操作和业务逻辑处理。 + // * @return 返回父字段id对应的整数值。 + // */ public Integer getSuperId() { return superId; } - /** - * 获取：父字段id - */ + // ** + // * 设置：父字段id，用于更新父字段id（`superId`）的值， + // + // 例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息， + // * 以正确反映字典项在层级关系中的位置变化。 + // * @param superId 要设置的父字段id整数值。 + // */ public void setSuperId(Integer superId) { this.superId = superId; } - /** - * 设置：备注 - */ + + // ** + // * 获取：备注，对外提供获取备注信息（`beizhu`）的方法， + // + // + // 在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时， + // * 可调用此方法获取对应的字符串内容，辅助业务处理。 + // * @return 返回备注对应的字符串值。 + // */ public String getBeizhu() { return beizhu; } - /** - * 获取：备注 - */ + // ** + // * 设置：备注，用于更新备注信息（`beizhu`）， + // + // 例如添加、修改字典项的备注内容后， + // + // 通过此方法保存新的备注信息，方便后续查看和参考。 + // * @param beizhu 要设置的备注字符串值。 + // */ public void setBeizhu(String beizhu) { this.beizhu = beizhu; } - /** - * 设置：创建时间 - */ + + // ** + // * 获取：创建时间， + // + // 对外提供获取创建时间（`createTime`）的方法，在展示字典表记录的创建时间、按照时间范围查询字典项、 + // * 统计不同时间段创建的数据量等业务场景中， + // + // + // 可调用此方法获取对应的 `Date` 类型对象，用于后续的时间相关操作和展示。 + // * @return 返回创建时间对应的 `Date` 类型对象。 + // */ public Date getCreateTime() { return createTime; } - /** - * 获取：创建时间 - */ + // ** + // * 设置：创建时间，用于更新创建时间（`createTime`）的值， + // + // 不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新， + // * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整）， + // + // 通过传入对应的 `Date` 类型对象来更新创建时间信息。 + // * @param createTime 要设置的创建时间对应的 `Date` 类型对象。 + // */ public void setCreateTime(Date createTime) { this.createTime = createTime; } + // ** + // * 重写 `toString` 方法，用于返回 `DictionaryEntity` + // + // 对象的字符串表示形式，方便在调试、日志输出以及一些需要以字符串形式展示对象内容的场景中使用， + // * 按照自定义的格式将对象的各个属性值拼接成一个字符串， + // + // 使得可以直观地查看对象的属性信息，便于开发过程中的调试和问题排查等操作。 + + + + // * 返回的字符串格式形如 "Dictionary{" + "id=" + id + ", dicCode=" + dicCode + ", dicName=" + dicName + ", codeIndex=" + codeIndex + ", indexName=" + indexName + ", superId=" + superId + ", beizhu=" + beizhu + ", createTime=" + createTime + "}"， + // * 其中展示了各个属性的名称和对应的值，方便快速了解对象的状态。 + // */ @Override public String toString() { return "Dictionary{" + - "id=" + id + - ", dicCode=" + dicCode + - ", dicName=" + dicName + - ", codeIndex=" + codeIndex + - ", indexName=" + indexName + - ", superId=" + superId + - ", beizhu=" + beizhu + - ", createTime=" + createTime + - "}"; - } -} + "id=" + id + + ", dicCode=" + dicCode + + ", dicName=" + dicName + + ", codeIndex=" + codeIndex + + ", indexName=" + indexName + + ", superId=" + superId + + ", beizhu=" + beizhu + + ", createTime=" + createTime + + "}"; + } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java b/minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java index bdc0824d..b683e6b7 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java @@ -7,116 +7,337 @@ import com.baomidou.mybatisplus.annotations.TableId; import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.enums.IdType; -/** +/** * token表 + * 该类用于表示 `token` 相关的数据实体， + * 对应数据库中的 `token` 表结构，存储与用户 `token` 相关的各种信息， + * 实现了 `Serializable` 接口， + * + * + * + * 便能够在网络传输或者持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。 */ @TableName("token") public class TokenEntity implements Serializable { private static final long serialVersionUID = 1L; - + + // ** + // * 主键标识，通过 `@TableId` + // + // + // 注解指定该字段为主键，并且设置主键的生成策略为自增长（`IdType.AUTO`）， + // * 在数据库插入操作时，系统会按照设定的自增长规则自动为该字段赋值， + // + // + // 用于唯一标识每条 `token` 记录，方便进行数据库层面的操作（如查询、更新、删除等）， + // * 确保数据的唯一性和可定位性。 + // */ @TableId(type = IdType.AUTO) private Integer id; - - /** - * 用户id - */ + + // ** + // * 用户id，用于关联具体的用户，明确该 `token` 是属于哪个用户的标识信息， + // * 通过这个字段可以建立 `token` + // + // 与用户之间的对应关系，在进行用户认证、权限验证等业务场景中， + // * 基于该用户 `id` 去查找对应的用户信息以及判断该 `token` 是否合法等操作。 + // */ private Integer userid; - - /** - * 用户名 - */ + + // ** + // * 用户名，存储对应用户的名称信息， + // + // 与 `userid` 一起进一步明确用户身份，增强用户标识的可读性和可辨识度， + // * 在一些业务场景中（如展示用户相关信息、 + // + // 记录操作日志等涉及到用户显示名称的情况）会用到该字段内容。 + // */ private String username; - - /** - * 表名 - */ + + // ** + // * 表名，可能用于标识该 `token` + // + // + // 相关数据存储所在的具体数据库表（在多表关联或者分表存储等复杂业务场景下）， + // * 可以帮助更准确地定位和管理与该 `token` 相关的其他数据信息， + // + // 也有助于区分不同业务模块下的 `token` 情况， + // * 例如不同业务表对应的 `token` 有不同的作用范围和验证规则等， + // + // 通过这个字段可以进行区分和相应的业务处理。 + // */ private String tablename; - - /** - * 角色 - */ + + // ** + // * 角色，用于记录用户在系统中所扮演的角色，例如管理员、普通用户、 + // + // + // 特定权限角色等不同角色往往具有不同的权限范围， + // * 通过该 `role` 字段可以在基于 `token` 进行权限验证等操作时， + // + // 判断用户是否具备执行某些特定操作的权限， + // * 确保系统的安全性和数据访问的合法性。 + // */ private String role; - - /** - * token - */ + + // ** + // * token，存储实际的 `token` 字符串值， + // + // 这是用于标识用户身份的关键信息， + // + // 在用户登录成功或者进行身份验证等操作后生成， + // * 后续用户在访问系统接口、进行页面操作等场景下， + // + // 需要携带该 `token` 字符串进行身份验证，系统通过验证该 `token` 的有效性来确定用户是否有权限继续操作， + // * 它通常是一个具有一定随机性和唯一性的字符串， + // + // 保证每个用户的 `token` 都能唯一标识其身份。 + // */ private String token; - - /** - * 过期时间 - */ + + // ** + // * 过期时间，记录该 `token` 的有效截止时间， + // + // 通过设置过期时间可以提高系统的安全性，避免 `token` 长期有效可能带来的安全风险， + // * 在进行 `token` 验证时， + // + // 会对比当前时间与该过期时间来判断 `token` 是否仍然有效， + // + // 对于过期的 `token` 则拒绝相应的操作请求， + // * 通常是一个 `Date` 类型的时间对象，表示具体的时间点。 + // */ private Date expiratedtime; - - /** - * 新增时间 - */ + + // ** + // * 新增时间，记录该 `token` 在系统中创建的时间点， + // + // 可用于查询、统计等业务场景，例如查看新生成的 `token` 情况、 + // * 分析不同时间段内 `token` 的生成频率等， + // + // 也有助于在一些数据管理和审计场景下了解 `token` 的生命周期相关信息， + // * 同样是一个 `Date` 类型的时间对象。 + // */ private Date addtime; + // ** + // * 获取：主键，对外提供获取主键值（`id`）的方法， + // + // 方便在其他类中访问该 `TokenEntity` 对象的主键信息， + // * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到 + // + // `token` 记录主键时可调用此方法获取，返回对应的整数值。 + // * @return 返回主键对应的整数值。 + // */ public Integer getId() { return id; } + // ** + // * 设置：主键，用于设置该对象的主键值， + // + // 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用， + // * 不过由于主键一般是自增长且由数据库管理， + // 在实际业务中手动设置的情况相对较少， + // 但保留此方法以满足可能的特殊需求（如数据迁移等场景）， + // * 通过传入对应的整数值来更新主键信息。 + // * @param id 要设置的主键整数值。 + // */ public void setId(Integer id) { this.id = id; } + // ** + // * 获取：用户id，对外提供获取用户 `id` + // + // 值（`userid`）的方法，在需要关联用户信息、进行基于用户的业务逻辑处理（如查找用户相关的其他数据、 + // * 判断 `token` 所属用户等情况）时， + // 可调用此方法获取对应的整数值，便于操作和业务逻辑实现。 + // * @return 返回用户 `id` 对应的整数值。 + // */ public Integer getUserid() { return userid; } + // ** + // * 设置：用户id，用于更新用户 `id` 值（`userid`）， + // 例如在某些特殊情况下（如用户信息变更导致关联的 `userid` 需要调整等）， + // * 通过传入新的整数值来改变该 `TokenEntity` + // 对象所关联的用户标识信息，不过这种情况相对较少出现，需谨慎操作以保证数据一致性。 + // * @param userid 要设置的用户 `id` 整数值。 + // */ public void setUserid(Integer userid) { this.userid = userid; } - public String getRole() { - return role; - } - - public void setRole(String role) { - this.role = role; + // ** + // * 获取：用户名，对外提供获取用户名（`username`）的方法， + // + // + // 在需要展示用户名称、基于用户名进行业务逻辑处理（如记录操作日志中显示用户名等情况）时， + // * 可调用此方法获取对应的字符串内容，方便进行相应的展示和操作。 + // * @return 返回用户名对应的字符串值。 + // */ + public String getUsername() { + return username; } - public String getToken() { - return token; + // ** + // * 设置：用户名，用于更新用户名（`username`）， + // + // 比如用户修改了自己的用户名后，通过此方法保存新的用户名信息到该 `TokenEntity` 对象中， + // * 确保相关业务逻辑中获取到的用户名是最新且准确的， + // + // 需要注意的是这种更新可能需要同时考虑与其他关联数据的一致性等问题。 + // * @param username 要设置的用户名字符串值。 + // */ + public void setUsername(String username) { + this.username = username; } + // ** + // * 获取：表名，对外提供获取表名（`tablename`）的方法， + // + // 在涉及到多表关联操作、区分不同业务模块下 `token` 的处理逻辑或者根据表名查找相关数据等业务场景中， + // * 可调用此方法获取对应的字符串内容， + // + // 便于进行相应的数据库操作和业务处理。 + // * @return 返回表名对应的字符串值。 + // */ public String getTablename() { return tablename; } + // ** + // * 设置：表名，用于更新表名（`tablename`）， + // + // 在一些特殊的业务场景变化（如数据库结构调整、业务模块重新划分导致表名变更等）时， + // * 通过传入新的字符串值来改变该 `TokenEntity` + // + // 对象对应的表名信息，不过这种变更需要谨慎处理，确保与数据库实际情况以及其他相关代码逻辑的一致性。 + // * @param tablename 要设置的表名字符串值。 + // */ public void setTablename(String tablename) { this.tablename = tablename; } + // ** + // * 获取：角色，对外提供获取角色（`role`）的方法， + // + // 在基于 `token` 进行权限验证、判断用户在系统中的操作权限范围等业务场景中， + // * 可调用此方法获取对应的字符串内容， + // + // 以便根据角色信息进行相应的权限控制和业务逻辑处理。 + // * @return 返回角色对应的字符串值。 + // */ + public String getRole() { + return role; + } + + // ** + // * 设置：角色，用于更新角色（`role`）， + // + // 例如在系统进行角色调整、用户权限变更等情况下，通过传入新的字符串值来改变该 `TokenEntity` 对象中记录的用户角色信息， + // * 从而影响后续基于角色的权限验证等业务操作， + // + // 同样需要注意保证数据一致性以及相关业务逻辑的正确调整。 + // * @param role 要设置的角色字符串值。 + // */ + public void setRole(String role) { + this.role = role; + } + + // ** + // * 获取：token，对外提供获取 `token` + // + // 字符串值（`token`）的方法，在需要使用 `token` 进行身份验证、传递给其他模块进行相关操作等场景中， + // * 可调用此方法获取对应的字符串内容， + // + // 它是整个 `TokenEntity` 对象中最为关键的用于标识用户身份的信息部分。 + // * @return 返回 `token` 对应的字符串值。 + // */ + public String getToken() { + return token; + } + + // ** + // * 设置：token，用于更新 `token` 字符串值（`token`）， + // + // 通常在 `token` 重新生成（如用户重新登录、`token` 过期后重新获取等情况）时， + // * 通过传入新的字符串值来替换原有的 `token` 信息， + // + // 确保 `token` 的有效性和安全性，同时需要注意更新相关的验证逻辑以及与其他模块的交互情况。 + // * @param token 要设置的 `token` 字符串值。 + // */ public void setToken(String token) { this.token = token; } + // ** + // * 获取：过期时间，对外提供获取过期时间（`expiratedtime`）的方法， + // + // 在进行 `token` 有效性验证、判断是否需要重新获取 `token` 等业务场景中， + // * 可调用此方法获取对应的 `Date` 类型对象， + // + // 以便与当前时间进行比较操作，进而确定 `token` 是否还能继续使用。 + // * @return 返回过期时间对应的 `Date` 类型对象。 + // */ public Date getExpiratedtime() { return expiratedtime; } + // ** + // * 设置：过期时间，用于更新过期时间（`expiratedtime`）的值， + // + // 例如在调整 `token` 的有效期策略、手动延长或缩短 `token` 有效期等特殊情况下， + // * 通过传入新的 `Date` 类型对象来改变该 `TokenEntity` + // + // 对象中记录的 `token` 过期时间信息，不过这种操作需要谨慎进行，避免影响系统的安全性和正常业务流程。 + // * @param expiratedtime 要设置的过期时间对应的 `Date` 类型对象。 + // */ public void setExpiratedtime(Date expiratedtime) { this.expiratedtime = expiratedtime; } + // ** + // * 获取：新增时间，对外提供获取新增时间（`addtime`）的方法， + // + // 在进行数据统计、审计以及一些基于时间顺序的业务逻辑处理（如查找近期生成的 `token` 等情况）时， + // * 可调用此方法获取对应的 `Date` 类型对象，方便进行相应的时间相关操作和业务逻辑实现。 + // * @return 返回新增时间对应的 `Date` 类型对象。 + // */ public Date getAddtime() { return addtime; } + // ** + // * 设置：新增时间，用于更新新增时间（`addtime`）的值， + // + // 虽然在实际业务中新增时间一般是在 `token` 创建时自动记录且较少手动修改， + // * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对新增时间进行调整）， + // + // 通过传入对应的 `Date` 类型对象来更新新增时间信息， + // * 同样需要注意保证数据的合理性和一致性。 + // */ public void setAddtime(Date addtime) { this.addtime = addtime; } - public String getUsername() { - return username; - } - - public void setUsername(String username) { - this.username = username; - } - - public TokenEntity(Integer userid, String username, String tablename,String role, String token, Date expiratedtime) { + // ** + // * 构造函数，用于创建 `TokenEntity` 对象实例时传入必要的参数进行初始化， + // + // 通常在创建新的 `token` 相关记录或者从数据库等外部数据源加载数据后创建对象时使用， + // * 接收用户 `id`、用户名、表名、角色、`token` 字符串以及过期时间等参数， + // + // 按照传入的值初始化对象的各个属性，方便快速构建一个完整的 `TokenEntity` 对象， + // * 用于后续的业务操作（如插入数据库、传递给其他模块等）。 + // * @param userid 用户的唯一标识，整数值。 + // * @param username 用户的名称，字符串值。 + // * @param tablename 所属表名，字符串值。 + // * @param role 用户在系统中所扮演的角色，字符串值。 + // * @param token 用于标识用户身份的 `token` 字符串值。 + // * @param expiratedtime `token` 的过期时间，`Date` 类型对象。 + // */ + public TokenEntity(Integer userid, String username, String tablename, String role, String token, Date expiratedtime) { super(); this.userid = userid; this.username = username; @@ -125,8 +346,16 @@ public class TokenEntity implements Serializable { this.token = token; this.expiratedtime = expiratedtime; } - + + // ** + // * 默认构造函数，用于创建一个空的 `TokenEntity` 对象实例， + // + // 当需要先创建对象再逐步设置属性值时可使用该构造函数， + // * 例如在一些复杂的业务逻辑中，先创建对象占位，后续根据不同的条件和数据来源来分别设置对象的各个属性， + // + // 方便灵活构建 `TokenEntity` 对象， + // * 为空对象的初始化提供了一种方式。 + // */ public TokenEntity() { } - -} +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java b/minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java index 36483ac1..67b10cf3 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java @@ -8,180 +8,266 @@ import java.util.Date; import org.springframework.format.annotation.DateTimeFormat; import java.io.Serializable; - /** * 字典表 * 接收传参的实体类 - *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） - * 取自ModelAndView 的model名称 + * 该类主要用于在系统与外部（如移动端等） + * 进行数据交互时，接收传递过来的与字典表相关的参数信息，起到数据传输载体的作用。 + * 在实际开发中，根据具体业务场景， + * 可以手动对其包含的字段进行筛选调整（去掉一些在特定接口或业务逻辑中不需要的字段）， + * 因为后端在很多情况下直接使用 `entity` 类 + * （如 `DictionaryEntity`）就可以满足基本的数据操作需求，这里的 `Model` 类更侧重于接收外部传入的数据格式适配。 + * 其名称取自 `ModelAndView` 的 `model`， + * 暗示了它在数据传递和视图模型构建方面的作用（通常用于构建适合展示或处理的数据模型结构）。 */ public class DictionaryModel implements Serializable { private static final long serialVersionUID = 1L; - - - - /** - * 主键 - */ + // ** + // * 主键，用于唯一标识字典表中的每一条记录， + // 在数据库操作中（如查询、更新、删除等）可通过主键精准定位到特定的字典表数据行， + // * 通常对应数据库表中定义的主键字段， + // 保证数据的唯一性和可识别性。 + // */ private Integer id; - - /** - * 字段 - */ + // ** + // * 字段，可能用于存储字典表中某个条目的特定代码或者标识信息， + // 例如可以是代表不同分类、类型等的代码值， + // * 通过该字段能够区分不同的字典项， + // 并且在业务逻辑中可以基于此字段进行相关的查询、匹配等操作。 + // */ private String dicCode; - - /** - * 字段名 - */ + // ** + // * 字段名，与 `dicCode` 相对应， + // 用于存储该字段对应的直观的名称描述， + // 方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义， + // * 例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。 + // */ private String dicName; - - /** - * 编码 - */ + // ** + // * 编码，可能是对字典表中各项进行编号的一个整数值， + // 用于在内部对字典项进行排序、索引或者作为另一种标识方式， + // * 在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。 + // */ private Integer codeIndex; - - /** - * 编码名字 - */ + // ** + // * 编码名字，与 `codeIndex` 相对应， + // 是对该编码所代表含义的文字描述， + // 同样是为了提高数据的可读性和可理解性， + // * 便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。 + // */ private String indexName; - - /** - * 父字段id - */ + // ** + // * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话）， + // * 通过这个 `superId` + // 可以构建字典项之间的父子关联关系，方便进行树形结构数据的展示、 + // 查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。 + // */ private Integer superId; - - /** - * 备注 - */ + // ** + // * 备注，用于存储一些对该字典项的额外说明信息， + // 例如该项的特殊用途、适用范围、创建背景等内容， + // * 在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时， + // 可以参考备注中的信息。 + // */ private String beizhu; - - /** - * 创建时间 - */ - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") - @DateTimeFormat + // ** + // * 创建时间，记录该字典表记录的创建时间点， + // 通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理， + // * 确保在前后端交互以及数据存储等场景下时间格式的一致性。 + // 例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。 + // * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式。 + // * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换。 + // */ + @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") + @DateTimeFormat private Date createTime; - - /** - * 获取：主键 - */ + // ** + // * 获取：主键，对外提供获取主键值的方法， + // 方便在其他类中访问该对象的主键信息， + // 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取。 + // * @return 返回主键对应的整数值。 + // */ public Integer getId() { return id; } - - /** - * 设置：主键 - */ + // ** + // * 设置：主键，用于设置该对象的主键值， + // 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用 + // ，例如创建新字典表记录对象并保存到数据库前需要设置主键值。 + // * @param id 要设置的主键整数值。 + // */ public void setId(Integer id) { this.id = id; } - /** - * 获取：字段 - */ + + // ** + // * 获取：字段，对外提供获取字段值（`dicCode`）的方法， + // 以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、 + // * 根据代码进行匹配判断等情况时可调用此方法获取字段值，返回对应的字符串内容。 + // * @return 返回字段对应的字符串值。 + // */ public String getDicCode() { return dicCode; } - - /** - * 设置：字段 - */ + // ** + // * 设置：字段，用于更新字段值（`dicCode`）， + // 例如在修改字典表记录中该字段的代码内容后， + // 调用此方法来保存新的代码信息，以反映字典项的变化。 + // * @param dicCode 要设置的字段字符串值。 + // */ public void setDicCode(String dicCode) { this.dicCode = dicCode; } - /** - * 获取：字段名 - */ + + // ** + // * 获取：字段名，对外提供获取字段名（`dicName`）的方法， + // 在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时， + // * 可调用此方法获取对应的字符串内容，方便操作和展示。 + // * @return 返回字段名对应的字符串值。 + // */ public String getDicName() { return dicName; } - - /** - * 设置：字段名 - */ + // ** + // * 设置：字段名，用于更新字段名（`dicName`）， + // 比如对字典项的名称进行修改后，通过此方法保存新的名称信息， + // 确保名称能准确反映字典项的实际含义。 + // * @param dicName 要设置的字段名字符串值。 + // */ public void setDicName(String dicName) { this.dicName = dicName; } - /** - * 获取：编码 - */ + + // ** + // * 获取：编码，对外提供获取编码值（`codeIndex`）的方法， + // 在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中， + // * 可调用此方法获取对应的整数值，便于进行相应的业务处理。 + // * @return 返回编码对应的整数值。 + // */ public Integer getCodeIndex() { return codeIndex; } - - /** - * 设置：编码 - */ + // ** + // * 设置：编码，用于更新编码值（`codeIndex`）， + // 例如调整字典项的编号顺序或者重新分配编码后， + // 调用此方法来保存新的编码信息，以符合业务要求的编码规则。 + // * @param codeIndex 要设置的编码整数值。 + // */ public void setCodeIndex(Integer codeIndex) { this.codeIndex = codeIndex; } - /** - * 获取：编码名字 - */ + + // ** + // * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法， + // 在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时， + // * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。 + // * @return 返回编码名字对应的字符串值。 + // */ public String getIndexName() { return indexName; } - - /** - * 设置：编码名字 - */ + // ** + // * 设置：编码名字，用于更新编码名字（`indexName`）， + // 比如对编码所代表的含义进行重新定义或者修改描述后，通过此方法保存新的名称信息， + // * 以便准确传达编码的实际意义。 + // * @param indexName 要设置的编码名字符串值。 + // */ public void setIndexName(String indexName) { this.indexName = indexName; } - /** - * 获取：父字段id - */ + + // ** + // * 获取：父字段id，对外提供获取父字段id（`superId`）的方法， + // 在处理字典表的层级关系数据时，比如查找某个父项下的子项、 + // * 判断字典项的层级归属等业务场景中， + // 可调用此方法获取对应的整数值， + // 方便进行相关的关联操作和业务逻辑处理。 + // * @return 返回父字段id对应的整数值。 + // */ + + + + + public Integer getSuperId() { return superId; } + // ** + // * 设置：父字段id，用于更新父字段id（`superId`）的值， + // 例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息， + // * 以正确反映字典项在层级关系中的位置变化。 + // * @param superId 要设置的父字段id整数值。 + // */ + + + - /** - * 设置：父字段id - */ public void setSuperId(Integer superId) { this.superId = superId; } - /** - * 获取：备注 - */ + + // ** + // * 获取：备注，对外提供获取备注信息（`beizhu`）的方法， + // + // 在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时， + // * 可调用此方法获取对应的字符串内容，辅助业务处理。 + // * @return 返回备注对应的字符串值。 + // */ public String getBeizhu() { return beizhu; } - - /** - * 设置：备注 - */ + // ** + // * 设置：备注，用于更新备注信息（`beizhu`）， + // + // 例如添加、修改字典项的备注内容后，通过此方法保存新的备注信息，方便后续查看和参考。 + // * @param beizhu 要设置的备注字符串值。 + // */ public void setBeizhu(String beizhu) { this.beizhu = beizhu; } - /** - * 获取：创建时间 - */ + + // ** + // * 获取：创建时间，对外提供获取创建时间（`createTime`）的方法， + // + // 在展示字典表记录的创建时间、按照时间范围查询字典项、 + // * 统计不同时间段创建的数据量等业务场景中，可调用此方法获取对应的 ` + // + // + // Date` 类型对象，用于后续的时间相关操作和展示。 + // * @return 返回创建时间对应的 `Date` 类型对象。 + // */ public Date getCreateTime() { return createTime; } + // ** + - /** - * 设置：创建时间 - */ + // * 设置：创建时间，用于更新创建时间（`createTime`）的值 + // + // ，不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新， + // * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整）， + // + // 通过传入对应的 `Date` 类型对象来更新创建时间信息。 + // * @param createTime 要设置的创建时间对应的 `Date` 类型对象。 + // */ public void setCreateTime(Date createTime) { this.createTime = createTime; } - - } +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java b/minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java index 4f517854..62db8a60 100644 --- a/minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java +++ b/minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java @@ -12,19 +12,45 @@ import java.util.Date; /** * 字典表 * 后端返回视图实体辅助类 - * （通常后端关联的表或者自定义的字段需要返回使用） + * 此类主要用于作为后端向外部（如前端界面或者其他调用接口的客户端）返回数据时的视图实体辅助类， + * 它继承自 `DictionaryEntity`，意味着拥有 `DictionaryEntity` 的所有属性及方法， + * 并且在此基础上可以根据业务需求添加额外的属性或者方法， + * 用于构建适合展示给外部的视图数据结构。通常在后端业务逻辑中涉及到关联其他表或者有自定义的字段需要一并返回给前端等使用场景下发挥作用， + * 帮助对要返回的数据进行整合、格式转换以及添加必要的展示相关逻辑等操作， + * 以满足前端展示或外部调用者对数据格式和内容的期望。 */ @TableName("dictionary") public class DictionaryView extends DictionaryEntity implements Serializable { - private static final long serialVersionUID = 1L; - - - - + private static final long serialVersionUID = 1L; + + // ** + // * 默认构造函数，用于创建一个空的 `DictionaryView` + // 对象实例，在某些场景下（比如先创建对象，后续再根据具体数据来填充属性值）会使用到， + // * 提供了一种灵活创建该视图实体对象的方式， + // + // 方便后续在复杂业务逻辑中按需构建对象并设置其属性。 + // */ public DictionaryView() { } + // ** + // * 构造函数，用于根据传入的 `DictionaryEntity` 对象， + // + // 通过 `BeanUtils` 工具类将其属性值复制到当前 `DictionaryView` 对象中， + // * 这样可以方便地基于已有的 `DictionaryEntity` + // + // + // 类型的数据对象来初始化 `DictionaryView` 对象，实现数据的传递和复用，避免重复设置各个属性，提高代码效率， + // * 在后端从数据库查询出 `DictionaryEntity` 数据后， + // + // 若要转换为适合返回的视图实体时，就可以使用这个构造函数进行属性值的复制， + // + // 不过在使用过程中需要注意可能出现的异常情况（已在代码中对异常进行了简单处理）。 + // * @param dictionaryEntity 要复制属性值的 `DictionaryEntity` + // + // 对象，通过该对象的属性来初始化当前 `DictionaryView` 对象的属性。 + // */ public DictionaryView(DictionaryEntity dictionaryEntity) { try { BeanUtils.copyProperties(this, dictionaryEntity); @@ -33,25 +59,4 @@ public class DictionaryView extends DictionaryEntity implements Serializable { e.printStackTrace(); } } - - - - - - - - - - - - - - - - - - - - - -} +} \ No newline at end of file diff --git a/minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java b/minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java index 93a2dd2e..a0e59a87 100644 --- a/minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java +++ b/minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java @@ -8,17 +8,67 @@ import javax.servlet.http.HttpServletRequest; /** * 字典表 服务类 + * 该接口定义了与字典表相关的业务逻辑方法， + * 继承自 MyBatis Plus 的 `IService` + * 接口（意味着具备 `IService` 提供的通用数据库操作相关的方法，如基本的增删改查等功能）， + * 在此基础上扩展了针对字典表特有的业务操作方法， + * 用于满足项目中对字典表数据处理的具体需求，方便在不同的业务场景下调用对应的方法来实现相应功能， + * 并且使得业务逻辑与数据持久化操作进行了有效的分离， + * 提高代码的可维护性和可扩展性。 */ public interface DictionaryService extends IService { /** - * @param params 查询参数 - * @return 带分页的查询出来的数据 - */ - PageUtils queryPage(Map params); - /** - * 字典表转换 - * @param obj - */ - void dictionaryConvert(Object obj, HttpServletRequest request); + * 根据传入的查询参数进行字典表数据的分页查询操作，并返回分页后的查询结果。 + * 此方法是用于满足按照特定条件分页获取字典表数据的业务需求， + * 调用者可以传入包含各种查询条件（ + * + * + * 如筛选条件、排序条件、页码、每页显示数量等信息）的 `Map` 类型参数， + * 该方法内部会基于这些参数与数据库进行交互，执行相应的查询语句， + * + * 获取符合条件的字典表数据分页信息，最终将结果封装在 `PageUtils` + * + * 类型的对象中返回，方便后续进行分页展示或其他相关业务处理。 + * + * @param params 查询参数，是一个 `Map` 类型的数据结构， + * + * 用于传递各种查询条件信息，不同的键值对可以表示不同的含义， + * 例如可以通过特定的键设置筛选字典表数据的关键字、 + * + * 按照某个字段进行排序的规则、指定要获取的页码以及每页显示的记录数量等，以灵活控制查询逻辑，获取期望的分页数据。 + * @return 返回一个 `PageUtils` 类型的对象， + * + * 该对象中封装了分页后的字典表数据以及分页相关的元信息（比如总记录数、总页数等）， + * 方便在前端展示或者其他业务场景下对分页数据进行处理， + * + * 例如分页展示、数据统计等操作。 + */ + PageUtils queryPage(Map params); + + /** + * 对字典表相关的数据对象进行转换操作，具体的转换逻辑可能根据业务需求而定， + * + * 并且会依赖于请求相关的上下文信息（通过 `HttpServletRequest` 获取）。 + * 这个方法通常用于对从数据库查询出来的字典表数据（可能是原始的实体对象或者其他相关的数据结构） + * + * 进行一些额外的处理，比如对字典表中的某些字段值进行格式转换、 + * 根据业务规则进行重新赋值、关联其他相关数据等操作，使其更适合后续的展示或者业务逻辑处理， + * + * 传入的 `Object` 类型参数表示可以接受各种类型的与字典表相关的数据对象进行转换处理。 + * + * @param obj 要进行转换操作的对象，类型为 `Object`， + * + * 它可以是字典表对应的实体类对象（如 `DictionaryEntity` 及其子类等）或者其他包含字典表相关数据的对象结构， + * 具体的类型取决于调用该方法时传入的实际参数情况，该对象将作为转换操作的基础数据来源， + * + * 其内部的字典表相关属性会根据业务逻辑进行相应的转换处理。 + * @param request `HttpServletRequest` 对象，用于获取请求相关的上下文信息， + * + * 例如可以从中获取用户相关信息、请求头信息等，这些信息可能会辅助字典表数据的转换逻辑， + * 比如根据用户的不同权限或者地区设置等对字典表中的某些字段进行不同的转换处理， + * + * 确保转换后的数据符合具体业务场景下的展示和使用要求。 + */ + void dictionaryConvert(Object obj, HttpServletRequest request); } \ No newline at end of file From 6e6a0d70d9a210676751d84252ade1ff22c49e03 Mon Sep 17 00:00:00 2001 From: p4vb9jpo3 <1605103955@qq.com> Date: Sun, 15 Dec 2024 20:35:00 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E6=B3=A8=E9=87=8A=20(#7)?= 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); } }