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<UsersEntity>().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中，方便前端知晓当前登录用户的角色权限等情况。
-		r.put("userId",user.getId());
+		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){
+	public R register(@RequestBody UsersEntity user) {
-//    	ValidatorUtils.validateEntity(user);
+		// 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证用户名、密码是否符合格式要求等，目前未生效。
-    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
+		// ValidatorUtils.validateEntity(user);
-    		return R.error("用户已存在");
+		// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件，根据传入的用户实体中的用户名去数据库中查询是否已存在相同用户名的用户记录，若存在则返回对应的UsersEntity对象，若不存在则返回null。
-    	}
+		if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()))!= null) {
-        usersService.insert(user);
+			return R.error("用户已存在");
-        return R.ok();
+		}
-    }
+		// 如果用户名未被使用，调用用户服务层的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){
+	public R resetPass(String username, HttpServletRequest request) {
-    	UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
+	// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件（查找用户名与传入的username相等的用户记录），从数据库中查询对应的用户实体信息。
-    	if(user==null) {
+	UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
-    		return R.error("账号不存在");
+	// 如果查询到的用户为null，即用户名对应的用户不存在，返回账号不存在的错误信息给前端。
-    	}
+	if (user == null) {
-    	user.setPassword("123456");
+		return R.error("账号不存在");
-        usersService.update(user,null);
+	}
-        return R.ok("密码已重置为：123456");
+	// 如果用户存在，将用户的密码设置为固定值“123456”，实际应用中这样直接设置密码不太安全，可后续优化为更安全合理的密码重置逻辑，比如通过发送验证码验证等方式。
-    }
+	user.setPassword("123456");
-	
+	// 调用用户服务层的update方法，传入更新后的user对象以及null（可能表示不需要其他额外的更新条件，具体取决于update方法的参数定义），将用户的密码更新到数据库中。
-	/**
+	usersService.update(user, null);
-     * 列表
+	// 返回操作成功的结果信息，并附带密码已重置为“123456”的提示内容，告知前端密码重置操作已完成。
-     */
+	return R.ok("密码已重置为：123456");
-    @RequestMapping("/page")
+}
-    public R page(@RequestParam Map<String, Object> params,UsersEntity user){
-        EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-    	PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
-        return R.ok().put("data", page);
-    }
 
-	/**
+/**
-     * 列表
+ * 列表（分页查询）
-     */
+ * 用于获取用户列表数据，并进行分页以及根据传入的用户对象构建查询条件等相关处理后返回给前端，返回结果包含分页相关信息以及符合条件的用户数据列表。
-    @RequestMapping("/list")
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/page"，完整路径为 "/users/page"。
-    public R list( UsersEntity user){
+ * @param params 包含查询参数的Map，例如分页参数（如每页条数、当前页码等）、筛选条件等，通过请求参数传入，用于构建数据库查询条件以及分页相关设置。
-       	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
+ * @param user 包含用户相关信息的UsersEntity对象，可能用于进一步构建查询条件，比如根据用户对象中的某些属性来筛选特定用户数据等，具体取决于业务逻辑和相关工具类（如MPUtil）的使用方式。
-      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
+ * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表信息（通过PageUtils对象承载）。
-        return R.ok().put("data", usersService.selectListView(ew));
+ */
-    }
+	@RequestMapping("/page")
-
+	public R page(@RequestParam Map<String, Object> params, UsersEntity user) {
-    /**
+	// 创建一个EntityWrapper对象，用于构建数据库查询条件，它可以方便地拼接各种查询条件语句，例如等于、大于、小于等条件，初始时为空，后续会根据业务逻辑添加相应条件。
-     * 信息
+	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-     */
+	// 调用用户服务层的queryPage方法进行分页查询，传入params参数用于分页相关设置以及通过MPUtil相关工具方法构建的查询条件。
-    @RequestMapping("/info/{id}")
+	// MPUtil.sort方法可能用于对查询结果进行排序设置，MPUtil.between方法可能用于构建范围查询条件，MPUtil.allLike方法可能用于构建模糊查询条件等，具体功能取决于MPUtil工具类的实现。
-    public R info(@PathVariable("id") String id){
+	PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
-        UsersEntity user = usersService.selectById(id);
+	return R.ok().put("data", page);
-        return R.ok().put("data", user);
+}
-    }
+
-    
+/**
-    /**
+ * 列表（另一种查询方式）
-     * 获取用户的session用户信息
+ * 根据传入的用户对象构建查询条件，从数据库中查询符合条件的用户数据列表并返回给前端，返回结果包含查询到的用户数据列表信息。
-     */
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/list"，完整路径为 "/users/list"。
-    @RequestMapping("/session")
+ * @param user 包含用户相关信息的UsersEntity对象，用于构建查询条件，通过MPUtil工具类的allEq方法将用户对象中的属性转换为相等查询条件，以便从数据库中筛选出符合条件的用户数据。
-    public R getCurrUser(HttpServletRequest request){
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的用户数据列表（通过调用usersService.selectListView方法查询得到）。
-    	Integer id = (Integer)request.getSession().getAttribute("userId");
+ */
-        UsersEntity user = usersService.selectById(id);
+	@RequestMapping("/list")
-        return R.ok().put("data", user);
+	public R list(UsersEntity user) {
-    }
+	// 创建一个EntityWrapper对象，用于构建数据库查询条件，方便后续添加具体的查询条件语句。
-
+	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-    /**
+	// 使用MPUtil工具类的allEq方法，将用户对象中的属性按照指定前缀（这里是"user"）转换为相等查询条件，添加到EntityWrapper对象中，用于构建查询符合该用户对象属性值的所有用户记录的条件语句。
-     * 保存
+	ew.allEq(MPUtil.allEQMapPre(user, "user"));
-     */
+	return R.ok().put("data", usersService.selectListView(ew));
-    @PostMapping("/save")
+}
-    public R save(@RequestBody UsersEntity user){
+
-//    	ValidatorUtils.validateEntity(user);
+/**
-    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
+ * 信息
-    		return R.error("用户已存在");
+ * 根据传入的用户ID，从数据库中查询对应的用户详细信息并返回给前端，若查询到则将用户信息封装在R对象中返回，若未查询到则返回相应错误信息（当前代码未做错误处理，实际可能需要完善）。
-    	}
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/info/{id}"，完整路径为 "/users/info/{id}"，其中{id}是路径变量，用于接收要查询信息的用户的唯一标识（通常是数据库中的主键ID）。
-    	user.setPassword("123456");
+ * @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量传入，用于指定要查询详细信息的用户。
-        usersService.insert(user);
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。
-        return R.ok();
+ */
-    }
+	@RequestMapping("/info/{id}")
-
+	public R info(@PathVariable("id") String id) {
-    /**
+	// 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。
-     * 修改
+	UsersEntity user = usersService.selectById(id);
-     */
+	return R.ok().put("data", user);
-    @RequestMapping("/update")
+}
-    public R update(@RequestBody UsersEntity user){
+
-//        ValidatorUtils.validateEntity(user);
+/**
-        usersService.updateById(user);//全部更新
+ * 获取用户的session用户信息
-        return R.ok();
+ * 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息并返回给前端，若获取到用户ID则进行查询并返回用户信息，若未获取到用户ID（比如会话中不存在该属性等情况）则可能返回相应错误信息（当前代码未做完善处理）。
-    }
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/session"，完整路径为 "/users/session"。
-
+ * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID属性值，用于后续查询用户信息操作。
-    /**
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。
-     * 删除
+ */
-     */
+	@RequestMapping("/session")
-    @RequestMapping("/delete")
+	public R getCurrUser(HttpServletRequest request) {
-    public R delete(@RequestBody Long[] ids){
+	// 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息。
-        usersService.deleteBatchIds(Arrays.asList(ids));
+	Integer id = (Integer) request.getSession().getAttribute("userId");
-        return R.ok();
+	// 通过用户服务层的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<UsersEntity>().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();
+}
 }

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<String, Object> 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());

minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java

@@ -12,11 +12,34 @@ import com.entity.UsersEntity;
 
 /**
  * 用户
+ * 这是一个接口定义，用于定义与用户数据访问相关的方法，该接口继承自BaseMapper<UsersEntity>，
+ * 意味着它会继承BaseMapper中提供的一些基础的数据库操作方法（例如根据ID查询、插入、更新、删除等操作方法），
+ * 同时在此基础上又自定义了一些针对用户数据查询的特定方法，方便在具体的数据访问层实现类中去实现这些方法逻辑，
+ * 以满足业务中对用户数据不同查询需求的操作。
  */
 public interface UsersDao extends BaseMapper<UsersEntity> {
-	
+
+	/**
+	 * 选择列表视图（简单查询版本）
+	 * 定义了一个用于查询用户数据列表的方法，该方法接收一个Wrapper<UsersEntity>类型的参数，
+	 * 这个Wrapper通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等），通过它可以灵活地定义查询用户数据的具体逻辑，
+	 * 返回的是一个UsersEntity类型的列表，即符合查询条件的用户数据集合。
+	 * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件，
+	 *                以此来精确地控制从数据库中获取哪些用户的数据。
+	 * @return 符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。
+	 */
 	List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
 
+	/**
+	 * 选择列表视图（带分页查询版本）
+	 * 定义了另一个用于查询用户数据列表的方法，此方法在简单查询版本的基础上增加了分页功能，
+	 * 它接收一个Pagination类型的分页参数对象和一个用于构建查询条件的Wrapper<UsersEntity>类型的参数，
+	 * 通过分页参数可以指定每页显示的数据条数、当前页码等信息，结合查询条件包装器一起实现带分页功能的用户数据查询操作，
+	 * 返回的同样是一个UsersEntity类型的列表，即当前页符合查询条件的用户数据集合。
+	 * @param page 用于设置分页相关参数的对象，比如可以指定每页的数据量、当前是第几页等，以便从数据库中获取对应分页的数据。
+	 * @param wrapper 用于构建查询条件的包装器对象，和上面的方法类似，用于精确控制查询哪些用户的数据，只是这里配合分页参数共同作用。
+	 * @return 当前页中符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。
+	 */
 	List<UsersEntity> selectListView(Pagination page, @Param("ew") Wrapper<UsersEntity> wrapper);
-	
+
 }

minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java

@@ -11,11 +11,28 @@ import com.entity.view.YonghuView;
 
 /**
  * 用户 Dao 接口
+ * 此接口用于定义针对用户数据进行持久化操作（通常是与数据库交互）相关的方法声明，它继承自BaseMapper<YonghuEntity>，
+ * 也就继承了BaseMapper中提供的如按主键查询、插入、更新、删除等基础数据库操作方法，在此基础上又自定义了特定的查询方法，
+ * 以满足业务中对用户数据更复杂查询需求，方便后续通过对应的实现类来具体实现这些方法逻辑，从而与数据库进行交互获取相应数据。
  *
- * @author 
+ * @author
+ * 这里标注了作者信息（具体作者名未填写完整），通常用于代码的归属及溯源等情况。
  */
 public interface YonghuDao extends BaseMapper<YonghuEntity> {
 
-   List<YonghuView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
+   /**
+    * 选择列表视图
+    * 该方法用于从数据库中查询用户数据列表，并且支持分页功能，它接收一个Pagination类型的分页参数对象以及一个Map<String, Object>类型的参数对象，
+    * 分页参数用于控制每页显示的数据量、当前页码等分页相关信息，而params参数则可以用于传递各种灵活的查询条件（例如筛选条件、排序条件等），
+    * 返回的是一个YonghuView类型的列表，YonghuView可能是专门用于展示给前端或者在业务逻辑中使用的用户数据视图对象，
+    * 即符合传入的分页及其他查询条件的用户数据集合（以视图对象形式呈现）。
+    *
+    * @param page 用于指定分页相关设置的对象，比如每页的记录条数、当前所在页码等信息，通过这个参数来实现分页查询功能，
+    *             使得可以按照指定的分页规则从数据库中获取相应的数据。
+    * @param params 用于传递各种查询条件的Map对象，键值对形式，其中键可以是自定义的表示不同查询条件的字符串（如"nameLike"表示按用户名模糊查询等），
+    *               值则是对应条件的具体内容（如模糊查询的关键字等），以此可以灵活构建出多样化的查询逻辑，从数据库中获取想要的用户数据子集。
+    * @return 符合传入的分页条件以及其他查询条件的用户视图对象列表，每个YonghuView对象代表一条符合要求的用户数据记录，方便后续在业务中展示或处理。
+    */
+   List<YonghuView> selectListView(Pagination page, @Param("params") Map<String, Object> params);
 
 }

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;
 	}
+}
 
 }

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<T> 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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @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 +
+                "id=" + id +
-            ", username=" + username +
+                ", username=" + username +
-            ", password=" + password +
+                ", password=" + password +
-            ", yonghuName=" + yonghuName +
+                ", yonghuName=" + yonghuName +
-            ", yonghuPhoto=" + yonghuPhoto +
+                ", yonghuPhoto=" + yonghuPhoto +
-            ", yonghuPhone=" + yonghuPhone +
+                ", yonghuPhone=" + yonghuPhone +
-            ", yonghuEmail=" + yonghuEmail +
+                ", yonghuEmail=" + yonghuEmail +
-            ", sexTypes=" + sexTypes +
+                ", sexTypes=" + sexTypes +
-            ", newMoney=" + newMoney +
+                ", newMoney=" + newMoney +
-            ", yonghuDelete=" + yonghuDelete +
+                ", yonghuDelete=" + yonghuDelete +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
     }
 }

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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @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;
     }
-
+}
-    }

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 static final long serialVersionUID = 1L;
-
+
-		/**
+	/**
-		* 性别的值
+	 * 性别的值
-		*/
+	 * 用于存储性别的具体值（可能是具体的文字描述，比如 "男"、"女" 等，区别于 YonghuEntity 中可能只是用代码表示性别的字段），
-		private String sexValue;
+	 * 方便直接展示给前端更直观的性别信息，而不是原始的代码形式，增强了数据展示的友好性和可读性。
-
+	 */
-
+	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;
+	}
 
-
+	/**
-			/**
+	 * 设置： 性别的值
-			* 获取： 性别的值
+	 * 这是一个用于设置 sexValue 属性值的公共设置方法（setter 方法），按照 Java 的 JavaBean 规范定义，
-			*/
+	 * 用于在需要更新 YonghuView 对象的性别值时调用，比如根据后端业务逻辑处理后得到的具体性别文字描述来更新该字段内容。
-			public String getSexValue() {
+	 * @param sexValue 要设置的性别的值字符串，用于更新 YonghuView 对象的 sexValue 字段内容。
-				return sexValue;
+	 */
-			}
+	public void setSexValue(String sexValue) {
-			/**
+		this.sexValue = sexValue;
-			* 设置： 性别的值
+	}
-			*/
+}
-			public void setSexValue(String sexValue) {
-				this.sexValue = sexValue;
-			}
-
-
-
-
-
-
-
-
-
-
-}

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<UsersEntity>，意味着它会继承 IService 接口中针对 UsersEntity 类型的一系列通用的服务层方法，
+// 比如常见的根据主键查询、插入、更新、删除等基础业务操作方法，在此基础上又自定义了一些特定于用户业务相关的方法，用于满足更复杂的业务需求。
+// 通常会有对应的实现类来具体实现这些方法逻辑，以实现与数据库或其他数据源交互来完成相应的业务功能。
 public interface UsersService extends IService<UsersEntity> {
+
+	/**
+	 * 查询分页数据
+	 * 此方法用于根据传入的参数（以 Map 形式传递各种查询相关的条件、分页信息等）查询用户数据，并返回分页后的结果信息，封装在 PageUtils 类中。
+	 * PageUtils 类可能包含了分页相关的属性，如总记录数、每页记录数、当前页码以及具体的分页数据列表等内容，方便前端进行分页展示以及其他相关业务处理。
+	 * 该方法主要应用在需要按照一定条件分页展示用户列表的业务场景中，比如在用户管理页面，管理员查看众多用户信息时按页进行展示。
+	 *
+	 * @param params 包含查询条件及分页相关参数的 Map 对象，键为参数名称（如 "pageNum" 表示当前页码，"pageSize" 表示每页记录数等，也可以包含自定义的筛选条件等），
+	 *               值为对应的参数值，通过这个参数可以灵活控制查询的具体逻辑以及分页设置。
+	 * @return 返回 PageUtils 对象，其中包含了符合查询条件的分页后的用户数据信息，可用于前端展示或后续的业务操作。
+	 */
+
  	PageUtils queryPage(Map<String, Object> params);
-    
+
+	/**
+	 * 选择列表视图
+	 * 定义了一个用于查询用户数据列表的方法，该方法接收一个 Wrapper<UsersEntity> 类型的参数，这个 Wrapper 通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等），
+	 * 通过它可以灵活地定义查询用户数据的具体逻辑，返回的是一个 UsersEntity 类型的列表，即符合查询条件的用户数据集合，方便在业务中获取特定条件下的用户数据列表，
+	 * 例如在查询满足某些特定属性（如特定角色、特定时间段内注册等）的用户列表场景下会用到该方法。
+	 *
+	 * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件，以此来精确地控制从数据库中获取哪些用户的数据。
+	 * @return 符合查询条件的用户实体对象列表，列表中的每个 UsersEntity 对象代表一条用户数据记录。
+	 */
+
    	List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper);
-   	
+	/**
+	 * 查询分页数据（带条件）
+	 * 与前面的 queryPage(Map<String, Object> params) 方法类似，也是用于查询分页的用户数据，但此方法额外接收一个 Wrapper<UsersEntity> 类型的参数，
+	 * 用于构建更复杂、更精确的查询条件，结合传入的 params 参数（包含分页相关设置及其他可能的通用查询条件），可以实现带特定条件的分页查询功能，
+	 * 比如在用户管理中按照特定角色、特定状态等条件分页查看用户信息时会使用该方法。
+	 *
+	 * @param params 包含查询条件及分页相关参数的 Map 对象，作用与前面 queryPage 方法中的 params 参数类似，用于设置分页相关属性以及一些基础的查询条件等。
+	 * @param wrapper 用于构建查询条件的包装器对象，用于添加额外的、更具体的查询条件，与 params 参数共同作用来精准控制查询哪些用户的数据以及如何分页展示这些数据。
+	 * @return 返回 PageUtils 对象，其中包含了符合传入的分页条件以及其他查询条件的分页后的用户数据信息，以供前端展示或后续业务操作使用。
+	 */
    	PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper);
-	   	
+
 }

minsu/minsuguanliw/src/main/java/com/service/YonghuService.java

@@ -15,5 +15,9 @@ public interface YonghuService extends IService<YonghuEntity> {
     * @param params 查询参数
     * @return 带分页的查询出来的数据
     */
+    // 定义了一个名为 `queryPage` 的方法，它接收一个 `Map<String, Object>` 类型的参数 `params`，
+    // 该方法的作用是根据传入的 `params` 参数中包含的各种查询条件及分页相关信息，查询相应的分页数据，
+    // 并返回一个 `PageUtils` 类型的对象，`PageUtils` 类通常用于封装分页相关的属性（如总记录数、每页记录数、当前页码以及具体的分页数据列表等），
+    // 以便后续进行分页展示或者其他与分页数据相关的业务操作。例如在用户管理系统中，通过传入不同的查询条件和分页参数，获取对应分页的用户数据列表等场景会调用此方法。
      PageUtils queryPage(Map<String, Object> params);
 }