p4vb9jpo3
/
homestay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

注释 ytt

Browse Source
pull/2/head
Yin 3 months ago
parent 3650f14bba
commit 9ffd2e8203
1 changed files with 253 additions and 109 deletions
Show Stats Download Patch File Download Diff File

362
minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java
Unescape View File

@ -36,45 +36,61 @@ import com.alibaba.fastjson.*;
* 用户
* 后端接口
* @author
* @email
*/
@RestController
@Controller
@RequestMapping("/yonghu")
public class YonghuController {
// 创建日志记录器，用于记录该类中的相关操作日志
private static final Logger logger = LoggerFactory.getLogger(YonghuController.class);
// 自动注入用户服务层接口，用于处理与用户相关的业务逻辑，如数据库操作等
@Autowired
private YonghuService yonghuService;
// 自动注入Token服务层接口，用于处理与用户Token相关的业务，例如生成、验证等操作
@Autowired
private TokenService tokenService;
// 自动注入字典服务层接口，用于处理字典数据相关的转换等操作
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 此处可能用于自动注入级联表相关的服务层接口，当前代码中未完整体现具体使用情况
/**
* 后端列表
*/
* 后端列表
* 用于获取用户列表数据，并进行分页、字典表数据转换等处理后返回给前端
* @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
* @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 从会话中获取用户角色信息
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此处条件永远为假，实际应该不会进入该分支，可能是预留逻辑待完善
if(false)
return R.error(511,"永不会进入");
// 如果用户角色是"用户"，则添加当前用户ID作为查询条件，用于筛选当前用户相关的数据
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId"));
params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1);
// 设置默认的逻辑删除开始和结束标识，用于筛选未删除的用户数据（这里假设1表示未删除）
params.put("yonghuDeleteStart",1);
params.put("yonghuDeleteEnd",1);
// 如果没有指定排序字段，则默认按照"id"字段进行排序
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
}
// 调用用户服务层的方法查询分页数据
PageUtils page = yonghuService.queryPage(params);
// 获取分页数据中的用户视图列表（可能是用于展示给前端的特定格式数据）
//字典表数据转换
List<YonghuView> list =(List<YonghuView>)page.getList();
// 遍历用户视图列表，对每个用户数据进行字典表数据转换操作
for(YonghuView c:list){
//修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
@ -83,16 +99,24 @@ public class YonghuController {
}
/**
* 后端详情
*/
* 后端详情
* 根据用户ID获取用户的详细信息，进行必要的数据转换后返回给前端
* @param id 用户的唯一标识（通常是数据库中的主键ID）
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
* @return R对象，封装了操作结果及相关数据，成功时包含用户详细信息
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
// 根据ID从数据库中查询用户实体信息
YonghuEntity yonghu = yonghuService.selectById(id);
if(yonghu !=null){
//entity转view
// 创建用户视图对象，用于转换和返回给前端展示的数据格式
YonghuView view = new YonghuView();
// 将用户实体中的数据复制到用户视图对象中，实现数据格式转换
BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
// 对用户视图对象中的相关字典表字段进行数据转换操作
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
@ -104,15 +128,21 @@ public class YonghuController {
}
/**
* 后端保存
*/
* 后端保存
* 用于保存新用户信息到数据库，会先检查用户名和手机号是否已被使用
* @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户注册等数据）
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
* @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用等错误信息
*/
@RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
// 此处条件永远为假，实际应该不会进入该分支，可能是预留逻辑待完善
if(false)
return R.error(511,"永远不会进入");
// 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
@ -123,11 +153,15 @@ public class YonghuController {
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 根据构建的查询条件查询是否已存在相同用户名或手机号的用户
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity==null){
yonghu.setYonghuDelete(1);
// 设置用户的逻辑删除标识为未删除（这里假设1表示未删除）
yonghu.setCreateTime(new Date());
// 设置默认密码（实际应用中可能需要更安全的密码处理方式）
yonghu.setPassword("123456");
// 将新用户信息插入到数据库中
yonghuService.insert(yonghu);
return R.ok();
}else {
@ -136,8 +170,12 @@ public class YonghuController {
}
/**
* 后端修改
*/
* 后端修改
* 根据传入的用户信息更新数据库中对应的用户数据，会先检查用户名和手机号是否已被其他用户使用（排除自身）
* @param yonghu 包含更新后用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户修改后的数据）
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
* @return R对象，封装了操作结果，成功表示更新成功，失败则提示账户或者手机号已经被使用等错误信息
*/
@RequestMapping("/update")
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
@ -157,12 +195,14 @@ public class YonghuController {
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 根据构建的查询条件查询是否已存在符合条件的用户
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
// 如果用户的照片字段为空字符串或"null"，则将其设置为null，可能是为了符合数据库存储要求
if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){
yonghu.setYonghuPhoto(null);
}
if(yonghuEntity==null){
yonghuService.updateById(yonghu);//根据id更新
yonghuService.updateById(yonghu);// 根据用户ID更新数据库中的用户信息
return R.ok();
}else {
return R.error(511,"账户或者手机号已经被使用");
@ -170,10 +210,12 @@ public class YonghuController {
}
/**
* 删除
*/
* 删除
* 批量将指定用户的逻辑删除标识设置为已删除（这里假设2表示已删除），实现软删除功能
* @param ids 包含要删除的用户ID的整数数组，通过请求体传入
* @return R对象，封装了操作结果，成功表示删除操作执行成功（实际只是更新了逻辑删除标识）
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
@ -193,34 +235,47 @@ public class YonghuController {
/**
* 批量上传
* 从指定的Excel文件（仅支持后缀为.xls的文件）中读取用户数据，进行重复性检查后批量插入到数据库中
* @param fileName 要上传的Excel文件名，从请求参数中获取
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如当前用户ID等
* @return R对象，封装了操作结果，成功表示批量插入成功，失败则提示各种错误信息，如文件格式错误、数据重复、插入异常等
*/
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
// 从会话中获取当前用户ID，并转换为整数类型
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<YonghuEntity> yonghuList = new ArrayList<>();//上传的东西
// 用于存储要查询是否重复的字段及对应的值，以字段名为键，值的列表为值
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
Date date = new Date();
int lastIndexOf = fileName.lastIndexOf(".");
// 如果文件名没有后缀，返回错误信息
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
String suffix = fileName.substring(lastIndexOf);
// 如果文件后缀不是.xls，返回错误信息，表明只支持该后缀的Excel文件
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
// 获取指定文件名对应的文件资源路径
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
File file = new File(resource.getFile());
// 如果文件不存在，返回错误信息，提示联系管理员
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
// 使用工具类读取Excel文件中的数据，返回二维列表，每一行表示一条数据
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
// 删除第一行数据，通常第一行是标题行等提示信息，不需要插入数据库
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
YonghuEntity yonghuEntity = new YonghuEntity();
// 以下是对用户实体各字段的赋值操作，目前都被注释掉了，可能需要根据实际Excel文件中的列顺序和数据内容进行正确赋值
// yonghuEntity.setUsername(data.get(0)); //账户 要改的
// //yonghuEntity.setPassword("123456");//密码
// yonghuEntity.setYonghuName(data.get(0)); //用户姓名 要改的
@ -234,8 +289,8 @@ public class YonghuController {
yonghuList.add(yonghuEntity);
//把要查询是否重复的字段放入map中
//账户
// 把要查询是否重复的字段（用户名和手机号）放入seachFields中，用于后续重复性检查
// 处理用户名字段
if(seachFields.containsKey("username")){
List<String> username = seachFields.get("username");
username.add(data.get(0));//要改的
@ -244,7 +299,7 @@ public class YonghuController {
username.add(data.get(0));//要改的
seachFields.put("username",username);
}
//手机号
// 处理手机号字段
if(seachFields.containsKey("yonghuPhone")){
List<String> yonghuPhone = seachFields.get("yonghuPhone");
yonghuPhone.add(data.get(0));//要改的
@ -257,93 +312,135 @@ public class YonghuController {
//查询是否重复
//账户
// 根据从Excel文件中读取的数据里的用户名，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同名用户
List<YonghuEntity> yonghuEntities_username = yonghuService.selectList(new EntityWrapper<YonghuEntity>().in("username", seachFields.get("username")).eq("yonghu_delete", 1));
// 如果查询到的同名用户数量大于0，说明存在重复的用户名
if(yonghuEntities_username.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
// 遍历查询到的同名用户列表，将他们的用户名添加到repeatFields列表中
for(YonghuEntity s:yonghuEntities_username){
repeatFields.add(s.getUsername());
}
// 返回错误信息，提示数据库中该表的[账户]字段已经存在，并列出重复的用户名数据
return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString());
}
//手机号
// 根据从Excel文件中读取的数据里的手机号，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同手机号用户
List<YonghuEntity> yonghuEntities_yonghuPhone = yonghuService.selectList(new EntityWrapper<YonghuEntity>().in("yonghu_phone", seachFields.get("yonghuPhone")).eq("yonghu_delete", 1));
// 如果查询到的同手机号用户数量大于0，说明存在重复的手机号
if(yonghuEntities_yonghuPhone.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(YonghuEntity s:yonghuEntities_yonghuPhone){
repeatFields.add(s.getYonghuPhone());
}
// 返回错误信息，提示数据库中该表的[手机号]字段已经存在，并列出重复的手机号数据
return R.error(511,"数据库的该表中的 [手机号] 字段已经存在 存在数据为:"+repeatFields.toString());
}
// 经过上述重复性检查后，如果没有重复数据，则批量将从Excel文件中读取并整理好的用户数据列表插入到数据库中
yonghuService.insertBatch(yonghuList);
return R.ok();
}
}
}
}catch (Exception e){
// 如果在上述批量插入等操作过程中出现异常，打印异常堆栈信息方便排查问题
e.printStackTrace();
// 返回错误信息，提示批量插入数据出现异常，并建议联系管理员处理
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
/**
* 登录
*/
@IgnoreAuth
* 登录
* 用于处理用户登录逻辑，验证用户名、密码以及账户是否已被删除等情况，登录成功后生成Token并返回相关用户信息
* @param username 用户名，从请求参数中获取
* @param password 密码，从请求参数中获取
* @param captcha 验证码，从请求参数中获取（当前代码中未体现验证码具体验证逻辑）
* @param request HttpServletRequest对象，用于获取当前请求相关的信息
* @return R对象，封装了操作结果及相关数据，成功时包含用户登录后的Token、角色、用户名、所属表名、用户ID等信息，失败则返回相应错误提示
*/
@IgnoreAuth // 该注解可能表示此登录接口不需要进行权限认证（具体取决于该注解的实际定义和功能）
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据传入的用户名从数据库中查询对应的用户实体信息
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
if(yonghu==null || !yonghu.getPassword().equals(password))
// 如果查询到的用户为null（即用户名不存在）或者密码不匹配，返回账号或密码不正确的错误信息
if (yonghu == null ||!yonghu.getPassword().equals(password))
return R.error("账号或密码不正确");
else if(yonghu.getYonghuDelete() != 1)
// 如果用户的逻辑删除标识不为1（这里假设1表示未删除，即账户已被删除），返回账户已被删除的错误信息
else if (yonghu.getYonghuDelete()!= 1)
return R.error("账户已被删除");
// // 获取监听器中的字典表
// 以下几行代码被注释掉了，可能原本是用于获取字典表相关数据进行后续处理的逻辑，目前未生效
// 获取当前Web应用上下文的ServletContext对象，用于获取应用范围内共享的数据（比如字典表数据等）
// ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext();
// Map<String, Map<Integer, String>> dictionaryMap= (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
// 从ServletContext中获取名为"dictionaryMap"的属性，该属性可能是一个嵌套的Map结构，外层键是字典类型，内层键值对是字典代码和对应的名称等信息
// Map<String, Map<Integer, String>> dictionaryMap = (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
// 从字典表数据中获取名为"role_types"的字典类型对应的内层Map，可能是用于获取角色相关的字典信息（如角色代码和角色名称的对应关系等）
// Map<Integer, String> role_types = dictionaryMap.get("role_types");
// role_types.get(.getRoleTypes());
String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户");
// 根据用户ID、用户名、用户类型等信息生成用户登录的Token（具体生成逻辑在TokenService中实现）
String token = tokenService.generateToken(yonghu.getId(), username, "yonghu", "用户");
R r = R.ok();
// 将生成的Token放入返回结果对象中
r.put("token", token);
r.put("role","用户");
r.put("username",yonghu.getYonghuName());
r.put("tableName","yonghu");
r.put("userId",yonghu.getId());
// 将用户角色放入返回结果对象中，这里固定为"用户"
r.put("role", "用户");
// 将用户的真实姓名（假设YonghuEntity中的YonghuName字段表示真实姓名）放入返回结果对象中
r.put("username", yonghu.getYonghuName());
// 将用户所属表名放入返回结果对象中，这里固定为"yonghu"
r.put("tableName", "yonghu");
// 将用户ID放入返回结果对象中
r.put("userId", yonghu.getId());
return r;
}
/**
* 注册
*/
@IgnoreAuth
* 注册
* 用于处理用户注册逻辑，先检查用户名和手机号是否已被使用，若未被使用则将新用户信息插入到数据库中
* @param yonghu 包含用户注册信息的YonghuEntity对象，通过请求体传入（通常是前端提交的注册表单数据等）
* @return R对象，封装了操作结果，成功表示注册成功，失败则提示账户或者手机号已经被使用的错误信息
*/
@IgnoreAuth // 该注解可能表示此注册接口不需要进行权限认证（具体取决于该注解的实际定义和功能）
@PostMapping(value = "/register")
public R register(@RequestBody YonghuEntity yonghu){
// ValidatorUtils.validateEntity(user);
public R register(@RequestBody YonghuEntity yonghu) {
// 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，目前未生效
// ValidatorUtils.validateEntity(user);
// 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
.or()
.eq("yonghu_phone", yonghu.getYonghuPhone())
.andNew()
.eq("yonghu_delete", 1)
;
.eq("username", yonghu.getUsername())
.or()
.eq("yonghu_phone", yonghu.getYonghuPhone())
.andNew()
.eq("yonghu_delete", 1);
// 根据构建的查询条件查询是否已存在相同用户名或手机号的用户
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity != null)
// 如果已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息
if (yonghuEntity!= null)
return R.error("账户或者手机号已经被使用");
// 设置新用户的初始余额为0.0（可能根据业务需求设定的初始值）
yonghu.setNewMoney(0.0);
// 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除）
yonghu.setYonghuDelete(1);
// 设置新用户的创建时间为当前时间
yonghu.setCreateTime(new Date());
// 将新用户信息插入到数据库中
yonghuService.insert(yonghu);
return R.ok();
}
/**
* 重置密码
* 根据传入的用户ID，将对应的用户密码重置为固定值"123456"（实际应用中可能需要更安全合理的密码重置逻辑）
* @param id 用户的唯一标识（通常是数据库中的主键ID），从请求参数中获取
* @return R对象，封装了操作结果，成功表示密码重置成功
*/
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id){
public R resetPassword(Integer id) {
YonghuEntity yonghu = new YonghuEntity();
// 设置要重置的密码为"123456"
yonghu.setPassword("123456");
// 设置要重置密码的用户ID
yonghu.setId(id);
// 根据用户ID更新数据库中对应的用户密码信息
yonghuService.updateById(yonghu);
return R.ok();
}
@ -351,124 +448,171 @@ public class YonghuController {
/**
* 忘记密码
* 用于处理用户忘记密码的情况，根据用户名查找对应的用户，若存在则将其密码重置为固定值“123456”（实际应用中可能需要更安全合理的重置逻辑，比如发送验证码验证等）
* @param username 用户名，从请求参数中获取，用于查找对应的用户
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，但在当前方法中未体现更多相关使用情况
* @return R对象，封装了操作结果，成功表示密码重置成功，若用户不存在则返回账号不存在的错误信息，若更新数据库操作失败则返回相应错误信息
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据传入的用户名从数据库中查询对应的用户实体信息
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
if(yonghu!=null){
// 如果查询到对应的用户实体信息不为null，说明该用户存在
if (yonghu!= null) {
// 将用户的密码设置为固定值“123456”，实际中这样直接设置密码不太安全，可后续优化为更安全的重置逻辑
yonghu.setPassword("123456");
// 通过用户服务层的方法根据用户实体中的ID（已设置好）更新数据库中该用户的密码信息，并获取更新操作的结果（true表示更新成功，false表示更新失败）
boolean b = yonghuService.updateById(yonghu);
if(!b){
return R.error();
// 如果更新操作失败（即b为false），返回相应的错误信息
if (!b) {
return R.error();
}
}else{
return R.error("账号不存在");
} else {
// 如果根据用户名未查询到对应的用户，返回账号不存在的错误信息
return R.error("账号不存在");
}
// 如果密码重置并更新数据库操作都成功，返回操作成功的结果信息
return R.ok();
}
/**
* 获取用户的session用户信息
*/
* 获取用户的session用户信息
* 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息，经过格式转换（实体转视图）和字典表字段转换后返回给前端展示
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID
* @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户视图信息，若查不到数据则返回相应错误信息
*/
@RequestMapping("/session")
public R getCurrYonghu(HttpServletRequest request){
Integer id = (Integer)request.getSession().getAttribute("userId");
public R getCurrYonghu(HttpServletRequest request) {
// 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息
Integer id = (Integer) request.getSession().getAttribute("userId");
// 根据获取到的用户ID从数据库中查询对应的用户实体信息
YonghuEntity yonghu = yonghuService.selectById(id);
if(yonghu !=null){
//entity转view
// 如果查询到的用户实体信息不为null，说明找到了对应的用户
if (yonghu!= null) {
// 创建一个用户视图对象，用于转换和返回适合前端展示的数据格式
YonghuView view = new YonghuView();
BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
// 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换
BeanUtils.copyProperties(yonghu, view);
//修改对应字典表字段
// 调用字典服务层的方法对用户视图对象中的相关字典表字段进行数据转换操作，使数据格式更符合前端展示需求
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
} else {
// 如果根据用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义）
return R.error(511, "查不到数据");
}
}
/**
* 退出
*/
* 退出
* 用于处理用户退出登录的操作，通过使当前请求的会话失效来实现清除用户登录状态等相关信息的效果
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象
* @return R对象，封装了操作结果及相关提示信息，这里返回退出成功的提示
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
// 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录等相关信息
request.getSession().invalidate();
// 返回操作成功的结果信息，并附带“退出成功”的提示内容
return R.ok("退出成功");
}
/**
* 前端列表
*/
* 前端列表
* 该方法用于获取用户列表数据并返回给前端展示，支持排序参数传入，若未传入排序字段则默认按照"id"字段倒序排列，同时会对获取到的数据进行字典表数据转换操作。
* 此接口标注了 @IgnoreAuth 注解，可能意味着该接口不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能）。
* @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等，通过请求参数传入。
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，比如可能用于后续字典表数据转换等操作获取相关上下文信息，但当前代码中未体现更多复杂使用情况。
* @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表（已经过字典表数据转换）。
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
// 判断传入的参数中排序字段是否为空，如果为空（即没有指定排序字段），则将排序字段设置为"id"，表示默认按照"id"字段进行倒序排序（此处未明确体现倒序逻辑，可能在PageUtils或相关数据库查询逻辑中处理）。
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
params.put("orderBy", "id");
}
// 调用用户服务层的queryPage方法，传入参数params，用于查询符合条件的分页用户数据，返回的PageUtils对象包含了分页相关信息以及用户数据列表等内容。
PageUtils page = yonghuService.queryPage(params);
//字典表数据转换
List<YonghuView> list =(List<YonghuView>)page.getList();
for(YonghuView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
// 获取分页数据中的用户视图列表（可能是用于展示给前端的特定格式数据），这里将PageUtils中的用户数据列表取出并强转类型为List<YonghuView>。
List<YonghuView> list = (List<YonghuView>) page.getList();
// 遍历用户视图列表，对每个用户数据进行字典表数据转换操作，调用dictionaryService的dictionaryConvert方法来处理，目的是使展示的数据符合字典表相关的业务格式要求。
for (YonghuView c : list)
dictionaryService.dictionaryConvert(c, request);
return R.ok().put("data", page);
}
/**
* 前端详情
*/
* 前端详情
* 根据传入的用户ID获取对应的用户详细信息，将用户实体数据转换为适合前端展示的视图数据格式，并进行字典表数据转换后返回给前端。
* @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量{id}传入，用于指定要查询详细信息的用户。
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，如在字典表数据转换时可能需要的一些上下文信息等，但当前代码中未体现更多复杂使用情况。
* @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户详细信息，若未查询到对应的数据则返回查不到数据的错误提示。
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。
YonghuEntity yonghu = yonghuService.selectById(id);
if(yonghu !=null){
if (yonghu!= null) {
//entity转view
YonghuView view = new YonghuView();
BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
// 创建一个用户视图对象，用于将从数据库查询到的用户实体数据转换为适合前端展示的数据格式。
YonghuView view = new YonghuView();
// 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换，比如将实体中的各个属性值对应复制到视图对象的相应属性中。
BeanUtils.copyProperties(yonghu, view);
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
// 调用字典服务层的dictionaryConvert方法，对用户视图对象中的相关字典表字段进行数据转换操作，使数据格式更符合前端展示需求，比如将字典代码转换为对应的字典名称等。
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
} else {
// 如果根据传入的用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义）。
return R.error(511, "查不到数据");
}
}
/**
* 前端保存
*/
* 前端保存
* 用于处理前端提交的新增用户信息的保存操作，会先检查用户名和手机号是否已被其他用户使用（逻辑删除标识为1表示未删除的用户），若未被使用则将新用户信息插入到数据库中。
* @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入，通常是前端提交的新增用户表单数据等内容。
* @param request HttpServletRequest对象，用于获取当前请求相关的信息，当前代码中主要用于日志记录展示请求相关信息，但未体现更多复杂使用情况。
* @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用的错误信息。
*/
@RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
logger.debug("add方法:,,Controller:{},,yonghu:{}", this.getClass().getName(), yonghu.toString());
// 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件，通过使用EntityWrapper来方便地构建数据库查询条件。
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername())
.or()
.eq("yonghu_phone", yonghu.getYonghuPhone())
.andNew()
.eq("yonghu_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
.eq("username", yonghu.getUsername())
.or()
.eq("yonghu_phone", yonghu.getYonghuPhone())
.andNew()
.eq("yonghu_delete", 1);
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 根据构建的查询条件查询是否已存在相同用户名或手机号的用户，调用用户服务层的selectOne方法执行查询操作，返回符合条件的用户实体对象（若存在），否则返回null。
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
if(yonghuEntity==null){
if (yonghuEntity == null) {
// 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除），表示该用户数据为有效可用状态。
yonghu.setYonghuDelete(1);
// 设置新用户的创建时间为当前时间，通过创建一个新的Date对象来表示当前时刻。
yonghu.setCreateTime(new Date());
yonghu.setPassword("123456");
yonghuService.insert(yonghu);
// 设置新用户的默认密码为"123456"，实际应用中可能需要更安全的密码设置方式，比如密码加密等操作。
yonghu.setPassword("123456");
// 将包含完整信息的新用户实体对象插入到数据库中，调用用户服务层的insert方法执行插入操作。
yonghuService.insert(yonghu);
return R.ok();
}else {
return R.error(511,"账户或者手机号已经被使用");
} else {
// 如果查询到已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息，错误码为511（具体含义由业务定义）。
return R.error(511, "账户或者手机号已经被使用");
}
}

Write Preview
Loading…
Cancel
Save