diff --git a/src/main/java/com/controller/FileController.java b/src/main/java/com/controller/FileController.java index bf53f29..2c49511 100644 --- a/src/main/java/com/controller/FileController.java +++ b/src/main/java/com/controller/FileController.java @@ -2,6 +2,9 @@ package com.controller; import java.io.File; import java.io.IOException; +import java.net.URLDecoder; +import java.nio.file.Files; +import java.nio.file.StandardCopyOption; import java.util.Date; import javax.servlet.http.HttpServletRequest; @@ -40,29 +43,33 @@ public class FileController{ public R upload(@RequestParam("file") MultipartFile file, String type,HttpServletRequest request) throws Exception { if (file.isEmpty()) { throw new EIException("上传文件不能为空"); + }String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1); + String path = URLDecoder.decode(request.getSession().getServletContext().getRealPath("/upload"),"UTF-8"); + File dest = new File(path); + + if (!dest.getParentFile().exists()) { + dest.getParentFile().mkdirs(); + }String path2 = path.replace("target\\jspm0c59i\\upload", "src\\main\\webapp\\upload\\"); + File upload2 = new File(path2); + if (!upload2.exists()) { + upload2.mkdirs(); } - String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1); - String fileName = new Date().getTime()+"."+fileExt; - File dest = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName); - file.transferTo(dest); - /** - * 如果使用idea或者eclipse重启项目，发现之前上传的图片或者文件丢失，将下面一行代码注释打开 - * 请将以下的"D:\\ssmpiv99\\src\\main\\webapp\\upload"替换成你本地项目的upload路径， - * 并且项目路径不能存在中文、空格等特殊字符 - */ - //FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload"+"/"+fileName)); /**修改了路径以后请将该行最前面的//注释去掉**/ + String fileName = new Date().getTime() + "." + fileExt; + File dest1 = new File(dest.getAbsolutePath() + "/" + fileName); + File dest2 = new File(upload2.getAbsolutePath() + "/" + fileName); + + file.transferTo(dest1); + Files.copy(dest1.toPath(), dest2.toPath(), StandardCopyOption.REPLACE_EXISTING); if(StringUtils.isNotBlank(type) && type.equals("1")) { ConfigEntity configEntity = configService.selectOne(new EntityWrapper().eq("name", "faceFile")); if(configEntity==null) { configEntity = new ConfigEntity(); configEntity.setName("faceFile"); configEntity.setValue(fileName); - } else { + }else { configEntity.setValue(fileName); - } - configService.insertOrUpdate(configEntity); - } - return R.ok().put("file", fileName); + }configService.insertOrUpdate(configEntity); + }return R.ok().put("file", fileName); } /** diff --git a/src/main/java/com/controller/NewsController.java b/src/main/java/com/controller/NewsController.java index 12f15e4..285a7dd 100644 --- a/src/main/java/com/controller/NewsController.java +++ b/src/main/java/com/controller/NewsController.java @@ -1,43 +1,46 @@ package com.controller; +// 定义控制器所在的包名 + +import java.math.BigDecimal; // 导入BigDecimal类，用于进行高精度的数学运算 +import java.text.SimpleDateFormat; // 导入SimpleDateFormat类，用于格式化和解析日期 +import java.text.ParseException; // 导入ParseException类，用于处理日期解析异常 +import java.util.ArrayList; // 导入ArrayList类，用于创建动态数组 +import java.util.Arrays; // 导入Arrays类，提供了对数组操作的工具方法 +import java.util.Calendar; // 导入Calendar类，用于日期时间的操作 +import java.util.Map; // 导入Map接口，用于键值对集合 +import java.util.HashMap; // 导入HashMap类，基于哈希表的Map实现 +import java.util.Iterator; // 导入Iterator接口，用于遍历集合 +import java.util.Date; // 导入Date类，用于日期时间的表示 +import java.util.List; // 导入List接口，用于列表集合 + +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口，用于访问HTTP请求信息 +import java.io.IOException; // 导入IOException类，用于处理IO异常 + +import com.utils.ValidatorUtils; // 导入自定义的ValidatorUtils工具类，用于数据验证 +import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang库的StringUtils类，用于字符串操作 +import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的Autowired注解，用于自动注入依赖 +import org.springframework.transaction.annotation.Transactional; // 导入Spring的Transactional注解，用于声明事务 +import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解，用于日期格式注解 +import org.springframework.web.bind.annotation.PathVariable; // 导入Spring的PathVariable注解，用于将URL中的参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestBody; // 导入Spring的RequestBody注解，用于将HTTP请求的body部分绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring的RequestMapping注解，用于定义请求映射 +import org.springframework.web.bind.annotation.RequestParam; // 导入Spring的RequestParam注解，用于将请求参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RestController; // 导入Spring的RestController注解，用于定义REST风格的控制器 + +import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus的EntityWrapper类，用于构建查询条件 +import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus的Wrapper接口，EntityWrapper实现该接口 +import com.annotation.IgnoreAuth; // 导入自定义的IgnoreAuth注解，用于忽略权限验证 + +import com.entity.NewsEntity; // 导入新闻实体类 +import com.entity.view.NewsView; // 导入新闻视图类 +import com.service.NewsService; // 导入新闻服务类 +import com.service.TokenService; // 导入Token服务类 +import com.utils.PageUtils; // 导入自定义的PageUtils工具类，用于分页处理 +import com.utils.R; // 导入自定义的R类，用于封装响应结果 +import com.utils.MD5Util; // 导入自定义的MD5Util工具类，用于MD5加密 +import com.utils.MPUtil; // 导入自定义的MPUtil工具类，提供MyBatis Plus工具方法 +import com.utils.CommonUtil; // 导入自定义的CommonUtil工具类，提供常用方法 -import java.math.BigDecimal; -import java.text.SimpleDateFormat; -import java.text.ParseException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Map; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Date; -import java.util.List; -import javax.servlet.http.HttpServletRequest; -import java.io.IOException; - -import com.utils.ValidatorUtils; -import org.apache.commons.lang3.StringUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.format.annotation.DateTimeFormat; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; -import com.baomidou.mybatisplus.mapper.EntityWrapper; -import com.baomidou.mybatisplus.mapper.Wrapper; -import com.annotation.IgnoreAuth; - -import com.entity.NewsEntity; -import com.entity.view.NewsView; - -import com.service.NewsService; -import com.service.TokenService; -import com.utils.PageUtils; -import com.utils.R; -import com.utils.MD5Util; -import com.utils.MPUtil; -import com.utils.CommonUtil; /** * 公告信息 @@ -50,181 +53,214 @@ import com.utils.CommonUtil; @RequestMapping("/news") public class NewsController { @Autowired - private NewsService newsService; - - - - - + private NewsService newsService;//注入新闻服务类 /** * 后端列表 */ @RequestMapping("/page") - public R page(@RequestParam Map params,NewsEntity news, - HttpServletRequest request){ - + public R page(@RequestParam Map params, NewsEntity news, HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); - request.setAttribute("data", page); + // 使用MPUtil工具类对查询条件进行排序和分页处理 + PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); + + // 将分页结果设置到request对象中 + request.setAttribute("data", page); + + // 返回成功响应，包含分页结果 return R.ok().put("data", page); } - + /** * 前端列表 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/list") - public R list(@RequestParam Map params,NewsEntity news, - HttpServletRequest request){ + public R list(@RequestParam Map params, NewsEntity news, HttpServletRequest request) { + // 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper ew = new EntityWrapper(); - PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); - request.setAttribute("data", page); + // 使用MPUtil工具类对查询条件进行排序和分页处理 + PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); + + // 将分页结果设置到request对象中 + request.setAttribute("data", page); + + // 返回成功响应，包含分页结果 return R.ok().put("data", page); } - /** + /** * 列表 */ @RequestMapping("/lists") - public R list( NewsEntity news){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( news, "news")); + //一个Spring MVC的注解，用于将HTTP请求映射到 list 方法。当客户端发送一个HTTP请求到 /lists 路径时，Spring MVC会调用 list 方法来处理这个请求 + public R list(NewsEntity news) //NewsEntity news 参数表示要查询的 NewsEntity 对象 + { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + + // 使用MPUtil工具类对查询条件进行排序和分页处理 + ew.allEq(MPUtil.allEQMapPre(news, "news")); + + // 返回成功响应，包含查询结果 return R.ok().put("data", newsService.selectListView(ew)); + //这行代码返回一个表示请求成功的响应对象，并将 newsService.selectListView(ew) 的结果添加到响应对象中，键为 "data"。 + //newsService.selectListView(ew) 方法用于查询满足 ew 对象的查询条件的记录，并返回一个包含查询结果的列表。 } - /** + /** * 查询 */ @RequestMapping("/query") - public R query(NewsEntity news){ - EntityWrapper< NewsEntity> ew = new EntityWrapper< NewsEntity>(); - ew.allEq(MPUtil.allEQMapPre( news, "news")); - NewsView newsView = newsService.selectView(ew); - return R.ok("查询公告信息成功").put("data", newsView); + public R query(NewsEntity news) { + // 创建一个EntityWrapper对象，用于构建查询条件 + EntityWrapper ew = new EntityWrapper(); + + // 使用MPUtil工具类对查询条件进行排序和分页处理 + ew.allEq(MPUtil.allEQMapPre(news, "news")); + +// 调用 newsService 对象的 selectView 方法，查询满足 ew 对象的查询条件的记录，并返回一个 NewsView 对象 + NewsView newsView = newsService.selectView(ew); + return R.ok("查询公告信息成功").put("data", newsView); } - + /** * 后端详情 */ + //一个Spring MVC的注解，用于将HTTP请求映射到 info 方法。 + //当客户端发送一个HTTP请求到 /info/{id} 路径时，Spring MVC会调用 info 方法来处理这个请求 @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ + public R info(@PathVariable("id") Long id) { + // 根据ID查询并返回结果 NewsEntity news = newsService.selectById(id); - return R.ok().put("data", news); + //调用 newsService 对象的 selectById 方法，根据 id 参数的值查询数据库中的记录，并返回一个 NewsEntity 对象。 + return R.ok().put("data", news); //将 news 对象添加到响应对象中，键为 "data" } - /** * 前端详情 */ - @IgnoreAuth + @IgnoreAuth @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ + public R detail(@PathVariable("id") Long id) { + // 根据ID查询并返回结果 NewsEntity news = newsService.selectById(id); return R.ok().put("data", news); } - - - /** * 后端保存 */ @RequestMapping("/save") - public R save(@RequestBody NewsEntity news, HttpServletRequest request){ - news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(news); + public R save(@RequestBody NewsEntity news, HttpServletRequest request) { + // 设置ID为当前时间戳加上一个随机数 + news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + + // 验证实体对象，如果需要验证，可以取消注释 + // ValidatorUtils.validateEntity(news); + // 插入数据，将 news 对象插入到数据库中 newsService.insert(news); + //返回一个表示请求成功的响应对象 return R.ok(); } - + /** * 前端保存 */ @RequestMapping("/add") - public R add(@RequestBody NewsEntity news, HttpServletRequest request){ - news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(news); + public R add(@RequestBody NewsEntity news, HttpServletRequest request) { + // 设置ID为当前时间戳加上一个随机数 + news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); + + // 验证实体对象，如果需要验证，可以取消注释 + // ValidatorUtils.validateEntity(news); + // 插入数据 newsService.insert(news); return R.ok(); } - /** * 修改 */ @RequestMapping("/update") @Transactional - public R update(@RequestBody NewsEntity news, HttpServletRequest request){ - //ValidatorUtils.validateEntity(news); - newsService.updateById(news);//全部更新 + public R update(@RequestBody NewsEntity news, HttpServletRequest request) { + // 验证实体对象，如果需要验证，可以取消注释 + // ValidatorUtils.validateEntity(news); + + // 更新数据 + newsService.updateById(news); return R.ok(); } - - /** * 删除 */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ + @RequestMapping("/delete")//这是一个Spring MVC的注解，用于将HTTP请求映射到 delete方法上 + public R delete(@RequestBody Long[] ids) { + // 批量删除数据 newsService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); + return R.ok();//R.ok() 方法通常表示请求成功，并返回一个默认的成功响应。 } - + /** * 提醒接口 */ - @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type,@RequestParam Map map) { - map.put("column", columnName); - map.put("type", type); - - if(type.equals("2")) { - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - Calendar c = Calendar.getInstance(); - Date remindStartDate = null; - Date remindEndDate = null; - if(map.get("remindstart")!=null) { - Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindStart); - remindStartDate = c.getTime(); - map.put("remindstart", sdf.format(remindStartDate)); - } - if(map.get("remindend")!=null) { - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); - remindEndDate = c.getTime(); - map.put("remindend", sdf.format(remindEndDate)); - } - } - - Wrapper wrapper = new EntityWrapper(); - if(map.get("remindstart")!=null) { - wrapper.ge(columnName, map.get("remindstart")); - } - if(map.get("remindend")!=null) { - wrapper.le(columnName, map.get("remindend")); - } - - - int count = newsService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - - - - - - - - -} + @RequestMapping("/remind/{columnName}/{type}") + //这是一个Spring MVC的注解，用于将HTTP请求映射到 remindCount 方法。当客户端发送一个HTTP请求到 /remind/{columnName}/{type} 路径时，Spring MVC会调用 remindCount 方法来处理这个请求。 + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + @PathVariable("type") String type, @RequestParam Map map) { + // 将列名和类型添加到map中,@PathVariable 注解表示 columnName 和 type 参数的值将从URL路径中获取 + map.put("column", columnName);//将 columnName 参数的值添加到 map 中，键为 "column"。 + map.put("type", type); + + if (type.equals("2")) //如果 type 参数的值为 "2" + { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + //创建一个 SimpleDateFormat 对象sdf，用于将日期格式化为 "yyyy-MM-dd" 格式。 + Calendar c = Calendar.getInstance(); + //创建一个 Calendar 对象，用于处理日期和时间。Calendar.getInstance() 方法返回一个表示当前日期和时间的 Calendar 对象。 + Date remindStartDate = null;//声明一个变量 remindStartDate,初始化为 null,这个变量将用于存储提醒开始日期。 + Date remindEndDate = null; + + if (map.get("remindstart") != null)//如果 map 中存在键为 "remindstart" 的元素 + { + Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); + //将 map 中键为 "remindstart" 的元素的值转换为 Integer 类型，并赋值给 remindStart + c.setTime(new Date());//setTime(new Date()) 方法将 Calendar 对象c的时间设置为当前时间。 + c.add(Calendar.DAY_OF_MONTH, remindStart);//将 Calendar 对象的时间增加 remindStart 天。 + remindStartDate = c.getTime();//返回一个表示 Calendar 对象当前时间的 Date 对象，并将其赋值给 remindStartDate。 + map.put("remindstart", sdf.format(remindStartDate));//将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并将其作为 map 中键为 "remindstart" 的元素的值。 + } + + if (map.get("remindend") != null) + { + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); + c.setTime(new Date());//c 的时间设置为当前时间 + c.add(Calendar.DAY_OF_MONTH, remindEnd);//c 的时间增加 remindStart 天 + remindEndDate = c.getTime(); + map.put("remindend", sdf.format(remindEndDate)); + } + } + + // 创建一个EntityWrapper对象，用于构建查询条件 + Wrapper wrapper = new EntityWrapper();//创建一个EntityWrapper对象，用于构建查询条件 + + if (map.get("remindstart") != null)//如果map中存在键为"remindstart"的元素 + { + wrapper.ge(columnName, map.get("remindstart"));//将 wrapper 对象的查询条件设置为 columnName>=map 中键为 "remindend" 的元素的值 + } + + if (map.get("remindend") != null) { + wrapper.le(columnName, map.get("remindend"));//将 wrapper 对象的查询条件设置为 columnName<=map 中键为 "remindend" 的元素的值 + } + + // 查询并返回结果 + int count = newsService.selectCount(wrapper);//查询满足wrapper对象的查询条件的记录数，并赋值给 count 变量 + return R.ok().put("count", count);//返回一个包含 count 变量的 R 对象(请求成功的响应对象) + } +} \ No newline at end of file diff --git a/src/main/java/com/controller/StoreupController.java b/src/main/java/com/controller/StoreupController.java index 46bfa76..c2620db 100644 --- a/src/main/java/com/controller/StoreupController.java +++ b/src/main/java/com/controller/StoreupController.java @@ -1,43 +1,44 @@ package com.controller; - -import java.math.BigDecimal; -import java.text.SimpleDateFormat; -import java.text.ParseException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Map; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Date; -import java.util.List; -import javax.servlet.http.HttpServletRequest; -import java.io.IOException; - -import com.utils.ValidatorUtils; -import org.apache.commons.lang3.StringUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.format.annotation.DateTimeFormat; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; -import com.baomidou.mybatisplus.mapper.EntityWrapper; -import com.baomidou.mybatisplus.mapper.Wrapper; -import com.annotation.IgnoreAuth; - -import com.entity.StoreupEntity; -import com.entity.view.StoreupView; - -import com.service.StoreupService; -import com.service.TokenService; -import com.utils.PageUtils; -import com.utils.R; -import com.utils.MD5Util; -import com.utils.MPUtil; -import com.utils.CommonUtil; +import java.math.BigDecimal; // 导入BigDecimal类，用于高精度的数学计算 +import java.text.SimpleDateFormat; // 导入SimpleDateFormat类，用于日期格式化 +import java.text.ParseException; // 导入ParseException类，用于处理日期解析异常 +import java.util.ArrayList; // 导入ArrayList类，用于创建动态数组 +import java.util.Arrays; // 导入Arrays类，提供对数组操作的工具方法 +import java.util.Calendar; // 导入Calendar类，用于日期时间操作 +import java.util.Map; // 导入Map接口，用于键值对集合 +import java.util.HashMap; // 导入HashMap类，基于哈希表的Map实现 +import java.util.Iterator; // 导入Iterator接口，用于遍历集合 +import java.util.Date; // 导入Date类，用于日期时间表示 +import java.util.List; // 导入List接口，用于列表集合 +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口，用于访问HTTP请求信息 +import java.io.IOException; // 导入IOException类，用于处理输入输出异常 + +import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类，用于实体验证 +import org.apache.commons.lang3.StringUtils; // 导入StringUtils类，提供字符串操作的工具方法 +import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解，用于自动注入依赖 +import org.springframework.transaction.annotation.Transactional; // 导入Transactional注解，用于声明事务管理 +import org.springframework.format.annotation.DateTimeFormat; // 导入DateTimeFormat注解，用于日期时间格式化 +import org.springframework.web.bind.annotation.PathVariable; // 导入PathVariable注解，用于将URL中的参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestBody; // 导入RequestBody注解，用于将HTTP请求体绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestMapping; // 导入RequestMapping注解，用于映射HTTP请求到控制器方法 +import org.springframework.web.bind.annotation.RequestParam; // 导入RequestParam注解，用于将请求参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RestController; // 导入RestController注解，用于声明一个REST风格的控制器 + +import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入EntityWrapper类，用于构建查询条件 +import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口，用于封装查询条件 + +import com.annotation.IgnoreAuth; // 导入IgnoreAuth注解，用于标记不需要认证的接口 + +import com.entity.StoreupEntity; // 导入StoreupEntity实体类，代表存储数据 +import com.entity.view.StoreupView; // 导入StoreupView视图类，用于展示存储数据 + +import com.service.StoreupService; // 导入StoreupService接口，用于存储业务操作 +import com.service.TokenService; // 导入TokenService接口，用于令牌操作（未使用） +import com.utils.PageUtils; // 导入PageUtils工具类，用于分页处理 +import com.utils.R; // 导入R工具类，用于构建统一的响应格式 +import com.utils.MD5Util; // 导入MD5Util工具类，用于MD5加密（未使用） +import com.utils.MPUtil; // 导入MPUtil工具类，提供MyBatis Plus操作的工具方法 +import com.utils.CommonUtil; // 导入CommonUtil工具类，提供通用的工具方法 /** * 收藏表 @@ -52,186 +53,170 @@ public class StoreupController { @Autowired private StoreupService storeupService; - - - - - /** * 后端列表 */ - @RequestMapping("/page") - public R page(@RequestParam Map params,StoreupEntity storeup, - HttpServletRequest request){ - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - storeup.setUserid((Long)request.getSession().getAttribute("userId")); + @RequestMapping("/page")//定义了一个处理HTTP请求的映射，当请求路径为/page时，会调用这个方法 + public R page(@RequestParam Map params,StoreupEntity storeup,HttpServletRequest request) + {//定义了一个公共方法，接收请求参数、实体对象和HTTP请求对象 + if(!request.getSession().getAttribute("role").toString().equals("管理员")) + {//检查当前用户的角色是否为管理员，如果不是管理员，则设置用户ID + storeup.setUserid((Long)request.getSession().getAttribute("userId"));//设置用户ID } - - EntityWrapper ew = new EntityWrapper(); - - PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); - request.setAttribute("data", page); - return R.ok().put("data", page); + EntityWrapper ew = new EntityWrapper();//创建一个实体包装器对象，用于构建查询条件 + PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));//调用storeupService的queryPage方法，根据查询条件和分页参数进行分页查询，并返回分页结果 + request.setAttribute("data", page);//将分页结果设置到HTTP请求对象中 + return R.ok().put("data", page);//返回一个包含分页结果的响应对象 } - /** * 前端列表 */ - @IgnoreAuth - @RequestMapping("/list") - public R list(@RequestParam Map params,StoreupEntity storeup, - HttpServletRequest request){ - EntityWrapper ew = new EntityWrapper(); - - PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params)); - request.setAttribute("data", page); - return R.ok().put("data", page); + @IgnoreAuth//定义了一个注解，用于标记不需要权限认证的接口 + @RequestMapping("/list")//定义了一个处理HTTP请求的映射，当请求路径为/list时，会调用这个方法 + public R list(@RequestParam Map params,StoreupEntity storeup,HttpServletRequest request) + { + EntityWrapper ew = new EntityWrapper();//创建一个实体包装器对象，用于构建查询条件 + PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));//调用storeupService的queryPage方法，根据查询条件和分页参数进行分页查询，并返回分页结果 + request.setAttribute("data", page);//将分页查询结果设置到HTTP请求对象中 + return R.ok().put("data", page);//返回一个包含分页查询结果的响应对象 } /** * 列表 */ @RequestMapping("/lists") - public R list( StoreupEntity storeup){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); - return R.ok().put("data", storeupService.selectListView(ew)); + public R list( StoreupEntity storeup)//定义了一个公共方法，接收实体对象 + { + EntityWrapper ew = new EntityWrapper();//创建一个实体包装器对象，用于构建查询条件 + ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); //使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 + return R.ok().put("data", storeupService.selectListView(ew));//根据查询条件查询出符合条件的实体对象列表，并返回一个包含实体对象列表的响应对象 } /** * 查询 */ - @RequestMapping("/query") - public R query(StoreupEntity storeup){ + @RequestMapping("/query")//定义了一个处理HTTP请求的映射，当请求路径为/query时，会调用这个方法。 + public R query(StoreupEntity storeup) + { EntityWrapper< StoreupEntity> ew = new EntityWrapper< StoreupEntity>(); + //创建一个实体包装器,用于构建查询条件 ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); + //使用allEq方法设置查询条件,MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象。 StoreupView storeupView = storeupService.selectView(ew); + //调用服务层的方法查询单个数据，并返回视图对象 return R.ok("查询收藏表成功").put("data", storeupView); + //返回一个包含查询结果的响应对象，并附带成功消息 } /** * 后端详情 */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ - StoreupEntity storeup = storeupService.selectById(id); - return R.ok().put("data", storeup); + @RequestMapping("/info/{id}")// 定义一个请求映射，当访问 /info/{id} 路径时，会调用这个方法 + public R info(@PathVariable("id") Long id)// 定义一个方法，接收一个路径变量 id，类型为 Long + { + StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据，并返回实体对象 + return R.ok().put("data", storeup);//返回一个包含查询结果的 R 对象，其中包含键 "data" 和对应的 storeup 实体对象 } - /** * 前端详情 */ - @IgnoreAuth - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ - StoreupEntity storeup = storeupService.selectById(id); - return R.ok().put("data", storeup); + @IgnoreAuth//定义了一个注解，用于标记不需要权限认证的接口 + @RequestMapping("/detail/{id}")//定义了一个处理HTTP请求的映射，当请求路径为/detail/{id}时，会调用这个方法 + public R detail(@PathVariable("id") Long id)//定义了一个方法，接收一个路径变量 id，类型为 Long + { + StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据，并返回实体对象 + return R.ok().put("data", storeup);//返回一个包含查询结果的响应对象，并附带成功消息 } - - - - /** * 后端保存 */ - @RequestMapping("/save") - public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request){ + @RequestMapping("/save")//定义了一个处理HTTP请求的映射，当请求路径为/save时，会调用这个方法 + public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法，接收一个JSON格式的请求体，类型为 StoreupEntity，并接收一个 HttpServletRequest 对象 + { storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); //ValidatorUtils.validateEntity(storeup); - storeup.setUserid((Long)request.getSession().getAttribute("userId")); - - storeupService.insert(storeup); - return R.ok(); + storeup.setUserid((Long)request.getSession().getAttribute("userId"));//从请求的 session 中获取用户ID，并设置到 storeup 实体对象中 + storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库 + return R.ok();//返回一个包含成功信息的 R 对象 } /** * 前端保存 */ - @RequestMapping("/add") - public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request){ - storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); + @RequestMapping("/add")//定义了一个处理HTTP请求的映射，当请求路径为/add时，会调用这个方法 + public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request) //定义一个方法，接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象 + { + storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());//生成一个新的唯一ID，由当前时间戳加上一个随机数 //ValidatorUtils.validateEntity(storeup); - - storeupService.insert(storeup); + storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库 return R.ok(); } - - /** * 修改 */ @RequestMapping("/update") - @Transactional - public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request){ + @Transactional//定义了一个事务注解，表示该方法中的数据库操作应该在一个事务中执行 + public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法，接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象 + { //ValidatorUtils.validateEntity(storeup); - storeupService.updateById(storeup);//全部更新 - return R.ok(); + storeupService.updateById(storeup);//调用服务层的方法根据 ID 更新 storeup 实体对象的所有字段 + return R.ok();//返回一个包含成功信息的 R 对象 } - - /** * 删除 */ @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - storeupService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); + public R delete(@RequestBody Long[] ids)// 定义一个方法，接收一个请求体中的 Long 数组，类型为 Long[] + { + storeupService.deleteBatchIds(Arrays.asList(ids));//调用服务层的方法，根据传入的 ID 数组批量删除数据 + return R.ok();//返回一个包含成功信息的 R 对象 R.ok()函数是R工具类中的一个静态方法，用于创建一个包含成功信息的响应对象 } /** * 提醒接口 */ - @RequestMapping("/remind/{columnName}/{type}") - public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type,@RequestParam Map map) { - map.put("column", columnName); - map.put("type", type); - - if(type.equals("2")) { - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - Calendar c = Calendar.getInstance(); - Date remindStartDate = null; - Date remindEndDate = null; - if(map.get("remindstart")!=null) { - Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindStart); - remindStartDate = c.getTime(); - map.put("remindstart", sdf.format(remindStartDate)); - } - if(map.get("remindend")!=null) { - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); - remindEndDate = c.getTime(); - map.put("remindend", sdf.format(remindEndDate)); - } - } - - Wrapper wrapper = new EntityWrapper(); - if(map.get("remindstart")!=null) { - wrapper.ge(columnName, map.get("remindstart")); - } - if(map.get("remindend")!=null) { - wrapper.le(columnName, map.get("remindend")); - } - if(!request.getSession().getAttribute("role").toString().equals("管理员")) { - wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); - } - - - int count = storeupService.selectCount(wrapper); - return R.ok().put("count", count); - } - - - - - - - - - + @RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射，当访问 /remind/{columnName}/{type} 路径时，会调用这个方法 + public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, + @PathVariable("type") String type,@RequestParam Map map) { // 定义一个方法，接收一个路径变量 columnName 和 type，类型为 String，以及一个请求参数 map，类型为 Map + map.put("column", columnName); // 将 columnName 添加到 map 中，键为 "column" + map.put("type", type); // 将 type 添加到 map 中，键为 "type" + + if(type.equals("2")) { // 如果 type 等于 "2" + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象，格式为 "yyyy-MM-dd" + Calendar c = Calendar.getInstance(); // 创建一个日历对象，获取当前时间 + Date remindStartDate = null; // 创建一个日期对象，用于存储提醒开始时间 + Date remindEndDate = null; // 创建一个日期对象，用于存储提醒结束时间 + if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 + Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数 + c.setTime(new Date()); // 设置日历对象的时间为当前时间 + c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天 + remindStartDate = c.getTime(); // 获取增加后的时间，并赋值给 remindStartDate + map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindstart" + } + if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数 + c.setTime(new Date()); // 设置日历对象的时间为当前时间 + c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天 + remindEndDate = c.getTime(); // 获取增加后的时间，并赋值给 remindEndDate + map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindend" + } + } + + Wrapper wrapper = new EntityWrapper(); // 创建一个实体包装器对象，用于构建查询条件 + if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 + wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件，查询 columnName 字段大于等于 "remindstart" 键对应的值 + } + if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 + wrapper.le(columnName, map.get("remindend")); // 设置查询条件，查询 columnName 字段小于等于 "remindend" 键对应的值 + } + if(!request.getSession().getAttribute("role").toString().equals("管理员")) { // 如果当前用户的角色不是管理员 + wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); // 设置查询条件，查询 userid 字段等于当前用户的 ID + } + + int count = storeupService.selectCount(wrapper); // 调用服务层的方法，根据查询条件查询符合条件的记录数，并赋值给 count + return R.ok().put("count", count); // 返回一个包含查询结果的响应对象，其中包含键 "count" 和对应的 count 值 + } + } diff --git a/src/main/java/com/controller/SystemintroController.java b/src/main/java/com/controller/SystemintroController.java index f68fd04..0b3a5b2 100644 --- a/src/main/java/com/controller/SystemintroController.java +++ b/src/main/java/com/controller/SystemintroController.java @@ -1,43 +1,45 @@ -package com.controller; - -import java.math.BigDecimal; -import java.text.SimpleDateFormat; -import java.text.ParseException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Map; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Date; -import java.util.List; -import javax.servlet.http.HttpServletRequest; -import java.io.IOException; - -import com.utils.ValidatorUtils; -import org.apache.commons.lang3.StringUtils; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.format.annotation.DateTimeFormat; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestParam; -import org.springframework.web.bind.annotation.RestController; -import com.baomidou.mybatisplus.mapper.EntityWrapper; -import com.baomidou.mybatisplus.mapper.Wrapper; -import com.annotation.IgnoreAuth; - -import com.entity.SystemintroEntity; -import com.entity.view.SystemintroView; - -import com.service.SystemintroService; -import com.service.TokenService; -import com.utils.PageUtils; -import com.utils.R; -import com.utils.MD5Util; -import com.utils.MPUtil; -import com.utils.CommonUtil; +package com.controller; // 定义一个包，用于组织和管理类 + +import java.math.BigDecimal; // 导入BigDecimal类，用于高精度的数学计算 +import java.text.SimpleDateFormat; // 导入SimpleDateFormat类，用于日期格式化 +import java.text.ParseException; // 导入ParseException类，用于处理日期解析异常 +import java.util.ArrayList; // 导入ArrayList类，用于创建动态数组 +import java.util.Arrays; // 导入Arrays类，提供对数组操作的工具方法 +import java.util.Calendar; // 导入Calendar类，用于日期时间操作 +import java.util.Map; // 导入Map接口，用于键值对集合 +import java.util.HashMap; // 导入HashMap类，基于哈希表的Map实现 +import java.util.Iterator; // 导入Iterator接口，用于遍历集合 +import java.util.Date; // 导入Date类，用于日期时间表示 +import java.util.List; // 导入List接口，用于列表集合 +import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口，用于访问HTTP请求信息 +import java.io.IOException; // 导入IOException类，用于处理输入输出异常 + +import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类，用于实体验证 +import org.apache.commons.lang3.StringUtils; // 导入StringUtils类，提供字符串操作的工具方法 +import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解，用于自动注入依赖 +import org.springframework.transaction.annotation.Transactional; // 导入Transactional注解，用于声明事务管理 +import org.springframework.format.annotation.DateTimeFormat; // 导入DateTimeFormat注解，用于日期时间格式化 +import org.springframework.web.bind.annotation.PathVariable; // 导入PathVariable注解，用于将URL中的参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestBody; // 导入RequestBody注解，用于将HTTP请求体绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RequestMapping; // 导入RequestMapping注解，用于映射HTTP请求到控制器方法 +import org.springframework.web.bind.annotation.RequestParam; // 导入RequestParam注解，用于将请求参数绑定到控制器方法的参数上 +import org.springframework.web.bind.annotation.RestController; // 导入RestController注解，用于声明一个REST风格的控制器 + +import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入EntityWrapper类，用于构建查询条件 +import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口，用于封装查询条件 + +import com.annotation.IgnoreAuth; // 导入IgnoreAuth注解，用于标记不需要认证的接口 + +import com.entity.SystemintroEntity; // 导入SystemintroEntity实体类，代表存储数据 +import com.entity.view.SystemintroView; // 导入SystemintroView视图类，用于展示存储数据 + +import com.service.SystemintroService; // 导入SystemintroService接口，用于存储业务操作 +import com.service.TokenService; // 导入TokenService接口，用于令牌操作（未使用） +import com.utils.PageUtils; // 导入PageUtils工具类，用于分页处理 +import com.utils.R; // 导入R工具类，用于构建统一的响应格式 +import com.utils.MD5Util; // 导入MD5Util工具类，用于MD5加密（未使用） +import com.utils.MPUtil; // 导入MPUtil工具类，提供MyBatis Plus操作的工具方法 +import com.utils.CommonUtil; // 导入CommonUtil工具类，提供通用的工具方法 /** * 关于我们 @@ -46,83 +48,75 @@ import com.utils.CommonUtil; * @email * @date 2023-02-21 09:46:06 */ -@RestController -@RequestMapping("/systemintro") +@RestController // 声明一个REST风格的控制器 +@RequestMapping("/systemintro") // 定义一个请求映射，当访问 /systemintro 路径时，会调用这个控制器 public class SystemintroController { - @Autowired - private SystemintroService systemintroService; - - - - - + @Autowired // 自动注入依赖 + private SystemintroService systemintroService; // 声明一个SystemintroService对象，用于存储业务操作 /** * 后端列表 */ - @RequestMapping("/page") + @RequestMapping("/page") // 定义一个请求映射，当访问 /page 路径时，会调用这个方法 public R page(@RequestParam Map params,SystemintroEntity systemintro, - HttpServletRequest request){ - - EntityWrapper ew = new EntityWrapper(); - - PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); - request.setAttribute("data", page); - return R.ok().put("data", page); + HttpServletRequest request){ // 定义一个方法，接收请求参数、实体对象和HTTP请求对象 + EntityWrapper ew = new EntityWrapper(); // 创建一个实体包装器对象，用于构建查询条件 + PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法，根据查询条件和分页参数进行分页查询，并返回分页结果 + request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中 + return R.ok().put("data", page); // 返回一个包含分页结果的响应对象 } /** * 前端列表 */ - @IgnoreAuth - @RequestMapping("/list") + @IgnoreAuth // 定义了一个注解，用于标记不需要权限认证的接口 + @RequestMapping("/list") // 定义一个请求映射，当访问 /list 路径时，会调用这个方法 public R list(@RequestParam Map params,SystemintroEntity systemintro, - HttpServletRequest request){ - EntityWrapper ew = new EntityWrapper(); - - PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); - request.setAttribute("data", page); - return R.ok().put("data", page); + HttpServletRequest request){ // 定义一个方法，接收请求参数、实体对象和HTTP请求对象 + EntityWrapper ew = new EntityWrapper(); // 创建一个实体包装器对象，用于构建查询条件 + PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法，根据查询条件和分页参数进行分页查询，并返回分页结果 + request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中 + return R.ok().put("data", page); // 返回一个包含分页结果的响应对象 } /** * 列表 */ - @RequestMapping("/lists") - public R list( SystemintroEntity systemintro){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); - return R.ok().put("data", systemintroService.selectListView(ew)); + @RequestMapping("/lists") // 定义一个请求映射，当访问 /lists 路径时，会调用这个方法 + public R list( SystemintroEntity systemintro){ // 定义一个方法，接收实体对象 + EntityWrapper ew = new EntityWrapper(); // 创建一个实体包装器对象，用于构建查询条件 + ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 + return R.ok().put("data", systemintroService.selectListView(ew)); // 根据查询条件查询出符合条件的实体对象列表，并返回一个包含实体对象列表的响应对象 } /** * 查询 */ - @RequestMapping("/query") - public R query(SystemintroEntity systemintro){ - EntityWrapper< SystemintroEntity> ew = new EntityWrapper< SystemintroEntity>(); - ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); - SystemintroView systemintroView = systemintroService.selectView(ew); - return R.ok("查询关于我们成功").put("data", systemintroView); + @RequestMapping("/query") // 定义一个请求映射，当访问 /query 路径时，会调用这个方法 + public R query(SystemintroEntity systemintro){ // 定义一个方法，接收实体对象 + EntityWrapper< SystemintroEntity> ew = new EntityWrapper< SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件 + ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 + SystemintroView systemintroView = systemintroService.selectView(ew); // 调用服务层的方法查询单个数据，并返回视图对象 + return R.ok("查询关于我们成功").put("data", systemintroView); // 返回一个包含查询结果的响应对象，并附带成功消息 } /** * 后端详情 */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") Long id){ - SystemintroEntity systemintro = systemintroService.selectById(id); - return R.ok().put("data", systemintro); + @RequestMapping("/info/{id}") // 定义一个请求映射，当访问 /info/{id} 路径时，会调用这个方法 + public R info(@PathVariable("id") Long id){ // 定义一个方法，接收一个路径变量 id，类型为 Long + SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据，并返回实体对象 + return R.ok().put("data", systemintro); // 返回一个包含查询结果的 R 对象，其中包含键 "data" 和对应的 systemintro 实体对象 } /** * 前端详情 */ - @IgnoreAuth - @RequestMapping("/detail/{id}") - public R detail(@PathVariable("id") Long id){ - SystemintroEntity systemintro = systemintroService.selectById(id); - return R.ok().put("data", systemintro); + @IgnoreAuth // 定义了一个注解，用于标记不需要权限认证的接口 + @RequestMapping("/detail/{id}") // 定义一个请求映射，当访问 /detail/{id} 路径时，会调用这个方法 + public R detail(@PathVariable("id") Long id){ // 定义一个方法，接收一个路径变量 id，类型为 Long + SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据，并返回实体对象 + return R.ok().put("data", systemintro); // 返回一个包含查询结果的响应对象，并附带成功消息 } @@ -131,37 +125,35 @@ public class SystemintroController { /** * 后端保存 */ - @RequestMapping("/save") - public R save(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ - systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(systemintro); - - systemintroService.insert(systemintro); - return R.ok(); + @RequestMapping("/save") // 定义一个请求映射，当访问 /save 路径时，会调用这个方法 + public R save(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个JSON格式的请求体，类型为 SystemintroEntity，并接收一个 HttpServletRequest 对象 + systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID，由当前时间戳加上一个随机数 + //ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求 + systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库 + return R.ok(); // 返回一个包含成功信息的 R 对象 } /** * 前端保存 */ - @RequestMapping("/add") - public R add(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ - systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); - //ValidatorUtils.validateEntity(systemintro); - - systemintroService.insert(systemintro); - return R.ok(); + @RequestMapping("/add") // 定义一个请求映射，当访问 /add 路径时，会调用这个方法 + public R add(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象 + systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID，由当前时间戳加上一个随机数 + //ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求 + systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库 + return R.ok(); // 返回一个包含成功信息的 R 对象 } /** * 修改 */ - @RequestMapping("/update") - @Transactional - public R update(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ - //ValidatorUtils.validateEntity(systemintro); - systemintroService.updateById(systemintro);//全部更新 - return R.ok(); + @RequestMapping("/update") // 定义一个请求映射，当访问 /update 路径时，会调用这个方法 + @Transactional // 定义了一个事务注解，表示该方法中的数据库操作应该在一个事务中执行 + public R update(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象 + //ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求 + systemintroService.updateById(systemintro); // 调用服务层的方法根据 ID 更新 systemintro 实体对象的所有字段 + return R.ok(); // 返回一个包含成功信息的 R 对象 } @@ -169,62 +161,52 @@ public class SystemintroController { /** * 删除 */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - systemintroService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); + @RequestMapping("/delete") // 定义一个请求映射，当访问 /delete 路径时，会调用这个方法 + public R delete(@RequestBody Long[] ids){ // 定义一个方法，接收一个请求体中的 Long 数组，类型为 Long[] + systemintroService.deleteBatchIds(Arrays.asList(ids)); // 调用服务层的方法，根据传入的 ID 数组批量删除数据 + return R.ok(); // 返回一个包含成功信息的 R 对象 } /** * 提醒接口 */ - @RequestMapping("/remind/{columnName}/{type}") + @RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射，当访问 /remind/{columnName}/{type} 路径时，会调用这个方法 public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, - @PathVariable("type") String type,@RequestParam Map map) { - map.put("column", columnName); - map.put("type", type); + @PathVariable("type") String type,@RequestParam Map map) { // 定义一个方法，接收一个路径变量 columnName 和 type，类型为 String，以及一个请求参数 map，类型为 Map + map.put("column", columnName); // 将 columnName 添加到 map 中，键为 "column" + map.put("type", type); // 将 type 添加到 map 中，键为 "type" - if(type.equals("2")) { - SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); - Calendar c = Calendar.getInstance(); - Date remindStartDate = null; - Date remindEndDate = null; - if(map.get("remindstart")!=null) { - Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindStart); - remindStartDate = c.getTime(); - map.put("remindstart", sdf.format(remindStartDate)); + if(type.equals("2")) { // 如果 type 等于 "2" + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象，格式为 "yyyy-MM-dd" + Calendar c = Calendar.getInstance(); // 创建一个日历对象，获取当前时间 + Date remindStartDate = null; // 创建一个日期对象，用于存储提醒开始时间 + Date remindEndDate = null; // 创建一个日期对象，用于存储提醒结束时间 + if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 + Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数 + c.setTime(new Date()); // 设置日历对象的时间为当前时间 + c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天 + remindStartDate = c.getTime(); // 获取增加后的时间，并赋值给 remindStartDate + map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindstart" } - if(map.get("remindend")!=null) { - Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); - c.setTime(new Date()); - c.add(Calendar.DAY_OF_MONTH,remindEnd); - remindEndDate = c.getTime(); - map.put("remindend", sdf.format(remindEndDate)); + if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 + Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数 + c.setTime(new Date()); // 设置日历对象的时间为当前时间 + c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天 + remindEndDate = c.getTime(); // 获取增加后的时间，并赋值给 remindEndDate + map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindend" } } - Wrapper wrapper = new EntityWrapper(); - if(map.get("remindstart")!=null) { - wrapper.ge(columnName, map.get("remindstart")); + Wrapper wrapper = new EntityWrapper(); // 创建一个实体包装器对象，用于构建查询条件 + if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 + wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件，查询 columnName 字段大于等于 "remindstart" 键对应的值 } - if(map.get("remindend")!=null) { - wrapper.le(columnName, map.get("remindend")); + if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 + wrapper.le(columnName, map.get("remindend")); // 设置查询条件，查询 columnName 字段小于等于 "remindend" 键对应的值 } - int count = systemintroService.selectCount(wrapper); - return R.ok().put("count", count); + int count = systemintroService.selectCount(wrapper); // 调用服务层的方法，根据查询条件查询符合条件的记录数，并赋值给 count + return R.ok().put("count", count); // 返回一个包含查询结果的响应对象，其中包含键 "count" 和对应的 count 值 } - - - - - - - - - - } diff --git a/src/main/java/com/controller/UsersController.java b/src/main/java/com/controller/UsersController.java index ea0abe3..6e9af25 100644 --- a/src/main/java/com/controller/UsersController.java +++ b/src/main/java/com/controller/UsersController.java @@ -35,140 +35,145 @@ import com.utils.ValidatorUtils; /** * 登录相关 */ -@RequestMapping("users") -@RestController -public class UsersController{ - - @Autowired - private UsersService userService; - - @Autowired - private TokenService tokenService; - - /** - * 登录 - */ - @IgnoreAuth - @PostMapping(value = "/login") - public R login(String username, String password, String captcha, HttpServletRequest request) { - UsersEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null || !user.getPassword().equals(password)) { - return R.error("账号或密码不正确"); - } - String token = tokenService.generateToken(user.getId(),username, "users", user.getRole()); - return R.ok().put("token", token); - } - - /** - * 注册 - */ - @IgnoreAuth - @PostMapping(value = "/register") - public R register(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); - if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); - } - userService.insert(user); - return R.ok(); +@RequestMapping("users") // 定义请求路径的基础 URL 为 "users" +@RestController // 标明该类是一个控制器，返回的对象直接作为 JSON 响应 +public class UsersController { + + @Autowired // 自动注入 UsersService 依赖 + private UsersService userService; + + @Autowired // 自动注入 TokenService 依赖 + private TokenService tokenService; + + /** + * 登录 + */ + @IgnoreAuth // 忽略认证，允许未登录用户访问 + @PostMapping(value = "/login") // 处理 POST 请求，路径为 "users/login" + public R login(String username, String password, String captcha, HttpServletRequest request) { + // 根据用户名查询用户 + UsersEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); + // 检查用户是否存在且密码是否匹配 + if(user == null || !user.getPassword().equals(password)) { + return R.error("账号或密码不正确"); // 返回错误信息 + } + // 生成用户的 token + String token = tokenService.generateToken(user.getId(), username, "users", user.getRole()); + return R.ok().put("token", token); // 返回成功信息和 token + } + + /** + * 注册 + */ + @IgnoreAuth // 忽略认证，允许未登录用户访问 + @PostMapping(value = "/register") // 处理 POST 请求，路径为 "users/register" + public R register(@RequestBody UsersEntity user) { + // 校验用户是否已存在 + if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + return R.error("用户已存在"); // 返回用户已存在的错误信息 + } + userService.insert(user); // 插入新用户 + return R.ok(); // 返回成功信息 } - /** - * 退出 - */ - @GetMapping(value = "logout") - public R logout(HttpServletRequest request) { - request.getSession().invalidate(); - return R.ok("退出成功"); - } - - /** + /** + * 退出 + */ + @GetMapping(value = "logout") // 处理 GET 请求，路径为 "users/logout" + public R logout(HttpServletRequest request) { + request.getSession().invalidate(); // 使 session 失效，用户登出 + return R.ok("退出成功"); // 返回成功信息 + } + + /** * 密码重置 */ - @IgnoreAuth - @RequestMapping(value = "/resetPass") + @IgnoreAuth // 忽略认证，允许未登录用户访问 + @RequestMapping(value = "/resetPass") // 处理请求，路径为 "users/resetPass" public R resetPass(String username, HttpServletRequest request){ + // 根据用户名查询用户 UsersEntity user = userService.selectOne(new EntityWrapper().eq("username", username)); - if(user==null) { - return R.error("账号不存在"); + if(user == null) { + return R.error("账号不存在"); // 返回账号不存在的错误信息 } - user.setPassword("123456"); - userService.update(user,null); - return R.ok("密码已重置为：123456"); + user.setPassword("123456"); // 将用户密码重置为 "123456" + userService.update(user, null); // 更新用户信息 + return R.ok("密码已重置为：123456"); // 返回成功信息 } - - /** + + /** * 列表 */ - @RequestMapping("/page") - public R page(@RequestParam Map params,UsersEntity user){ - EntityWrapper ew = new EntityWrapper(); - PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); - return R.ok().put("data", page); + @RequestMapping("/page") // 处理请求，路径为 "users/page" + public R page(@RequestParam Map params, UsersEntity user) { + EntityWrapper ew = new EntityWrapper(); // 创建查询条件 + // 调用服务层方法查询分页数据 + PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); + return R.ok().put("data", page); // 返回查询结果 } - /** + /** * 列表 */ - @RequestMapping("/list") - public R list( UsersEntity user){ - EntityWrapper ew = new EntityWrapper(); - ew.allEq(MPUtil.allEQMapPre( user, "user")); - return R.ok().put("data", userService.selectListView(ew)); + @RequestMapping("/list") // 处理请求，路径为 "users/list" + public R list(UsersEntity user) { + EntityWrapper ew = new EntityWrapper(); // 创建查询条件 + ew.allEq(MPUtil.allEQMapPre(user, "user")); // 添加所有相等条件 + return R.ok().put("data", userService.selectListView(ew)); // 返回查询结果 } /** * 信息 */ - @RequestMapping("/info/{id}") - public R info(@PathVariable("id") String id){ - UsersEntity user = userService.selectById(id); - return R.ok().put("data", user); + @RequestMapping("/info/{id}") // 处理请求，路径为 "users/info/{id}" + public R info(@PathVariable("id") String id) { + UsersEntity user = userService.selectById(id); // 根据 ID 查找用户 + return R.ok().put("data", user); // 返回用户信息 } - + /** - * 获取用户的session用户信息 + * 获取用户的 session 用户信息 */ - @RequestMapping("/session") - public R getCurrUser(HttpServletRequest request){ - Long id = (Long)request.getSession().getAttribute("userId"); - UsersEntity user = userService.selectById(id); - return R.ok().put("data", user); + @RequestMapping("/session") // 处理请求，路径为 "users/session" + public R getCurrUser(HttpServletRequest request) { + Long id = (Long) request.getSession().getAttribute("userId"); // 从 session 中获取用户 ID + UsersEntity user = userService.selectById(id); // 根据 ID 查找用户 + return R.ok().put("data", user); // 返回用户信息 } /** * 保存 */ - @PostMapping("/save") - public R save(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); - if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) !=null) { - return R.error("用户已存在"); + @PostMapping("/save") // 处理 POST 请求，路径为 "users/save" + public R save(@RequestBody UsersEntity user) { + // 校验用户是否已存在 + if(userService.selectOne(new EntityWrapper().eq("username", user.getUsername())) != null) { + return R.error("用户已存在"); // 返回用户已存在的错误信息 } - userService.insert(user); - return R.ok(); + userService.insert(user); // 插入新用户 + return R.ok(); // 返回成功信息 } /** * 修改 */ - @RequestMapping("/update") - public R update(@RequestBody UsersEntity user){ -// ValidatorUtils.validateEntity(user); + @RequestMapping("/update") // 处理请求，路径为 "users/update" + public R update(@RequestBody UsersEntity user) { + // 校验用户是否已存在 UsersEntity u = userService.selectOne(new EntityWrapper().eq("username", user.getUsername())); - if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) { - return R.error("用户名已存在。"); + if(u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) { + return R.error("用户名已存在。"); // 返回用户名已存在的错误信息 } - userService.updateById(user);//全部更新 - return R.ok(); + userService.updateById(user); // 更新用户信息 + return R.ok(); // 返回成功信息 } /** * 删除 */ - @RequestMapping("/delete") - public R delete(@RequestBody Long[] ids){ - userService.deleteBatchIds(Arrays.asList(ids)); - return R.ok(); + @RequestMapping("/delete") // 处理请求，路径为 "users/delete" + public R delete(@RequestBody Long[] ids) { + userService.deleteBatchIds(Arrays.asList(ids)); // 批量删除用户 + return R.ok(); // 返回成功信息 } -} +} \ No newline at end of file diff --git a/src/main/java/com/dao/NewsDao.java b/src/main/java/com/dao/NewsDao.java index 727f160..eb37ec0 100644 --- a/src/main/java/com/dao/NewsDao.java +++ b/src/main/java/com/dao/NewsDao.java @@ -11,25 +11,28 @@ import org.apache.ibatis.annotations.Param; import com.entity.vo.NewsVO; import com.entity.view.NewsView; - /** * 公告信息 + * 该接口用于定义与公告信息相关的数据访问操作 * * @author * @email * @date 2023-02-21 09:46:06 */ public interface NewsDao extends BaseMapper { - - List selectListVO(@Param("ew") Wrapper wrapper); - - NewsVO selectVO(@Param("ew") Wrapper wrapper); - - List selectListView(@Param("ew") Wrapper wrapper); - - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); - - NewsView selectView(@Param("ew") Wrapper wrapper); - + + // 根据查询条件（Wrapper）选择公告的信息列表，并返回一个 NewsVO 对象的列表 + List selectListVO(@Param("ew") Wrapper wrapper); + + // 根据查询条件（Wrapper）选择单个公告的信息，并返回一个 NewsVO 对象 + NewsVO selectVO(@Param("ew") Wrapper wrapper); + + // 根据查询条件（Wrapper）选择公告的信息视图列表，并返回一个 NewsView 对象的列表 + List selectListView(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）与分页信息选择公告的信息视图列表，并返回一个 NewsView 对象的列表 + List selectListView(Pagination page, @Param("ew") Wrapper wrapper); + + // 根据查询条件（Wrapper）选择单个公告的信息视图，并返回一个 NewsView 对象 + NewsView selectView(@Param("ew") Wrapper wrapper); } diff --git a/src/main/java/com/dao/StoreupDao.java b/src/main/java/com/dao/StoreupDao.java index 3df9b75..80e1fa2 100644 --- a/src/main/java/com/dao/StoreupDao.java +++ b/src/main/java/com/dao/StoreupDao.java @@ -1,35 +1,37 @@ -package com.dao; +package com.dao; // 声明该接口所在的包为com.dao -import com.entity.StoreupEntity; -import com.baomidou.mybatisplus.mapper.BaseMapper; -import java.util.List; -import java.util.Map; -import com.baomidou.mybatisplus.mapper.Wrapper; -import com.baomidou.mybatisplus.plugins.pagination.Pagination; - -import org.apache.ibatis.annotations.Param; -import com.entity.vo.StoreupVO; -import com.entity.view.StoreupView; +import com.entity.StoreupEntity; // 导入StoreupEntity类，代表收藏表的实体类 +import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus框架的BaseMapper接口，提供基础的CRUD操作 +import java.util.List; // 导入List接口，用于返回列表结果 +import java.util.Map; // 导入Map接口（虽然在此代码中未使用） +import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口，用于构造查询条件 +import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 导入Pagination类，用于支持分页查询 +import org.apache.ibatis.annotations.Param; // 导入Param注解，用于在Mapper方法中定义参数 +import com.entity.vo.StoreupVO; // 导入StoreupVO类，代表用于展示的视图对象 +import com.entity.view.StoreupView; // 导入StoreupView类，代表用于视图展示的另一个对象 /** * 收藏表 * - * @author - * @email - * @date 2023-02-21 09:46:06 + * @author // 作者信息（未填写） + * @email // 邮箱信息（未填写） + * @date 2023-02-21 09:46:06 // 该接口的创建日期 */ -public interface StoreupDao extends BaseMapper { - - List selectListVO(@Param("ew") Wrapper wrapper); - - StoreupVO selectVO(@Param("ew") Wrapper wrapper); - - List selectListView(@Param("ew") Wrapper wrapper); - - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); - - StoreupView selectView(@Param("ew") Wrapper wrapper); - +public interface StoreupDao extends BaseMapper { // 定义StoreupDao接口，继承BaseMapper以获得基本的数据库操作 + + // 根据条件查询返回StoreupVO类型的列表 + List selectListVO(@Param("ew") Wrapper wrapper); + + // 根据条件查询返回单个StoreupVO对象 + StoreupVO selectVO(@Param("ew") Wrapper wrapper); + + // 根据条件查询返回StoreupView类型的列表 + List selectListView(@Param("ew") Wrapper wrapper); + + // 根据条件及分页信息查询返回StoreupView类型的列表 + List selectListView(Pagination page, @Param("ew") Wrapper wrapper); + // 根据条件查询返回单个StoreupView对象 + StoreupView selectView(@Param("ew") Wrapper wrapper); } diff --git a/src/main/java/com/dao/SystemintroDao.java b/src/main/java/com/dao/SystemintroDao.java index d653848..0df7fc7 100644 --- a/src/main/java/com/dao/SystemintroDao.java +++ b/src/main/java/com/dao/SystemintroDao.java @@ -11,9 +11,9 @@ import org.apache.ibatis.annotations.Param; import com.entity.vo.SystemintroVO; import com.entity.view.SystemintroView; - /** * 关于我们 + * 该接口用于定义与"关于我们"页面相关的数据访问操作 * * @author * @email @@ -21,15 +21,18 @@ import com.entity.view.SystemintroView; */ public interface SystemintroDao extends BaseMapper { - List selectListVO(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）选择系统介绍的信息列表，并返回一个 SystemintroVO 对象的列表 + List selectListVO(@Param("ew") Wrapper wrapper); - SystemintroVO selectVO(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）选择单个系统介绍的信息，并返回一个 SystemintroVO 对象 + SystemintroVO selectVO(@Param("ew") Wrapper wrapper); - List selectListView(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）选择系统介绍信息视图的列表，并返回一个 SystemintroView 对象的列表 + List selectListView(@Param("ew") Wrapper wrapper); - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); - - SystemintroView selectView(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）和分页信息选择系统介绍信息视图的列表，并返回一个 SystemintroView 对象的列表 + List selectListView(Pagination page, @Param("ew") Wrapper wrapper); - + // 根据查询条件（Wrapper）选择单个平台介绍的信息视图，并返回一个 SystemintroView 对象 + SystemintroView selectView(@Param("ew") Wrapper wrapper); } diff --git a/src/main/java/com/dao/UsersDao.java b/src/main/java/com/dao/UsersDao.java index 0056042..0fa884f 100644 --- a/src/main/java/com/dao/UsersDao.java +++ b/src/main/java/com/dao/UsersDao.java @@ -9,14 +9,17 @@ import com.baomidou.mybatisplus.mapper.BaseMapper; import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.entity.UsersEntity; - /** * 用户 + * 该接口用于定义与用户相关的数据访问操作 */ public interface UsersDao extends BaseMapper { - List selectListView(@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）选择用户列表，并返回一个 UsersEntity 对象的列表 + List selectListView(@Param("ew") Wrapper wrapper); - List selectListView(Pagination page,@Param("ew") Wrapper wrapper); + // 根据查询条件（Wrapper）和分页信息选择用户列表，并返回一个 UsersEntity 对象的列表 + List selectListView(Pagination page, @Param("ew") Wrapper wrapper); } + diff --git a/src/main/java/com/entity/StoreupEntity.java b/src/main/java/com/entity/StoreupEntity.java index 5e2932f..a3f49b3 100644 --- a/src/main/java/com/entity/StoreupEntity.java +++ b/src/main/java/com/entity/StoreupEntity.java @@ -5,14 +5,11 @@ import com.baomidou.mybatisplus.annotations.TableName; import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; - import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import java.lang.reflect.InvocationTargetException; - import java.io.Serializable; import java.util.Date; import java.util.List; - import org.springframework.format.annotation.DateTimeFormat; import com.fasterxml.jackson.annotation.JsonFormat; import org.apache.commons.beanutils.BeanUtils; @@ -32,16 +29,13 @@ import com.baomidou.mybatisplus.enums.IdType; public class StoreupEntity implements Serializable { private static final long serialVersionUID = 1L; - public StoreupEntity() { - } public StoreupEntity(T t) { try { BeanUtils.copyProperties(this, t); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block e.printStackTrace(); } } @@ -54,52 +48,43 @@ public class StoreupEntity implements Serializable { /** * 用户id */ - private Long userid; /** * 商品id */ - private Long refid; /** * 表名 */ - private String tablename; /** * 名称 */ - private String name; /** * 图片 */ - private String picture; /** * 类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注) */ - private String type; /** * 推荐类型 */ - private String inteltype; /** * 备注 */ - private String remark; - @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @DateTimeFormat private Date addtime; @@ -214,5 +199,4 @@ public class StoreupEntity implements Serializable { public String getRemark() { return remark; } - } diff --git a/src/main/java/com/entity/UsersEntity.java b/src/main/java/com/entity/UsersEntity.java index 959ac00..c97921e 100644 --- a/src/main/java/com/entity/UsersEntity.java +++ b/src/main/java/com/entity/UsersEntity.java @@ -7,71 +7,72 @@ import com.baomidou.mybatisplus.annotations.TableId; import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.enums.IdType; + /** * 用户 */ -@TableName("users") -public class UsersEntity implements Serializable { - private static final long serialVersionUID = 1L; +@TableName("users") // 指定实体类对应的数据库表为users +public class UsersEntity implements Serializable { // 定义UsersEntity类，实现Serializable接口 + private static final long serialVersionUID = 1L; // 定义序列化ID - @TableId(type = IdType.AUTO) - private Long id; + @TableId(type = IdType.AUTO) // 标识为主键，并设置主键自增 + private Long id; // 主键id /** * 用户账号 */ - private String username; + private String username; // 用户名 /** * 密码 */ - private String password; + private String password; // 用户密码 /** * 用户类型 */ - private String role; + private String role; // 用户角色 - private Date addtime; + private Date addtime; // 添加时间 - public String getUsername() { - return username; + public String getUsername() { // 获取用户名 + return username; // 返回username } - public void setUsername(String username) { - this.username = username; + public void setUsername(String username) { // 设置用户名 + this.username = username; // 赋值username } - public String getPassword() { - return password; + public String getPassword() { // 获取密码 + return password; // 返回password } - public void setPassword(String password) { - this.password = password; + public void setPassword(String password) { // 设置密码 + this.password = password; // 赋值password } - public String getRole() { - return role; + public String getRole() { // 获取用户角色 + return role; // 返回role } - public void setRole(String role) { - this.role = role; + public void setRole(String role) { // 设置用户角色 + this.role = role; // 赋值role } - public Date getAddtime() { - return addtime; + public Date getAddtime() { // 获取添加时间 + return addtime; // 返回addtime } - public void setAddtime(Date addtime) { - this.addtime = addtime; + public void setAddtime(Date addtime) { // 设置添加时间 + this.addtime = addtime; // 赋值addtime } - public Long getId() { - return id; + public Long getId() { // 获取主键id + return id; // 返回id } - public void setId(Long id) { - this.id = id; + public void setId(Long id) { // 设置主键id + this.id = id; // 赋值id } } diff --git a/src/main/java/com/entity/WenjuandiaochaEntity.java b/src/main/java/com/entity/WenjuandiaochaEntity.java index d826017..c32fc74 100644 --- a/src/main/java/com/entity/WenjuandiaochaEntity.java +++ b/src/main/java/com/entity/WenjuandiaochaEntity.java @@ -28,6 +28,7 @@ import com.baomidou.mybatisplus.enums.IdType; * @email * @date 2023-02-21 09:46:06 */ +// @TableName("wenjuandiaocha") public class WenjuandiaochaEntity implements Serializable { private static final long serialVersionUID = 1L; diff --git a/src/main/java/com/entity/model/NewsModel.java b/src/main/java/com/entity/model/NewsModel.java index d938d01..7bad100 100644 --- a/src/main/java/com/entity/model/NewsModel.java +++ b/src/main/java/com/entity/model/NewsModel.java @@ -12,80 +12,69 @@ import java.io.Serializable; /** * 公告信息 * 接收传参的实体类 - *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） - * 取自ModelAndView 的model名称 + * （实际开发中配合移动端接口开发手动去掉些没用的字段，后端一般用 entity 就够用了） + * 取自 ModelAndView 的 model 名称 * @author * @email * @date 2023-02-21 09:46:06 */ -public class NewsModel implements Serializable { - private static final long serialVersionUID = 1L; +public class NewsModel implements Serializable { + private static final long serialVersionUID = 1L; // 序列化版本号 - - /** - * 简介 - */ - - private String introduction; - - /** - * 图片 - */ - - private String picture; - - /** - * 内容 - */ - - private String content; - - - /** - * 设置：简介 - */ - - public void setIntroduction(String introduction) { - this.introduction = introduction; - } - - /** - * 获取：简介 - */ - public String getIntroduction() { - return introduction; - } - - - /** - * 设置：图片 - */ - - public void setPicture(String picture) { - this.picture = picture; - } - - /** - * 获取：图片 - */ - public String getPicture() { - return picture; - } - - - /** - * 设置：内容 - */ - - public void setContent(String content) { - this.content = content; - } - - /** - * 获取：内容 - */ - public String getContent() { - return content; - } - + /** + * 简介 + */ + private String introduction; // 存放公告的简介 + + /** + * 图片 + */ + private String picture; // 存放公告相关的图片 + + /** + * 内容 + */ + private String content; // 存放公告的详细内容 + + /** + * 设置：简介 + */ + public void setIntroduction(String introduction) { + this.introduction = introduction; // 设置简介字段 + } + + /** + * 获取：简介 + */ + public String getIntroduction() { + return introduction; // 返回简介字段的值 + } + + /** + * 设置：图片 + */ + public void setPicture(String picture) { + this.picture = picture; // 设置图片字段 + } + + /** + * 获取：图片 + */ + public String getPicture() { + return picture; // 返回图片字段的值 + } + + /** + * 设置：内容 + */ + public void setContent(String content) { + this.content = content; // 设置内容字段 + } + + /** + * 获取：内容 + */ + public String getContent() { + return content; // 返回内容字段的值 + } } diff --git a/src/main/java/com/entity/view/NewsView.java b/src/main/java/com/entity/view/NewsView.java index 54273be..e4aa33e 100644 --- a/src/main/java/com/entity/view/NewsView.java +++ b/src/main/java/com/entity/view/NewsView.java @@ -9,6 +9,10 @@ import java.lang.reflect.InvocationTargetException; import java.io.Serializable; +/** + * 公告信息 + * 后端返回视图实体辅助类 + * （通常后端关联的表或者自定义的字段需要返回使用） /** * 公告信息 * 后端返回视图实体辅助类 @@ -17,20 +21,22 @@ import java.io.Serializable; * @email * @date 2023-02-21 09:46:06 */ -@TableName("news") -public class NewsView extends NewsEntity implements Serializable { - private static final long serialVersionUID = 1L; +@TableName("news") // 指定该类对应的数据库表名为 "news" +public class NewsView extends NewsEntity implements Serializable { + private static final long serialVersionUID = 1L; // 序列化版本号 - public NewsView(){ - } - - public NewsView(NewsEntity newsEntity){ - try { - BeanUtils.copyProperties(this, newsEntity); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - - } + // 默认构造函数 + public NewsView() { + } + + // 构造函数，接受一个 NewsEntity 对象并复制其属性 + public NewsView(NewsEntity newsEntity) { + try { + BeanUtils.copyProperties(this, newsEntity); // 使用 BeanUtils 复制属性 + } catch (IllegalAccessException | InvocationTargetException e) { + // 捕获并处理属性复制过程中的异常 + e.printStackTrace(); // 打印异常堆栈跟踪 + } + } } + diff --git a/src/main/java/com/entity/view/StoreupView.java b/src/main/java/com/entity/view/StoreupView.java index 10b15a8..a8d7150 100644 --- a/src/main/java/com/entity/view/StoreupView.java +++ b/src/main/java/com/entity/view/StoreupView.java @@ -14,23 +14,24 @@ import java.io.Serializable; * 后端返回视图实体辅助类 * （通常后端关联的表或者自定义的字段需要返回使用） * @author - * @email + * @email * @date 2023-02-21 09:46:06 */ -@TableName("storeup") -public class StoreupView extends StoreupEntity implements Serializable { - private static final long serialVersionUID = 1L; +@TableName("storeup") // 指定该类对应的数据库表名为 "storeup" +public class StoreupView extends StoreupEntity implements Serializable { + private static final long serialVersionUID = 1L; // 序列化版本号 - public StoreupView(){ - } - - public StoreupView(StoreupEntity storeupEntity){ - try { - BeanUtils.copyProperties(this, storeupEntity); - } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - - } + // 默认构造函数 + public StoreupView() { + } + + // 构造函数，接受一个 StoreupEntity 对象并复制其属性 + public StoreupView(StoreupEntity storeupEntity) { + try { + BeanUtils.copyProperties(this, storeupEntity); // 使用 BeanUtils 复制属性 + } catch (IllegalAccessException | InvocationTargetException e) { + // 捕获并处理属性复制过程中的异常 + e.printStackTrace(); // 打印异常堆栈跟踪 + } + } } diff --git a/src/main/java/com/entity/view/SystemintroView.java b/src/main/java/com/entity/view/SystemintroView.java index c9c5582..3927125 100644 --- a/src/main/java/com/entity/view/SystemintroView.java +++ b/src/main/java/com/entity/view/SystemintroView.java @@ -1,13 +1,17 @@ package com.entity.view; +// 导入系统介绍实体类 import com.entity.SystemintroEntity; +// 导入MyBatis-Plus的注解库 import com.baomidou.mybatisplus.annotations.TableName; +// 导入Apache Commons BeanUtils类 import org.apache.commons.beanutils.BeanUtils; +// 导入反射异常处理类 import java.lang.reflect.InvocationTargetException; +// 导入序列化接口 import java.io.Serializable; - /** * 关于我们 @@ -17,20 +21,24 @@ import java.io.Serializable; * @email * @date 2023-02-21 09:46:06 */ +// 指定表名为"systemintro"的实体类 @TableName("systemintro") -public class SystemintroView extends SystemintroEntity implements Serializable { +public class SystemintroView extends SystemintroEntity implements Serializable { + // 版本控制 private static final long serialVersionUID = 1L; - public SystemintroView(){ + // 默认构造函数 + public SystemintroView() { } - - public SystemintroView(SystemintroEntity systemintroEntity){ - try { + + // 带参构造函数，用于根据SystemintroEntity对象初始化SystemintroView + public SystemintroView(SystemintroEntity systemintroEntity) { + try { + // 复制systemintroEntity的属性到当前对象 BeanUtils.copyProperties(this, systemintroEntity); } catch (IllegalAccessException | InvocationTargetException e) { - // TODO Auto-generated catch block + // 捕获反射过程中的异常并打印堆栈信息 e.printStackTrace(); } - } } diff --git a/src/main/java/com/service/NewsService.java b/src/main/java/com/service/NewsService.java index b745972..bf6f403 100644 --- a/src/main/java/com/service/NewsService.java +++ b/src/main/java/com/service/NewsService.java @@ -14,24 +14,24 @@ import com.entity.view.NewsView; /** * 公告信息 * - * @author - * @email - * @date 2023-02-21 09:46:06 + * @author // 作者信息 + * @email // 邮箱信息 + * @date 2023-02-21 09:46:06 // 创建日期 */ -public interface NewsService extends IService { +public interface NewsService extends IService { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 - PageUtils queryPage(Map params); + PageUtils queryPage(Map params); // 根据传入的参数进行分页查询，并返回分页结果 - List selectListVO(Wrapper wrapper); - - NewsVO selectVO(@Param("ew") Wrapper wrapper); - - List selectListView(Wrapper wrapper); - - NewsView selectView(@Param("ew") Wrapper wrapper); - - PageUtils queryPage(Map params,Wrapper wrapper); - + List selectListVO(Wrapper wrapper); // 根据条件包装器查询并返回 NewsVO 列表 + + NewsVO selectVO(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 NewsVO 对象 + + List selectListView(Wrapper wrapper); // 根据条件包装器查询并返回 NewsView 列表 + + NewsView selectView(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 NewsView 对象 + + PageUtils queryPage(Map params, Wrapper wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 } + diff --git a/src/main/java/com/service/StoreupService.java b/src/main/java/com/service/StoreupService.java index 254b2fa..c4e64fb 100644 --- a/src/main/java/com/service/StoreupService.java +++ b/src/main/java/com/service/StoreupService.java @@ -10,28 +10,27 @@ import com.entity.vo.StoreupVO; import org.apache.ibatis.annotations.Param; import com.entity.view.StoreupView; - /** * 收藏表 * - * @author - * @email - * @date 2023-02-21 09:46:06 + * @author // 作者信息 + * @email // 邮箱信息 + * @date 2023-02-21 09:46:06 // 创建日期 */ -public interface StoreupService extends IService { - - PageUtils queryPage(Map params); - - List selectListVO(Wrapper wrapper); - - StoreupVO selectVO(@Param("ew") Wrapper wrapper); - - List selectListView(Wrapper wrapper); - - StoreupView selectView(@Param("ew") Wrapper wrapper); - - PageUtils queryPage(Map params,Wrapper wrapper); - +public interface StoreupService extends IService { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 + + PageUtils queryPage(Map params); // 根据传入的参数进行分页查询，并返回分页结果 + + List selectListVO(Wrapper wrapper); // 根据条件包装器查询并返回 StoreupVO 列表 + + StoreupVO selectVO(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 StoreupVO 对象 + + List selectListView(Wrapper wrapper); // 根据条件包装器查询并返回 StoreupView 列表 + + StoreupView selectView(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 StoreupView 对象 + + PageUtils queryPage(Map params, Wrapper wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 } + diff --git a/src/main/java/com/service/SystemintroService.java b/src/main/java/com/service/SystemintroService.java index 92f0de8..5cd122c 100644 --- a/src/main/java/com/service/SystemintroService.java +++ b/src/main/java/com/service/SystemintroService.java @@ -9,29 +9,27 @@ import java.util.Map; import com.entity.vo.SystemintroVO; import org.apache.ibatis.annotations.Param; import com.entity.view.SystemintroView; - - /** * 关于我们 * - * @author - * @email - * @date 2023-02-21 09:46:06 + * @author // 作者信息 + * @email // 邮箱信息 + * @date 2023-02-21 09:46:06 // 创建日期 */ -public interface SystemintroService extends IService { - - PageUtils queryPage(Map params); - - List selectListVO(Wrapper wrapper); - - SystemintroVO selectVO(@Param("ew") Wrapper wrapper); - - List selectListView(Wrapper wrapper); - - SystemintroView selectView(@Param("ew") Wrapper wrapper); - - PageUtils queryPage(Map params,Wrapper wrapper); - +public interface SystemintroService extends IService { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 + + PageUtils queryPage(Map params); // 根据传入的参数进行分页查询，并返回分页结果 + + List selectListVO(Wrapper wrapper); // 根据条件包装器查询并返回 SystemintroVO 列表 + + SystemintroVO selectVO(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 SystemintroVO 对象 + + List selectListView(Wrapper wrapper); // 根据条件包装器查询并返回 SystemintroView 列表 + + SystemintroView selectView(@Param("ew") Wrapper wrapper); // 根据条件包装器查询并返回单个 SystemintroView 对象 + + PageUtils queryPage(Map params, Wrapper wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 } + diff --git a/src/main/java/com/service/UsersService.java b/src/main/java/com/service/UsersService.java index 62669bd..3a55a5c 100644 --- a/src/main/java/com/service/UsersService.java +++ b/src/main/java/com/service/UsersService.java @@ -11,15 +11,15 @@ import com.baomidou.mybatisplus.service.IService; import com.entity.UsersEntity; import com.utils.PageUtils; - /** * 系统用户 */ -public interface UsersService extends IService { - PageUtils queryPage(Map params); - - List selectListView(Wrapper wrapper); - - PageUtils queryPage(Map params,Wrapper wrapper); - +public interface UsersService extends IService { // 声明一个接口，扩展 IService，用于基本的 CRUD 操作 + + PageUtils queryPage(Map params); // 根据传入的参数进行分页查询，并返回分页结果 + + List selectListView(Wrapper wrapper); // 根据条件包装器查询并返回 UsersEntity 列表 + + PageUtils queryPage(Map params, Wrapper wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 } + diff --git a/src/main/java/com/service/impl/NewsServiceImpl.java b/src/main/java/com/service/impl/NewsServiceImpl.java index 8cabfe1..c2f7e1d 100644 --- a/src/main/java/com/service/impl/NewsServiceImpl.java +++ b/src/main/java/com/service/impl/NewsServiceImpl.java @@ -18,46 +18,52 @@ import com.service.NewsService; import com.entity.vo.NewsVO; import com.entity.view.NewsView; -@Service("newsService") +@Service("newsService") // 声明该类为服务层组件，并指定服务名称为 "newsService" public class NewsServiceImpl extends ServiceImpl implements NewsService { - - + + // 实现分页查询 @Override public PageUtils queryPage(Map params) { + // 创建一个分页对象，使用传入的参数获取页面信息 Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() + new Query(params).getPage(), // 获取分页对象 + new EntityWrapper() // 构建查询条件的包装器 ); - return new PageUtils(page); + return new PageUtils(page); // 返回分页结果包装 } + // 实现带条件的分页查询 @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 = new Query(params).getPage(); + // 设置页面记录 + page.setRecords(baseMapper.selectListView(page, wrapper)); + PageUtils pageUtil = new PageUtils(page); // 包装分页结果 + return pageUtil; // 返回分页结果 + } + // 查询符合条件的所有 NewsVO 对象 @Override - public List selectListVO(Wrapper wrapper) { - return baseMapper.selectListVO(wrapper); - } - - @Override - public NewsVO selectVO(Wrapper wrapper) { - return baseMapper.selectVO(wrapper); - } - - @Override - public List selectListView(Wrapper wrapper) { - return baseMapper.selectListView(wrapper); - } - - @Override - public NewsView selectView(Wrapper wrapper) { - return baseMapper.selectView(wrapper); - } - + public List selectListVO(Wrapper wrapper) { + return baseMapper.selectListVO(wrapper); // 调用 DAO 层方法执行查询 + } + + // 查询单个 NewsVO 对象 + @Override + public NewsVO selectVO(Wrapper wrapper) { + return baseMapper.selectVO(wrapper); // 调用 DAO 层方法执行查询 + } + + // 查询符合条件的所有 NewsView 对象 + @Override + public List selectListView(Wrapper wrapper) { + return baseMapper.selectListView(wrapper); // 调用 DAO 层方法执行查询 + } + // 查询单个 NewsView 对象 + @Override + public NewsView selectView(Wrapper wrapper) { + return baseMapper.selectView(wrapper); // 调用 DAO 层方法执行查询 + } } diff --git a/src/main/java/com/service/impl/StoreupServiceImpl.java b/src/main/java/com/service/impl/StoreupServiceImpl.java index a3f441c..6ae9767 100644 --- a/src/main/java/com/service/impl/StoreupServiceImpl.java +++ b/src/main/java/com/service/impl/StoreupServiceImpl.java @@ -18,46 +18,51 @@ import com.service.StoreupService; import com.entity.vo.StoreupVO; import com.entity.view.StoreupView; -@Service("storeupService") +@Service("storeupService") // 将该类标记为服务，并指定 bean 的名称为 "storeupService" public class StoreupServiceImpl extends ServiceImpl implements StoreupService { - - @Override public PageUtils queryPage(Map params) { + // 根据传入的参数创建分页对象，并调用 selectPage 方法获取数据 Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() + new Query(params).getPage(), // 构造分页信息 + new EntityWrapper() // 创建 EntityWrapper 用于封装查询条件 ); + // 返回封装好的分页结果 return new PageUtils(page); } @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 = new Query(params).getPage(); + // 设置分页记录 + page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据 + // 返回封装好的分页结果 + PageUtils pageUtil = new PageUtils(page); + return pageUtil; + } @Override - public List selectListVO(Wrapper wrapper) { - return baseMapper.selectListVO(wrapper); - } - - @Override - public StoreupVO selectVO(Wrapper wrapper) { - return baseMapper.selectVO(wrapper); - } - - @Override - public List selectListView(Wrapper wrapper) { - return baseMapper.selectListView(wrapper); - } - - @Override - public StoreupView selectView(Wrapper wrapper) { - return baseMapper.selectView(wrapper); - } - + public List selectListVO(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回 StoreupVO 列表 + return baseMapper.selectListVO(wrapper); + } + + @Override + public StoreupVO selectVO(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回单个 StoreupVO 对象 + return baseMapper.selectVO(wrapper); + } + + @Override + public List selectListView(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回 StoreupView 列表 + return baseMapper.selectListView(wrapper); + } + @Override + public StoreupView selectView(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回单个 StoreupView 对象 + return baseMapper.selectView(wrapper); + } } diff --git a/src/main/java/com/service/impl/SystemintroServiceImpl.java b/src/main/java/com/service/impl/SystemintroServiceImpl.java index 587fafd..1c0c32d 100644 --- a/src/main/java/com/service/impl/SystemintroServiceImpl.java +++ b/src/main/java/com/service/impl/SystemintroServiceImpl.java @@ -18,46 +18,51 @@ import com.service.SystemintroService; import com.entity.vo.SystemintroVO; import com.entity.view.SystemintroView; -@Service("systemintroService") +@Service("systemintroService") // 将该类标记为服务，并指定 bean 的名称为 "systemintroService" public class SystemintroServiceImpl extends ServiceImpl implements SystemintroService { - - @Override public PageUtils queryPage(Map params) { + // 根据传入的参数创建分页对象，并调用 selectPage 方法获取数据 Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() + new Query(params).getPage(), // 构造分页信息 + new EntityWrapper() // 创建 EntityWrapper 用于封装查询条件 ); + // 返回封装好的分页结果 return new PageUtils(page); } @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 = new Query(params).getPage(); + // 设置分页记录 + page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据 + // 返回封装好的分页结果 + PageUtils pageUtil = new PageUtils(page); + return pageUtil; + } @Override - public List selectListVO(Wrapper wrapper) { - return baseMapper.selectListVO(wrapper); - } - - @Override - public SystemintroVO selectVO(Wrapper wrapper) { - return baseMapper.selectVO(wrapper); - } - - @Override - public List selectListView(Wrapper wrapper) { - return baseMapper.selectListView(wrapper); - } - - @Override - public SystemintroView selectView(Wrapper wrapper) { - return baseMapper.selectView(wrapper); - } - + public List selectListVO(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回 SystemintroVO 列表 + return baseMapper.selectListVO(wrapper); + } + + @Override + public SystemintroVO selectVO(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回单个 SystemintroVO 对象 + return baseMapper.selectVO(wrapper); + } + + @Override + public List selectListView(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回 SystemintroView 列表 + return baseMapper.selectListView(wrapper); + } + @Override + public SystemintroView selectView(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回单个 SystemintroView 对象 + return baseMapper.selectView(wrapper); + } } diff --git a/src/main/java/com/service/impl/UsersServiceImpl.java b/src/main/java/com/service/impl/UsersServiceImpl.java index 75967a7..66fcb3d 100644 --- a/src/main/java/com/service/impl/UsersServiceImpl.java +++ b/src/main/java/com/service/impl/UsersServiceImpl.java @@ -21,29 +21,34 @@ import com.utils.Query; /** * 系统用户 */ -@Service("usersService") +@Service("usersService") // 将该类标记为服务，并指定 bean 的名称为 "usersService" public class UsersServiceImpl extends ServiceImpl implements UsersService { @Override public PageUtils queryPage(Map params) { + // 根据传入的参数创建分页对象，并调用 selectPage 方法获取用户数据 Page page = this.selectPage( - new Query(params).getPage(), - new EntityWrapper() + new Query(params).getPage(), // 构造分页信息 + new EntityWrapper() // 创建 EntityWrapper 用于封装查询条件 ); + // 返回封装好的分页结果 return new PageUtils(page); } @Override public List selectListView(Wrapper wrapper) { + // 根据 Wrapper 条件查询并返回 UsersEntity 列表 return baseMapper.selectListView(wrapper); } @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 = new Query(params).getPage(); + // 设置分页记录 + page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据 + // 返回封装好的分页结果 + PageUtils pageUtil = new PageUtils(page); + return pageUtil; } }