p4vkf3rot
/
j2ee1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: p4vkf3rot:main
Branches Tags
p4vkf3rot:main
p4vkf3rot:wujiamei_branch
p4vkf3rot:zhangshuting_branch
p4vkf3rot:hujiali_branch
p4vkf3rot:develop
..
compare: p4vkf3rot:wujiamei_branch
Branches Tags
p4vkf3rot:main
p4vkf3rot:wujiamei_branch
p4vkf3rot:zhangshuting_branch
p4vkf3rot:hujiali_branch
p4vkf3rot:develop

No commits in common. 'main' and 'wujiamei_branch' have entirely different histories.
main ... wujiamei_b

77 changed files with 2939 additions and 3825 deletions
Show Stats

92
src/main/java/com/controller/ConfigController.java
Unescape View File

@ -1,5 +1,7 @@
package com.controller; package com.controller;
import java.util.Arrays; import java.util.Arrays;
import java.util.Map; import java.util.Map;
@ -12,10 +14,10 @@ import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis-Plus的实体包装器 import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity; // 配置实体类 import com.entity.ConfigEntity;
import com.service.ConfigService; // 配置服务类 import com.service.ConfigService;
import com.utils.MPUtil; // MyBatis-Plus工具类 import com.utils.MPUtil;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.utils.R; import com.utils.R;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils;
@ -23,106 +25,88 @@ import com.utils.ValidatorUtils;
/** /**
* 登录相关 * 登录相关
*/ */
@RequestMapping("config") // 设置基本请求路径为"/config" @RequestMapping("config")
@RestController // 标记为REST风格的控制器 @RestController
public class ConfigController { public class ConfigController{
@Autowired // 自动注入ConfigService @Autowired
private ConfigService configService; private ConfigService configService;
/** /**
* 列表 * 列表
* @param params 查询参数
* @param config 配置信息
* @return 分页后的配置信息
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) { public R page(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造 EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据 PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
* @param params 查询参数
* @param config 配置信息
* @return 所有配置信息的列表
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) { public R list(@RequestParam Map<String, Object> params,ConfigEntity config){
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建EntityWrapper用于条件构造 EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>();
PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params)); // 查询分页数据 PageUtils page = configService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, config), params), params));
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 信息 * 信息
* @param id 配置ID
* @return 指定ID的配置信息
*/ */
@RequestMapping("/info/{id}") // 用于获取指定ID的配置信息 @RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) { public R info(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id); // 根据ID查询配置 ConfigEntity config = configService.selectById(id);
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 详情 * 详情
* @param id 配置ID
* @return 指定ID的配置信息，忽略身份验证
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/detail/{id}") // 用于获取指定ID的配置信息详情 @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") String id) { public R detail(@PathVariable("id") String id){
ConfigEntity config = configService.selectById(id); // 根据ID查询配置 ConfigEntity config = configService.selectById(id);
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 根据name获取信息 * 根据name获取信息
* @param name 配置名称
* @return 指定名称的配置信息
*/ */
@RequestMapping("/info") // 用于根据名称获取配置信息 @RequestMapping("/info")
public R infoByName(@RequestParam String name) { public R infoByName(@RequestParam String name){
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); // 根据名称查询配置 ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
return R.ok().put("data", config); return R.ok().put("data", config);
} }
/** /**
* 保存 * 保存
* @param config 配置信息
* @return 保存结果
*/ */
@PostMapping("/save") // 用于保存配置 @PostMapping("/save")
public R save(@RequestBody ConfigEntity config) { public R save(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config); // 验证配置实体（注释掉此行可以在需要时启用） // ValidatorUtils.validateEntity(config);
configService.insert(config); // 保存配置 configService.insert(config);
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
* @param config 配置信息
* @return 修改结果
*/ */
@RequestMapping("/update") // 用于修改配置 @RequestMapping("/update")
public R update(@RequestBody ConfigEntity config) { public R update(@RequestBody ConfigEntity config){
// ValidatorUtils.validateEntity(config); // 验证配置实体（注释掉此行可以在需要时启用） // ValidatorUtils.validateEntity(config);
configService.updateById(config); // 根据ID更新配置 configService.updateById(config);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除
* @param ids 配置ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") // 用于删除配置 @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
configService.deleteBatchIds(Arrays.asList(ids)); // 批量删除配置 configService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
} }

85
src/main/java/com/controller/FileController.java
Unescape View File

@ -10,14 +10,14 @@ import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解 import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; // 导入Spring的REST控制器注解 import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile; // 导入Spring的文件上传接口 import org.springframework.web.multipart.MultipartFile;
import com.annotation.IgnoreAuth; // 导入自定义注解，表示忽略身份验证 import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity; import com.entity.ConfigEntity;
import com.entity.EIException; import com.entity.EIException;
import com.service.ConfigService; import com.service.ConfigService;
@ -26,84 +26,65 @@ import com.utils.R;
/** /**
* 上传文件映射表 * 上传文件映射表
*/ */
@RestController // 标记该类为REST控制器 @RestController
@RequestMapping("file") // 设置基本请求路径为"/file" @RequestMapping("file")
@SuppressWarnings({"unchecked","rawtypes"}) // 忽略编译警告 @SuppressWarnings({"unchecked","rawtypes"})
public class FileController { public class FileController{
@Autowired
@Autowired // 自动注入ConfigService服务
private ConfigService configService; private ConfigService configService;
/** /**
* 上传文件 * 上传文件
* @param file 上传的文件
* @param type 文件类型标识
* @param request HttpServletRequest对象
* @return 上传结果
*/ */
@RequestMapping("/upload") // 映射请求路径为"/upload" @RequestMapping("/upload")
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
public R upload(@RequestParam("file") MultipartFile file, String type, HttpServletRequest request) throws Exception { public R upload(@RequestParam("file") MultipartFile file, String type,HttpServletRequest request) throws Exception {
// 检查上传的文件是否为空
if (file.isEmpty()) { if (file.isEmpty()) {
throw new EIException("上传文件不能为空"); throw new EIException("上传文件不能为空");
} }
// 获取文件扩展名 String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1); String fileName = new Date().getTime()+"."+fileExt;
String fileName = new Date().getTime() + "." + fileExt; File dest = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName);
// 定义文件保存的目标路径
File dest = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
file.transferTo(dest); file.transferTo(dest);
/** /**
* 如果使用IDEA或者Eclipse重启项目后发现之前上传的文件丢失， * 如果使用idea或者eclipse重启项目，发现之前上传的图片或者文件丢失，将下面一行代码注释打开
* 请将下面一行代码注释打开 * 请将以下的"D:\\ssmpiv99\\src\\main\\webapp\\upload"替换成你本地项目的upload路径，
* 并将"D:\\ssmpiv99\\src\\main\\webapp\\upload"替换为你本地项目的upload路径， * 并且项目路径不能存在中文、空格等特殊字符
* 确保项目路径中不存在中文、空格等特殊字符
*/ */
// FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload" + "/" + fileName)); /** 修改了路径后请将该行最前面的//注释去掉 **/ //FileUtils.copyFile(dest, new File("D:\\ssmpiv99\\src\\main\\webapp\\upload"+"/"+fileName)); /**修改了路径以后请将该行最前面的//注释去掉**/
if(StringUtils.isNotBlank(type) && type.equals("1")) {
// 如果type不为空且等于"1"，则更新或保存配置信息
if (StringUtils.isNotBlank(type) && type.equals("1")) {
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if (configEntity == null) { if(configEntity==null) {
configEntity = new ConfigEntity(); // 创建新的配置实体 configEntity = new ConfigEntity();
configEntity.setName("faceFile"); configEntity.setName("faceFile");
configEntity.setValue(fileName); configEntity.setValue(fileName);
} else { } else {
configEntity.setValue(fileName); configEntity.setValue(fileName);
} }
configService.insertOrUpdate(configEntity); // 保存或更新配置 configService.insertOrUpdate(configEntity);
} }
return R.ok().put("file", fileName); // 返回上传结果，包含文件名 return R.ok().put("file", fileName);
} }
/** /**
* 下载文件 * 下载文件
* @param fileName 文件名
* @param request HttpServletRequest对象
* @param response HttpServletResponse对象
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/download") // 映射请求路径为"/download" @RequestMapping("/download")
public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) { public void download(@RequestParam String fileName, HttpServletRequest request, HttpServletResponse response) {
try { try {
// 定义文件的完整路径 File file = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+fileName);
File file = new File(request.getSession().getServletContext().getRealPath("/upload") + "/" + fileName);
// 检查文件是否存在
if (file.exists()) { if (file.exists()) {
response.reset(); // 重置响应 response.reset();
// 设置响应头，指示文件下载 response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName+"\"");
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
response.setHeader("Cache-Control", "no-cache"); response.setHeader("Cache-Control", "no-cache");
response.setHeader("Access-Control-Allow-Credentials", "true"); response.setHeader("Access-Control-Allow-Credentials", "true");
response.setContentType("application/octet-stream; charset=UTF-8"); // 设置内容类型 response.setContentType("application/octet-stream; charset=UTF-8");
// 将文件内容写入响应输出流
IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream()); IOUtils.write(FileUtils.readFileToByteArray(file), response.getOutputStream());
} }
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); // 打印异常信息 e.printStackTrace();
} }
} }
} }

279
src/main/java/com/controller/ForumController.java
Unescape View File

@ -2,41 +2,41 @@ package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException; // 导入解析异常 import java.text.ParseException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; // 导入Arrays工具类 import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Map; // 导入Map接口 import java.util.Map;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; // 导入迭代器接口 import java.util.Iterator;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import javax.servlet.http.HttpServletRequest; // 导入Servlet请求类 import javax.servlet.http.HttpServletRequest;
import java.io.IOException; import java.io.IOException;
import com.utils.ValidatorUtils; // 导入验证工具类 import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的StringUtils类，用于字符串操作 import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring的依赖注入注解 import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; // 导入路径变量注解 import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody; // 导入请求体注解 import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; // 导入REST控制器注解 import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.ForumEntity; // 导入论坛实体类 import com.entity.ForumEntity;
import com.entity.view.ForumView; // 导入论坛视图类 import com.entity.view.ForumView;
import com.service.ForumService; // 导入论坛服务类 import com.service.ForumService;
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; // 导入分页工具类 import com.utils.PageUtils;
import com.utils.R; import com.utils.R;
import com.utils.MD5Util; import com.utils.MD5Util;
import com.utils.MPUtil; // 导入MyBatis-Plus工具类 import com.utils.MPUtil;
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
@ -46,238 +46,217 @@ import com.utils.CommonUtil;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController // 标记该类为REST控制器 @RestController
@RequestMapping("/forum") @RequestMapping("/forum")
public class ForumController { public class ForumController {
@Autowired @Autowired
private ForumService forumService; // 注入论坛服务 private ForumService forumService;
/** /**
* 后端列表 * 后端列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@RequestMapping("/page") // 映射请求路径为"/page" @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) { public R page(@RequestParam Map<String, Object> params,ForumEntity forum,
// 如果当前用户不是管理员，则设置用户ID HttpServletRequest request){
if (!request.getSession().getAttribute("role").toString().equals("管理员")) { if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long) request.getSession().getAttribute("userId")); forum.setUserid((Long)request.getSession().getAttribute("userId"));
} }
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中 request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 前端列表 * 前端列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@RequestMapping("/list") // 映射请求路径为"/list" @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) { public R list(@RequestParam Map<String, Object> params,ForumEntity forum,
// 如果当前用户不是管理员，则设置用户ID HttpServletRequest request){
if (!request.getSession().getAttribute("role").toString().equals("管理员")) { if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
forum.setUserid((Long) request.getSession().getAttribute("userId")); forum.setUserid((Long)request.getSession().getAttribute("userId"));
} }
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中 request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 允许匿名访问的列表 * 列表
* @param params 请求参数
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 论坛列表分页数据
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/flist") // 映射请求路径为"/flist" @RequestMapping("/flist")
public R flist(@RequestParam Map<String, Object> params, ForumEntity forum, HttpServletRequest request) { public R flist(@RequestParam Map<String, Object> params,ForumEntity forum, HttpServletRequest request){
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>();
// 查询论坛列表分页数据
PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params)); PageUtils page = forumService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, forum), params), params));
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 查询论坛信息 * 查询
* @param forum 论坛实体
* @return 论坛信息
*/ */
@RequestMapping("/query") // 映射请求路径为"/query" @RequestMapping("/query")
public R query(ForumEntity forum) { public R query(ForumEntity forum){
EntityWrapper<ForumEntity> ew = new EntityWrapper<ForumEntity>(); EntityWrapper< ForumEntity> ew = new EntityWrapper< ForumEntity>();
ew.allEq(MPUtil.allEQMapPre(forum, "forum")); // 构建查询条件 ew.allEq(MPUtil.allEQMapPre( forum, "forum"));
ForumView forumView = forumService.selectView(ew); // 查询论坛视图 ForumView forumView = forumService.selectView(ew);
return R.ok("查询论坛表成功").put("data", forumView); return R.ok("查询论坛表成功").put("data", forumView);
} }
/** /**
* 获取后端论坛详情 * 后端详情
* @param id 论坛ID
* @return 论坛信息
*/ */
@RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}" @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) { public R info(@PathVariable("id") Long id){
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛 ForumEntity forum = forumService.selectById(id);
return R.ok().put("data", forum); return R.ok().put("data", forum);
} }
/** /**
* 获取前端论坛详情 * 前端详情
* @param id 论坛ID
* @return 论坛信息
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}" @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) { public R detail(@PathVariable("id") Long id){
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛 ForumEntity forum = forumService.selectById(id);
return R.ok().put("data", forum); return R.ok().put("data", forum);
} }
/** /**
* 获取论坛及其子项 * 论坛详情
* @param id 论坛ID
* @return 论坛信息及子项
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/list/{id}") // 映射请求路径为"/list/{id}" @RequestMapping("/list/{id}")
public R list(@PathVariable("id") String id) { public R list(@PathVariable("id") String id){
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛 ForumEntity forum = forumService.selectById(id);
getChilds(forum); // 获取子项 getChilds(forum);
return R.ok().put("data", forum); // 返回论坛信息及子项 return R.ok().put("data", forum);
} }
/**
* 递归获取子项
* @param forum 论坛实体
* @return 具有子项的论坛
*/
private ForumEntity getChilds(ForumEntity forum) { private ForumEntity getChilds(ForumEntity forum) {
List<ForumEntity> childs = new ArrayList<ForumEntity>(); List<ForumEntity> childs = new ArrayList<ForumEntity>();
childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId())); // 根据父ID查询子项 childs = forumService.selectList(new EntityWrapper<ForumEntity>().eq("parentid", forum.getId()));
if (childs == null || childs.size() == 0) { if(childs == null || childs.size()==0) {
return null; // 如果没有子项，则返回null return null;
} }
forum.setChilds(childs); // 设置子项 forum.setChilds(childs);
for (ForumEntity forumEntity : childs) { for(ForumEntity forumEntity : childs) {
getChilds(forumEntity); // 递归获取每个子项的子项 getChilds(forumEntity);
} }
return forum; // 返回具有子项的论坛 return forum;
} }
/** /**
* 后端保存论坛信息 * 后端保存
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/save") // 映射请求路径为"/save" @RequestMapping("/save")
public R save(@RequestBody ForumEntity forum, HttpServletRequest request) { public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(forum);
forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID forum.setUserid((Long)request.getSession().getAttribute("userId"));
forumService.insert(forum); // 保存论坛信息
forumService.insert(forum);
return R.ok(); return R.ok();
} }
/** /**
* 前端保存论坛信息 * 前端保存
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/add") // 映射请求路径为"/add" @RequestMapping("/add")
public R add(@RequestBody ForumEntity forum, HttpServletRequest request) { public R add(@RequestBody ForumEntity forum, HttpServletRequest request){
forum.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID forum.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(forum);
forum.setUserid((Long) request.getSession().getAttribute("userId")); // 设置用户ID forum.setUserid((Long)request.getSession().getAttribute("userId"));
forumService.insert(forum); // 保存论坛信息
forumService.insert(forum);
return R.ok(); return R.ok();
} }
/** /**
* 修改论坛信息 * 修改
* @param forum 论坛实体
* @param request HttpServletRequest对象
* @return 修改结果
*/ */
@RequestMapping("/update") // 映射请求路径为"/update" @RequestMapping("/update")
@Transactional // 开启事务 @Transactional
public R update(@RequestBody ForumEntity forum, HttpServletRequest request) { public R update(@RequestBody ForumEntity forum, HttpServletRequest request){
// ValidatorUtils.validateEntity(forum); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(forum);
forumService.updateById(forum); // 更新论坛信息 forumService.updateById(forum);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* 删除论坛 * 删除
* @param ids 论坛ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") // 映射请求路径为"/delete" @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
forumService.deleteBatchIds(Arrays.asList(ids)); // 批量删除论坛 forumService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
* @param columnName 列名
* @param type 类型
* @param map 查询参数
* @param request HttpServletRequest对象
* @return 提醒数量
*/ */
@RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/remind/{columnName}/{type}" @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) { @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName); // 将列名放入请求参数 map.put("column", columnName);
map.put("type", type); // 将类型放入请求参数 map.put("type", type);
// 如果类型为2，进行日期提醒处理 if(type.equals("2")) {
if (type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance(); Calendar c = Calendar.getInstance();
Date remindStartDate = null; Date remindStartDate = null;
Date remindEndDate = null; Date remindEndDate = null;
if (map.get("remindstart") != null) { if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart); // 加上提醒天数 c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime(); remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate)); // 格式化日期并放入请求参数 map.put("remindstart", sdf.format(remindStartDate));
} }
if (map.get("remindend") != null) { if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd); // 加上提醒天数 c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); // 格式化日期并放入请求参数 map.put("remindend", sdf.format(remindEndDate));
} }
} }
// 构建查询条件
Wrapper<ForumEntity> wrapper = new EntityWrapper<ForumEntity>(); Wrapper<ForumEntity> wrapper = new EntityWrapper<ForumEntity>();
if (map.get("remindstart") != null) { if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期 wrapper.ge(columnName, map.get("remindstart"));
} }
if (map.get("remindend") != null) { if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期 wrapper.le(columnName, map.get("remindend"));
} }
int count = forumService.selectCount(wrapper); // 查询数量
return R.ok().put("count", count); // 返回数量 int count = forumService.selectCount(wrapper);
return R.ok().put("count", count);
} }
} }

234
src/main/java/com/controller/LeixingController.java
Unescape View File

@ -1,6 +1,6 @@
package com.controller; package com.controller;
import java.math.BigDecimal; // 导入BigDecimal以处理高精度数值 import java.math.BigDecimal;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException; import java.text.ParseException;
import java.util.ArrayList; import java.util.ArrayList;
@ -8,35 +8,35 @@ import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Map; import java.util.Map;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; // 导入迭代器接口 import java.util.Iterator;
import java.util.Date; import java.util.Date;
import java.util.List; // 导入List接口 import java.util.List;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.IOException; import java.io.IOException;
import com.utils.ValidatorUtils; import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils; // 导入Apache Commons Lang的字符串处理类 import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; // 导入请求参数注解 import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper，用于构建查询条件 import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis-Plus的Wrapper接口 import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.LeixingEntity; import com.entity.LeixingEntity;
import com.entity.view.LeixingView; // 导入类型视图类 import com.entity.view.LeixingView;
import com.service.LeixingService; // 导入类型服务类 import com.service.LeixingService;
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; // 导入分页工具类 import com.utils.PageUtils;
import com.utils.R; // 导入响应工具类 import com.utils.R;
import com.utils.MD5Util; import com.utils.MD5Util;
import com.utils.MPUtil; // 导入MyBatis-Plus工具类 import com.utils.MPUtil;
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
@ -46,201 +46,185 @@ import com.utils.CommonUtil;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController // 标记该类为REST控制器 @RestController
@RequestMapping("/leixing") // 设置基本请求路径为"/leixing" @RequestMapping("/leixing")
public class LeixingController { public class LeixingController {
@Autowired @Autowired
private LeixingService leixingService; // 自动注入类型服务 private LeixingService leixingService;
/** /**
* 后端列表 * 后端列表
* @param params 请求参数
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 列表数据
*/ */
@RequestMapping("/page") // 映射请求路径为"/page" @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, LeixingEntity leixing, public R page(@RequestParam Map<String, Object> params,LeixingEntity leixing,
HttpServletRequest request) { HttpServletRequest request){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件 EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
// 查询分页数据
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params)); PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中 request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 前端列表 * 前端列表
* @param params 请求参数
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 列表数据
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/list") // 映射请求路径为"/list" @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, LeixingEntity leixing, public R list(@RequestParam Map<String, Object> params,LeixingEntity leixing,
HttpServletRequest request) { HttpServletRequest request){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件 EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
// 查询分页数据
PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params)); PageUtils page = leixingService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, leixing), params), params));
request.setAttribute("data", page); // 将数据设置到请求属性中 request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 查询所有列表 * 列表
* @param leixing 类型实体
* @return 查询结果
*/ */
@RequestMapping("/lists") // 映射请求路径为"/lists" @RequestMapping("/lists")
public R list(LeixingEntity leixing) { public R list( LeixingEntity leixing){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件 EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>();
ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件 ew.allEq(MPUtil.allEQMapPre( leixing, "leixing"));
return R.ok().put("data", leixingService.selectListView(ew)); return R.ok().put("data", leixingService.selectListView(ew));
} }
/** /**
* 查询具体信息 * 查询
* @param leixing 类型实体
* @return 查询结果
*/ */
@RequestMapping("/query") // 映射请求路径为"/query" @RequestMapping("/query")
public R query(LeixingEntity leixing) { public R query(LeixingEntity leixing){
EntityWrapper<LeixingEntity> ew = new EntityWrapper<LeixingEntity>(); // 创建查询条件 EntityWrapper< LeixingEntity> ew = new EntityWrapper< LeixingEntity>();
ew.allEq(MPUtil.allEQMapPre(leixing, "leixing")); // 设置查询条件 ew.allEq(MPUtil.allEQMapPre( leixing, "leixing"));
LeixingView leixingView = leixingService.selectView(ew); // 查询类型视图 LeixingView leixingView = leixingService.selectView(ew);
return R.ok("查询类型成功").put("data", leixingView); return R.ok("查询类型成功").put("data", leixingView);
} }
/** /**
* 获取后端详情 * 后端详情
* @param id 类型ID
* @return 类型信息
*/ */
@RequestMapping("/info/{id}") // 映射请求路径为"/info/{id}" @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) { public R info(@PathVariable("id") Long id){
LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型 LeixingEntity leixing = leixingService.selectById(id);
return R.ok().put("data", leixing); return R.ok().put("data", leixing);
} }
/** /**
* 获取前端详情 * 前端详情
* @param id 类型ID
* @return 类型信息
*/ */
@IgnoreAuth // 忽略身份验证 @IgnoreAuth
@RequestMapping("/detail/{id}") // 映射请求路径为"/detail/{id}" @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) { public R detail(@PathVariable("id") Long id){
LeixingEntity leixing = leixingService.selectById(id); // 根据ID查询类型 LeixingEntity leixing = leixingService.selectById(id);
return R.ok().put("data", leixing); return R.ok().put("data", leixing);
} }
/** /**
* 后端保存类型信息 * 后端保存
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/save") // 映射请求路径为"/save" @RequestMapping("/save")
public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request) { public R save(@RequestBody LeixingEntity leixing, HttpServletRequest request){
leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(leixing);
leixingService.insert(leixing); // 保存类型信息 leixingService.insert(leixing);
return R.ok(); return R.ok();
} }
/** /**
* 前端保存类型信息 * 前端保存
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 保存结果
*/ */
@RequestMapping("/add") // 映射请求路径为"/add" @RequestMapping("/add")
public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request) { public R add(@RequestBody LeixingEntity leixing, HttpServletRequest request){
leixing.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); // 生成唯一ID leixing.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
// ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(leixing);
leixingService.insert(leixing); // 保存类型信息 leixingService.insert(leixing);
return R.ok(); return R.ok();
} }
/** /**
* 修改类型信息 * 修改
* @param leixing 类型实体
* @param request HttpServletRequest对象
* @return 修改结果
*/ */
@RequestMapping("/update") // 映射请求路径为"/update" @RequestMapping("/update")
@Transactional // 开启事务 @Transactional
public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request) { public R update(@RequestBody LeixingEntity leixing, HttpServletRequest request){
// ValidatorUtils.validateEntity(leixing); // 验证实体（可选择启用） //ValidatorUtils.validateEntity(leixing);
leixingService.updateById(leixing); // 更新类型信息 leixingService.updateById(leixing);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* 删除类型 * 删除
* @param ids 类型ID数组
* @return 删除结果
*/ */
@RequestMapping("/delete") // 映射请求路径为"/delete" @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
leixingService.deleteBatchIds(Arrays.asList(ids)); // 批量删除类型 leixingService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
* @param columnName 列名
* @param type 类型
* @param map 查询参数
* @param request HttpServletRequest对象
* @return 提醒数量
*/ */
@RequestMapping("/remind/{columnName}/{type}") // 映射请求路径为"/remind/{columnName}/{type}" @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) { @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName); // 将列名放入请求参数 map.put("column", columnName);
map.put("type", type); // 将类型放入请求参数 map.put("type", type);
// 如果类型为2，进行日期提醒处理 if(type.equals("2")) {
if (type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance(); Calendar c = Calendar.getInstance();
Date remindStartDate = null; Date remindStartDate = null;
Date remindEndDate = null; Date remindEndDate = null;
// 处理提醒开始时间 if(map.get("remindstart")!=null) {
if (map.get("remindstart") != null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindStart); // 添加提醒天数 c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime(); // 获取新的开始日期 remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate)); // 格式化并放入请求参数 map.put("remindstart", sdf.format(remindStartDate));
} }
// 处理提醒结束时间 if(map.get("remindend")!=null) {
if (map.get("remindend") != null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd); // 添加提醒天数 c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); // 获取新的结束日期 remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); // 格式化并放入请求参数 map.put("remindend", sdf.format(remindEndDate));
} }
} }
// 构建查询条件
Wrapper<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>(); Wrapper<LeixingEntity> wrapper = new EntityWrapper<LeixingEntity>();
if (map.get("remindstart") != null) { if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于开始日期 wrapper.ge(columnName, map.get("remindstart"));
} }
if (map.get("remindend") != null) { if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于结束日期 wrapper.le(columnName, map.get("remindend"));
} }
int count = leixingService.selectCount(wrapper); // 查询数量
return R.ok().put("count", count); // 返回数量 int count = leixingService.selectCount(wrapper);
return R.ok().put("count", count);
} }
} }

169
src/main/java/com/controller/NewsController.java
Unescape View File

@ -1,6 +1,5 @@
package com.controller; package com.controller;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.text.ParseException; import java.text.ParseException;
@ -12,7 +11,6 @@ import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.io.IOException; import java.io.IOException;
@ -26,13 +24,13 @@ import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
import com.entity.NewsEntity; import com.entity.NewsEntity;
import com.entity.view.NewsView; import com.entity.view.NewsView;
import com.service.NewsService; import com.service.NewsService;
import com.service.TokenService; import com.service.TokenService;
import com.utils.PageUtils; import com.utils.PageUtils;
@ -52,23 +50,24 @@ import com.utils.CommonUtil;
@RequestMapping("/news") @RequestMapping("/news")
public class NewsController { public class NewsController {
@Autowired @Autowired
private NewsService newsService;//注入新闻服务类 private NewsService newsService;
/** /**
* 后端列表 * 后端列表
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) { public R page(@RequestParam Map<String, Object> params,NewsEntity news,
// 创建一个EntityWrapper对象，用于构建查询条件 HttpServletRequest request){
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>(); EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page); request.setAttribute("data", page);
// 返回成功响应，包含分页结果
return R.ok().put("data", page); return R.ok().put("data", page);
} }
@ -77,17 +76,12 @@ public class NewsController {
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, NewsEntity news, HttpServletRequest request) { public R list(@RequestParam Map<String, Object> params,NewsEntity news,
// 创建一个EntityWrapper对象，用于构建查询条件 HttpServletRequest request){
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>(); EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
// 使用MPUtil工具类对查询条件进行排序和分页处理
PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params)); PageUtils page = newsService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, news), params), params));
// 将分页结果设置到request对象中
request.setAttribute("data", page); request.setAttribute("data", page);
// 返回成功响应，包含分页结果
return R.ok().put("data", page); return R.ok().put("data", page);
} }
@ -95,33 +89,19 @@ public class NewsController {
* 列表 * 列表
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
//一个Spring MVC的注解，用于将HTTP请求映射到 list 方法。当客户端发送一个HTTP请求到 /lists 路径时，Spring MVC会调用 list 方法来处理这个请求 public R list( NewsEntity news){
public R list(NewsEntity news) //NewsEntity news 参数表示要查询的 NewsEntity 对象
{
// 创建一个EntityWrapper对象，用于构建查询条件
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>(); EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>();
ew.allEq(MPUtil.allEQMapPre( news, "news"));
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 返回成功响应，包含查询结果
return R.ok().put("data", newsService.selectListView(ew)); return R.ok().put("data", newsService.selectListView(ew));
//这行代码返回一个表示请求成功的响应对象，并将 newsService.selectListView(ew) 的结果添加到响应对象中，键为 "data"。
//newsService.selectListView(ew) 方法用于查询满足 ew 对象的查询条件的记录，并返回一个包含查询结果的列表。
} }
/** /**
* 查询 * 查询
*/ */
@RequestMapping("/query") @RequestMapping("/query")
public R query(NewsEntity news) { public R query(NewsEntity news){
// 创建一个EntityWrapper对象，用于构建查询条件 EntityWrapper< NewsEntity> ew = new EntityWrapper< NewsEntity>();
EntityWrapper<NewsEntity> ew = new EntityWrapper<NewsEntity>(); ew.allEq(MPUtil.allEQMapPre( news, "news"));
// 使用MPUtil工具类对查询条件进行排序和分页处理
ew.allEq(MPUtil.allEQMapPre(news, "news"));
// 调用 newsService 对象的 selectView 方法，查询满足 ew 对象的查询条件的记录，并返回一个 NewsView 对象
NewsView newsView = newsService.selectView(ew); NewsView newsView = newsService.selectView(ew);
return R.ok("查询公告信息成功").put("data", newsView); return R.ok("查询公告信息成功").put("data", newsView);
} }
@ -129,40 +109,34 @@ public class NewsController {
/** /**
* 后端详情 * 后端详情
*/ */
//一个Spring MVC的注解，用于将HTTP请求映射到 info 方法。
//当客户端发送一个HTTP请求到 /info/{id} 路径时，Spring MVC会调用 info 方法来处理这个请求
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) { public R info(@PathVariable("id") Long id){
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id); NewsEntity news = newsService.selectById(id);
//调用 newsService 对象的 selectById 方法，根据 id 参数的值查询数据库中的记录，并返回一个 NewsEntity 对象。 return R.ok().put("data", news);
return R.ok().put("data", news); //将 news 对象添加到响应对象中，键为 "data"
} }
/** /**
* 前端详情 * 前端详情
*/ */
@IgnoreAuth @IgnoreAuth
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) { public R detail(@PathVariable("id") Long id){
// 根据ID查询并返回结果
NewsEntity news = newsService.selectById(id); NewsEntity news = newsService.selectById(id);
return R.ok().put("data", news); return R.ok().put("data", news);
} }
/** /**
* 后端保存 * 后端保存
*/ */
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody NewsEntity news, HttpServletRequest request) { public R save(@RequestBody NewsEntity news, HttpServletRequest request){
// 设置ID为当前时间戳加上一个随机数 news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); //ValidatorUtils.validateEntity(news);
// 验证实体对象，如果需要验证，可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据，将 news 对象插入到数据库中
newsService.insert(news); newsService.insert(news);
//返回一个表示请求成功的响应对象
return R.ok(); return R.ok();
} }
@ -170,100 +144,87 @@ public class NewsController {
* 前端保存 * 前端保存
*/ */
@RequestMapping("/add") @RequestMapping("/add")
public R add(@RequestBody NewsEntity news, HttpServletRequest request) { public R add(@RequestBody NewsEntity news, HttpServletRequest request){
// 设置ID为当前时间戳加上一个随机数 news.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
news.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue()); //ValidatorUtils.validateEntity(news);
// 验证实体对象，如果需要验证，可以取消注释
// ValidatorUtils.validateEntity(news);
// 插入数据
newsService.insert(news); newsService.insert(news);
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
*/ */
@RequestMapping("/update") @RequestMapping("/update")
@Transactional @Transactional
public R update(@RequestBody NewsEntity news, HttpServletRequest request) { public R update(@RequestBody NewsEntity news, HttpServletRequest request){
// 验证实体对象，如果需要验证，可以取消注释 //ValidatorUtils.validateEntity(news);
// ValidatorUtils.validateEntity(news); newsService.updateById(news);//全部更新
// 更新数据
newsService.updateById(news);
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除
*/ */
@RequestMapping("/delete")//这是一个Spring MVC的注解，用于将HTTP请求映射到 delete方法上 @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
// 批量删除数据
newsService.deleteBatchIds(Arrays.asList(ids)); newsService.deleteBatchIds(Arrays.asList(ids));
return R.ok();//R.ok() 方法通常表示请求成功，并返回一个默认的成功响应。 return R.ok();
} }
/** /**
* 提醒接口 * 提醒接口
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/remind/{columnName}/{type}")
//这是一个Spring MVC的注解，用于将HTTP请求映射到 remindCount 方法。当客户端发送一个HTTP请求到 /remind/{columnName}/{type} 路径时，Spring MVC会调用 remindCount 方法来处理这个请求。
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) { @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
// 将列名和类型添加到map中,@PathVariable 注解表示 columnName 和 type 参数的值将从URL路径中获取 map.put("column", columnName);
map.put("column", columnName);//将 columnName 参数的值添加到 map 中，键为 "column"。
map.put("type", type); map.put("type", type);
if (type.equals("2")) //如果 type 参数的值为 "2" if(type.equals("2")) {
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//创建一个 SimpleDateFormat 对象sdf，用于将日期格式化为 "yyyy-MM-dd" 格式。
Calendar c = Calendar.getInstance(); Calendar c = Calendar.getInstance();
//创建一个 Calendar 对象，用于处理日期和时间。Calendar.getInstance() 方法返回一个表示当前日期和时间的 Calendar 对象。 Date remindStartDate = null;
Date remindStartDate = null;//声明一个变量 remindStartDate,初始化为 null,这个变量将用于存储提醒开始日期。
Date remindEndDate = null; Date remindEndDate = null;
if(map.get("remindstart")!=null) {
if (map.get("remindstart") != null)//如果 map 中存在键为 "remindstart" 的元素
{
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
//将 map 中键为 "remindstart" 的元素的值转换为 Integer 类型，并赋值给 remindStart c.setTime(new Date());
c.setTime(new Date());//setTime(new Date()) 方法将 Calendar 对象c的时间设置为当前时间。 c.add(Calendar.DAY_OF_MONTH,remindStart);
c.add(Calendar.DAY_OF_MONTH, remindStart);//将 Calendar 对象的时间增加 remindStart 天。 remindStartDate = c.getTime();
remindStartDate = c.getTime();//返回一个表示 Calendar 对象当前时间的 Date 对象，并将其赋值给 remindStartDate。 map.put("remindstart", sdf.format(remindStartDate));
map.put("remindstart", sdf.format(remindStartDate));//将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并将其作为 map 中键为 "remindstart" 的元素的值。
} }
if(map.get("remindend")!=null) {
if (map.get("remindend") != null)
{
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());//c 的时间设置为当前时间 c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, remindEnd);//c 的时间增加 remindStart 天 c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); map.put("remindend", sdf.format(remindEndDate));
} }
} }
// 创建一个EntityWrapper对象，用于构建查询条件
Wrapper<NewsEntity> wrapper = new EntityWrapper<NewsEntity>(); Wrapper<NewsEntity> wrapper = new EntityWrapper<NewsEntity>();
//创建一个EntityWrapper对象，用于构建查询条件 if(map.get("remindstart")!=null) {
if (map.get("remindstart") != null)//如果map中存在键为"remindstart"的元素
{
wrapper.ge(columnName, map.get("remindstart")); wrapper.ge(columnName, map.get("remindstart"));
//将 wrapper 对象的查询条件设置为 columnName>=map 中键为 "remindend" 的元素的值
} }
if(map.get("remindend")!=null) {
if (map.get("remindend") != null) {
wrapper.le(columnName, map.get("remindend")); wrapper.le(columnName, map.get("remindend"));
//将 wrapper 对象的查询条件设置为 columnName<=map 中键为 "remindend" 的元素的值
} }
// 查询并返回结果
int count = newsService.selectCount(wrapper); int count = newsService.selectCount(wrapper);
//查询满足wrapper对象的查询条件的记录数，并赋值给 count 变量 return R.ok().put("count", count);
return R.ok().put("count", count);//返回一个包含 count 变量的 R 对象(请求成功的响应对象)
} }
} }

200
src/main/java/com/controller/StoreupController.java
Unescape View File

@ -52,170 +52,186 @@ public class StoreupController {
@Autowired @Autowired
private StoreupService storeupService; private StoreupService storeupService;
/** /**
* 后端列表 * 后端列表
*/ */
@RequestMapping("/page")//定义了一个处理HTTP请求的映射，当请求路径为/page时，会调用这个方法 @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,StoreupEntity storeup,HttpServletRequest request) public R page(@RequestParam Map<String, Object> params,StoreupEntity storeup,
{//定义了一个公共方法，接收请求参数、实体对象和HTTP请求对象 HttpServletRequest request){
if(!request.getSession().getAttribute("role").toString().equals("管理员")) if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
{//检查当前用户的角色是否为管理员，如果不是管理员，则设置用户ID storeup.setUserid((Long)request.getSession().getAttribute("userId"));
storeup.setUserid((Long)request.getSession().getAttribute("userId"));//设置用户ID
}
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象，用于构建查询条件
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);//返回一个包含分页结果的响应对象
} }
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();
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//定义了一个注解，用于标记不需要权限认证的接口 @IgnoreAuth
@RequestMapping("/list")//定义了一个处理HTTP请求的映射，当请求路径为/list时，会调用这个方法 @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,StoreupEntity storeup,HttpServletRequest request) public R list(@RequestParam Map<String, Object> params,StoreupEntity storeup,
{ HttpServletRequest request){
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象，用于构建查询条件 EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();
PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));//调用storeupService的queryPage方法，根据查询条件和分页参数进行分页查询，并返回分页结果
request.setAttribute("data", page);//将分页查询结果设置到HTTP请求对象中 PageUtils page = storeupService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, storeup), params), params));
return R.ok().put("data", page);//返回一个包含分页查询结果的响应对象 request.setAttribute("data", page);
return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
*/ */
@RequestMapping("/lists") @RequestMapping("/lists")
public R list( StoreupEntity storeup)//定义了一个公共方法，接收实体对象 public R list( StoreupEntity storeup){
{ EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();
EntityWrapper<StoreupEntity> ew = new EntityWrapper<StoreupEntity>();//创建一个实体包装器对象，用于构建查询条件 ew.allEq(MPUtil.allEQMapPre( storeup, "storeup"));
ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); //使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 return R.ok().put("data", storeupService.selectListView(ew));
return R.ok().put("data", storeupService.selectListView(ew));//根据查询条件查询出符合条件的实体对象列表，并返回一个包含实体对象列表的响应对象
} }
/** /**
* 查询 * 查询
*/ */
@RequestMapping("/query")//定义了一个处理HTTP请求的映射，当请求路径为/query时，会调用这个方法。 @RequestMapping("/query")
public R query(StoreupEntity storeup) public R query(StoreupEntity storeup){
{
EntityWrapper< StoreupEntity> ew = new EntityWrapper< StoreupEntity>(); EntityWrapper< StoreupEntity> ew = new EntityWrapper< StoreupEntity>();
//创建一个实体包装器,用于构建查询条件
ew.allEq(MPUtil.allEQMapPre( storeup, "storeup")); ew.allEq(MPUtil.allEQMapPre( storeup, "storeup"));
//使用allEq方法设置查询条件,MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"storeup",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象。
StoreupView storeupView = storeupService.selectView(ew); StoreupView storeupView = storeupService.selectView(ew);
//调用服务层的方法查询单个数据，并返回视图对象
return R.ok("查询收藏表成功").put("data", storeupView); return R.ok("查询收藏表成功").put("data", storeupView);
//返回一个包含查询结果的响应对象，并附带成功消息
} }
/** /**
* 后端详情 * 后端详情
*/ */
@RequestMapping("/info/{id}")// 定义一个请求映射，当访问 /info/{id} 路径时，会调用这个方法 @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id)// 定义一个方法，接收一个路径变量 id，类型为 Long public R info(@PathVariable("id") Long id){
{ StoreupEntity storeup = storeupService.selectById(id);
StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据，并返回实体对象 return R.ok().put("data", storeup);
return R.ok().put("data", storeup);//返回一个包含查询结果的 R 对象，其中包含键 "data" 和对应的 storeup 实体对象
} }
/** /**
* 前端详情 * 前端详情
*/ */
@IgnoreAuth//定义了一个注解，用于标记不需要权限认证的接口 @IgnoreAuth
@RequestMapping("/detail/{id}")//定义了一个处理HTTP请求的映射，当请求路径为/detail/{id}时，会调用这个方法 @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id)//定义了一个方法，接收一个路径变量 id，类型为 Long public R detail(@PathVariable("id") Long id){
{ StoreupEntity storeup = storeupService.selectById(id);
StoreupEntity storeup = storeupService.selectById(id);//调用服务层的方法根据ID查询数据，并返回实体对象 return R.ok().put("data", storeup);
return R.ok().put("data", storeup);//返回一个包含查询结果的响应对象，并附带成功消息
} }
/** /**
* 后端保存 * 后端保存
*/ */
@RequestMapping("/save")//定义了一个处理HTTP请求的映射，当请求路径为/save时，会调用这个方法 @RequestMapping("/save")
public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法，接收一个JSON格式的请求体，类型为 StoreupEntity，并接收一个 HttpServletRequest 对象 public R save(@RequestBody StoreupEntity storeup, HttpServletRequest request){
{
storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(storeup); //ValidatorUtils.validateEntity(storeup);
storeup.setUserid((Long)request.getSession().getAttribute("userId"));//从请求的 session 中获取用户ID，并设置到 storeup 实体对象中 storeup.setUserid((Long)request.getSession().getAttribute("userId"));
storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库
return R.ok();//返回一个包含成功信息的 R 对象 storeupService.insert(storeup);
return R.ok();
} }
/** /**
* 前端保存 * 前端保存
*/ */
@RequestMapping("/add")//定义了一个处理HTTP请求的映射，当请求路径为/add时，会调用这个方法 @RequestMapping("/add")
public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request) //定义一个方法，接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象 public R add(@RequestBody StoreupEntity storeup, HttpServletRequest request){
{ storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
storeup.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());//生成一个新的唯一ID，由当前时间戳加上一个随机数
//ValidatorUtils.validateEntity(storeup); //ValidatorUtils.validateEntity(storeup);
storeupService.insert(storeup);//调用服务层的方法将 storeup 实体对象插入数据库
storeupService.insert(storeup);
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
*/ */
@RequestMapping("/update") @RequestMapping("/update")
@Transactional//定义了一个事务注解，表示该方法中的数据库操作应该在一个事务中执行 @Transactional
public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request)//定义了一个方法，接收一个请求体中的 StoreupEntity 对象和 HttpServletRequest 对象 public R update(@RequestBody StoreupEntity storeup, HttpServletRequest request){
{
//ValidatorUtils.validateEntity(storeup); //ValidatorUtils.validateEntity(storeup);
storeupService.updateById(storeup);//调用服务层的方法根据 ID 更新 storeup 实体对象的所有字段 storeupService.updateById(storeup);//全部更新
return R.ok();//返回一个包含成功信息的 R 对象 return R.ok();
} }
/** /**
* 删除 * 删除
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids)// 定义一个方法，接收一个请求体中的 Long 数组，类型为 Long[] public R delete(@RequestBody Long[] ids){
{ storeupService.deleteBatchIds(Arrays.asList(ids));
storeupService.deleteBatchIds(Arrays.asList(ids));//调用服务层的方法，根据传入的 ID 数组批量删除数据 return R.ok();
return R.ok();//返回一个包含成功信息的 R 对象 R.ok()函数是R工具类中的一个静态方法，用于创建一个包含成功信息的响应对象
} }
/** /**
* 提醒接口 * 提醒接口
*/ */
@RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射，当访问 /remind/{columnName}/{type} 路径时，会调用这个方法 @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { // 定义一个方法，接收一个路径变量 columnName 和 type，类型为 String，以及一个请求参数 map，类型为 Map<String, Object> @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName); // 将 columnName 添加到 map 中，键为 "column" map.put("column", columnName);
map.put("type", type); // 将 type 添加到 map 中，键为 "type" map.put("type", type);
if(type.equals("2")) { // 如果 type 等于 "2" if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象，格式为 "yyyy-MM-dd" SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance(); // 创建一个日历对象，获取当前时间 Calendar c = Calendar.getInstance();
Date remindStartDate = null; // 创建一个日期对象，用于存储提醒开始时间 Date remindStartDate = null;
Date remindEndDate = null; // 创建一个日期对象，用于存储提醒结束时间 Date remindEndDate = null;
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date()); // 设置日历对象的时间为当前时间 c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天 c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime(); // 获取增加后的时间，并赋值给 remindStartDate remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindstart" map.put("remindstart", sdf.format(remindStartDate));
} }
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); // 设置日历对象的时间为当前时间 c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天 c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); // 获取增加后的时间，并赋值给 remindEndDate remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindend" map.put("remindend", sdf.format(remindEndDate));
} }
} }
Wrapper<StoreupEntity> wrapper = new EntityWrapper<StoreupEntity>(); // 创建一个实体包装器对象，用于构建查询条件 Wrapper<StoreupEntity> wrapper = new EntityWrapper<StoreupEntity>();
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件，查询 columnName 字段大于等于 "remindstart" 键对应的值 wrapper.ge(columnName, map.get("remindstart"));
} }
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend")); // 设置查询条件，查询 columnName 字段小于等于 "remindend" 键对应的值 wrapper.le(columnName, map.get("remindend"));
} }
if(!request.getSession().getAttribute("role").toString().equals("管理员")) { // 如果当前用户的角色不是管理员 if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
wrapper.eq("userid", (Long)request.getSession().getAttribute("userId")); // 设置查询条件，查询 userid 字段等于当前用户的 ID wrapper.eq("userid", (Long)request.getSession().getAttribute("userId"));
} }
int count = storeupService.selectCount(wrapper); // 调用服务层的方法，根据查询条件查询符合条件的记录数，并赋值给 count
return R.ok().put("count", count); // 返回一个包含查询结果的响应对象，其中包含键 "count" 和对应的 count 值 int count = storeupService.selectCount(wrapper);
return R.ok().put("count", count);
} }
} }

271
src/main/java/com/controller/SystemintroController.java
Unescape View File

@ -1,45 +1,43 @@
package com.controller; // 定义一个包，用于组织和管理类 package com.controller;
import java.math.BigDecimal; // 导入BigDecimal类，用于高精度的数学计算 import java.math.BigDecimal;
import java.text.SimpleDateFormat; // 导入SimpleDateFormat类，用于日期格式化 import java.text.SimpleDateFormat;
import java.text.ParseException; // 导入ParseException类，用于处理日期解析异常 import java.text.ParseException;
import java.util.ArrayList; // 导入ArrayList类，用于创建动态数组 import java.util.ArrayList;
import java.util.Arrays; // 导入Arrays类，提供对数组操作的工具方法 import java.util.Arrays;
import java.util.Calendar; // 导入Calendar类，用于日期时间操作 import java.util.Calendar;
import java.util.Map; // 导入Map接口，用于键值对集合 import java.util.Map;
import java.util.HashMap; // 导入HashMap类，基于哈希表的Map实现 import java.util.HashMap;
import java.util.Iterator; // 导入Iterator接口，用于遍历集合 import java.util.Iterator;
import java.util.Date; // 导入Date类，用于日期时间表示 import java.util.Date;
import java.util.List; // 导入List接口，用于列表集合 import java.util.List;
import javax.servlet.http.HttpServletRequest; // 导入HttpServletRequest接口，用于访问HTTP请求信息 import javax.servlet.http.HttpServletRequest;
import java.io.IOException; // 导入IOException类，用于处理输入输出异常 import java.io.IOException;
import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类，用于实体验证 import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils; // 导入StringUtils类，提供字符串操作的工具方法 import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired; // 导入Autowired注解，用于自动注入依赖 import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; // 导入Transactional注解，用于声明事务管理 import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat; // 导入DateTimeFormat注解，用于日期时间格式化 import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable; // 导入PathVariable注解，用于将URL中的参数绑定到控制器方法的参数上 import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody; // 导入RequestBody注解，用于将HTTP请求体绑定到控制器方法的参数上 import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; // 导入RequestMapping注解，用于映射HTTP请求到控制器方法 import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam; // 导入RequestParam注解，用于将请求参数绑定到控制器方法的参数上 import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; // 导入RestController注解，用于声明一个REST风格的控制器 import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入EntityWrapper类，用于构建查询条件 import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口，用于封装查询条件 import com.annotation.IgnoreAuth;
import com.annotation.IgnoreAuth; // 导入IgnoreAuth注解，用于标记不需要认证的接口 import com.entity.SystemintroEntity;
import com.entity.view.SystemintroView;
import com.entity.SystemintroEntity; // 导入SystemintroEntity实体类，代表存储数据
import com.entity.view.SystemintroView; // 导入SystemintroView视图类，用于展示存储数据 import com.service.SystemintroService;
import com.service.TokenService;
import com.service.SystemintroService; // 导入SystemintroService接口，用于存储业务操作 import com.utils.PageUtils;
import com.service.TokenService; // 导入TokenService接口，用于令牌操作（未使用） import com.utils.R;
import com.utils.PageUtils; // 导入PageUtils工具类，用于分页处理 import com.utils.MD5Util;
import com.utils.R; // 导入R工具类，用于构建统一的响应格式 import com.utils.MPUtil;
import com.utils.MD5Util; // 导入MD5Util工具类，用于MD5加密（未使用） import com.utils.CommonUtil;
import com.utils.MPUtil; // 导入MPUtil工具类，提供MyBatis Plus操作的工具方法
import com.utils.CommonUtil; // 导入CommonUtil工具类，提供通用的工具方法
/** /**
* 关于我们 * 关于我们
@ -48,75 +46,83 @@ import com.utils.CommonUtil; // 导入CommonUtil工具类，提供通用的工
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController // 声明一个REST风格的控制器 @RestController
@RequestMapping("/systemintro") // 定义一个请求映射，当访问 /systemintro 路径时，会调用这个控制器 @RequestMapping("/systemintro")
public class SystemintroController { public class SystemintroController {
@Autowired // 自动注入依赖 @Autowired
private SystemintroService systemintroService; // 声明一个SystemintroService对象，用于存储业务操作 private SystemintroService systemintroService;
/** /**
* 后端列表 * 后端列表
*/ */
@RequestMapping("/page") // 定义一个请求映射，当访问 /page 路径时，会调用这个方法 @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,SystemintroEntity systemintro, public R page(@RequestParam Map<String, Object> params,SystemintroEntity systemintro,
HttpServletRequest request){ // 定义一个方法，接收请求参数、实体对象和HTTP请求对象 HttpServletRequest request){
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件
PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法，根据查询条件和分页参数进行分页查询，并返回分页结果 EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>();
request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中
return R.ok().put("data", page); // 返回一个包含分页结果的响应对象 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);
} }
/** /**
* 前端列表 * 前端列表
*/ */
@IgnoreAuth // 定义了一个注解，用于标记不需要权限认证的接口 @IgnoreAuth
@RequestMapping("/list") // 定义一个请求映射，当访问 /list 路径时，会调用这个方法 @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,SystemintroEntity systemintro, public R list(@RequestParam Map<String, Object> params,SystemintroEntity systemintro,
HttpServletRequest request){ // 定义一个方法，接收请求参数、实体对象和HTTP请求对象 HttpServletRequest request){
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件 EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>();
PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params)); // 调用服务层的方法，根据查询条件和分页参数进行分页查询，并返回分页结果
request.setAttribute("data", page); // 将分页结果设置到HTTP请求对象中 PageUtils page = systemintroService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, systemintro), params), params));
return R.ok().put("data", page); // 返回一个包含分页结果的响应对象 request.setAttribute("data", page);
return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
*/ */
@RequestMapping("/lists") // 定义一个请求映射，当访问 /lists 路径时，会调用这个方法 @RequestMapping("/lists")
public R list( SystemintroEntity systemintro){ // 定义一个方法，接收实体对象 public R list( SystemintroEntity systemintro){
EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件 EntityWrapper<SystemintroEntity> ew = new EntityWrapper<SystemintroEntity>();
ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro"));
return R.ok().put("data", systemintroService.selectListView(ew)); // 根据查询条件查询出符合条件的实体对象列表，并返回一个包含实体对象列表的响应对象 return R.ok().put("data", systemintroService.selectListView(ew));
} }
/** /**
* 查询 * 查询
*/ */
@RequestMapping("/query") // 定义一个请求映射，当访问 /query 路径时，会调用这个方法 @RequestMapping("/query")
public R query(SystemintroEntity systemintro){ // 定义一个方法，接收实体对象 public R query(SystemintroEntity systemintro){
EntityWrapper< SystemintroEntity> ew = new EntityWrapper< SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件 EntityWrapper< SystemintroEntity> ew = new EntityWrapper< SystemintroEntity>();
ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro")); // 使用allEq方法设置查询条件，MPUtil.allEQMapPre方法将实体对象的属性转换为Map,并添加前缀"systemintro",allEq方法将Map中的键值对作为查询条件，查询出符合条件的实体对象 ew.allEq(MPUtil.allEQMapPre( systemintro, "systemintro"));
SystemintroView systemintroView = systemintroService.selectView(ew); // 调用服务层的方法查询单个数据，并返回视图对象 SystemintroView systemintroView = systemintroService.selectView(ew);
return R.ok("查询关于我们成功").put("data", systemintroView); // 返回一个包含查询结果的响应对象，并附带成功消息 return R.ok("查询关于我们成功").put("data", systemintroView);
} }
/** /**
* 后端详情 * 后端详情
*/ */
@RequestMapping("/info/{id}") // 定义一个请求映射，当访问 /info/{id} 路径时，会调用这个方法 @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){ // 定义一个方法，接收一个路径变量 id，类型为 Long public R info(@PathVariable("id") Long id){
SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据，并返回实体对象 SystemintroEntity systemintro = systemintroService.selectById(id);
return R.ok().put("data", systemintro); // 返回一个包含查询结果的 R 对象，其中包含键 "data" 和对应的 systemintro 实体对象 return R.ok().put("data", systemintro);
} }
/** /**
* 前端详情 * 前端详情
*/ */
@IgnoreAuth // 定义了一个注解，用于标记不需要权限认证的接口 @IgnoreAuth
@RequestMapping("/detail/{id}") // 定义一个请求映射，当访问 /detail/{id} 路径时，会调用这个方法 @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){ // 定义一个方法，接收一个路径变量 id，类型为 Long public R detail(@PathVariable("id") Long id){
SystemintroEntity systemintro = systemintroService.selectById(id); // 调用服务层的方法根据ID查询数据，并返回实体对象 SystemintroEntity systemintro = systemintroService.selectById(id);
return R.ok().put("data", systemintro); // 返回一个包含查询结果的响应对象，并附带成功消息 return R.ok().put("data", systemintro);
} }
@ -125,38 +131,37 @@ public class SystemintroController {
/** /**
* 后端保存 * 后端保存
*/ */
@RequestMapping("/save") // 定义一个请求映射，当访问 /save 路径时，会调用这个方法 @RequestMapping("/save")
public R save(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个JSON格式的请求体，类型为 SystemintroEntity，并接收一个 HttpServletRequest 对象 public R save(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){
systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID，由当前时间戳加上一个随机数 systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求 //ValidatorUtils.validateEntity(systemintro);
systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库
return R.ok(); // 返回一个包含成功信息的 R 对象 systemintroService.insert(systemintro);
return R.ok();
} }
/** /**
* 前端保存 * 前端保存
*/ */
@RequestMapping("/add") @RequestMapping("/add")
// 定义一个请求映射，当访问 /add 路径时，会调用这个方法 public R add(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){
public R add(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象 systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
systemintro.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); // 生成一个新的唯一ID，由当前时间戳加上一个随机数 //ValidatorUtils.validateEntity(systemintro);
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求
systemintroService.insert(systemintro); // 调用服务层的方法将 systemintro 实体对象插入数据库 systemintroService.insert(systemintro);
return R.ok(); // 返回一个包含成功信息的 R 对象 return R.ok();
} }
/** /**
* 修改 * 修改
*/ */
@RequestMapping("/update") // 定义一个请求映射，当访问 /update 路径时，会调用这个方法 @RequestMapping("/update")
@Transactional // 定义了一个事务注解，表示该方法中的数据库操作应该在一个事务中执行 @Transactional
public R update(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){ // 定义一个方法，接收一个请求体中的 SystemintroEntity 对象和 HttpServletRequest 对象 public R update(@RequestBody SystemintroEntity systemintro, HttpServletRequest request){
//ValidatorUtils.validateEntity(systemintro); // 注释掉的代码，用于验证 systemintro 实体对象是否符合要求 //ValidatorUtils.validateEntity(systemintro);
systemintroService.updateById(systemintro); systemintroService.updateById(systemintro);//全部更新
// 调用服务层的方法根据 ID 更新 systemintro 实体对象的所有字段
return R.ok(); return R.ok();
// 返回一个包含成功信息的 R 对象
} }
@ -165,57 +170,61 @@ public class SystemintroController {
* 删除 * 删除
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
// 定义一个请求映射，当访问 /delete 路径时，会调用这个方法 public R delete(@RequestBody Long[] ids){
public R delete(@RequestBody Long[] ids){ // 定义一个方法，接收一个请求体中的 Long 数组，类型为 Long[] systemintroService.deleteBatchIds(Arrays.asList(ids));
systemintroService.deleteBatchIds(Arrays.asList(ids)); // 调用服务层的方法，根据传入的 ID 数组批量删除数据
return R.ok(); return R.ok();
// 返回一个包含成功信息的 R 对象
} }
/** /**
* 提醒接口 * 提醒接口
*/ */
@RequestMapping("/remind/{columnName}/{type}") // 定义一个请求映射，当访问 /remind/{columnName}/{type} 路径时，会调用这个方法 @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { // 定义一个方法，接收一个路径变量 columnName 和 type，类型为 String，以及一个请求参数 map，类型为 Map<String, Object> @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName); // 将 columnName 添加到 map 中，键为 "column" map.put("column", columnName);
map.put("type", type); map.put("type", type);
// 将 type 添加到 map 中，键为 "type"
if(type.equals("2")) { // 如果 type 等于 "2" if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 创建一个日期格式化对象，格式为 "yyyy-MM-dd" SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance(); // 创建一个日历对象，获取当前时间 Calendar c = Calendar.getInstance();
Date remindStartDate = null; Date remindStartDate = null;
// 创建一个日期对象，用于存储提醒开始时间 Date remindEndDate = null;
Date remindEndDate = null; // 创建一个日期对象，用于存储提醒结束时间 if(map.get("remindstart")!=null) {
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 "remindstart" 键对应的值转换为整数 c.setTime(new Date());
c.setTime(new Date()); // 设置日历对象的时间为当前时间 c.add(Calendar.DAY_OF_MONTH,remindStart);
c.add(Calendar.DAY_OF_MONTH,remindStart); // 将日历对象的时间增加 remindStart 天 remindStartDate = c.getTime();
remindStartDate = c.getTime(); // 获取增加后的时间，并赋值给 remindStartDate map.put("remindstart", sdf.format(remindStartDate));
map.put("remindstart", sdf.format(remindStartDate)); // 将 remindStartDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindstart"
} }
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 "remindend" 键对应的值转换为整数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date()); // 设置日历对象的时间为当前时间 c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd); // 将日历对象的时间增加 remindEnd 天 c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime(); // 获取增加后的时间，并赋值给 remindEndDate remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate)); // 将 remindEndDate 格式化为 "yyyy-MM-dd" 格式，并添加到 map 中，键为 "remindend" map.put("remindend", sdf.format(remindEndDate));
} }
} }
Wrapper<SystemintroEntity> wrapper = new EntityWrapper<SystemintroEntity>(); // 创建一个实体包装器对象，用于构建查询条件 Wrapper<SystemintroEntity> wrapper = new EntityWrapper<SystemintroEntity>();
if(map.get("remindstart")!=null) { // 如果 map 中存在 "remindstart" 键 if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); // 设置查询条件，查询 columnName 字段大于等于 "remindstart" 键对应的值 wrapper.ge(columnName, map.get("remindstart"));
} }
if(map.get("remindend")!=null) { // 如果 map 中存在 "remindend" 键 if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend")); // 设置查询条件，查询 columnName 字段小于等于 "remindend" 键对应的值 wrapper.le(columnName, map.get("remindend"));
} }
int count = systemintroService.selectCount(wrapper); // 调用服务层的方法，根据查询条件查询符合条件的记录数，并赋值给 count int count = systemintroService.selectCount(wrapper);
return R.ok().put("count", count); return R.ok().put("count", count);
// 返回一个包含查询结果的响应对象，其中包含键 "count" 和对应的 count 值
} }
}
}

133
src/main/java/com/controller/UsersController.java
Unescape View File

@ -35,151 +35,140 @@ import com.utils.ValidatorUtils;
/** /**
* 登录相关 * 登录相关
*/ */
@RequestMapping("users") // 定义请求路径的基础 URL 为 "users" @RequestMapping("users")
@RestController // 标明该类是一个控制器，返回的对象直接作为 JSON 响应 @RestController
public class UsersController { public class UsersController{
@Autowired // 自动注入 UsersService 依赖 @Autowired
private UsersService userService; private UsersService userService;
@Autowired // 自动注入 TokenService 依赖 @Autowired
private TokenService tokenService; private TokenService tokenService;
/** /**
* 登录 * 登录
*/ */
@IgnoreAuth // 忽略认证，允许未登录用户访问 @IgnoreAuth
@PostMapping(value = "/login") // 处理 POST 请求，路径为 "users/login" @PostMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) { public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username)); UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
// 检查用户是否存在且密码是否匹配 if(user==null || !user.getPassword().equals(password)) {
if(user == null || !user.getPassword().equals(password)) { return R.error("账号或密码不正确");
return R.error("账号或密码不正确"); // 返回错误信息
} }
// 生成用户的 token String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
String token = tokenService.generateToken(user.getId(), username, "users", user.getRole()); return R.ok().put("token", token);
return R.ok().put("token", token); // 返回成功信息和 token
} }
/** /**
* 注册 * 注册
*/ */
@IgnoreAuth @IgnoreAuth
// 忽略认证，允许未登录用户访问 @PostMapping(value = "/register")
@PostMapping(value = "/register") // 处理 POST 请求，路径为 "users/register" public R register(@RequestBody UsersEntity user){
public R register(@RequestBody UsersEntity user) { // ValidatorUtils.validateEntity(user);
// 校验用户是否已存在 if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) { return R.error("用户已存在");
return R.error("用户已存在"); // 返回用户已存在的错误信息
} }
userService.insert(user); // 插入新用户 userService.insert(user);
return R.ok(); // 返回成功信息 return R.ok();
} }
/** /**
* 退出 * 退出
*/ */
@GetMapping(value = "logout") @GetMapping(value = "logout")
// 处理 GET 请求，路径为 "users/logout"
public R logout(HttpServletRequest request) { public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使 session 失效，用户登出 request.getSession().invalidate();
return R.ok("退出成功"); // 返回成功信息 return R.ok("退出成功");
} }
/** /**
* 密码重置 * 密码重置
*/ */
@IgnoreAuth // 忽略认证，允许未登录用户访问 @IgnoreAuth
@RequestMapping(value = "/resetPass") // 处理请求，路径为 "users/resetPass" @RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request){ public R resetPass(String username, HttpServletRequest request){
// 根据用户名查询用户
UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username)); UsersEntity user = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
if(user == null) { if(user==null) {
return R.error("账号不存在"); // 返回账号不存在的错误信息 return R.error("账号不存在");
} }
user.setPassword("123456"); user.setPassword("123456");
// 将用户密码重置为 "123456" userService.update(user,null);
userService.update(user, null);
// 更新用户信息
return R.ok("密码已重置为：123456"); return R.ok("密码已重置为：123456");
// 返回成功信息
} }
/** /**
* 列表 * 列表
*/ */
@RequestMapping("/page") // 处理请求，路径为 "users/page" @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, UsersEntity user) { public R page(@RequestParam Map<String, Object> params,UsersEntity user){
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>(); // 创建查询条件 EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
// 调用服务层方法查询分页数据
PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params)); PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
return R.ok().put("data", page); // 返回查询结果 return R.ok().put("data", page);
} }
/** /**
* 列表 * 列表
*/ */
@RequestMapping("/list") // 处理请求，路径为 "users/list" @RequestMapping("/list")
public R list(UsersEntity user) { public R list( UsersEntity user){
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>(); // 创建查询条件 EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
ew.allEq(MPUtil.allEQMapPre(user, "user")); // 添加所有相等条件 ew.allEq(MPUtil.allEQMapPre( user, "user"));
return R.ok().put("data", userService.selectListView(ew)); return R.ok().put("data", userService.selectListView(ew));
// 返回查询结果
} }
/** /**
* 信息 * 信息
*/ */
@RequestMapping("/info/{id}") // 处理请求，路径为 "users/info/{id}" @RequestMapping("/info/{id}")
public R info(@PathVariable("id") String id) { public R info(@PathVariable("id") String id){
UsersEntity user = userService.selectById(id); // 根据 ID 查找用户 UsersEntity user = userService.selectById(id);
return R.ok().put("data", user); // 返回用户信息 return R.ok().put("data", user);
} }
/** /**
* 获取用户的 session 用户信息 * 获取用户的session用户信息
*/ */
@RequestMapping("/session") // 处理请求，路径为 "users/session" @RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) { public R getCurrUser(HttpServletRequest request){
Long id = (Long) request.getSession().getAttribute("userId"); // 从 session 中获取用户 ID Long id = (Long)request.getSession().getAttribute("userId");
UsersEntity user = userService.selectById(id); // 根据 ID 查找用户 UsersEntity user = userService.selectById(id);
return R.ok().put("data", user); // 返回用户信息 return R.ok().put("data", user);
} }
/** /**
* 保存 * 保存
*/ */
@PostMapping("/save") // 处理 POST 请求，路径为 "users/save" @PostMapping("/save")
public R save(@RequestBody UsersEntity user) { public R save(@RequestBody UsersEntity user){
// 校验用户是否已存在 // ValidatorUtils.validateEntity(user);
if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) != null) { if(userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
return R.error("用户已存在"); // 返回用户已存在的错误信息 return R.error("用户已存在");
} }
userService.insert(user); // 插入新用户 userService.insert(user);
return R.ok(); // 返回成功信息 return R.ok();
} }
/** /**
* 修改 * 修改
*/ */
@RequestMapping("/update") // 处理请求，路径为 "users/update" @RequestMapping("/update")
public R update(@RequestBody UsersEntity user) { public R update(@RequestBody UsersEntity user){
// 校验用户是否已存在 // ValidatorUtils.validateEntity(user);
UsersEntity u = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())); UsersEntity u = userService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()));
if(u != null && u.getId() != user.getId() && u.getUsername().equals(user.getUsername())) { if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {
return R.error("用户名已存在。"); // 返回用户名已存在的错误信息 return R.error("用户名已存在。");
} }
userService.updateById(user); // 更新用户信息 userService.updateById(user);//全部更新
return R.ok(); // 返回成功信息 return R.ok();
} }
/** /**
* 删除 * 删除
*/ */
@RequestMapping("/delete") // 处理请求，路径为 "users/delete" @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) { public R delete(@RequestBody Long[] ids){
userService.deleteBatchIds(Arrays.asList(ids)); // 批量删除用户 userService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); // 返回成功信息 return R.ok();
} }
} }

309
src/main/java/com/controller/WenjuandiaochaController.java
Unescape View File

@ -52,68 +52,187 @@ import com.entity.StoreupEntity;
@RequestMapping("/wenjuandiaocha") @RequestMapping("/wenjuandiaocha")
public class WenjuandiaochaController { public class WenjuandiaochaController {
@Autowired @Autowired
private WenjuandiaochaService wenjuandiaochaService; // 注入问卷调查服务 private WenjuandiaochaService wenjuandiaochaService;
@Autowired @Autowired
private StoreupService storeupService; // 注入收藏服务 private StoreupService storeupService;
/**
* 后端列表
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha,
HttpServletRequest request){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
* 列表
*/
@RequestMapping("/lists")
public R list( WenjuandiaochaEntity wenjuandiaocha){
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha"));
return R.ok().put("data", wenjuandiaochaService.selectListView(ew));
}
/**
* 查询
*/
@RequestMapping("/query")
public R query(WenjuandiaochaEntity wenjuandiaocha){
EntityWrapper< WenjuandiaochaEntity> ew = new EntityWrapper< WenjuandiaochaEntity>();
ew.allEq(MPUtil.allEQMapPre( wenjuandiaocha, "wenjuandiaocha"));
WenjuandiaochaView wenjuandiaochaView = wenjuandiaochaService.selectView(ew);
return R.ok("查询问卷调查成功").put("data", wenjuandiaochaView);
}
/**
* 后端详情
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
* 前端详情
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){
WenjuandiaochaEntity wenjuandiaocha = wenjuandiaochaService.selectById(id);
wenjuandiaocha.setClicktime(new Date());
wenjuandiaochaService.updateById(wenjuandiaocha);
return R.ok().put("data", wenjuandiaocha);
}
/**
* 后端保存
*/
@RequestMapping("/save")
public R save(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
wenjuandiaocha.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.insert(wenjuandiaocha);
return R.ok();
}
/**
* 修改
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
//ValidatorUtils.validateEntity(wenjuandiaocha);
wenjuandiaochaService.updateById(wenjuandiaocha);//全部更新
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){
wenjuandiaochaService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/** /**
* 提醒接口 * 提醒接口
*/ */
@RequestMapping("/remind/{columnName}/{type}") @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) { @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
// 将列名和类型添加到 map 中
map.put("column", columnName); map.put("column", columnName);
map.put("type", type); map.put("type", type);
// 如果类型为 "2"，处理日期范围 if(type.equals("2")) {
if (type.equals("2")) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // 定义日期格式 Calendar c = Calendar.getInstance();
Calendar c = Calendar.getInstance(); // 获取当前日期时间
Date remindStartDate = null; Date remindStartDate = null;
Date remindEndDate = null; Date remindEndDate = null;
if(map.get("remindstart")!=null) {
// 处理 remindstart 参数 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
if (map.get("remindstart") != null) { c.setTime(new Date());
Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 将 remindstart 转换为整数 c.add(Calendar.DAY_OF_MONTH,remindStart);
c.setTime(new Date()); // 设置当前时间 remindStartDate = c.getTime();
c.add(Calendar.DAY_OF_MONTH, remindStart); // 添加 remindStart 天 map.put("remindstart", sdf.format(remindStartDate));
remindStartDate = c.getTime(); // 获取新的开始日期
map.put("remindstart", sdf.format(remindStartDate)); // 格式化并添加到 map 中
} }
if(map.get("remindend")!=null) {
// 处理 remindend 参数 Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
if (map.get("remindend") != null) { c.setTime(new Date());
Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 将 remindend 转换为整数 c.add(Calendar.DAY_OF_MONTH,remindEnd);
c.setTime(new Date()); // 设置当前时间 remindEndDate = c.getTime();
c.add(Calendar.DAY_OF_MONTH, remindEnd); // 添加 remindEnd 天 map.put("remindend", sdf.format(remindEndDate));
remindEndDate = c.getTime(); // 获取新的结束日期
map.put("remindend", sdf.format(remindEndDate)); // 格式化并添加到 map 中
} }
} }
// 创建 EntityWrapper 对象，用于构建查询条件
Wrapper<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>(); Wrapper<WenjuandiaochaEntity> wrapper = new EntityWrapper<WenjuandiaochaEntity>();
if (map.get("remindstart") != null) { if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart")); // 大于等于 remindstart wrapper.ge(columnName, map.get("remindstart"));
} }
if (map.get("remindend") != null) { if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend")); // 小于等于 remindend wrapper.le(columnName, map.get("remindend"));
} }
// 查询符合条件的记录数
int count = wenjuandiaochaService.selectCount(wrapper); int count = wenjuandiaochaService.selectCount(wrapper);
return R.ok().put("count", count); // 返回记录数 return R.ok().put("count", count);
} }
/** /**
* 前端智能排序 * 前端智能排序
*/ */
@IgnoreAuth // 忽略认证 @IgnoreAuth
@RequestMapping("/autoSort") @RequestMapping("/autoSort")
public R autoSort(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request, String pre) { public R autoSort(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request,String pre){
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
Map<String, Object> newMap = new HashMap<String, Object>(); Map<String, Object> newMap = new HashMap<String, Object>();
Map<String, Object> param = new HashMap<String, Object>(); Map<String, Object> param = new HashMap<String, Object>();
@ -122,8 +241,6 @@ public class WenjuandiaochaController {
Map.Entry<String, Object> entry = it.next(); Map.Entry<String, Object> entry = it.next();
String key = entry.getKey(); String key = entry.getKey();
String newKey = entry.getKey(); String newKey = entry.getKey();
// 处理 pre 参数
if (pre.endsWith(".")) { if (pre.endsWith(".")) {
newMap.put(pre + newKey, entry.getValue()); newMap.put(pre + newKey, entry.getValue());
} else if (StringUtils.isEmpty(pre)) { } else if (StringUtils.isEmpty(pre)) {
@ -132,160 +249,134 @@ public class WenjuandiaochaController {
newMap.put(pre + "." + newKey, entry.getValue()); newMap.put(pre + "." + newKey, entry.getValue());
} }
} }
// 设置排序条件
params.put("sort", "clicktime"); params.put("sort", "clicktime");
params.put("order", "desc"); params.put("order", "desc");
// 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params)); PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", page); // 返回分页数据 return R.ok().put("data", page);
} }
/** /**
* 协同算法（按收藏推荐） * 协同算法（按收藏推荐）
*/ */
@RequestMapping("/autoSort2") @RequestMapping("/autoSort2")
public R autoSort2(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) { public R autoSort2(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
// 获取用户 ID
String userId = request.getSession().getAttribute("userId").toString(); String userId = request.getSession().getAttribute("userId").toString();
String inteltypeColumn = "leixing"; // 定义智能类型列名 String inteltypeColumn = "leixing";
List<StoreupEntity> storeups = storeupService.selectList(new EntityWrapper<StoreupEntity>().eq("type", 1).eq("userid", userId).eq("tablename", "wenjuandiaocha").orderBy("addtime", false)); List<StoreupEntity> storeups = storeupService.selectList(new EntityWrapper<StoreupEntity>().eq("type", 1).eq("userid", userId).eq("tablename", "wenjuandiaocha").orderBy("addtime", false));
List<String> inteltypes = new ArrayList<String>(); List<String> inteltypes = new ArrayList<String>();
Integer limit = params.get("limit") == null ? 10 : Integer.parseInt(params.get("limit").toString()); // 设置限制数量，默认为 10 Integer limit = params.get("limit")==null?10:Integer.parseInt(params.get("limit").toString());
List<WenjuandiaochaEntity> wenjuandiaochaList = new ArrayList<WenjuandiaochaEntity>(); List<WenjuandiaochaEntity> wenjuandiaochaList = new ArrayList<WenjuandiaochaEntity>();
//去重
// 去重 if(storeups!=null && storeups.size()>0) {
if (storeups != null && storeups.size() > 0) { for(StoreupEntity s : storeups) {
for (StoreupEntity s : storeups) {
wenjuandiaochaList.addAll(wenjuandiaochaService.selectList(new EntityWrapper<WenjuandiaochaEntity>().eq(inteltypeColumn, s.getInteltype()))); wenjuandiaochaList.addAll(wenjuandiaochaService.selectList(new EntityWrapper<WenjuandiaochaEntity>().eq(inteltypeColumn, s.getInteltype())));
} }
} }
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
params.put("sort", "id"); params.put("sort", "id");
params.put("order", "desc"); params.put("order", "desc");
// 查询分页数据
PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params)); PageUtils page = wenjuandiaochaService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>) page.getList(); List<WenjuandiaochaEntity> pageList = (List<WenjuandiaochaEntity>)page.getList();
if(wenjuandiaochaList.size()<limit) {
// 如果结果数量小于限制数量，则从分页数据中添加 int toAddNum = (limit-wenjuandiaochaList.size())<=pageList.size()?(limit-wenjuandiaochaList.size()):pageList.size();
if (wenjuandiaochaList.size() < limit) { for(WenjuandiaochaEntity o1 : pageList) {
int toAddNum = (limit - wenjuandiaochaList.size()) <= pageList.size() ? (limit - wenjuandiaochaList.size()) : pageList.size();
for (WenjuandiaochaEntity o1 : pageList) {
boolean addFlag = true; boolean addFlag = true;
for (WenjuandiaochaEntity o2 : wenjuandiaochaList) { for(WenjuandiaochaEntity o2 : wenjuandiaochaList) {
if (o1.getId().intValue() == o2.getId().intValue()) { if(o1.getId().intValue()==o2.getId().intValue()) {
addFlag = false; addFlag = false;
break; break;
} }
} }
if (addFlag) { if(addFlag) {
wenjuandiaochaList.add(o1); wenjuandiaochaList.add(o1);
if (--toAddNum == 0) break; if(--toAddNum==0) break;
} }
} }
} else if (wenjuandiaochaList.size() > limit) { } else if(wenjuandiaochaList.size()>limit) {
wenjuandiaochaList = wenjuandiaochaList.subList(0, limit); // 如果结果数量大于限制数量，则截取前 limit 个 wenjuandiaochaList = wenjuandiaochaList.subList(0, limit);
} }
page.setList(wenjuandiaochaList);
page.setList(wenjuandiaochaList); // 设置新的列表 return R.ok().put("data", page);
return R.ok().put("data", page); // 返回分页数据
} }
/** /**
* （按值统计） * （按值统计）
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}") @RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) { public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectValue(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectValue(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) { for(Map<String, Object> m : result) {
for (String k : m.keySet()) { for(String k : m.keySet()) {
if (m.get(k) instanceof Date) { if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k))); m.put(k, sdf.format((Date)m.get(k)));
} }
} }
} }
return R.ok().put("data", result); // 返回统计结果 return R.ok().put("data", result);
} }
/** /**
* （按值统计）时间统计类型 * （按值统计）时间统计类型
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) { public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName); params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType); params.put("timeStatType", timeStatType);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询时间统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectTimeStatValue(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectTimeStatValue(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) { for(Map<String, Object> m : result) {
for (String k : m.keySet()) { for(String k : m.keySet()) {
if (m.get(k) instanceof Date) { if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k))); m.put(k, sdf.format((Date)m.get(k)));
} }
} }
} }
return R.ok().put("data", result); // 返回时间统计结果 return R.ok().put("data", result);
} }
/** /**
* 分组统计 * 分组统计
*/ */
@RequestMapping("/group/{columnName}") @RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) { public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName); params.put("column", columnName);
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询分组统计结果
List<Map<String, Object>> result = wenjuandiaochaService.selectGroup(params, ew); List<Map<String, Object>> result = wenjuandiaochaService.selectGroup(params, ew);
// 处理日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) { for(Map<String, Object> m : result) {
for (String k : m.keySet()) { for(String k : m.keySet()) {
if (m.get(k) instanceof Date) { if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k))); m.put(k, sdf.format((Date)m.get(k)));
} }
} }
} }
return R.ok().put("data", result); // 返回分组统计结果 return R.ok().put("data", result);
} }
/** /**
* 总数量 * 总数量
*/ */
@RequestMapping("/count") @RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params, WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request) { public R count(@RequestParam Map<String, Object> params,WenjuandiaochaEntity wenjuandiaocha, HttpServletRequest request){
// 创建 EntityWrapper 对象，用于构建查询条件
EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>(); EntityWrapper<WenjuandiaochaEntity> ew = new EntityWrapper<WenjuandiaochaEntity>();
// 查询符合条件的记录数
int count = wenjuandiaochaService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params)); int count = wenjuandiaochaService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandiaocha), params), params));
return R.ok().put("data", count); // 返回记录数 return R.ok().put("data", count);
} }
} }

106
src/main/java/com/controller/YonghuController.java
Unescape View File

@ -39,7 +39,6 @@ import com.utils.MD5Util;
import com.utils.MPUtil; import com.utils.MPUtil;
import com.utils.CommonUtil; import com.utils.CommonUtil;
/** /**
* 用户 * 用户
* 后端接口 * 后端接口
@ -47,56 +46,56 @@ import com.utils.CommonUtil;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@RestController // 标记这是一个REST控制器 @RestController
@RequestMapping("/yonghu") // 设置请求路径的前缀为/yonghu @RequestMapping("/yonghu")
public class YonghuController { public class YonghuController {
@Autowired @Autowired
private YonghuService yonghuService; // 自动注入YonghuService服务 private YonghuService yonghuService;
@Autowired @Autowired
private TokenService tokenService; // 自动注入TokenService服务 private TokenService tokenService;
/** /**
* 登录 * 登录
*/ */
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping(value = "/login") // 设置请求路径为/login @RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) { public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username)); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
// 验证用户名和密码
if(u==null || !u.getMima().equals(password)) { if(u==null || !u.getMima().equals(password)) {
return R.error("账号或密码不正确"); return R.error("账号或密码不正确");
} }
// 生成并返回token
String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" ); String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" );
return R.ok().put("token", token); return R.ok().put("token", token);
} }
/** /**
* 注册 * 注册
*/ */
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping("/register") // 设置请求路径为/register @RequestMapping("/register")
public R register(@RequestBody YonghuEntity yonghu){ public R register(@RequestBody YonghuEntity yonghu){
// 检查用户是否已存在 //ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) { if(u!=null) {
return R.error("注册用户已存在"); return R.error("注册用户已存在");
} }
// 生成用户ID并插入用户数据
Long uId = new Date().getTime(); Long uId = new Date().getTime();
yonghu.setId(uId); yonghu.setId(uId);
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
} }
/** /**
* 退出 * 退出
*/ */
@RequestMapping("/logout") // 设置请求路径为/logout @RequestMapping("/logout")
public R logout(HttpServletRequest request) { public R logout(HttpServletRequest request) {
// 使当前会话失效
request.getSession().invalidate(); request.getSession().invalidate();
return R.ok("退出成功"); return R.ok("退出成功");
} }
@ -104,11 +103,9 @@ public class YonghuController {
/** /**
* 获取用户的session用户信息 * 获取用户的session用户信息
*/ */
@RequestMapping("/session") // 设置请求路径为/session @RequestMapping("/session")
public R getCurrUser(HttpServletRequest request){ public R getCurrUser(HttpServletRequest request){
// 从session中获取用户ID
Long id = (Long)request.getSession().getAttribute("userId"); Long id = (Long)request.getSession().getAttribute("userId");
// 根据ID查询用户信息
YonghuEntity u = yonghuService.selectById(id); YonghuEntity u = yonghuService.selectById(id);
return R.ok().put("data", u); return R.ok().put("data", u);
} }
@ -116,28 +113,28 @@ public class YonghuController {
/** /**
* 密码重置 * 密码重置
*/ */
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping(value = "/resetPass") // 设置请求路径为/resetPass @RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request){ public R resetPass(String username, HttpServletRequest request){
// 根据用户名查询用户
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username)); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if(u==null) { if(u==null) {
return R.error("账号不存在"); return R.error("账号不存在");
} }
// 重置密码为123456
u.setMima("123456"); u.setMima("123456");
yonghuService.updateById(u); yonghuService.updateById(u);
return R.ok("密码已重置为：123456"); return R.ok("密码已重置为：123456");
} }
/** /**
* 后端列表 * 后端列表
*/ */
@RequestMapping("/page") // 设置请求路径为/page @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params,YonghuEntity yonghu, public R page(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request){ HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
// 分页查询用户列表
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page); request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
@ -146,12 +143,12 @@ public class YonghuController {
/** /**
* 前端列表 * 前端列表
*/ */
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping("/list") // 设置请求路径为/list @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params,YonghuEntity yonghu, public R list(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request){ HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
// 分页查询用户列表
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page); request.setAttribute("data", page);
return R.ok().put("data", page); return R.ok().put("data", page);
@ -160,7 +157,7 @@ public class YonghuController {
/** /**
* 列表 * 列表
*/ */
@RequestMapping("/lists") // 设置请求路径为/lists @RequestMapping("/lists")
public R list( YonghuEntity yonghu){ public R list( YonghuEntity yonghu){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
@ -170,7 +167,7 @@ public class YonghuController {
/** /**
* 查询 * 查询
*/ */
@RequestMapping("/query") // 设置请求路径为/query @RequestMapping("/query")
public R query(YonghuEntity yonghu){ public R query(YonghuEntity yonghu){
EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>(); EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu")); ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
@ -181,7 +178,7 @@ public class YonghuController {
/** /**
* 后端详情 * 后端详情
*/ */
@RequestMapping("/info/{id}") // 设置请求路径为/info/{id} @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id){ public R info(@PathVariable("id") Long id){
YonghuEntity yonghu = yonghuService.selectById(id); YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu); return R.ok().put("data", yonghu);
@ -190,23 +187,28 @@ public class YonghuController {
/** /**
* 前端详情 * 前端详情
*/ */
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping("/detail/{id}") // 设置请求路径为/detail/{id} @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id){ public R detail(@PathVariable("id") Long id){
YonghuEntity yonghu = yonghuService.selectById(id); YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu); return R.ok().put("data", yonghu);
} }
/** /**
* 后端保存 * 后端保存
*/ */
@RequestMapping("/save") // 设置请求路径为/save @RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) { if(u!=null) {
return R.error("用户已存在"); return R.error("用户已存在");
} }
yonghu.setId(new Date().getTime()); yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
@ -215,32 +217,38 @@ public class YonghuController {
/** /**
* 前端保存 * 前端保存
*/ */
@RequestMapping("/add") // 设置请求路径为/add @RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue()); yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao())); YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) { if(u!=null) {
return R.error("用户已存在"); return R.error("用户已存在");
} }
yonghu.setId(new Date().getTime()); yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu); yonghuService.insert(yonghu);
return R.ok(); return R.ok();
} }
/** /**
* 修改 * 修改
*/ */
@RequestMapping("/update") // 设置请求路径为/update @RequestMapping("/update")
@Transactional // 开启事务 @Transactional
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){ public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
//ValidatorUtils.validateEntity(yonghu);
yonghuService.updateById(yonghu);//全部更新 yonghuService.updateById(yonghu);//全部更新
return R.ok(); return R.ok();
} }
/** /**
* 删除 * 删除
*/ */
@RequestMapping("/delete") // 设置请求路径为/delete @RequestMapping("/delete")
public R delete(@RequestBody Long[] ids){ public R delete(@RequestBody Long[] ids){
yonghuService.deleteBatchIds(Arrays.asList(ids)); yonghuService.deleteBatchIds(Arrays.asList(ids));
return R.ok(); return R.ok();
@ -249,7 +257,7 @@ public class YonghuController {
/** /**
* 提醒接口 * 提醒接口
*/ */
@RequestMapping("/remind/{columnName}/{type}") // 设置请求路径为/remind/{columnName}/{type} @RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) { @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("column", columnName); map.put("column", columnName);
@ -284,14 +292,21 @@ public class YonghuController {
wrapper.le(columnName, map.get("remindend")); wrapper.le(columnName, map.get("remindend"));
} }
int count = yonghuService.selectCount(wrapper); int count = yonghuService.selectCount(wrapper);
return R.ok().put("count", count); return R.ok().put("count", count);
} }
/** /**
* （按值统计） * （按值统计）
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}") // 设置请求路径为/value/{xColumnName}/{yColumnName} @RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) { public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
@ -312,7 +327,7 @@ public class YonghuController {
/** /**
* （按值统计）时间统计类型 * （按值统计）时间统计类型
*/ */
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") // 设置请求路径为/value/{xColumnName}/{yColumnName}/{timeStatType} @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) { public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName); params.put("xColumn", xColumnName);
@ -334,7 +349,7 @@ public class YonghuController {
/** /**
* 分组统计 * 分组统计
*/ */
@RequestMapping("/group/{columnName}") // 设置请求路径为/group/{columnName} @RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) { public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>(); Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName); params.put("column", columnName);
@ -351,13 +366,18 @@ public class YonghuController {
return R.ok().put("data", result); return R.ok().put("data", result);
} }
/** /**
* 总数量 * 总数量
*/ */
@RequestMapping("/count") // 设置请求路径为/count @RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params,YonghuEntity yonghu, HttpServletRequest request){ public R count(@RequestParam Map<String, Object> params,YonghuEntity yonghu, HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>(); EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params)); int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
return R.ok().put("data", count); return R.ok().put("data", count);
} }
} }

11
src/main/java/com/dao/ConfigDao.java
Unescape View File

@ -1,15 +1,12 @@
package com.dao; package com.dao;
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口 import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.entity.ConfigEntity; // 导入配置实体类 import com.entity.ConfigEntity;
/** /**
* 配置 DAO 接口 * 配置
* 该接口用于数据访问层，对ConfigEntity实体的数据库操作
*/ */
public interface ConfigDao extends BaseMapper<ConfigEntity> { public interface ConfigDao extends BaseMapper<ConfigEntity> {
// ConfigDao接口继承了BaseMapper接口，意味着它自动获得了CRUD方法
// 可以根据需要在此处添加自定义的方法
}
}

42
src/main/java/com/dao/ForumDao.java
Unescape View File

@ -1,19 +1,19 @@
package com.dao; package com.dao;
import com.entity.ForumEntity; // 导入论坛实体类 import com.entity.ForumEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口 import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.vo.ForumVO; // 导入论坛VO类 import com.entity.vo.ForumVO;
import com.entity.view.ForumView; // 导入论坛视图类 import com.entity.view.ForumView;
/** /**
* 论坛表 DAO 接口 * 论坛表
* 该接口用于数据访问层，对ForumEntity实体的数据库操作
* *
* @author * @author
* @email * @email
@ -21,39 +21,15 @@ import com.entity.view.ForumView; // 导入论坛视图类
*/ */
public interface ForumDao extends BaseMapper<ForumEntity> { public interface ForumDao extends BaseMapper<ForumEntity> {
/**
* 查询论坛列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 论坛VO对象列表
*/
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper); List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询单个论坛，返回VO对象
* @param wrapper 查询条件包装器
* @return 论坛VO对象
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper); ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询论坛列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 论坛视图对象列表
*/
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper); List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper);
/** List<ForumView> selectListView(Pagination page,@Param("ew") Wrapper<ForumEntity> wrapper);
* 分页查询论坛列表，返回视图对象列表
* @param page 分页对象
* @param wrapper 查询条件包装器
* @return 论坛视图对象列表
*/
List<ForumView> selectListView(Pagination page, @Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询单个论坛，返回视图对象
* @param wrapper 查询条件包装器
* @return 论坛视图对象
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper); ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
} }

36
src/main/java/com/dao/LeixingDao.java
Unescape View File

@ -8,12 +8,12 @@ import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO; // 导入类型VO类 import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView; import com.entity.view.LeixingView;
/** /**
* 类型 DAO 接口 * 类型
* 该接口用于与数据库交互，操作LeixingEntity实体
* *
* @author * @author
* @email * @email
@ -21,39 +21,15 @@ import com.entity.view.LeixingView;
*/ */
public interface LeixingDao extends BaseMapper<LeixingEntity> { public interface LeixingDao extends BaseMapper<LeixingEntity> {
/**
* 查询类型列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 类型VO对象列表
*/
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper); List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回VO对象
* @param wrapper 查询条件包装器
* @return 单个类型VO对象
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper); LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 类型视图对象列表
*/
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper); List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/** List<LeixingView> selectListView(Pagination page,@Param("ew") Wrapper<LeixingEntity> wrapper);
* 分页查询类型列表，返回视图对象列表
* @param page 分页对象
* @param wrapper 查询条件包装器
* @return 分页后的类型视图对象列表
*/
List<LeixingView> selectListView(Pagination page, @Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回视图对象
* @param wrapper 查询条件包装器
* @return 单个类型视图对象
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper); LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
} }

12
src/main/java/com/dao/NewsDao.java
Unescape View File

@ -11,9 +11,9 @@ import org.apache.ibatis.annotations.Param;
import com.entity.vo.NewsVO; import com.entity.vo.NewsVO;
import com.entity.view.NewsView; import com.entity.view.NewsView;
/** /**
* 公告信息 * 公告信息
* 该接口用于定义与公告信息相关的数据访问操作
* *
* @author * @author
* @email * @email
@ -21,19 +21,15 @@ import com.entity.view.NewsView;
*/ */
public interface NewsDao extends BaseMapper<NewsEntity> { public interface NewsDao extends BaseMapper<NewsEntity> {
// 根据查询条件（Wrapper）选择公告的信息列表，并返回一个 NewsVO 对象的列表
List<NewsVO> selectListVO(@Param("ew") Wrapper<NewsEntity> wrapper); List<NewsVO> selectListVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件（Wrapper）选择单个公告的信息，并返回一个 NewsVO 对象
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper); NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件（Wrapper）选择公告的信息视图列表，并返回一个 NewsView 对象的列表
List<NewsView> selectListView(@Param("ew") Wrapper<NewsEntity> wrapper); List<NewsView> selectListView(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件（Wrapper）与分页信息选择公告的信息视图列表，并返回一个 NewsView 对象的列表 List<NewsView> selectListView(Pagination page,@Param("ew") Wrapper<NewsEntity> wrapper);
List<NewsView> selectListView(Pagination page, @Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件（Wrapper）选择单个公告的信息视图，并返回一个 NewsView 对象
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper); NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
} }

37
src/main/java/com/dao/StoreupDao.java
Unescape View File

@ -1,40 +1,35 @@
package com.dao; // 声明该接口所在的包为com.dao package com.dao;
import com.entity.StoreupEntity; // 导入StoreupEntity类，代表收藏表的实体类 import com.entity.StoreupEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus框架的BaseMapper接口，提供基础的CRUD操作 import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List; // 导入List接口，用于返回列表结果 import java.util.List;
import java.util.Map; // 导入Map接口（虽然在此代码中未使用） import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入Wrapper接口，用于构造查询条件 import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 导入Pagination类，用于支持分页查询 import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.StoreupVO;
import com.entity.view.StoreupView;
import org.apache.ibatis.annotations.Param; // 导入Param注解，用于在Mapper方法中定义参数
import com.entity.vo.StoreupVO; // 导入StoreupVO类，代表用于展示的视图对象
import com.entity.view.StoreupView; // 导入StoreupView类，代表用于视图展示的另一个对象
/** /**
* 收藏表 * 收藏表
* *
* @author // 作者信息（未填写） * @author
* @email // 邮箱信息（未填写） * @email
* @date 2023-02-21 09:46:06 // 该接口的创建日期 * @date 2023-02-21 09:46:06
*/ */
public interface StoreupDao extends BaseMapper<StoreupEntity> { // 定义StoreupDao接口，继承BaseMapper以获得基本的数据库操作 public interface StoreupDao extends BaseMapper<StoreupEntity> {
// 根据条件查询返回StoreupVO类型的列表
List<StoreupVO> selectListVO(@Param("ew") Wrapper<StoreupEntity> wrapper); List<StoreupVO> selectListVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
// 根据条件查询返回单个StoreupVO对象
StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper); StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
// 根据条件查询返回StoreupView类型的列表
List<StoreupView> selectListView(@Param("ew") Wrapper<StoreupEntity> wrapper); List<StoreupView> selectListView(@Param("ew") Wrapper<StoreupEntity> wrapper);
// 根据条件及分页信息查询返回StoreupView类型的列表 List<StoreupView> selectListView(Pagination page,@Param("ew") Wrapper<StoreupEntity> wrapper);
List<StoreupView> selectListView(Pagination page, @Param("ew") Wrapper<StoreupEntity> wrapper);
// 根据条件查询返回单个StoreupView对象
StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper); StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper);
} }

9
src/main/java/com/dao/SystemintroDao.java
Unescape View File

@ -11,9 +11,9 @@ import org.apache.ibatis.annotations.Param;
import com.entity.vo.SystemintroVO; import com.entity.vo.SystemintroVO;
import com.entity.view.SystemintroView; import com.entity.view.SystemintroView;
/** /**
* 关于我们 * 关于我们
* 该接口用于定义与"关于我们"页面相关的数据访问操作
* *
* @author * @author
* @email * @email
@ -21,19 +21,14 @@ import com.entity.view.SystemintroView;
*/ */
public interface SystemintroDao extends BaseMapper<SystemintroEntity> { public interface SystemintroDao extends BaseMapper<SystemintroEntity> {
// 根据查询条件（Wrapper）选择系统介绍的信息列表，并返回一个 SystemintroVO 对象的列表
List<SystemintroVO> selectListVO(@Param("ew") Wrapper<SystemintroEntity> wrapper); List<SystemintroVO> selectListVO(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件（Wrapper）选择单个系统介绍的信息，并返回一个 SystemintroVO 对象
SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper); SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件（Wrapper）选择系统介绍信息视图的列表，并返回一个 SystemintroView 对象的列表
List<SystemintroView> selectListView(@Param("ew") Wrapper<SystemintroEntity> wrapper); List<SystemintroView> selectListView(@Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件（Wrapper）和分页信息选择系统介绍信息视图的列表，并返回一个 SystemintroView 对象的列表 List<SystemintroView> selectListView(Pagination page,@Param("ew") Wrapper<SystemintroEntity> wrapper);
List<SystemintroView> selectListView(Pagination page, @Param("ew") Wrapper<SystemintroEntity> wrapper);
// 根据查询条件（Wrapper）选择单个平台介绍的信息视图，并返回一个 SystemintroView 对象
SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper); SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper);

9
src/main/java/com/dao/UsersDao.java
Unescape View File

@ -9,19 +9,14 @@ import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination; import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.entity.UsersEntity; import com.entity.UsersEntity;
/** /**
* 用户 * 用户
* 该接口用于定义与用户相关的数据访问操作
*/ */
public interface UsersDao extends BaseMapper<UsersEntity> { public interface UsersDao extends BaseMapper<UsersEntity> {
// 根据查询条件（Wrapper）选择用户列表，并返回一个 UsersEntity 对象的列表
List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper); List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
// 根据查询条件（Wrapper）和分页信息选择用户列表，并返回一个 UsersEntity 对象的列表 List<UsersEntity> selectListView(Pagination page,@Param("ew") Wrapper<UsersEntity> wrapper);
List<UsersEntity> selectListView(Pagination page, @Param("ew") Wrapper<UsersEntity> wrapper);
} }

72
src/main/java/com/dao/WenjuandiaochaDao.java
Unescape View File

@ -13,73 +13,31 @@ import com.entity.view.WenjuandiaochaView;
/** /**
* 问卷调查数据访问对象接口 * 问卷调查
* 该接口继承自BaseMapper，提供了基本的CRUD操作方法 *
* @author 未填写具体作者 * @author
* @email 未填写具体邮箱 * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface WenjuandiaochaDao extends BaseMapper<WenjuandiaochaEntity> { public interface WenjuandiaochaDao extends BaseMapper<WenjuandiaochaEntity> {
/** List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据条件查询问卷调查列表，并将结果转换为WenjuandiaochaVO对象列表
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查VO对象列表
*/
List<WenjuandiaochaVO> selectListVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据条件查询单个问卷调查记录，并将其转换为WenjuandiaochaVO对象
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查VO对象
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据条件查询问卷调查列表，并将结果转换为WenjuandiaochaView对象列表
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查View对象列表
*/
List<WenjuandiaochaView> selectListView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** List<WenjuandiaochaView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据条件和分页参数查询问卷调查列表，并将结果转换为WenjuandiaochaView对象列表
* @param page 分页参数对象
* @param ew 查询条件封装对象
* @return 分页后的符合条件的问卷调查View对象列表
*/
List<WenjuandiaochaView> selectListView(Pagination page, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据条件查询单个问卷调查记录，并将其转换为WenjuandiaochaView对象
* @param ew 查询条件封装对象
* @return 符合条件的问卷调查View对象
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/**
* 根据自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数
* @param ew 查询条件封装对象
* @return 符合条件的数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据时间统计自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数，可能包含时间范围等信息
* @param ew 查询条件封装对象
* @return 符合条件的时间统计数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
/** List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
* 根据分组查询自定义参数和条件查询数据库，并返回Map对象列表
* @param params 自定义查询参数，可能包含分组依据等信息
* @param ew 查询条件封装对象
* @return 符合条件的分组数据结果集，返回值为Map对象列表
*/
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<WenjuandiaochaEntity> ew);
} List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
}

14
src/main/java/com/entity/ConfigEntity.java
Unescape View File

@ -9,25 +9,25 @@ import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 类说明 : * 类说明 :
*/ */
@TableName("config")// 指定该类对应的数据库表名为"config" @TableName("config")
public class ConfigEntity implements Serializable{ public class ConfigEntity implements Serializable{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO) // 主键ID，使用自增长方式 @TableId(type = IdType.AUTO)
private Long id; private Long id;
/** /**
* 配置项的名称（键） * key
*/ */
private String name; private String name;
/** /**
* 配置项的值 * value
*/ */
private String value; private String value;
public Long getId() { public Long getId() {
return id; // 返回配置ID return id;
} }
public void setId(Long id) { public void setId(Long id) {
@ -39,7 +39,7 @@ private static final long serialVersionUID = 1L;
} }
public void setName(String name) { public void setName(String name) {
this.name = name;//设置配置名称 this.name = name;
} }
public String getValue() { public String getValue() {
@ -47,7 +47,7 @@ private static final long serialVersionUID = 1L;
} }
public void setValue(String value) { public void setValue(String value) {
this.value = value;// 设置配置值 this.value = value;
} }
} }

20
src/main/java/com/entity/ForumEntity.java
Unescape View File

@ -16,8 +16,6 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField; import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill; import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
@ -39,15 +37,14 @@ public class ForumEntity<T> implements Serializable {
} }
// 接收ForumEntity对象的构造函数
public ForumEntity(T t) { public ForumEntity(T t) {
try { try {
// 复制属性，将传入对象的属性复制到当前对象
BeanUtils.copyProperties(this, t); BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理，打印堆栈信息 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
}
/** /**
* 主键id * 主键id
@ -102,10 +99,10 @@ public class ForumEntity<T> implements Serializable {
private Date addtime; private Date addtime;
public Date getAddtime() { public Date getAddtime() {
return addtime;// 返回添加时间 return addtime;
} }
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime;// 设置添加时间 this.addtime = addtime;
} }
public Long getId() { public Long getId() {
@ -113,12 +110,9 @@ public class ForumEntity<T> implements Serializable {
} }
public void setId(Long id) { public void setId(Long id) {
this.id = id;// 设置帖子ID this.id = id;
} }
/** @TableField(exist = false)
* 存放子帖子的列表
*/
@TableField(exist = false) // 该字段不在数据库表中存在
private List<ForumEntity> childs; private List<ForumEntity> childs;
public List<ForumEntity> getChilds() { public List<ForumEntity> getChilds() {
@ -126,7 +120,7 @@ public class ForumEntity<T> implements Serializable {
} }
public void setChilds(List<ForumEntity> childs) { public void setChilds(List<ForumEntity> childs) {
this.childs = childs;// 设置子帖子 this.childs = childs;
} }
/** /**
* 设置：帖子标题 * 设置：帖子标题

16
src/main/java/com/entity/LeixingEntity.java
Unescape View File

@ -16,8 +16,6 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import org.apache.poi.ss.formula.functions.T;
import com.baomidou.mybatisplus.annotations.TableField; import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill; import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
@ -39,13 +37,11 @@ public class LeixingEntity<T> implements Serializable {
} }
// 接收LeixingEntity对象的构造函数
public LeixingEntity(T t) { public LeixingEntity(T t) {
try { try {
// 复制属性，将传入对象的属性复制到当前对象
BeanUtils.copyProperties(this, t); BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理，打印堆栈信息 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
@ -62,15 +58,15 @@ public class LeixingEntity<T> implements Serializable {
private String leixing; private String leixing;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")// 指定JSON格式化 @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat// 用于Spring格式化 @DateTimeFormat
private Date addtime;// 存放添加时间 private Date addtime;
public Date getAddtime() { public Date getAddtime() {
return addtime; return addtime;
} }
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime;// 设置添加时间 this.addtime = addtime;
} }
public Long getId() { public Long getId() {
@ -78,7 +74,7 @@ public class LeixingEntity<T> implements Serializable {
} }
public void setId(Long id) { public void setId(Long id) {
this.id = id;// 设置类型ID this.id = id;
} }
/** /**
* 设置：类型 * 设置：类型

16
src/main/java/com/entity/StoreupEntity.java
Unescape View File

@ -5,11 +5,14 @@ import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull; import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
@ -29,13 +32,16 @@ import com.baomidou.mybatisplus.enums.IdType;
public class StoreupEntity<T> implements Serializable { public class StoreupEntity<T> implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public StoreupEntity() { public StoreupEntity() {
} }
public StoreupEntity(T t) { public StoreupEntity(T t) {
try { try {
BeanUtils.copyProperties(this, t); BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
@ -48,43 +54,52 @@ public class StoreupEntity<T> implements Serializable {
/** /**
* 用户id * 用户id
*/ */
private Long userid; private Long userid;
/** /**
* 商品id * 商品id
*/ */
private Long refid; private Long refid;
/** /**
* 表名 * 表名
*/ */
private String tablename; private String tablename;
/** /**
* 名称 * 名称
*/ */
private String name; private String name;
/** /**
* 图片 * 图片
*/ */
private String picture; private String picture;
/** /**
* 类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注) * 类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注)
*/ */
private String type; private String type;
/** /**
* 推荐类型 * 推荐类型
*/ */
private String inteltype; private String inteltype;
/** /**
* 备注 * 备注
*/ */
private String remark; private String remark;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat @DateTimeFormat
private Date addtime; private Date addtime;
@ -199,4 +214,5 @@ public class StoreupEntity<T> implements Serializable {
public String getRemark() { public String getRemark() {
return remark; return remark;
} }
} }

59
src/main/java/com/entity/UsersEntity.java
Unescape View File

@ -7,72 +7,71 @@ import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 用户 * 用户
*/ */
@TableName("users") // 指定实体类对应的数据库表为users @TableName("users")
public class UsersEntity implements Serializable { // 定义UsersEntity类，实现Serializable接口 public class UsersEntity implements Serializable {
private static final long serialVersionUID = 1L; // 定义序列化ID private static final long serialVersionUID = 1L;
@TableId(type = IdType.AUTO) // 标识为主键，并设置主键自增 @TableId(type = IdType.AUTO)
private Long id; // 主键id private Long 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() { // 获取用户名 public String getUsername() {
return username; // 返回username return username;
} }
public void setUsername(String username) { // 设置用户名 public void setUsername(String username) {
this.username = username; // 赋值username this.username = username;
} }
public String getPassword() { // 获取密码 public String getPassword() {
return password; // 返回password return password;
} }
public void setPassword(String password) { // 设置密码 public void setPassword(String password) {
this.password = password; // 赋值password this.password = password;
} }
public String getRole() { // 获取用户角色 public String getRole() {
return role; // 返回role return role;
} }
public void setRole(String role) { // 设置用户角色 public void setRole(String role) {
this.role = role; // 赋值role this.role = role;
} }
public Date getAddtime() { // 获取添加时间 public Date getAddtime() {
return addtime; // 返回addtime return addtime;
} }
public void setAddtime(Date addtime) { // 设置添加时间 public void setAddtime(Date addtime) {
this.addtime = addtime; // 赋值addtime this.addtime = addtime;
} }
public Long getId() { // 获取主键id public Long getId() {
return id; // 返回id return id;
} }
public void setId(Long id) { // 设置主键id public void setId(Long id) {
this.id = id; // 赋值id this.id = id;
} }
} }

141
src/main/java/com/entity/WenjuandiaochaEntity.java
Unescape View File

@ -3,6 +3,7 @@ package com.entity;
import com.baomidou.mybatisplus.annotations.TableId; import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull; import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@ -10,39 +11,37 @@ import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
import java.util.Date; import java.util.Date;
import java.util.List;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 问卷调查 * 问卷调查
* 数据库通用操作实体类（普通增删改查） * 数据库通用操作实体类（普通增删改查）
* @author 作者名 * @author
* @email 邮箱地址 * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("wenjuandiaocha") // 指定该实体类对应的数据库表名为“wenjuandiaocha” @TableName("wenjuandiaocha")
@JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知属性，防止反序列化时出现错误 public class WenjuandiaochaEntity<T> implements Serializable {
public class WenjuandiaochaEntity<T> implements Serializable { // 实现Serializable接口以支持序列化 private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号
/**
* 无参构造函数
*/
public WenjuandiaochaEntity() { public WenjuandiaochaEntity() {
} }
/**
* 带泛型参数的构造函数，用于从传入的对象t中复制属性值
* @param t 传入的对象，其属性将被复制到当前实体对象中
*/
public WenjuandiaochaEntity(T t) { public WenjuandiaochaEntity(T t) {
try { try {
BeanUtils.copyProperties(this, t); // 使用BeanUtils工具类复制属性 BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 打印堆栈跟踪信息以便调试 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
@ -50,274 +49,210 @@ public class WenjuandiaochaEntity<T> implements Serializable { // 实现Serializ
/** /**
* 主键id * 主键id
*/ */
@TableId // 指定该字段为主键 @TableId
private Long id; private Long id;
/** /**
* 问卷标题 * 问卷标题
* 使用NotBlank注解确保问卷标题不为空字符串
*/ */
@NotBlank(message = "问卷标题不能为空")
private String wenjuanbiaoti; private String wenjuanbiaoti;
/** /**
* 封面图片 * 封面图片
* 使用NotBlank注解确保封面图片路径不为空字符串
*/ */
@NotBlank(message = "封面图片路径不能为空")
private String fengmiantupian; private String fengmiantupian;
/** /**
* 类型 * 类型
* 使用NotBlank注解确保类型不为空字符串
*/ */
@NotBlank(message = "类型不能为空")
private String leixing; private String leixing;
/** /**
* 问题一 * 问题一
* 使用NotBlank注解确保问题一不为空字符串
*/ */
@NotBlank(message = "问题一不能为空")
private String wentiyi; private String wentiyi;
/** /**
* 问题二 * 问题二
* 使用NotBlank注解确保问题二不为空字符串
*/ */
@NotBlank(message = "问题二不能为空")
private String wentier; private String wentier;
/** /**
* 问题三 * 问题三
* 使用NotBlank注解确保问题三不为空字符串
*/ */
@NotBlank(message = "问题三不能为空")
private String wentisan; private String wentisan;
/** /**
* 问题四 * 问题四
* 使用NotBlank注解确保问题四不为空字符串
*/ */
@NotBlank(message = "问题四不能为空")
private String wentisi; private String wentisi;
/** /**
* 问题五 * 问题五
* 使用NotBlank注解确保问题五不为空字符串
*/ */
@NotBlank(message = "问题五不能为空")
private String wentiwu; private String wentiwu;
/** /**
* 发布日期 * 发布日期
* 使用JsonFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，时区为东八区
* 使用DateTimeFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，用于处理请求参数中的日期格式
* 使用NotNull注解确保发布日期不为null
*/ */
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@NotNull(message = "发布日期不能为空") @DateTimeFormat
private Date faburiqi; private Date faburiqi;
/** /**
* 最近点击时间 * 最近点击时间
* 使用JsonFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，时区为东八区
* 使用DateTimeFormat注解指定日期格式为“yyyy-MM-dd HH:mm:ss”，用于处理请求参数中的日期格式
*/ */
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") @DateTimeFormat
private Date clicktime; private Date clicktime;
/**
* 设置：添加时间
* @param addtime 问卷的添加时间
*/
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
/** @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
* 获取：添加时间 @DateTimeFormat
* @return 问卷的添加时间 private Date addtime;
*/
public Date getAddtime() { public Date getAddtime() {
return addtime; return addtime;
} }
public void setAddtime(Date addtime) {
/** this.addtime = addtime;
* 设置：主键id
* @param id 主键id
*/
public void setId(Long id) {
this.id = id;
} }
/**
* 获取：主键id
* @return 主键id
*/
public Long getId() { public Long getId() {
return id; return id;
} }
public void setId(Long id) {
this.id = id;
}
/** /**
* 设置：问卷标题 * 设置：问卷标题
* @param wenjuanbiaoti 问卷标题
*/ */
public void setWenjuanbiaoti(String wenjuanbiaoti) { public void setWenjuanbiaoti(String wenjuanbiaoti) {
this.wenjuanbiaoti = wenjuanbiaoti; this.wenjuanbiaoti = wenjuanbiaoti;
} }
/** /**
* 获取：问卷标题 * 获取：问卷标题
* @return 问卷标题
*/ */
public String getWenjuanbiaoti() { public String getWenjuanbiaoti() {
return wenjuanbiaoti; return wenjuanbiaoti;
} }
/** /**
* 设置：封面图片 * 设置：封面图片
* @param fengmiantupian 封面图片路径
*/ */
public void setFengmiantupian(String fengmiantupian) { public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian; this.fengmiantupian = fengmiantupian;
} }
/** /**
* 获取：封面图片 * 获取：封面图片
* @return 封面图片路径
*/ */
public String getFengmiantupian() { public String getFengmiantupian() {
return fengmiantupian; return fengmiantupian;
} }
/** /**
* 设置：类型 * 设置：类型
* @param leixing 问卷类型
*/ */
public void setLeixing(String leixing) { public void setLeixing(String leixing) {
this.leixing = leixing; this.leixing = leixing;
} }
/** /**
* 获取：类型 * 获取：类型
* @return 问卷类型
*/ */
public String getLeixing() { public String getLeixing() {
return leixing; return leixing;
} }
/** /**
* 设置：问题一 * 设置：问题一
* @param wentiyi 问题一的内容
*/ */
public void setWentiyi(String wentiyi) { public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi; this.wentiyi = wentiyi;
} }
/** /**
* 获取：问题一 * 获取：问题一
* @return 问题一的内容
*/ */
public String getWentiyi() { public String getWentiyi() {
return wentiyi; return wentiyi;
} }
/** /**
* 设置：问题二 * 设置：问题二
* @param wentier 问题二的内容
*/ */
public void setWentier(String wentier) { public void setWentier(String wentier) {
this.wentier = wentier; this.wentier = wentier;
} }
/** /**
* 获取：问题二 * 获取：问题二
* @return 问题二的内容
*/ */
public String getWentier() { public String getWentier() {
return wentier; return wentier;
} }
/** /**
* 设置：问题三 * 设置：问题三
* @param wentisan 问题三的内容
*/ */
public void setWentisan(String wentisan) { public void setWentisan(String wentisan) {
this.wentisan = wentisan; this.wentisan = wentisan;
} }
/** /**
* 获取：问题三 * 获取：问题三
* @return 问题三的内容
*/ */
public String getWentisan() { public String getWentisan() {
return wentisan; return wentisan;
} }
/** /**
* 设置：问题四 * 设置：问题四
* @param wentisi 问题四的内容
*/ */
public void setWentisi(String wentisi) { public void setWentisi(String wentisi) {
this.wentisi = wentisi; this.wentisi = wentisi;
} }
/** /**
* 获取：问题四 * 获取：问题四
* @return 问题四的内容
*/ */
public String getWentisi() { public String getWentisi() {
return wentisi; return wentisi;
} }
/** /**
* 设置：问题五 * 设置：问题五
* @param wentiwu 问题五的内容
*/ */
public void setWentiwu(String wentiwu) { public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu; this.wentiwu = wentiwu;
} }
/** /**
* 获取：问题五 * 获取：问题五
* @return 问题五的内容
*/ */
public String getWentiwu() { public String getWentiwu() {
return wentiwu; return wentiwu;
} }
/** /**
* 设置：发布日期 * 设置：发布日期
* @param faburiqi 问卷的发布日期
*/ */
public void setFaburiqi(Date faburiqi) { public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi; this.faburiqi = faburiqi;
} }
/** /**
* 获取：发布日期 * 获取：发布日期
* @return 问卷的发布日期
*/ */
public Date getFaburiqi() { public Date getFaburiqi() {
return faburiqi; return faburiqi;
} }
/** /**
* 设置：最近点击时间 * 设置：最近点击时间
* @param clicktime 最近点击该问卷的时间
*/ */
public void setClicktime(Date clicktime) { public void setClicktime(Date clicktime) {
this.clicktime = clicktime; this.clicktime = clicktime;
} }
/** /**
* 获取：最近点击时间 * 获取：最近点击时间
* @return 最近点击该问卷的时间
*/ */
public Date getClicktime() { public Date getClicktime() {
return clicktime; return clicktime;
} }
} }

73
src/main/java/com/entity/model/ForumModel.java
Unescape View File

@ -1,144 +1,157 @@
package com.entity.model; package com.entity.model;
import com.entity.ForumEntity; import com.entity.ForumEntity;
import java.io.Serializable; // 导入可序列化接口
import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/** /**
* 论坛表 * 论坛表
* 接收传参的实体类 * 接收传参的实体类
* （实际开发中配合移动端接口开发手动去掉些没用的字段，后端一般用entity就够用了） *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView的model名称 * 取自ModelAndView 的model名称
*
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class ForumModel implements Serializable { public class ForumModel implements Serializable {
private static final long serialVersionUID = 1L; // 版本控制 private static final long serialVersionUID = 1L;
/** /**
* 帖子内容 * 帖子内容
*/ */
private String content; // 存放帖子内容
private String content;
/** /**
* 父节点id * 父节点id
*/ */
private Long parentid; // 存放父节点ID
private Long parentid;
/** /**
* 用户id * 用户id
*/ */
private Long userid; // 存放用户ID
private Long userid;
/** /**
* 用户名 * 用户名
*/ */
private String username; // 存放用户名
private String username;
/** /**
* 头像 * 头像
*/ */
private String avatarurl; // 存放用户头像URL
private String avatarurl;
/** /**
* 状态 * 状态
*/ */
private String isdone; // 存放帖子状态（例如：已完成/未完成等）
private String isdone;
/** /**
* 设置：帖子内容 * 设置：帖子内容
* @param content 帖子内容
*/ */
public void setContent(String content) { public void setContent(String content) {
this.content = content; // 设置帖子内容 this.content = content;
} }
/** /**
* 获取：帖子内容 * 获取：帖子内容
* @return 帖子内容
*/ */
public String getContent() { public String getContent() {
return content; return content;
} }
/** /**
* 设置：父节点id * 设置：父节点id
* @param parentid 父节点ID
*/ */
public void setParentid(Long parentid) { public void setParentid(Long parentid) {
this.parentid = parentid; // 设置父节点ID this.parentid = parentid;
} }
/** /**
* 获取：父节点id * 获取：父节点id
* @return 父节点ID
*/ */
public Long getParentid() { public Long getParentid() {
return parentid; // 返回父节点ID return parentid;
} }
/** /**
* 设置：用户id * 设置：用户id
* @param userid 用户ID
*/ */
public void setUserid(Long userid) { public void setUserid(Long userid) {
this.userid = userid; // 设置用户ID this.userid = userid;
} }
/** /**
* 获取：用户id * 获取：用户id
* @return 用户ID
*/ */
public Long getUserid() { public Long getUserid() {
return userid; return userid;
} }
/** /**
* 设置：用户名 * 设置：用户名
* @param username 用户名
*/ */
public void setUsername(String username) { public void setUsername(String username) {
this.username = username; // 设置用户名 this.username = username;
} }
/** /**
* 获取：用户名 * 获取：用户名
* @return 用户名
*/ */
public String getUsername() { public String getUsername() {
return username; return username;
} }
/** /**
* 设置：头像 * 设置：头像
* @param avatarurl 头像URL
*/ */
public void setAvatarurl(String avatarurl) { public void setAvatarurl(String avatarurl) {
this.avatarurl = avatarurl; // 设置头像URL this.avatarurl = avatarurl;
} }
/** /**
* 获取：头像 * 获取：头像
* @return 头像URL
*/ */
public String getAvatarurl() { public String getAvatarurl() {
return avatarurl; return avatarurl;
} }
/** /**
* 设置：状态 * 设置：状态
* @param isdone 帖子状态
*/ */
public void setIsdone(String isdone) { public void setIsdone(String isdone) {
this.isdone = isdone; // 设置帖子状态 this.isdone = isdone;
} }
/** /**
* 获取：状态 * 获取：状态
* @return 帖子状态
*/ */
public String getIsdone() { public String getIsdone() {
return isdone; return isdone;
} }
} }

4
src/main/java/com/entity/model/LeixingModel.java
Unescape View File

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class LeixingModel implements Serializable { public class LeixingModel implements Serializable {
private static final long serialVersionUID = 1L;// 版本控制 private static final long serialVersionUID = 1L;
// 可以根据需求定义属性，例如类型的名称、描述等
} }

36
src/main/java/com/entity/model/NewsModel.java
Unescape View File

@ -9,73 +9,83 @@ import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 公告信息 * 公告信息
* 接收传参的实体类 * 接收传参的实体类
* （实际开发中配合移动端接口开发手动去掉些没用的字段，后端一般用 entity 就够用了） *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自 ModelAndView 的 model 名称 * 取自ModelAndView 的model名称
* @author * @author
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class NewsModel implements Serializable { public class NewsModel implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号 private static final long serialVersionUID = 1L;
/** /**
* 简介 * 简介
*/ */
private String introduction; // 存放公告的简介
private String introduction;
/** /**
* 图片 * 图片
*/ */
private String picture; // 存放公告相关的图片
private String picture;
/** /**
* 内容 * 内容
*/ */
private String content; // 存放公告的详细内容
private String content;
/** /**
* 设置：简介 * 设置：简介
*/ */
public void setIntroduction(String introduction) { public void setIntroduction(String introduction) {
this.introduction = introduction; // 设置简介字段 this.introduction = introduction;
} }
/** /**
* 获取：简介 * 获取：简介
*/ */
public String getIntroduction() { public String getIntroduction() {
return introduction; // 返回简介字段的值 return introduction;
} }
/** /**
* 设置：图片 * 设置：图片
*/ */
public void setPicture(String picture) { public void setPicture(String picture) {
this.picture = picture; // 设置图片字段 this.picture = picture;
} }
/** /**
* 获取：图片 * 获取：图片
*/ */
public String getPicture() { public String getPicture() {
return picture; // 返回图片字段的值 return picture;
} }
/** /**
* 设置：内容 * 设置：内容
*/ */
public void setContent(String content) { public void setContent(String content) {
this.content = content; // 设置内容字段 this.content = content;
} }
/** /**
* 获取：内容 * 获取：内容
*/ */
public String getContent() { public String getContent() {
return content; // 返回内容字段的值 return content;
} }
} }

46
src/main/java/com/entity/model/WenjuandiaochaModel.java
Unescape View File

@ -1,75 +1,90 @@
package com.entity.model; package com.entity.model;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date; import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 问卷调查模型类 * 问卷调查
* 该类用于接收传参，通常在实际开发中配合移动端接口开发时手动去掉一些不需要的字段 * 接收传参的实体类
* 取自ModelAndView的model名称 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* @author 未填写具体作者 * 取自ModelAndView 的model名称
* @email 未填写具体邮箱 * @author
* @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class WenjuandiaochaModel implements Serializable { public class WenjuandiaochaModel implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 封面图片 * 封面图片
*/ */
private String fengmiantupian; private String fengmiantupian;
/** /**
* 类型 * 类型
*/ */
private String leixing; private String leixing;
/** /**
* 问题一 * 问题一
*/ */
private String wentiyi; private String wentiyi;
/** /**
* 问题二 * 问题二
*/ */
private String wentier; private String wentier;
/** /**
* 问题三 * 问题三
*/ */
private String wentisan; private String wentisan;
/** /**
* 问题四 * 问题四
*/ */
private String wentisi; private String wentisi;
/** /**
* 问题五 * 问题五
*/ */
private String wentiwu; private String wentiwu;
/** /**
* 发布日期 * 发布日期
*/ */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat @DateTimeFormat
private Date faburiqi; private Date faburiqi;
/** /**
* 最近点击时间 * 最近点击时间
*/ */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat @DateTimeFormat
private Date clicktime; private Date clicktime;
/** /**
* 设置：封面图片 * 设置：封面图片
*/ */
public void setFengmiantupian(String fengmiantupian) { public void setFengmiantupian(String fengmiantupian) {
this.fengmiantupian = fengmiantupian; this.fengmiantupian = fengmiantupian;
} }
@ -81,9 +96,11 @@ public class WenjuandiaochaModel implements Serializable {
return fengmiantupian; return fengmiantupian;
} }
/** /**
* 设置：类型 * 设置：类型
*/ */
public void setLeixing(String leixing) { public void setLeixing(String leixing) {
this.leixing = leixing; this.leixing = leixing;
} }
@ -95,9 +112,11 @@ public class WenjuandiaochaModel implements Serializable {
return leixing; return leixing;
} }
/** /**
* 设置：问题一 * 设置：问题一
*/ */
public void setWentiyi(String wentiyi) { public void setWentiyi(String wentiyi) {
this.wentiyi = wentiyi; this.wentiyi = wentiyi;
} }
@ -109,9 +128,11 @@ public class WenjuandiaochaModel implements Serializable {
return wentiyi; return wentiyi;
} }
/** /**
* 设置：问题二 * 设置：问题二
*/ */
public void setWentier(String wentier) { public void setWentier(String wentier) {
this.wentier = wentier; this.wentier = wentier;
} }
@ -123,9 +144,11 @@ public class WenjuandiaochaModel implements Serializable {
return wentier; return wentier;
} }
/** /**
* 设置：问题三 * 设置：问题三
*/ */
public void setWentisan(String wentisan) { public void setWentisan(String wentisan) {
this.wentisan = wentisan; this.wentisan = wentisan;
} }
@ -137,9 +160,11 @@ public class WenjuandiaochaModel implements Serializable {
return wentisan; return wentisan;
} }
/** /**
* 设置：问题四 * 设置：问题四
*/ */
public void setWentisi(String wentisi) { public void setWentisi(String wentisi) {
this.wentisi = wentisi; this.wentisi = wentisi;
} }
@ -151,9 +176,11 @@ public class WenjuandiaochaModel implements Serializable {
return wentisi; return wentisi;
} }
/** /**
* 设置：问题五 * 设置：问题五
*/ */
public void setWentiwu(String wentiwu) { public void setWentiwu(String wentiwu) {
this.wentiwu = wentiwu; this.wentiwu = wentiwu;
} }
@ -165,9 +192,11 @@ public class WenjuandiaochaModel implements Serializable {
return wentiwu; return wentiwu;
} }
/** /**
* 设置：发布日期 * 设置：发布日期
*/ */
public void setFaburiqi(Date faburiqi) { public void setFaburiqi(Date faburiqi) {
this.faburiqi = faburiqi; this.faburiqi = faburiqi;
} }
@ -179,9 +208,11 @@ public class WenjuandiaochaModel implements Serializable {
return faburiqi; return faburiqi;
} }
/** /**
* 设置：最近点击时间 * 设置：最近点击时间
*/ */
public void setClicktime(Date clicktime) { public void setClicktime(Date clicktime) {
this.clicktime = clicktime; this.clicktime = clicktime;
} }
@ -192,4 +223,5 @@ public class WenjuandiaochaModel implements Serializable {
public Date getClicktime() { public Date getClicktime() {
return clicktime; return clicktime;
} }
} }

8
src/main/java/com/entity/view/ForumView.java
Unescape View File

@ -24,15 +24,13 @@ public class ForumView extends ForumEntity implements Serializable {
public ForumView(){ public ForumView(){
} }
// 接收 ForumEntity 对象的构造函数 public ForumView(ForumEntity forumEntity){
public ForumView(ForumEntity forumEntity) {
try { try {
// 将ForumEntity的属性复制到当前ForumView对象
BeanUtils.copyProperties(this, forumEntity); BeanUtils.copyProperties(this, forumEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理，打印堆栈信息 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
}
}
} }

7
src/main/java/com/entity/view/LeixingView.java
Unescape View File

@ -24,14 +24,13 @@ public class LeixingView extends LeixingEntity implements Serializable {
public LeixingView(){ public LeixingView(){
} }
// 接收 LeixingEntity 对象的构造函数 public LeixingView(LeixingEntity leixingEntity){
public LeixingView(LeixingEntity leixingEntity) {
try { try {
// 将LeixingEntity的属性复制到当前LeixingView对象
BeanUtils.copyProperties(this, leixingEntity); BeanUtils.copyProperties(this, leixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理，打印堆栈信息 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
} }

22
src/main/java/com/entity/view/NewsView.java
Unescape View File

@ -9,10 +9,6 @@ import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
/**
* 公告信息
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
/** /**
* 公告信息 * 公告信息
* 后端返回视图实体辅助类 * 后端返回视图实体辅助类
@ -21,22 +17,20 @@ import java.io.Serializable;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("news") // 指定该类对应的数据库表名为 "news" @TableName("news")
public class NewsView extends NewsEntity implements Serializable { public class NewsView extends NewsEntity implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号 private static final long serialVersionUID = 1L;
// 默认构造函数 public NewsView(){
public NewsView() {
} }
// 构造函数，接受一个 NewsEntity 对象并复制其属性 public NewsView(NewsEntity newsEntity){
public NewsView(NewsEntity newsEntity) {
try { try {
BeanUtils.copyProperties(this, newsEntity); // 使用 BeanUtils 复制属性 BeanUtils.copyProperties(this, newsEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并处理属性复制过程中的异常 // TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈跟踪 e.printStackTrace();
} }
} }
} }

17
src/main/java/com/entity/view/StoreupView.java
Unescape View File

@ -17,21 +17,20 @@ import java.io.Serializable;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("storeup") // 指定该类对应的数据库表名为 "storeup" @TableName("storeup")
public class StoreupView extends StoreupEntity implements Serializable { public class StoreupView extends StoreupEntity implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号 private static final long serialVersionUID = 1L;
// 默认构造函数 public StoreupView(){
public StoreupView() {
} }
// 构造函数，接受一个 StoreupEntity 对象并复制其属性 public StoreupView(StoreupEntity storeupEntity){
public StoreupView(StoreupEntity storeupEntity) {
try { try {
BeanUtils.copyProperties(this, storeupEntity); // 使用 BeanUtils 复制属性 BeanUtils.copyProperties(this, storeupEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并处理属性复制过程中的异常 // TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈跟踪 e.printStackTrace();
} }
} }
} }

18
src/main/java/com/entity/view/SystemintroView.java
Unescape View File

@ -1,18 +1,14 @@
package com.entity.view; package com.entity.view;
// 导入系统介绍实体类
import com.entity.SystemintroEntity; import com.entity.SystemintroEntity;
// 导入MyBatis-Plus的注解库
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils类
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
// 导入反射异常处理类
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable; import java.io.Serializable;
/** /**
* 关于我们 * 关于我们
* 后端返回视图实体辅助类 * 后端返回视图实体辅助类
@ -21,24 +17,20 @@ import java.io.Serializable;
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
// 指定表名为"systemintro"的实体类
@TableName("systemintro") @TableName("systemintro")
public class SystemintroView extends SystemintroEntity implements Serializable { public class SystemintroView extends SystemintroEntity implements Serializable {
// 版本控制
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// 默认构造函数 public SystemintroView(){
public SystemintroView() {
} }
// 带参构造函数，用于根据SystemintroEntity对象初始化SystemintroView public SystemintroView(SystemintroEntity systemintroEntity){
public SystemintroView(SystemintroEntity systemintroEntity) {
try { try {
// 复制systemintroEntity的属性到当前对象
BeanUtils.copyProperties(this, systemintroEntity); BeanUtils.copyProperties(this, systemintroEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 捕获反射过程中的异常并打印堆栈信息 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
} }

26
src/main/java/com/entity/view/WenjuandiaochaView.java
Unescape View File

@ -1,40 +1,36 @@
package com.entity.view; package com.entity.view;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils; import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 问卷调查视图实体类 * 问卷调查
* 该类用于在后端返回视图时使用的辅助实体类。 * 后端返回视图实体辅助类
* 通常在后端需要关联其他表或自定义字段时，会使用此类来封装返回的数据。 * （通常后端关联的表或者自定义的字段需要返回使用）
* @author 未填写具体作者 * @author
* @email 未填写具体邮箱 * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
@TableName("wenjuandiaocha") @TableName("wenjuandiaocha")
public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable { public class WenjuandiaochaView extends WenjuandiaochaEntity implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** public WenjuandiaochaView(){
* 无参构造函数
*/
public WenjuandiaochaView() {
} }
/** public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity){
* 带参数的构造函数，用于将WenjuandiaochaEntity对象的属性复制到WenjuandiaochaView对象中
* @param wenjuandiaochaEntity 问卷调查实体对象
*/
public WenjuandiaochaView(WenjuandiaochaEntity wenjuandiaochaEntity) {
try { try {
BeanUtils.copyProperties(this, wenjuandiaochaEntity); BeanUtils.copyProperties(this, wenjuandiaochaEntity);
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// 打印堆栈跟踪信息以便调试 // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
} }
} }

2
src/main/java/com/entity/vo/LeixingVO.java
Unescape View File

@ -19,7 +19,7 @@ import java.io.Serializable;
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class LeixingVO implements Serializable { public class LeixingVO implements Serializable {
private static final long serialVersionUID = 1L;// 版本控制，用于序列化 private static final long serialVersionUID = 1L;
} }

48
src/main/java/com/entity/vo/NewsVO.java
Unescape View File

@ -1,13 +1,14 @@
package com.entity.vo; // 定义包名 package com.entity.vo;
import com.entity.NewsEntity; // 导入NewsEntity类 import com.entity.NewsEntity;
import com.baomidou.mybatisplus.annotations.TableName; // 导入MyBatis-Plus的TableName注解 import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; // 导入Jackson的JsonFormat注解 import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date; // 导入Date类 import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解 import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.io.Serializable; // 导入Serializable接口
/** /**
* 公告信息 * 公告信息
@ -17,63 +18,74 @@ import java.io.Serializable; // 导入Serializable接口
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class NewsVO implements Serializable { // 定义NewsVO类，实现Serializable接口 public class NewsVO implements Serializable {
private static final long serialVersionUID = 1L; // 定义序列化版本号 private static final long serialVersionUID = 1L;
/** /**
* 简介 * 简介
*/ */
private String introduction; // 定义简介字段
private String introduction;
/** /**
* 图片 * 图片
*/ */
private String picture; // 定义图片字段
private String picture;
/** /**
* 内容 * 内容
*/ */
private String content; // 定义内容字段
private String content;
/** /**
* 设置：简介 * 设置：简介
*/ */
public void setIntroduction(String introduction) { // 设置简介的方法
public void setIntroduction(String introduction) {
this.introduction = introduction; this.introduction = introduction;
} }
/** /**
* 获取：简介 * 获取：简介
*/ */
public String getIntroduction() { // 获取简介的方法 public String getIntroduction() {
return introduction; return introduction;
} }
/** /**
* 设置：图片 * 设置：图片
*/ */
public void setPicture(String picture) { // 设置图片的方法
public void setPicture(String picture) {
this.picture = picture; this.picture = picture;
} }
/** /**
* 获取：图片 * 获取：图片
*/ */
public String getPicture() { // 获取图片的方法 public String getPicture() {
return picture; return picture;
} }
/** /**
* 设置：内容 * 设置：内容
*/ */
public void setContent(String content) { // 设置内容的方法
public void setContent(String content) {
this.content = content; this.content = content;
} }
/** /**
* 获取：内容 * 获取：内容
*/ */
public String getContent() { // 获取内容的方法 public String getContent() {
return content; return content;
} }
} }

84
src/main/java/com/entity/vo/StoreupVO.java
Unescape View File

@ -1,13 +1,14 @@
package com.entity.vo; // 定义包名 package com.entity.vo;
import com.entity.StoreupEntity; // 导入StoreupEntity类 import com.entity.StoreupEntity;
import com.baomidou.mybatisplus.annotations.TableName; // 导入MyBatis-Plus的TableName注解 import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; // 导入Jackson的JsonFormat注解 import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date; // 导入Date类 import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解 import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.io.Serializable; // 导入Serializable接口
/** /**
* 收藏表 * 收藏表
@ -17,139 +18,162 @@ import java.io.Serializable; // 导入Serializable接口
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class StoreupVO implements Serializable { // 定义StoreupVO类，实现Serializable接口 public class StoreupVO implements Serializable {
private static final long serialVersionUID = 1L; // 定义序列化版本号 private static final long serialVersionUID = 1L;
/** /**
* 商品id * 商品id
*/ */
private Long refid; // 定义商品id字段
private Long refid;
/** /**
* 表名 * 表名
*/ */
private String tablename; // 定义表名字段
private String tablename;
/** /**
* 名称 * 名称
*/ */
private String name; // 定义名称字段
private String name;
/** /**
* 图片 * 图片
*/ */
private String picture; // 定义图片字段
private String picture;
/** /**
* 类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注) * 类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注)
*/ */
private String type; // 定义类型字段
private String type;
/** /**
* 推荐类型 * 推荐类型
*/ */
private String inteltype; // 定义推荐类型字段
private String inteltype;
/** /**
* 备注 * 备注
*/ */
private String remark; // 定义备注字段
private String remark;
/** /**
* 设置：商品id * 设置：商品id
*/ */
public void setRefid(Long refid) { // 设置商品id的方法
public void setRefid(Long refid) {
this.refid = refid; this.refid = refid;
} }
/** /**
* 获取：商品id * 获取：商品id
*/ */
public Long getRefid() { // 获取商品id的方法 public Long getRefid() {
return refid; return refid;
} }
/** /**
* 设置：表名 * 设置：表名
*/ */
public void setTablename(String tablename) { // 设置表名的方法
public void setTablename(String tablename) {
this.tablename = tablename; this.tablename = tablename;
} }
/** /**
* 获取：表名 * 获取：表名
*/ */
public String getTablename() { // 获取表名的方法 public String getTablename() {
return tablename; return tablename;
} }
/** /**
* 设置：名称 * 设置：名称
*/ */
public void setName(String name) { // 设置名称的方法
public void setName(String name) {
this.name = name; this.name = name;
} }
/** /**
* 获取：名称 * 获取：名称
*/ */
public String getName() { // 获取名称的方法 public String getName() {
return name; return name;
} }
/** /**
* 设置：图片 * 设置：图片
*/ */
public void setPicture(String picture) { // 设置图片的方法
public void setPicture(String picture) {
this.picture = picture; this.picture = picture;
} }
/** /**
* 获取：图片 * 获取：图片
*/ */
public String getPicture() { // 获取图片的方法 public String getPicture() {
return picture; return picture;
} }
/** /**
* 设置：类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注) * 设置：类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注)
*/ */
public void setType(String type) { // 设置类型的方法
public void setType(String type) {
this.type = type; this.type = type;
} }
/** /**
* 获取：类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注) * 获取：类型(1:收藏,21:赞,22:踩,31:竞拍参与,41:关注)
*/ */
public String getType() { // 获取类型的方法 public String getType() {
return type; return type;
} }
/** /**
* 设置：推荐类型 * 设置：推荐类型
*/ */
public void setInteltype(String inteltype) { // 设置推荐类型的方法
public void setInteltype(String inteltype) {
this.inteltype = inteltype; this.inteltype = inteltype;
} }
/** /**
* 获取：推荐类型 * 获取：推荐类型
*/ */
public String getInteltype() { // 获取推荐类型的方法 public String getInteltype() {
return inteltype; return inteltype;
} }
/** /**
* 设置：备注 * 设置：备注
*/ */
public void setRemark(String remark) { // 设置备注的方法
public void setRemark(String remark) {
this.remark = remark; this.remark = remark;
} }
/** /**
* 获取：备注 * 获取：备注
*/ */
public String getRemark() { // 获取备注的方法 public String getRemark() {
return remark; return remark;
} }
} }

66
src/main/java/com/entity/vo/SystemintroVO.java
Unescape View File

@ -1,13 +1,14 @@
package com.entity.vo; // 定义包名 package com.entity.vo;
import com.entity.SystemintroEntity; // 导入SystemintroEntity类 import com.entity.SystemintroEntity;
import com.baomidou.mybatisplus.annotations.TableName; // 导入MyBatis-Plus的TableName注解 import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; // 导入Jackson的JsonFormat注解 import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date; // 导入Date类 import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; // 导入Spring的DateTimeFormat注解 import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.io.Serializable; // 导入Serializable接口
/** /**
* 关于我们 * 关于我们
@ -17,101 +18,118 @@ import java.io.Serializable; // 导入Serializable接口
* @email * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public class SystemintroVO implements Serializable { // 定义SystemintroVO类，实现Serializable接口 public class SystemintroVO implements Serializable {
private static final long serialVersionUID = 1L; // 定义序列化版本号 private static final long serialVersionUID = 1L;
/** /**
* 副标题 * 副标题
*/ */
private String subtitle; // 定义副标题字段
private String subtitle;
/** /**
* 内容 * 内容
*/ */
private String content; // 定义内容字段
private String content;
/** /**
* 图片1 * 图片1
*/ */
private String picture1; // 定义图片1字段
private String picture1;
/** /**
* 图片2 * 图片2
*/ */
private String picture2; // 定义图片2字段
private String picture2;
/** /**
* 图片3 * 图片3
*/ */
private String picture3; // 定义图片3字段
private String picture3;
/** /**
* 设置：副标题 * 设置：副标题
*/ */
public void setSubtitle(String subtitle) { // 设置副标题的方法
public void setSubtitle(String subtitle) {
this.subtitle = subtitle; this.subtitle = subtitle;
} }
/** /**
* 获取：副标题 * 获取：副标题
*/ */
public String getSubtitle() { // 获取副标题的方法 public String getSubtitle() {
return subtitle; return subtitle;
} }
/** /**
* 设置：内容 * 设置：内容
*/ */
public void setContent(String content) { // 设置内容的方法
public void setContent(String content) {
this.content = content; this.content = content;
} }
/** /**
* 获取：内容 * 获取：内容
*/ */
public String getContent() { // 获取内容的方法 public String getContent() {
return content; return content;
} }
/** /**
* 设置：图片1 * 设置：图片1
*/ */
public void setPicture1(String picture1) { // 设置图片1的方法
public void setPicture1(String picture1) {
this.picture1 = picture1; this.picture1 = picture1;
} }
/** /**
* 获取：图片1 * 获取：图片1
*/ */
public String getPicture1() { // 获取图片1的方法 public String getPicture1() {
return picture1; return picture1;
} }
/** /**
* 设置：图片2 * 设置：图片2
*/ */
public void setPicture2(String picture2) { // 设置图片2的方法
public void setPicture2(String picture2) {
this.picture2 = picture2; this.picture2 = picture2;
} }
/** /**
* 获取：图片2 * 获取：图片2
*/ */
public String getPicture2() { // 获取图片2的方法 public String getPicture2() {
return picture2; return picture2;
} }
/** /**
* 设置：图片3 * 设置：图片3
*/ */
public void setPicture3(String picture3) { // 设置图片3的方法
public void setPicture3(String picture3) {
this.picture3 = picture3; this.picture3 = picture3;
} }
/** /**
* 获取：图片3 * 获取：图片3
*/ */
public String getPicture3() { // 获取图片3的方法 public String getPicture3() {
return picture3; return picture3;
} }
} }

13
src/main/java/com/service/ConfigService.java
Unescape View File

@ -3,8 +3,8 @@ package com.service;
import java.util.Map; import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;// 导入MyBatis-Plus的Wrapper接口，用于构建查询条件 import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;// 导入MyBatis-Plus的服务接口 import com.baomidou.mybatisplus.service.IService;
import com.entity.ConfigEntity; import com.entity.ConfigEntity;
import com.utils.PageUtils; import com.utils.PageUtils;
@ -13,12 +13,5 @@ import com.utils.PageUtils;
* 系统用户 * 系统用户
*/ */
public interface ConfigService extends IService<ConfigEntity> { public interface ConfigService extends IService<ConfigEntity> {
PageUtils queryPage(Map<String, Object> params,Wrapper<ConfigEntity> wrapper);
/**
* 查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 封装好的分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper);
} }

43
src/main/java/com/service/ForumService.java
Unescape View File

@ -3,12 +3,14 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService; import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.entity.ForumEntity; // 导入论坛实体类 import com.entity.ForumEntity;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.entity.vo.ForumVO;// 导入论坛VO类 import com.entity.vo.ForumVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.ForumView;v// 导入论坛视图类 import com.entity.view.ForumView;
/** /**
* 论坛表 * 论坛表
* *
@ -18,47 +20,18 @@ import com.entity.view.ForumView;v// 导入论坛视图类
*/ */
public interface ForumService extends IService<ForumEntity> { public interface ForumService extends IService<ForumEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
/**
* 查询VO列表
* @param wrapper 查询条件包装器
* @return ForumVO对象列表
*/
List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper); List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper);
/**
* 查询单个VO对象
* @param wrapper 查询条件包装器
* @return 单个ForumVO对象
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper); ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询视图列表
* @param wrapper 查询条件包装器
* @return ForumView对象列表
*/
List<ForumView> selectListView(Wrapper<ForumEntity> wrapper); List<ForumView> selectListView(Wrapper<ForumEntity> wrapper);
/**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个ForumView对象
*/
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper); ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<ForumEntity> wrapper);
* 带条件的查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper);
} }

39
src/main/java/com/service/LeixingService.java
Unescape View File

@ -3,12 +3,12 @@ package com.service;
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService; import com.baomidou.mybatisplus.service.IService;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.entity.LeixingEntity; // 导入类型实体类 import com.entity.LeixingEntity;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import com.entity.vo.LeixingVO; import com.entity.vo.LeixingVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.LeixingView;// 导入类型视图类 import com.entity.view.LeixingView;
/** /**
@ -20,47 +20,18 @@ import com.entity.view.LeixingView;// 导入类型视图类
*/ */
public interface LeixingService extends IService<LeixingEntity> { public interface LeixingService extends IService<LeixingEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
/**
* 查询类型列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return LeixingVO对象列表
*/
List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper); List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回VO对象
* @param wrapper 查询条件包装器
* @return 单个LeixingVO对象
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper); LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return LeixingView对象列表
*/
List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper); List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回视图对象
* @param wrapper 查询条件包装器
* @return 单个LeixingView对象
*/
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper); LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<LeixingEntity> wrapper);
* 带条件的查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper);
} }

22
src/main/java/com/service/NewsService.java
Unescape View File

@ -14,24 +14,24 @@ import com.entity.view.NewsView;
/** /**
* 公告信息 * 公告信息
* *
* @author // 作者信息 * @author
* @email // 邮箱信息 * @email
* @date 2023-02-21 09:46:06 // 创建日期 * @date 2023-02-21 09:46:06
*/ */
public interface NewsService extends IService<NewsEntity> { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 public interface NewsService extends IService<NewsEntity> {
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params);
List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回 NewsVO 列表 List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper);
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回单个 NewsVO 对象 NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
List<NewsView> selectListView(Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回 NewsView 列表 List<NewsView> selectListView(Wrapper<NewsEntity> wrapper);
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper); // 根据条件包装器查询并返回单个 NewsView 对象 NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params,Wrapper<NewsEntity> wrapper);
}
}

23
src/main/java/com/service/StoreupService.java
Unescape View File

@ -10,27 +10,28 @@ import com.entity.vo.StoreupVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.StoreupView; import com.entity.view.StoreupView;
/** /**
* 收藏表 * 收藏表
* *
* @author // 作者信息 * @author
* @email // 邮箱信息 * @email
* @date 2023-02-21 09:46:06 // 创建日期 * @date 2023-02-21 09:46:06
*/ */
public interface StoreupService extends IService<StoreupEntity> { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 public interface StoreupService extends IService<StoreupEntity> {
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params);
List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回 StoreupVO 列表 List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper);
StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回单个 StoreupVO 对象 StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回 StoreupView 列表 List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper);
StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper); // 根据条件包装器查询并返回单个 StoreupView 对象 StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper);
PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params,Wrapper<StoreupEntity> wrapper);
}
}

24
src/main/java/com/service/SystemintroService.java
Unescape View File

@ -9,27 +9,29 @@ import java.util.Map;
import com.entity.vo.SystemintroVO; import com.entity.vo.SystemintroVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.SystemintroView; import com.entity.view.SystemintroView;
/** /**
* 关于我们 * 关于我们
* *
* @author // 作者信息 * @author
* @email // 邮箱信息 * @email
* @date 2023-02-21 09:46:06 // 创建日期 * @date 2023-02-21 09:46:06
*/ */
public interface SystemintroService extends IService<SystemintroEntity> { // 声明一个接口，扩展 IService 用于基本的 CRUD 操作 public interface SystemintroService extends IService<SystemintroEntity> {
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params);
List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回 SystemintroVO 列表 List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper);
SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回单个 SystemintroVO 对象 SystemintroVO selectVO(@Param("ew") Wrapper<SystemintroEntity> wrapper);
List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回 SystemintroView 列表 List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper);
SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper); // 根据条件包装器查询并返回单个 SystemintroView 对象 SystemintroView selectView(@Param("ew") Wrapper<SystemintroEntity> wrapper);
PageUtils queryPage(Map<String, Object> params, Wrapper<SystemintroEntity> wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果 PageUtils queryPage(Map<String, Object> params,Wrapper<SystemintroEntity> wrapper);
}
}

10
src/main/java/com/service/UsersService.java
Unescape View File

@ -11,15 +11,15 @@ import com.baomidou.mybatisplus.service.IService;
import com.entity.UsersEntity; import com.entity.UsersEntity;
import com.utils.PageUtils; import com.utils.PageUtils;
/** /**
* 系统用户 * 系统用户
*/ */
public interface UsersService extends IService<UsersEntity> { // 声明一个接口，扩展 IService，用于基本的 CRUD 操作 public interface UsersService extends IService<UsersEntity> {
PageUtils queryPage(Map<String, Object> params);
PageUtils queryPage(Map<String, Object> params); // 根据传入的参数进行分页查询，并返回分页结果 List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper);
List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper); // 根据条件包装器查询并返回 UsersEntity 列表 PageUtils queryPage(Map<String, Object> params,Wrapper<UsersEntity> wrapper);
PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper); // 根据参数和条件包装器进行分页查询，并返回分页结果
} }

62
src/main/java/com/service/WenjuandafuService.java
Unescape View File

@ -20,70 +20,26 @@ import com.entity.view.WenjuandafuView;
*/ */
public interface WenjuandafuService extends IService<WenjuandafuEntity> { public interface WenjuandafuService extends IService<WenjuandafuEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
/**
* 查询问卷答复列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 问卷答复VO对象列表
*/
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper); List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询单个问卷答复，返回VO对象
* @param wrapper 查询条件包装器
* @return 问卷答复VO对象
*/
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象列表
*/
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper); List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询单个问卷答复，返回视图对象
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象
*/
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper); WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
* 查询分页数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复的值，以Map形式返回
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 值的Map列表
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/** List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
* 根据时间统计查询问卷答复的值
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值的Map列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/** List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
* 查询分组统计数据
* @param params 查询参数 List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
* @param wrapper 查询条件包装器
* @return 分组统计的Map列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper); }

68
src/main/java/com/service/WenjuandiaochaService.java
Unescape View File

@ -10,80 +10,36 @@ import com.entity.vo.WenjuandiaochaVO;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import com.entity.view.WenjuandiaochaView; import com.entity.view.WenjuandiaochaView;
/** /**
* 问卷调查服务接口 * 问卷调查
* *
* @author 作者名 * @author
* @email 邮箱地址 * @email
* @date 2023-02-21 09:46:06 * @date 2023-02-21 09:46:06
*/ */
public interface WenjuandiaochaService extends IService<WenjuandiaochaEntity> { public interface WenjuandiaochaService extends IService<WenjuandiaochaEntity> {
/**
* 分页查询问卷调查数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params); PageUtils queryPage(Map<String, Object> params);
/**
* 查询问卷调查列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查列表
*/
List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper); List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper);
/**
* 查询单个问卷调查（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查
*/
WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); WenjuandiaochaVO selectVO(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/**
* 查询问卷调查视图列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查视图列表
*/
List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper); List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper);
/**
* 查询单个问卷调查视图（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查视图
*/
WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper); WenjuandiaochaView selectView(@Param("ew") Wrapper<WenjuandiaochaEntity> wrapper);
/** PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
* 分页查询问卷调查数据（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
/** List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
* 查询问卷调查的统计值（带条件）
* @param params 查询参数 List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
* @param wrapper 查询条件包装器
* @return 统计值列表 List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandiaochaEntity> wrapper);
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
/**
* 查询问卷调查的时间统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
/**
* 查询问卷调查的分组统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计值列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper);
} }

8
src/main/java/com/service/impl/ConfigServiceImpl.java
Unescape View File

@ -24,10 +24,10 @@ import com.utils.Query;
public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService { public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) {
// 使用MyBatis-Plus的selectPage方法进行分页查询
Page<ConfigEntity> page = this.selectPage( Page<ConfigEntity> page = this.selectPage(
new Query<ConfigEntity>(params).getPage(), // 获取分页参数 new Query<ConfigEntity>(params).getPage(),
wrapper // 查询条件 wrapper
); );
return new PageUtils(page); // 返回分页结果 return new PageUtils(page);
}
} }

60
src/main/java/com/service/impl/ForumServiceImpl.java
Unescape View File

@ -18,76 +18,46 @@ import com.service.ForumService;
import com.entity.vo.ForumVO; import com.entity.vo.ForumVO;
import com.entity.view.ForumView; import com.entity.view.ForumView;
@Service("forumService") // 将该类标记为Spring的Service组件 @Service("forumService")
public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService { public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 调用selectPage方法进行分页查询
Page<ForumEntity> page = this.selectPage( Page<ForumEntity> page = this.selectPage(
new Query<ForumEntity>(params).getPage(), // 获取分页信息 new Query<ForumEntity>(params).getPage(),
new EntityWrapper<ForumEntity>() // 创建查询条件 new EntityWrapper<ForumEntity>()
); );
return new PageUtils(page); // 返回分页结果 return new PageUtils(page);
} }
/**
* 查询分页数据，带条件
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<ForumEntity> wrapper) {
// 创建分页对象 Page<ForumView> page =new Query<ForumView>(params).getPage();
Page<ForumView> page = new Query<ForumView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置记录 PageUtils pageUtil = new PageUtils(page);
page.setRecords(baseMapper.selectListView(page, wrapper)); return pageUtil;
return new PageUtils(page); // 返回分页结果
} }
/**
* 查询VO列表
* @param wrapper 查询条件包装器
* @return VO对象列表
*/
@Override @Override
public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) { public List<ForumVO> selectListVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法，返回VO对象列表 return baseMapper.selectListVO(wrapper);
} }
/**
* 查询单个VO对象
* @param wrapper 查询条件包装器
* @return 单个VO对象
*/
@Override @Override
public ForumVO selectVO(Wrapper<ForumEntity> wrapper) { public ForumVO selectVO(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用数据访问对象方法，返回单个VO对象 return baseMapper.selectVO(wrapper);
} }
/**
* 查询视图列表
* @param wrapper 查询条件包装器
* @return 视图对象列表
*/
@Override @Override
public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) { public List<ForumView> selectListView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法，返回视图对象列表 return baseMapper.selectListView(wrapper);
} }
/**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个视图对象
*/
@Override @Override
public ForumView selectView(Wrapper<ForumEntity> wrapper) { public ForumView selectView(Wrapper<ForumEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法，返回单个视图对象 return baseMapper.selectView(wrapper);
} }
} }

62
src/main/java/com/service/impl/LeixingServiceImpl.java
Unescape View File

@ -17,75 +17,47 @@ import com.entity.LeixingEntity;
import com.service.LeixingService; import com.service.LeixingService;
import com.entity.vo.LeixingVO; import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView; import com.entity.view.LeixingView;
@Service("leixingService") // 将该类标记为Spring的Service组件
@Service("leixingService")
public class LeixingServiceImpl extends ServiceImpl<LeixingDao, LeixingEntity> implements LeixingService { public class LeixingServiceImpl extends ServiceImpl<LeixingDao, LeixingEntity> implements LeixingService {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 使用selectPage方法进行分页查询
Page<LeixingEntity> page = this.selectPage( Page<LeixingEntity> page = this.selectPage(
new Query<LeixingEntity>(params).getPage(), // 获取分页信息 new Query<LeixingEntity>(params).getPage(),
new EntityWrapper<LeixingEntity>() // 创建查询条件 new EntityWrapper<LeixingEntity>()
); );
return new PageUtils(page); // 返回分页结果 return new PageUtils(page);
} }
/**
* 查询分页数据，带条件
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<LeixingEntity> wrapper) {
// 创建分页对象 Page<LeixingView> page =new Query<LeixingView>(params).getPage();
Page<LeixingView> page = new Query<LeixingView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置记录 PageUtils pageUtil = new PageUtils(page);
page.setRecords(baseMapper.selectListView(page, wrapper)); return pageUtil;
return new PageUtils(page); // 返回分页结果
} }
/**
* 查询VO列表
* @param wrapper 查询条件包装器
* @return VO对象列表
*/
@Override @Override
public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) { public List<LeixingVO> selectListVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用数据访问对象方法，返回VO对象列表 return baseMapper.selectListVO(wrapper);
} }
/**
* 查询单个VO对象
* @param wrapper 查询条件包装器
* @return 单个VO对象
*/
@Override @Override
public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) { public LeixingVO selectVO(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用数据访问对象方法，返回单个VO对象 return baseMapper.selectVO(wrapper);
} }
/**
* 查询视图列表
* @param wrapper 查询条件包装器
* @return 视图对象列表
*/
@Override @Override
public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) { public List<LeixingView> selectListView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用数据访问对象方法，返回视图对象列表 return baseMapper.selectListView(wrapper);
} }
/**
* 查询单个视图对象
* @param wrapper 查询条件包装器
* @return 单个视图对象
*/
@Override @Override
public LeixingView selectView(Wrapper<LeixingEntity> wrapper) { public LeixingView selectView(Wrapper<LeixingEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用数据访问对象方法，返回单个视图对象 return baseMapper.selectView(wrapper);
} }
}

36
src/main/java/com/service/impl/NewsServiceImpl.java
Unescape View File

@ -18,52 +18,46 @@ import com.service.NewsService;
import com.entity.vo.NewsVO; import com.entity.vo.NewsVO;
import com.entity.view.NewsView; import com.entity.view.NewsView;
@Service("newsService") // 声明该类为服务层组件，并指定服务名称为 "newsService" @Service("newsService")
public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService { public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService {
// 实现分页查询
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 创建一个分页对象，使用传入的参数获取页面信息
Page<NewsEntity> page = this.selectPage( Page<NewsEntity> page = this.selectPage(
new Query<NewsEntity>(params).getPage(), // 获取分页对象 new Query<NewsEntity>(params).getPage(),
new EntityWrapper<NewsEntity>() // 构建查询条件的包装器 new EntityWrapper<NewsEntity>()
); );
return new PageUtils(page); // 返回分页结果包装 return new PageUtils(page);
} }
// 实现带条件的分页查询
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper) {
// 创建分页对象 Page<NewsView> page =new Query<NewsView>(params).getPage();
Page<NewsView> page = new Query<NewsView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置页面记录 PageUtils pageUtil = new PageUtils(page);
page.setRecords(baseMapper.selectListView(page, wrapper)); return pageUtil;
PageUtils pageUtil = new PageUtils(page); // 包装分页结果
return pageUtil; // 返回分页结果
} }
// 查询符合条件的所有 NewsVO 对象
@Override @Override
public List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper) { public List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectListVO(wrapper); // 调用 DAO 层方法执行查询 return baseMapper.selectListVO(wrapper);
} }
// 查询单个 NewsVO 对象
@Override @Override
public NewsVO selectVO(Wrapper<NewsEntity> wrapper) { public NewsVO selectVO(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectVO(wrapper); // 调用 DAO 层方法执行查询 return baseMapper.selectVO(wrapper);
} }
// 查询符合条件的所有 NewsView 对象
@Override @Override
public List<NewsView> selectListView(Wrapper<NewsEntity> wrapper) { public List<NewsView> selectListView(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectListView(wrapper); // 调用 DAO 层方法执行查询 return baseMapper.selectListView(wrapper);
} }
// 查询单个 NewsView 对象
@Override @Override
public NewsView selectView(Wrapper<NewsEntity> wrapper) { public NewsView selectView(Wrapper<NewsEntity> wrapper) {
return baseMapper.selectView(wrapper); // 调用 DAO 层方法执行查询 return baseMapper.selectView(wrapper);
} }
} }

23
src/main/java/com/service/impl/StoreupServiceImpl.java
Unescape View File

@ -18,51 +18,46 @@ import com.service.StoreupService;
import com.entity.vo.StoreupVO; import com.entity.vo.StoreupVO;
import com.entity.view.StoreupView; import com.entity.view.StoreupView;
@Service("storeupService") // 将该类标记为服务，并指定 bean 的名称为 "storeupService" @Service("storeupService")
public class StoreupServiceImpl extends ServiceImpl<StoreupDao, StoreupEntity> implements StoreupService { public class StoreupServiceImpl extends ServiceImpl<StoreupDao, StoreupEntity> implements StoreupService {
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象，并调用 selectPage 方法获取数据
Page<StoreupEntity> page = this.selectPage( Page<StoreupEntity> page = this.selectPage(
new Query<StoreupEntity>(params).getPage(), // 构造分页信息 new Query<StoreupEntity>(params).getPage(),
new EntityWrapper<StoreupEntity>() // 创建 EntityWrapper 用于封装查询条件 new EntityWrapper<StoreupEntity>()
); );
// 返回封装好的分页结果
return new PageUtils(page); return new PageUtils(page);
} }
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper) {
// 创建分页对象 Page<StoreupView> page =new Query<StoreupView>(params).getPage();
Page<StoreupView> page = new Query<StoreupView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }
@Override @Override
public List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper) { public List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 StoreupVO 列表
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override @Override
public StoreupVO selectVO(Wrapper<StoreupEntity> wrapper) { public StoreupVO selectVO(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 StoreupVO 对象
return baseMapper.selectVO(wrapper); return baseMapper.selectVO(wrapper);
} }
@Override @Override
public List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper) { public List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 StoreupView 列表
return baseMapper.selectListView(wrapper); return baseMapper.selectListView(wrapper);
} }
@Override @Override
public StoreupView selectView(Wrapper<StoreupEntity> wrapper) { public StoreupView selectView(Wrapper<StoreupEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 StoreupView 对象
return baseMapper.selectView(wrapper); return baseMapper.selectView(wrapper);
} }
} }

23
src/main/java/com/service/impl/SystemintroServiceImpl.java
Unescape View File

@ -18,51 +18,46 @@ import com.service.SystemintroService;
import com.entity.vo.SystemintroVO; import com.entity.vo.SystemintroVO;
import com.entity.view.SystemintroView; import com.entity.view.SystemintroView;
@Service("systemintroService") // 将该类标记为服务，并指定 bean 的名称为 "systemintroService" @Service("systemintroService")
public class SystemintroServiceImpl extends ServiceImpl<SystemintroDao, SystemintroEntity> implements SystemintroService { public class SystemintroServiceImpl extends ServiceImpl<SystemintroDao, SystemintroEntity> implements SystemintroService {
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象，并调用 selectPage 方法获取数据
Page<SystemintroEntity> page = this.selectPage( Page<SystemintroEntity> page = this.selectPage(
new Query<SystemintroEntity>(params).getPage(), // 构造分页信息 new Query<SystemintroEntity>(params).getPage(),
new EntityWrapper<SystemintroEntity>() // 创建 EntityWrapper 用于封装查询条件 new EntityWrapper<SystemintroEntity>()
); );
// 返回封装好的分页结果
return new PageUtils(page); return new PageUtils(page);
} }
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<SystemintroEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<SystemintroEntity> wrapper) {
// 创建分页对象 Page<SystemintroView> page =new Query<SystemintroView>(params).getPage();
Page<SystemintroView> page = new Query<SystemintroView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }
@Override @Override
public List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper) { public List<SystemintroVO> selectListVO(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 SystemintroVO 列表
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
@Override @Override
public SystemintroVO selectVO(Wrapper<SystemintroEntity> wrapper) { public SystemintroVO selectVO(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 SystemintroVO 对象
return baseMapper.selectVO(wrapper); return baseMapper.selectVO(wrapper);
} }
@Override @Override
public List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper) { public List<SystemintroView> selectListView(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 SystemintroView 列表
return baseMapper.selectListView(wrapper); return baseMapper.selectListView(wrapper);
} }
@Override @Override
public SystemintroView selectView(Wrapper<SystemintroEntity> wrapper) { public SystemintroView selectView(Wrapper<SystemintroEntity> wrapper) {
// 根据 Wrapper 条件查询并返回单个 SystemintroView 对象
return baseMapper.selectView(wrapper); return baseMapper.selectView(wrapper);
} }
} }

19
src/main/java/com/service/impl/UsersServiceImpl.java
Unescape View File

@ -21,33 +21,28 @@ import com.utils.Query;
/** /**
* 系统用户 * 系统用户
*/ */
@Service("usersService") // 将该类标记为服务，并指定 bean 的名称为 "usersService" @Service("usersService")
public class UsersServiceImpl extends ServiceImpl<UsersDao, UsersEntity> implements UsersService { public class UsersServiceImpl extends ServiceImpl<UsersDao, UsersEntity> implements UsersService {
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 根据传入的参数创建分页对象，并调用 selectPage 方法获取用户数据
Page<UsersEntity> page = this.selectPage( Page<UsersEntity> page = this.selectPage(
new Query<UsersEntity>(params).getPage(), // 构造分页信息 new Query<UsersEntity>(params).getPage(),
new EntityWrapper<UsersEntity>() // 创建 EntityWrapper 用于封装查询条件 new EntityWrapper<UsersEntity>()
); );
// 返回封装好的分页结果
return new PageUtils(page); return new PageUtils(page);
} }
@Override @Override
public List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper) { public List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper) {
// 根据 Wrapper 条件查询并返回 UsersEntity 列表
return baseMapper.selectListView(wrapper); return baseMapper.selectListView(wrapper);
} }
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params,
// 创建分页对象 Wrapper<UsersEntity> wrapper) {
Page<UsersEntity> page = new Query<UsersEntity>(params).getPage(); Page<UsersEntity> page =new Query<UsersEntity>(params).getPage();
// 设置分页记录 page.setRecords(baseMapper.selectListView(page,wrapper));
page.setRecords(baseMapper.selectListView(page, wrapper)); // 根据分页信息和条件查询数据
// 返回封装好的分页结果
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }

69
src/main/java/com/service/impl/WenjuandiaochaServiceImpl.java
Unescape View File

@ -11,27 +11,19 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils; import com.utils.PageUtils;
import com.utils.Query; import com.utils.Query;
import com.dao.WenjuandiaochaDao; import com.dao.WenjuandiaochaDao;
import com.entity.WenjuandiaochaEntity; import com.entity.WenjuandiaochaEntity;
import com.service.WenjuandiaochaService; import com.service.WenjuandiaochaService;
import com.entity.vo.WenjuandiaochaVO; import com.entity.vo.WenjuandiaochaVO;
import com.entity.view.Wenjuandiaocha; import com.entity.view.WenjuandiaochaView;
/**
* 问卷调查服务实现类
* 继承自MyBatis-Plus的ServiceImpl，并实现WenjuandiaochaService接口
*/
@Service("wenjuandiaochaService") @Service("wenjuandiaochaService")
public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, WenjuandiaochaEntity> implements WenjuandiaochaService { public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, WenjuandiaochaEntity> implements WenjuandiaochaService {
/**
* 分页查询问卷调查数据
* @param params 查询参数
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params) { public PageUtils queryPage(Map<String, Object> params) {
// 使用MyBatis-Plus的分页插件进行分页查询
Page<WenjuandiaochaEntity> page = this.selectPage( Page<WenjuandiaochaEntity> page = this.selectPage(
new Query<WenjuandiaochaEntity>(params).getPage(), new Query<WenjuandiaochaEntity>(params).getPage(),
new EntityWrapper<WenjuandiaochaEntity>() new EntityWrapper<WenjuandiaochaEntity>()
@ -39,93 +31,50 @@ public class WenjuandiaochaServiceImpl extends ServiceImpl<WenjuandiaochaDao, We
return new PageUtils(page); return new PageUtils(page);
} }
/**
* 分页查询问卷调查数据（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分页结果
*/
@Override @Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
// 创建分页对象 Page<WenjuandiaochaView> page =new Query<WenjuandiaochaView>(params).getPage();
Page<WenjuandiaochaView> page = new Query<WenjuandiaochaView>(params).getPage(); page.setRecords(baseMapper.selectListView(page,wrapper));
// 设置分页记录
page.setRecords(baseMapper.selectListView(page, wrapper));
// 返回分页工具类
PageUtils pageUtil = new PageUtils(page); PageUtils pageUtil = new PageUtils(page);
return pageUtil; return pageUtil;
} }
/**
* 查询问卷调查列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查列表
*/
@Override @Override
public List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper) { public List<WenjuandiaochaVO> selectListVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListVO(wrapper); return baseMapper.selectListVO(wrapper);
} }
/**
* 查询单个问卷调查（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查
*/
@Override @Override
public WenjuandiaochaVO selectVO(Wrapper<WenjuandiaochaEntity> wrapper) { public WenjuandiaochaVO selectVO(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectVO(wrapper); return baseMapper.selectVO(wrapper);
} }
/**
* 查询问卷调查视图列表（带条件）
* @param wrapper 查询条件包装器
* @return 问卷调查视图列表
*/
@Override @Override
public List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper) { public List<WenjuandiaochaView> selectListView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectListView(wrapper); return baseMapper.selectListView(wrapper);
} }
/**
* 查询单个问卷调查视图（带条件）
* @param wrapper 查询条件包装器
* @return 单个问卷调查视图
*/
@Override @Override
public WenjuandiaochaView selectView(Wrapper<WenjuandiaochaEntity> wrapper) { public WenjuandiaochaView selectView(Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectView(wrapper); return baseMapper.selectView(wrapper);
} }
/**
* 查询问卷调查的统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectValue(params, wrapper); return baseMapper.selectValue(params, wrapper);
} }
/**
* 查询问卷调查的时间统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectTimeStatValue(params, wrapper); return baseMapper.selectTimeStatValue(params, wrapper);
} }
/**
* 查询问卷调查的分组统计值（带条件）
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计值列表
*/
@Override @Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) { public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandiaochaEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper); return baseMapper.selectGroup(params, wrapper);
} }
} }

23
src/main/java/com/utils/FileUtil.java
Unescape View File

@ -1,7 +1,7 @@
package com.utils; package com.utils;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.File;// 导入File类 import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
@ -11,26 +11,17 @@ import java.io.InputStream;
*/ */
public class FileUtil { public class FileUtil {
/**
* 将文件转换为字节数组
* @param file
* @return
* @throws IOException 可能抛出输入输出异常
*/
public static byte[] FileToByte(File file) throws IOException { public static byte[] FileToByte(File file) throws IOException {
// 将文件数据转为输入流 // 将数据转为流
@SuppressWarnings("resource") // 这个资源在方法末尾会自动关闭，抑制编译警告 @SuppressWarnings("resource")
InputStream content = new FileInputStream(file); // 创建FileInputStream对象读取文件 InputStream content = new FileInputStream(file);
ByteArrayOutputStream swapStream = new ByteArrayOutputStream(); // 创建字节数组输出流对象 ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
byte[] buff = new byte[100]; byte[] buff = new byte[100];
int rc = 0; int rc = 0;
// 循环读取文件数据，直到文件结束
while ((rc = content.read(buff, 0, 100)) > 0) { while ((rc = content.read(buff, 0, 100)) > 0) {
swapStream.write(buff, 0, rc); // 将读取的数据写入字节数组输出流 swapStream.write(buff, 0, rc);
} }
// 获得二进制数组
return swapStream.toByteArray(); return swapStream.toByteArray();
} }
} }

4
src/main/resources/config.properties
Unescape View File

@ -1,8 +1,8 @@
validationQuery=SELECT 1 validationQuery=SELECT 1
jdbc_url=jdbc:mysql://127.0.0.1:3306/jspm0c59i?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true jdbc_url=jdbc:mysql://127.0.0.1:3306/jspm0c59i?useUnicode=true&characterEncoding=UTF-8&tinyInt1isBit=false
jdbc_username=root jdbc_username=root
jdbc_password=ZST123456 jdbc_password=123456
#jdbc_url=jdbc:sqlserver://127.0.0.1:1433;DatabaseName=jspm0c59i #jdbc_url=jdbc:sqlserver://127.0.0.1:1433;DatabaseName=jspm0c59i
#jdbc_username=sa #jdbc_username=sa

95
src/main/resources/mapper/ChatDao.xml
Unescape View File

@ -3,109 +3,38 @@
<mapper namespace="com.dao.ChatDao"> <mapper namespace="com.dao.ChatDao">
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.ChatEntity的属性
-->
<resultMap type="com.entity.ChatEntity" id="chatMap"> <resultMap type="com.entity.ChatEntity" id="chatMap">
<result property="userid" column="userid"/> <!-- 将数据库列userid映射到ChatEntity的属性userid --> <result property="userid" column="userid"/>
<result property="adminid" column="adminid"/> <!-- 将数据库列adminid映射到ChatEntity的属性adminid --> <result property="adminid" column="adminid"/>
<result property="ask" column="ask"/> <!-- 将数据库列ask映射到ChatEntity的属性ask --> <result property="ask" column="ask"/>
<result property="reply" column="reply"/> <!-- 将数据库列reply映射到ChatEntity的属性reply --> <result property="reply" column="reply"/>
<result property="isreply" column="isreply"/> <!-- 将数据库列isreply映射到ChatEntity的属性isreply --> <result property="isreply" column="isreply"/>
</resultMap> </resultMap>
<!--
分页查询Chat的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.ChatVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.ChatVO"> resultType="com.entity.vo.ChatVO" >
SELECT * FROM chat chat SELECT * FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Chat的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.ChatVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.ChatVO"> resultType="com.entity.vo.ChatVO" >
SELECT chat.* FROM chat chat SELECT chat.* FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Chat的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.ChatView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.ChatView"> resultType="com.entity.view.ChatView" >
SELECT chat.* FROM chat chat SELECT chat.* FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Chat的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.ChatView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.ChatView"> resultType="com.entity.view.ChatView" >
SELECT * FROM chat chat SELECT * FROM chat chat <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select>
<!--
查询Chat的统计值
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
这里假设需要查询每个用户和管理员的聊天总数，具体查询逻辑需要根据实际需求编写
-->
<select id="selectValue"
resultType="map">
SELECT COUNT(*) AS total, userid, adminid
FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
GROUP BY userid, adminid <!-- 按userid和adminid分组，统计每个用户和管理员的聊天总数 -->
</select> </select>
<!--
查询Chat的时间统计值
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
这里假设需要查询某个时间范围内的每日聊天总数，具体查询逻辑需要根据实际需求编写
-->
<select id="selectTimeStatValue"
resultType="map">
SELECT DATE(ask) AS date, COUNT(*) AS count
FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE(ask) <!-- 按ask列的日期分组，统计每日聊天总数 -->
</select>
<!--
查询Chat的分组统计值
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
这里假设需要查询按isreply字段分组的聊天记录数，具体查询逻辑需要根据实际需求编写
-->
<select id="selectGroup"
resultType="map">
SELECT isreply, COUNT(*) AS count
FROM chat chat
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
GROUP BY isreply <!-- 按isreply字段分组，统计每个分组的聊天记录数 -->
</select>
</mapper> </mapper>

164
src/main/resources/mapper/CommonDao.xml
Unescape View File

@ -2,158 +2,70 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.CommonDao"> <mapper namespace="com.dao.CommonDao">
<select id="getOption" resultType="String" >
<!-- SELECT distinct ${column} FROM ${table}
查询表中的唯一选项值 where ${column} is not null and ${column} !=''
@param column 需要查询的列名 <if test = "conditionColumn != null and conditionValue != null">
@param table 需要查询的表名 and ${conditionColumn}=#{conditionValue}
@param conditionColumn 附加条件的列名（可选）
@param conditionValue 附加条件的列值（可选）
@param level 级别条件（可选）
@param parent 父级条件（可选）
@return 唯一的选项值列表
-->
<select id="getOption" resultType="String">
SELECT DISTINCT ${column} FROM ${table}
WHERE ${column} IS NOT NULL AND ${column} != ''
<!-- 如果条件列和条件值不为空，则添加相应的条件 -->
<if test="conditionColumn != null and conditionValue != null">
AND ${conditionColumn} = #{conditionValue}
</if> </if>
<!-- 如果级别条件不为空，则添加相应的条件 --> <if test = "level != null">
<if test="level != null"> and level=#{level}
AND level = #{level}
</if> </if>
<!-- 如果父级条件不为空，则添加相应的条件 --> <if test = "parent != null">
<if test="parent != null"> and parent=#{parent}
AND parent = #{parent}
</if> </if>
</select> </select>
<!-- <select id="getFollowByOption" resultType="map" >
根据选项值查询表中的记录 SELECT * FROM ${table} where ${column}=#{columnValue}
@param column 需要查询的列名
@param columnValue 列的值
@param table 需要查询的表名
@return 符合条件的记录列表
-->
<select id="getFollowByOption" resultType="map">
SELECT * FROM ${table}
WHERE ${column} = #{columnValue}
</select> </select>
<!--
更新表中记录的审核状态
@param table 需要更新的表名
@param sfsh 审核状态
@param id 记录的id
-->
<update id="sh"> <update id="sh">
UPDATE ${table} UPDATE ${table} set sfsh=#{sfsh} where id=#{id}
SET sfsh = #{sfsh}
WHERE id = #{id}
</update> </update>
<!-- <select id="remindCount" resultType="int" >
查询表中需要提醒的记录数 SELECT count(1) FROM ${table}
@param table 需要查询的表名 where 1=1
@param column 需要查询的列名 <if test = "type == 1 ">
@param type 提醒类型（1或2） <if test = " remindstart != null ">
@param remindstart 提醒开始时间 and ${column} &gt;= #{remindstart}
@param remindend 提醒结束时间
@return 符合条件的记录数
-->
<select id="remindCount" resultType="int">
SELECT COUNT(1) FROM ${table}
WHERE 1=1
<!-- 如果类型为1，则根据数值范围进行过滤 -->
<if test="type == 1">
<if test="remindstart != null">
AND ${column} >= #{remindstart}
</if> </if>
<if test="remindend != null"> <if test = " remindend != null ">
AND ${column} <= #{remindend} and ${column} &lt;= #{remindend}
</if> </if>
</if> </if>
<!-- 如果类型为2，则根据日期范围进行过滤 --> <if test = "type == 2 ">
<if test="type == 2"> <if test = " remindstart != null ">
<if test="remindstart != null"> and ${column} &gt;= str_to_date(#{remindstart},'%Y-%m-%d')
AND ${column} >= STR_TO_DATE(#{remindstart}, '%Y-%m-%d')
</if> </if>
<if test="remindend != null"> <if test = " remindend != null ">
AND ${column} <= STR_TO_DATE(#{remindend}, '%Y-%m-%d') and ${column} &lt;= str_to_date(#{remindend},'%Y-%m-%d')
</if> </if>
</if> </if>
</select> </select>
<!-- <select id="selectCal" resultType="map" >
查询表中某一列的统计信息（总和、最大值、最小值、平均值） SELECT sum(${column}) sum,max(${column}) max,min(${column}) min,avg(${column}) avg FROM ${table}
@param column 需要查询的列名
@param table 需要查询的表名
@return 包含统计信息的map
-->
<select id="selectCal" resultType="map">
SELECT SUM(${column}) AS sum,
MAX(${column}) AS max,
MIN(${column}) AS min,
AVG(${column}) AS avg
FROM ${table}
</select> </select>
<!-- <select id="selectGroup" resultType="map" >
按某一列分组查询记录总数 SELECT ${column} , count(1) total FROM ${table} group by ${column}
@param column 需要分组的列名
@param table 需要查询的表名
@return 包含分组信息和记录总数的map列表
-->
<select id="selectGroup" resultType="map">
SELECT ${column},
COUNT(1) AS total
FROM ${table}
GROUP BY ${column}
</select> </select>
<!-- <select id="selectValue" resultType="map" >
按某一列分组查询另一列的总和 SELECT ${xColumn}, sum(${yColumn}) total FROM ${table} group by ${xColumn}
@param xColumn 需要分组的列名
@param yColumn 需要求和的列名
@param table 需要查询的表名
@return 包含分组信息和总和的map列表
-->
<select id="selectValue" resultType="map">
SELECT ${xColumn},
SUM(${yColumn}) AS total
FROM ${table}
GROUP BY ${xColumn}
</select> </select>
<!-- <select id="selectTimeStatValue" resultType="map" >
按时间统计查询某一列的总和 <if test = 'timeStatType == "日"'>
@param timeStatType 时间统计类型（日、月、年） SELECT DATE_FORMAT(${xColumn},'%Y-%m-%d') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m-%d')
@param xColumn 需要格式化的时间列名
@param yColumn 需要求和的列名
@param table 需要查询的表名
@return 包含格式化时间信息和总和的map列表
-->
<select id="selectTimeStatValue" resultType="map">
<!-- 根据时间统计类型进行不同的日期格式化处理 -->
<if test='timeStatType == "日"'>
SELECT DATE_FORMAT(${xColumn}, '%Y-%m-%d') AS ${xColumn},
SUM(${yColumn}) AS total
FROM ${table}
GROUP BY DATE_FORMAT(${xColumn}, '%Y-%m-%d')
</if> </if>
<if test='timeStatType == "月"'> <if test = 'timeStatType == "月"'>
SELECT DATE_FORMAT(${xColumn}, '%Y-%m') AS ${xColumn}, SELECT DATE_FORMAT(${xColumn},'%Y-%m') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m')
SUM(${yColumn}) AS total
FROM ${table}
GROUP BY DATE_FORMAT(${xColumn}, '%Y-%m')
</if> </if>
<if test='timeStatType == "年"'> <if test = 'timeStatType == "年"'>
SELECT DATE_FORMAT(${xColumn}, '%Y') AS ${xColumn}, SELECT DATE_FORMAT(${xColumn},'%Y') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y')
SUM(${yColumn}) AS total
FROM ${table}
GROUP BY DATE_FORMAT(${xColumn}, '%Y')
</if> </if>
</select> </select>
</mapper> </mapper>

3
src/main/resources/mapper/ConfigDao.xml
Unescape View File

@ -1,8 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.ConfigDao"> <mapper namespace="com.dao.ConfigDao">
<!-- 定义Mapper的命名空间，对应于ConfigDao接口 -->
</mapper> </mapper>

59
src/main/resources/mapper/ForumDao.xml
Unescape View File

@ -1,71 +1,42 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.ForumDao"> <mapper namespace="com.dao.ForumDao">
<!-- 定义Mapper的命名空间，对应于ForumDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.ForumEntity的属性
-->
<resultMap type="com.entity.ForumEntity" id="forumMap"> <resultMap type="com.entity.ForumEntity" id="forumMap">
<result property="title" column="title"/> <!-- 将数据库列title映射到ForumEntity的属性title --> <result property="title" column="title"/>
<result property="content" column="content"/> <!-- 将数据库列content映射到ForumEntity的属性content --> <result property="content" column="content"/>
<result property="parentid" column="parentid"/> <!-- 将数据库列parentid映射到ForumEntity的属性parentid --> <result property="parentid" column="parentid"/>
<result property="userid" column="userid"/> <!-- 将数据库列userid映射到ForumEntity的属性userid --> <result property="userid" column="userid"/>
<result property="username" column="username"/> <!-- 将数据库列username映射到ForumEntity的属性username --> <result property="username" column="username"/>
<result property="avatarurl" column="avatarurl"/> <!-- 将数据库列avatarurl映射到ForumEntity的属性avatarurl --> <result property="avatarurl" column="avatarurl"/>
<result property="isdone" column="isdone"/> <!-- 将数据库列isdone映射到ForumEntity的属性isdone --> <result property="isdone" column="isdone"/>
</resultMap> </resultMap>
<!--
分页查询Forum的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.ForumVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.ForumVO"> resultType="com.entity.vo.ForumVO" >
SELECT * FROM forum forum SELECT * FROM forum forum
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Forum的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.ForumVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.ForumVO"> resultType="com.entity.vo.ForumVO" >
SELECT forum.* FROM forum forum SELECT forum.* FROM forum forum
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Forum的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.ForumView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.ForumView"> resultType="com.entity.view.ForumView" >
SELECT forum.* FROM forum forum SELECT forum.* FROM forum forum
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Forum的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.ForumView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.ForumView"> resultType="com.entity.view.ForumView" >
SELECT * FROM forum forum SELECT * FROM forum forum <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
</mapper> </mapper>

90
src/main/resources/mapper/LeixingDao.xml
Unescape View File

@ -1,108 +1,36 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.LeixingDao"> <mapper namespace="com.dao.LeixingDao">
<!-- 定义Mapper的命名空间，对应于LeixingDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.LeixingEntity的属性
-->
<resultMap type="com.entity.LeixingEntity" id="leixingMap"> <resultMap type="com.entity.LeixingEntity" id="leixingMap">
<result property="leixing" column="leixing"/> <!-- 将数据库列leixing映射到LeixingEntity的属性leixing --> <result property="leixing" column="leixing"/>
</resultMap> </resultMap>
<!--
分页查询Leixing的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.LeixingVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.LeixingVO"> resultType="com.entity.vo.LeixingVO" >
SELECT * FROM leixing leixing SELECT * FROM leixing leixing
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Leixing的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.LeixingVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.LeixingVO"> resultType="com.entity.vo.LeixingVO" >
SELECT leixing.* FROM leixing leixing SELECT leixing.* FROM leixing leixing
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
当然，我会在你的代码中添加详细的注释，以确保每个部分的功能和参数都能被详细理解。以下是添加了注释的代码：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.LeixingDao">
<!-- 定义Mapper的命名空间，对应于LeixingDao接口 -->
<!--
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.LeixingEntity的属性
-->
<resultMap type="com.entity.LeixingEntity" id="leixingMap">
<result property="leixing" column="leixing"/> <!-- 将数据库列leixing映射到LeixingEntity的属性leixing -->
</resultMap>
<!--
分页查询Leixing的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.LeixingVO
-->
<select id="selectListVO"
resultType="com.entity.vo.LeixingVO">
SELECT * FROM leixing leixing
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Leixing的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.LeixingVO
-->
<select id="selectVO"
resultType="com.entity.vo.LeixingVO">
SELECT leixing.* FROM leixing leixing
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select>
<!--
分页查询Leixing的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.LeixingView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.LeixingView"> resultType="com.entity.view.LeixingView" >
SELECT leixing.* FROM leixing leixing SELECT leixing.* FROM leixing leixing
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Leixing的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.LeixingView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.LeixingView"> resultType="com.entity.view.LeixingView" >
SELECT * FROM leixing leixing SELECT * FROM leixing leixing <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
</mapper> </mapper>

53
src/main/resources/mapper/NewsDao.xml
Unescape View File

@ -1,68 +1,39 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.NewsDao"> <mapper namespace="com.dao.NewsDao">
<!-- 定义Mapper的命名空间，对应于NewsDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.NewsEntity的属性
-->
<resultMap type="com.entity.NewsEntity" id="newsMap"> <resultMap type="com.entity.NewsEntity" id="newsMap">
<result property="title" column="title"/> <!-- 将数据库列title映射到NewsEntity的属性title --> <result property="title" column="title"/>
<result property="introduction" column="introduction"/> <!-- 将数据库列introduction映射到NewsEntity的属性introduction --> <result property="introduction" column="introduction"/>
<result property="picture" column="picture"/> <!-- 将数据库列picture映射到NewsEntity的属性picture --> <result property="picture" column="picture"/>
<result property="content" column="content"/> <!-- 将数据库列content映射到NewsEntity的属性content --> <result property="content" column="content"/>
</resultMap> </resultMap>
<!--
分页查询News的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.NewsVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.NewsVO"> resultType="com.entity.vo.NewsVO" >
SELECT * FROM news news SELECT * FROM news news
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个News的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.NewsVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.NewsVO"> resultType="com.entity.vo.NewsVO" >
SELECT news.* FROM news news SELECT news.* FROM news news
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询News的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.NewsView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.NewsView"> resultType="com.entity.view.NewsView" >
SELECT news.* FROM news news SELECT news.* FROM news news
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个News的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.NewsView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.NewsView"> resultType="com.entity.view.NewsView" >
SELECT * FROM news news SELECT * FROM news news <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
</mapper> </mapper>

61
src/main/resources/mapper/StoreupDao.xml
Unescape View File

@ -1,72 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.StoreupDao"> <mapper namespace="com.dao.StoreupDao">
<!-- 定义Mapper的命名空间，对应于StoreupDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.StoreupEntity的属性
-->
<resultMap type="com.entity.StoreupEntity" id="storeupMap"> <resultMap type="com.entity.StoreupEntity" id="storeupMap">
<result property="userid" column="userid"/> <!-- 将数据库列userid映射到StoreupEntity的属性userid --> <result property="userid" column="userid"/>
<result property="refid" column="refid"/> <!-- 将数据库列refid映射到StoreupEntity的属性refid --> <result property="refid" column="refid"/>
<result property="tablename" column="tablename"/> <!-- 将数据库列tablename映射到StoreupEntity的属性tablename --> <result property="tablename" column="tablename"/>
<result property="name" column="name"/> <!-- 将数据库列name映射到StoreupEntity的属性name --> <result property="name" column="name"/>
<result property="picture" column="picture"/> <!-- 将数据库列picture映射到StoreupEntity的属性picture --> <result property="picture" column="picture"/>
<result property="type" column="type"/> <!-- 将数据库列type映射到StoreupEntity的属性type --> <result property="type" column="type"/>
<result property="inteltype" column="inteltype"/> <!-- 将数据库列inteltype映射到StoreupEntity的属性inteltype --> <result property="inteltype" column="inteltype"/>
<result property="remark" column="remark"/> <!-- 将数据库列remark映射到StoreupEntity的属性remark --> <result property="remark" column="remark"/>
</resultMap> </resultMap>
<!--
分页查询Storeup的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.StoreupVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.StoreupVO"> resultType="com.entity.vo.StoreupVO" >
SELECT * FROM storeup storeup SELECT * FROM storeup storeup
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Storeup的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.StoreupVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.StoreupVO"> resultType="com.entity.vo.StoreupVO" >
SELECT storeup.* FROM storeup storeup SELECT storeup.* FROM storeup storeup
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Storeup的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.StoreupView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.StoreupView"> resultType="com.entity.view.StoreupView" >
SELECT storeup.* FROM storeup storeup SELECT storeup.* FROM storeup storeup
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Storeup的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.StoreupView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.StoreupView"> resultType="com.entity.view.StoreupView" >
SELECT * FROM storeup storeup SELECT * FROM storeup storeup <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
</mapper> </mapper>

57
src/main/resources/mapper/SystemintroDao.xml
Unescape View File

@ -1,70 +1,41 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.SystemintroDao"> <mapper namespace="com.dao.SystemintroDao">
<!-- 定义Mapper的命名空间，对应于SystemintroDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.SystemintroEntity的属性
-->
<resultMap type="com.entity.SystemintroEntity" id="systemintroMap"> <resultMap type="com.entity.SystemintroEntity" id="systemintroMap">
<result property="title" column="title"/> <!-- 将数据库列title映射到SystemintroEntity的属性title --> <result property="title" column="title"/>
<result property="subtitle" column="subtitle"/> <!-- 将数据库列subtitle映射到SystemintroEntity的属性subtitle --> <result property="subtitle" column="subtitle"/>
<result property="content" column="content"/> <!-- 将数据库列content映射到SystemintroEntity的属性content --> <result property="content" column="content"/>
<result property="picture1" column="picture1"/> <!-- 将数据库列picture1映射到SystemintroEntity的属性picture1 --> <result property="picture1" column="picture1"/>
<result property="picture2" column="picture2"/> <!-- 将数据库列picture2映射到SystemintroEntity的属性picture2 --> <result property="picture2" column="picture2"/>
<result property="picture3" column="picture3"/> <!-- 将数据库列picture3映射到SystemintroEntity的属性picture3 --> <result property="picture3" column="picture3"/>
</resultMap> </resultMap>
<!--
分页查询Systemintro的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.SystemintroVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.SystemintroVO"> resultType="com.entity.vo.SystemintroVO" >
SELECT * FROM systemintro systemintro SELECT * FROM systemintro systemintro
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Systemintro的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.SystemintroVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.SystemintroVO"> resultType="com.entity.vo.SystemintroVO" >
SELECT systemintro.* FROM systemintro systemintro SELECT systemintro.* FROM systemintro systemintro
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Systemintro的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.SystemintroView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.SystemintroView"> resultType="com.entity.view.SystemintroView" >
SELECT systemintro.* FROM systemintro systemintro SELECT systemintro.* FROM systemintro systemintro
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Systemintro的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.SystemintroView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.SystemintroView"> resultType="com.entity.view.SystemintroView" >
SELECT * FROM systemintro systemintro SELECT * FROM systemintro systemintro <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
</mapper> </mapper>

10
src/main/resources/mapper/TokenDao.xml
Unescape View File

@ -1,20 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.TokenDao"> <mapper namespace="com.dao.TokenDao">
<!-- 定义Mapper的命名空间，对应于TokenDao接口 -->
<!--
分页查询Token的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.TokenEntity
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.TokenEntity" > resultType="com.entity.TokenEntity" >
SELECT t.* FROM token t SELECT t.* FROM token t
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>

10
src/main/resources/mapper/UsersDao.xml
Unescape View File

@ -1,20 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.UsersDao"> <mapper namespace="com.dao.UsersDao">
<!-- 定义Mapper的命名空间，对应于UsersDao接口 -->
<!--
分页查询Users的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.UsersEntity
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.UsersEntity" > resultType="com.entity.UsersEntity" >
SELECT u.* FROM users u SELECT u.* FROM users u
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>

140
src/main/resources/mapper/WenjuandafuDao.xml
Unescape View File

@ -1,138 +1,84 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.WenjuandafuDao"> <mapper namespace="com.dao.WenjuandafuDao">
<!-- 定义Mapper的命名空间，对应于WenjuandafuDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.WenjuandafuEntity的属性
-->
<resultMap type="com.entity.WenjuandafuEntity" id="wenjuandafuMap"> <resultMap type="com.entity.WenjuandafuEntity" id="wenjuandafuMap">
<result property="wenjuanbiaoti" column="wenjuanbiaoti"/> <!-- 将数据库列wenjuanbiaoti映射到WenjuandafuEntity的属性wenjuanbiaoti --> <result property="wenjuanbiaoti" column="wenjuanbiaoti"/>
<result property="leixing" column="leixing"/> <!-- 将数据库列leixing映射到WenjuandafuEntity的属性leixing --> <result property="leixing" column="leixing"/>
<result property="wentiyi" column="wentiyi"/> <!-- 将数据库列wentiyi映射到WenjuandafuEntity的属性wentiyi --> <result property="wentiyi" column="wentiyi"/>
<result property="dafuyi" column="dafuyi"/> <!-- 将数据库列dafuyi映射到WenjuandafuEntity的属性dafuyi --> <result property="dafuyi" column="dafuyi"/>
<result property="wentier" column="wentier"/> <!-- 将数据库列wentier映射到WenjuandafuEntity的属性wentier --> <result property="wentier" column="wentier"/>
<result property="dafuer" column="dafuer"/> <!-- 将数据库列dafuer映射到WenjuandafuEntity的属性dafuer --> <result property="dafuer" column="dafuer"/>
<result property="wentisan" column="wentisan"/> <!-- 将数据库列wentisan映射到WenjuandafuEntity的属性wentisan --> <result property="wentisan" column="wentisan"/>
<result property="dafusan" column="dafusan"/> <!-- 将数据库列dafusan映射到WenjuandafuEntity的属性dafusan --> <result property="dafusan" column="dafusan"/>
<result property="wentisi" column="wentisi"/> <!-- 将数据库列wentisi映射到WenjuandafuEntity的属性wentisi --> <result property="wentisi" column="wentisi"/>
<result property="dafusi" column="dafusi"/> <!-- 将数据库列dafusi映射到WenjuandafuEntity的属性dafusi --> <result property="dafusi" column="dafusi"/>
<result property="wentiwu" column="wentiwu"/> <!-- 将数据库列wentiwu映射到WenjuandafuEntity的属性wentiwu --> <result property="wentiwu" column="wentiwu"/>
<result property="dafuwu" column="dafuwu"/> <!-- 将数据库列dafuwu映射到WenjuandafuEntity的属性dafuwu --> <result property="dafuwu" column="dafuwu"/>
<result property="zhanghao" column="zhanghao"/> <!-- 将数据库列zhanghao映射到WenjuandafuEntity的属性zhanghao --> <result property="zhanghao" column="zhanghao"/>
<result property="xingming" column="xingming"/> <!-- 将数据库列xingming映射到WenjuandafuEntity的属性xingming --> <result property="xingming" column="xingming"/>
<result property="tijiaoriqi" column="tijiaoriqi"/> <!-- 将数据库列tijiaoriqi映射到WenjuandafuEntity的属性tijiaoriqi --> <result property="tijiaoriqi" column="tijiaoriqi"/>
</resultMap> </resultMap>
<!--
分页查询Wenjuandafu的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.WenjuandafuVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.WenjuandafuVO"> resultType="com.entity.vo.WenjuandafuVO" >
SELECT * FROM wenjuandafu wenjuandafu SELECT * FROM wenjuandafu wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Wenjuandafu的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.WenjuandafuVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.WenjuandafuVO"> resultType="com.entity.vo.WenjuandafuVO" >
SELECT wenjuandafu.* FROM wenjuandafu wenjuandafu SELECT wenjuandafu.* FROM wenjuandafu wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Wenjuandafu的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.WenjuandafuView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.WenjuandafuView"> resultType="com.entity.view.WenjuandafuView" >
SELECT wenjuandafu.* FROM wenjuandafu wenjuandafu SELECT wenjuandafu.* FROM wenjuandafu wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Wenjuandafu的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.WenjuandafuView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.WenjuandafuView"> resultType="com.entity.view.WenjuandafuView" >
SELECT * FROM wenjuandafu wenjuandafu SELECT * FROM wenjuandafu wenjuandafu <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询Wenjuandafu的统计值 <select id="selectValue" resultType="map" >
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandafu
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括xColumn和yColumn
@return 包含统计值的map列表
-->
<select id="selectValue" resultType="map">
SELECT ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.xColumn} <!-- 按xColumn分组，统计每个组的yColumn总和 --> group by ${params.xColumn}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
<!-- <select id="selectTimeStatValue" resultType="map" >
查询Wenjuandafu的时间统计值 <if test = 'params.timeStatType == "日"'>
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT DATE_FORMAT(${params.xColumn},'%Y-%m-%d') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandafu
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括timeStatType、xColumn和yColumn
@return 包含时间统计值的map列表
-->
<select id="selectTimeStatValue" resultType="map">
<!-- 根据时间统计类型进行不同的日期格式化处理 -->
<if test='params.timeStatType == "日"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') <!-- 按日分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m-%d')
</if> </if>
<if test='params.timeStatType == "月"'> <if test = 'params.timeStatType == "月"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandafu SELECT DATE_FORMAT(${params.xColumn},'%Y-%m') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m') <!-- 按月分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m')
</if> </if>
<if test='params.timeStatType == "年"'> <if test = 'params.timeStatType == "年"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandafu SELECT DATE_FORMAT(${params.xColumn},'%Y') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y') <!-- 按年分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y')
</if> </if>
</select> </select>
<!-- <select id="selectGroup" resultType="map" >
查询Wenjuandafu的分组统计值 SELECT ${params.column} , count(1) total FROM wenjuandafu
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括column
@return 包含分组统计值的map列表
-->
<select id="selectGroup" resultType="map">
SELECT ${params.column}, count(1) AS total FROM wenjuandafu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.column} <!-- 按column分组，统计每个组的记录数 --> group by ${params.column}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
</mapper> </mapper>

130
src/main/resources/mapper/WenjuandiaochaDao.xml
Unescape View File

@ -1,133 +1,79 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.WenjuandiaochaDao"> <mapper namespace="com.dao.WenjuandiaochaDao">
<!-- 定义Mapper的命名空间，对应于WenjuandiaochaDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.WenjuandiaochaEntity的属性
-->
<resultMap type="com.entity.WenjuandiaochaEntity" id="wenjuandiaochaMap"> <resultMap type="com.entity.WenjuandiaochaEntity" id="wenjuandiaochaMap">
<result property="wenjuanbiaoti" column="wenjuanbiaoti"/> <!-- 将数据库列wenjuanbiaoti映射到WenjuandiaochaEntity的属性wenjuanbiaoti --> <result property="wenjuanbiaoti" column="wenjuanbiaoti"/>
<result property="fengmiantupian" column="fengmiantupian"/> <!-- 将数据库列fengmiantupian映射到WenjuandiaochaEntity的属性fengmiantupian --> <result property="fengmiantupian" column="fengmiantupian"/>
<result property="leixing" column="leixing"/> <!-- 将数据库列leixing映射到WenjuandiaochaEntity的属性leixing --> <result property="leixing" column="leixing"/>
<result property="wentiyi" column="wentiyi"/> <!-- 将数据库列wentiyi映射到WenjuandiaochaEntity的属性wentiyi --> <result property="wentiyi" column="wentiyi"/>
<result property="wentier" column="wentier"/> <!-- 将数据库列wentier映射到WenjuandiaochaEntity的属性wentier --> <result property="wentier" column="wentier"/>
<result property="wentisan" column="wentisan"/> <!-- 将数据库列wentisan映射到WenjuandiaochaEntity的属性wentisan --> <result property="wentisan" column="wentisan"/>
<result property="wentisi" column="wentisi"/> <!-- 将数据库列wentisi映射到WenjuandiaochaEntity的属性wentisi --> <result property="wentisi" column="wentisi"/>
<result property="wentiwu" column="wentiwu"/> <!-- 将数据库列wentiwu映射到WenjuandiaochaEntity的属性wentiwu --> <result property="wentiwu" column="wentiwu"/>
<result property="faburiqi" column="faburiqi"/> <!-- 将数据库列faburiqi映射到WenjuandiaochaEntity的属性faburiqi --> <result property="faburiqi" column="faburiqi"/>
<result property="clicktime" column="clicktime"/> <!-- 将数据库列clicktime映射到WenjuandiaochaEntity的属性clicktime --> <result property="clicktime" column="clicktime"/>
</resultMap> </resultMap>
<!--
分页查询Wenjuandiaocha的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.WenjuandiaochaVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.WenjuandiaochaVO"> resultType="com.entity.vo.WenjuandiaochaVO" >
SELECT * FROM wenjuandiaocha wenjuandiaocha SELECT * FROM wenjuandiaocha wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Wenjuandiaocha的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.WenjuandiaochaVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.WenjuandiaochaVO"> resultType="com.entity.vo.WenjuandiaochaVO" >
SELECT wenjuandiaocha.* FROM wenjuandiaocha wenjuandiaocha SELECT wenjuandiaocha.* FROM wenjuandiaocha wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Wenjuandiaocha的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.WenjuandiaochaView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.WenjuandiaochaView"> resultType="com.entity.view.WenjuandiaochaView" >
SELECT wenjuandiaocha.* FROM wenjuandiaocha wenjuandiaocha SELECT wenjuandiaocha.* FROM wenjuandiaocha wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Wenjuandiaocha的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.WenjuandiaochaView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.WenjuandiaochaView"> resultType="com.entity.view.WenjuandiaochaView" >
SELECT * FROM wenjuandiaocha wenjuandiaocha SELECT * FROM wenjuandiaocha wenjuandiaocha <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询Wenjuandiaocha的统计值 <select id="selectValue" resultType="map" >
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandiaocha
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括xColumn和yColumn
@return 包含统计值的map列表
-->
<select id="selectValue" resultType="map">
SELECT ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.xColumn} <!-- 按xColumn分组，统计每个组的yColumn总和 --> group by ${params.xColumn}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
<!-- <select id="selectTimeStatValue" resultType="map" >
查询Wenjuandiaocha的时间统计值 <if test = 'params.timeStatType == "日"'>
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT DATE_FORMAT(${params.xColumn},'%Y-%m-%d') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandiaocha
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括timeStatType、xColumn和yColumn
@return 包含时间统计值的map列表
-->
<select id="selectTimeStatValue" resultType="map">
<!-- 根据时间统计类型进行不同的日期格式化处理 -->
<if test='params.timeStatType == "日"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') <!-- 按日分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m-%d')
</if> </if>
<if test='params.timeStatType == "月"'> <if test = 'params.timeStatType == "月"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandiaocha SELECT DATE_FORMAT(${params.xColumn},'%Y-%m') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m') <!-- 按月分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m')
</if> </if>
<if test='params.timeStatType == "年"'> <if test = 'params.timeStatType == "年"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM wenjuandiaocha SELECT DATE_FORMAT(${params.xColumn},'%Y') ${params.xColumn}, sum(${params.yColumn}) total FROM wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y') <!-- 按年分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y')
</if> </if>
</select> </select>
<!-- <select id="selectGroup" resultType="map" >
查询Wenjuandiaocha的分组统计值 SELECT ${params.column} , count(1) total FROM wenjuandiaocha
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括column
@return 包含分组统计值的map列表
-->
<select id="selectGroup" resultType="map">
SELECT ${params.column}, count(1) AS total FROM wenjuandiaocha
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.column} <!-- 按column分组，统计每个组的记录数 --> group by ${params.column}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
</mapper> </mapper>

124
src/main/resources/mapper/YonghuDao.xml
Unescape View File

@ -1,130 +1,76 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!-- 指定XML文档的版本和编码 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 声明这是一个MyBatis的Mapper文件，并引用MyBatis 3.0的DTD文件 -->
<mapper namespace="com.dao.YonghuDao"> <mapper namespace="com.dao.YonghuDao">
<!-- 定义Mapper的命名空间，对应于YonghuDao接口 -->
<!-- <!-- 可根据自己的需求，是否要使用 -->
可根据自己的需求，是否要使用
定义一个resultMap，将数据库列映射到com.entity.YonghuEntity的属性
-->
<resultMap type="com.entity.YonghuEntity" id="yonghuMap"> <resultMap type="com.entity.YonghuEntity" id="yonghuMap">
<result property="zhanghao" column="zhanghao"/> <!-- 将数据库列zhanghao映射到YonghuEntity的属性zhanghao --> <result property="zhanghao" column="zhanghao"/>
<result property="mima" column="mima"/> <!-- 将数据库列mima映射到YonghuEntity的属性mima --> <result property="mima" column="mima"/>
<result property="xingming" column="xingming"/> <!-- 将数据库列xingming映射到YonghuEntity的属性xingming --> <result property="xingming" column="xingming"/>
<result property="xingbie" column="xingbie"/> <!-- 将数据库列xingbie映射到YonghuEntity的属性xingbie --> <result property="xingbie" column="xingbie"/>
<result property="youxiang" column="youxiang"/> <!-- 将数据库列youxiang映射到YonghuEntity的属性youxiang --> <result property="youxiang" column="youxiang"/>
<result property="shoujihaoma" column="shoujihaoma"/> <!-- 将数据库列shoujihaoma映射到YonghuEntity的属性shoujihaoma --> <result property="shoujihaoma" column="shoujihaoma"/>
<result property="touxiang" column="touxiang"/> <!-- 将数据库列touxiang映射到YonghuEntity的属性touxiang --> <result property="touxiang" column="touxiang"/>
</resultMap> </resultMap>
<!--
分页查询Yonghu的VO列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.YonghuVO
-->
<select id="selectListVO" <select id="selectListVO"
resultType="com.entity.vo.YonghuVO"> resultType="com.entity.vo.YonghuVO" >
SELECT * FROM yonghu yonghu SELECT * FROM yonghu yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Yonghu的VO记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.vo.YonghuVO
-->
<select id="selectVO" <select id="selectVO"
resultType="com.entity.vo.YonghuVO"> resultType="com.entity.vo.YonghuVO" >
SELECT yonghu.* FROM yonghu yonghu SELECT yonghu.* FROM yonghu yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
分页查询Yonghu的视图列表
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.YonghuView
-->
<select id="selectListView" <select id="selectListView"
resultType="com.entity.view.YonghuView"> resultType="com.entity.view.YonghuView" >
SELECT yonghu.* FROM yonghu yonghu SELECT yonghu.* FROM yonghu yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询单个Yonghu的视图记录
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为com.entity.view.YonghuView
-->
<select id="selectView" <select id="selectView"
resultType="com.entity.view.YonghuView"> resultType="com.entity.view.YonghuView" >
SELECT * FROM yonghu yonghu SELECT * FROM yonghu yonghu <where> 1=1 ${ew.sqlSegment}</where>
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where>
</select> </select>
<!--
查询Yonghu的统计值 <select id="selectValue" resultType="map" >
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT ${params.xColumn}, sum(${params.yColumn}) total FROM yonghu
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括xColumn和yColumn
@return 包含统计值的map列表
-->
<select id="selectValue" resultType="map">
SELECT ${params.xColumn}, sum(${params.yColumn}) AS total FROM yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.xColumn} <!-- 按xColumn分组，统计每个组的yColumn总和 --> group by ${params.xColumn}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
<!-- <select id="selectTimeStatValue" resultType="map" >
查询Yonghu的时间统计值 <if test = 'params.timeStatType == "日"'>
使用${ew.sqlSegment}来动态拼接SQL条件 SELECT DATE_FORMAT(${params.xColumn},'%Y-%m-%d') ${params.xColumn}, sum(${params.yColumn}) total FROM yonghu
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括timeStatType、xColumn和yColumn
@return 包含时间统计值的map列表
-->
<select id="selectTimeStatValue" resultType="map">
<!-- 根据时间统计类型进行不同的日期格式化处理 -->
<if test='params.timeStatType == "日"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m-%d') <!-- 按日分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m-%d')
</if> </if>
<if test='params.timeStatType == "月"'> <if test = 'params.timeStatType == "月"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y-%m') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM yonghu SELECT DATE_FORMAT(${params.xColumn},'%Y-%m') ${params.xColumn}, sum(${params.yColumn}) total FROM yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y-%m') <!-- 按月分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y-%m')
</if> </if>
<if test='params.timeStatType == "年"'> <if test = 'params.timeStatType == "年"'>
SELECT DATE_FORMAT(${params.xColumn}, '%Y') AS ${params.xColumn}, sum(${params.yColumn}) AS total FROM yonghu SELECT DATE_FORMAT(${params.xColumn},'%Y') ${params.xColumn}, sum(${params.yColumn}) total FROM yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY DATE_FORMAT(${params.xColumn}, '%Y') <!-- 按年分组，统计每个组的yColumn总和 --> group by DATE_FORMAT(${params.xColumn},'%Y')
</if> </if>
</select> </select>
<!-- <select id="selectGroup" resultType="map" >
查询Yonghu的分组统计值 SELECT ${params.column} , count(1) total FROM yonghu
使用${ew.sqlSegment}来动态拼接SQL条件
resultType指定返回的结果类型为map
@param params 包含查询参数的map，包括column
@return 包含分组统计值的map列表
-->
<select id="selectGroup" resultType="map">
SELECT ${params.column}, count(1) AS total FROM yonghu
<!-- 动态SQL条件，1=1是为了方便添加WHERE子句中的其他条件 -->
<where> 1=1 ${ew.sqlSegment}</where> <where> 1=1 ${ew.sqlSegment}</where>
GROUP BY ${params.column} <!-- 按column分组，统计每个组的记录数 --> group by ${params.column}
LIMIT 10 <!-- 限制结果集最多返回10条记录 --> limit 10
</select> </select>
</mapper> </mapper>

2
src/main/webapp/front/index.jsp
Unescape View File

@ -7,7 +7,7 @@
<head> <head>
<meta charset="utf-8"> <meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"> <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<title>问卷调查系统</title> <title>基于j2ee的问卷调查系统</title>
<link rel="stylesheet" href="./layui/css/layui.css"> <link rel="stylesheet" href="./layui/css/layui.css">
<!-- 主题（主要颜色设置） --> <!-- 主题（主要颜色设置） -->
<link rel="stylesheet" href="./css/theme.css" /> <link rel="stylesheet" href="./css/theme.css" />

2
src/main/webapp/front/js/config.js
Unescape View File

@ -1,5 +1,5 @@
var projectName = '问卷调查系统'; var projectName = '基于j2ee的问卷调查系统';
/** /**
* 轮播图配置 * 轮播图配置
*/ */

2
src/main/webapp/front/pages/login/login.jsp
Unescape View File

@ -60,7 +60,7 @@
<div id="login" class="login" :style='{"minHeight":"100vh","width":"100%","alignItems":"flex-start","background":"url(http://codegen.caihongy.cn/20230207/860aeea5c04f45119e98c796e63dee11.jpg) no-repeat right bottom / 100% auto,#fff","justifyContent":"flex-end","display":"flex"}'> <div id="login" class="login" :style='{"minHeight":"100vh","width":"100%","alignItems":"flex-start","background":"url(http://codegen.caihongy.cn/20230207/860aeea5c04f45119e98c796e63dee11.jpg) no-repeat right bottom / 100% auto,#fff","justifyContent":"flex-end","display":"flex"}'>
<form id="loginForm" class="layui-form login-form" :style='{"border":"8px outset #bcdbdf","padding":"20px 20px 20px","boxShadow":"inset 0px 0px 0px 0px #666","margin":"5% 7% 0 0","borderRadius":"0px","flexWrap":"wrap","background":"rgba(255,255,255,.9)","display":"flex","width":"800px","position":"relative","justifyContent":"center","height":"auto"}'> <form id="loginForm" class="layui-form login-form" :style='{"border":"8px outset #bcdbdf","padding":"20px 20px 20px","boxShadow":"inset 0px 0px 0px 0px #666","margin":"5% 7% 0 0","borderRadius":"0px","flexWrap":"wrap","background":"rgba(255,255,255,.9)","display":"flex","width":"800px","position":"relative","justifyContent":"center","height":"auto"}'>
<div v-if="true" :style='{"margin":"0 0 4px","color":"#555","textAlign":"center","display":"none","width":"62%","lineHeight":"44px","fontSize":"24px","textShadow":"0px 0px 0px rgba(64, 158, 255, .5)"}'>USER / LOGIN</div> <div v-if="true" :style='{"margin":"0 0 4px","color":"#555","textAlign":"center","display":"none","width":"62%","lineHeight":"44px","fontSize":"24px","textShadow":"0px 0px 0px rgba(64, 158, 255, .5)"}'>USER / LOGIN</div>
<div v-if="true" :style='{"boxShadow":"inset 0px 0px 0px 0px #c5f1c0","margin":"4px 0 40px","borderColor":"#bdefb6","color":"#333","textAlign":"center","borderRadius":"0px","background":"url(http://codegen.caihongy.cn/20230204/13e68e581e9e42b7a53fd23ab9faef74.png) no-repeat left top /100% 100%,#d7eef2","borderWidth":"0px","width":"100%","lineHeight":"44px","fontSize":"16px","borderStyle":"solid","textShadow":"0px 0px 0px rgba(64, 158, 255, .5)"}'>问卷调查系统</div> <div v-if="true" :style='{"boxShadow":"inset 0px 0px 0px 0px #c5f1c0","margin":"4px 0 40px","borderColor":"#bdefb6","color":"#333","textAlign":"center","borderRadius":"0px","background":"url(http://codegen.caihongy.cn/20230204/13e68e581e9e42b7a53fd23ab9faef74.png) no-repeat left top /100% 100%,#d7eef2","borderWidth":"0px","width":"100%","lineHeight":"44px","fontSize":"16px","borderStyle":"solid","textShadow":"0px 0px 0px rgba(64, 158, 255, .5)"}'>基于j2ee的问卷调查系统</div>
<div :style='{"width":"80%","margin":"0 0 20px","flexWrap":"wrap","display":"flex"}' class="form-item"> <div :style='{"width":"80%","margin":"0 0 20px","flexWrap":"wrap","display":"flex"}' class="form-item">
<div class="layui-form-label" v-if="false" :style='{"width":"64px","padding":"0 10px 0 0","lineHeight":"44px","fontSize":"14px","color":"#333"}'>账号</div> <div class="layui-form-label" v-if="false" :style='{"width":"64px","padding":"0 10px 0 0","lineHeight":"44px","fontSize":"14px","color":"#333"}'>账号</div>
<input :style='{"padding":"0 10px","boxShadow":"inset 0px 0px 0px 0px #c5f1c0","borderColor":"#eee","color":"#333","outline":"0px solid #efefef","outlineOffset":"4px","borderRadius":"0px","flex":"1","borderWidth":"1px","background":"#fff","width":"100%","fontSize":"14px","borderStyle":"solid","height":"40px"}' type="text" name="username" required lay-verify="required" placeholder="请输入账号" autocomplete="off" class="layui-input"> <input :style='{"padding":"0 10px","boxShadow":"inset 0px 0px 0px 0px #c5f1c0","borderColor":"#eee","color":"#333","outline":"0px solid #efefef","outlineOffset":"4px","borderRadius":"0px","flex":"1","borderWidth":"1px","background":"#fff","width":"100%","fontSize":"14px","borderStyle":"solid","height":"40px"}' type="text" name="username" required lay-verify="required" placeholder="请输入账号" autocomplete="off" class="layui-input">

2
src/main/webapp/index.jsp
Unescape View File

@ -116,7 +116,7 @@
<!-- Main Content --> <!-- Main Content -->
<div id="home-container"> <div id="home-container">
<div class="home-container-title">欢迎使用&nbsp;问卷调查系统</div> <div class="home-container-title">欢迎使用&nbsp;基于j2ee的问卷调查系统</div>
<div class="cards" :style='{"margin":"20px 0 20px 0","alignItems":"center","justifyContent":"center","display":"flex"}'> <div class="cards" :style='{"margin":"20px 0 20px 0","alignItems":"center","justifyContent":"center","display":"flex"}'>
<div class="item" :style='{"boxShadow":"0 0px 0px rgba(0,0,0,.3)","margin":"0 10px","borderRadius":"4px","display":"flex"}' v-if="crossBtnControl2('yonghu','首页总数')"> <div class="item" :style='{"boxShadow":"0 0px 0px rgba(0,0,0,.3)","margin":"0 10px","borderRadius":"4px","display":"flex"}' v-if="crossBtnControl2('yonghu','首页总数')">

2
src/main/webapp/jsp/static/head.jsp
Unescape View File

@ -3,7 +3,7 @@
<meta charset="utf-8"> <meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>问卷调查系统</title> <title>基于j2ee的问卷调查系统</title>
<!-- Fav Icon Link --> <!-- Fav Icon Link -->
<link rel="shortcut icon" type="image/png" href="${pageContext.request.contextPath}/resources/images/fav.png"> <link rel="shortcut icon" type="image/png" href="${pageContext.request.contextPath}/resources/images/fav.png">
<!-- Bootstrap core CSS --> <!-- Bootstrap core CSS -->

2
src/main/webapp/jsp/static/topNav.jsp
Unescape View File

@ -161,7 +161,7 @@
} }
</style> </style>
<div id="top-container"> <div id="top-container">
<a class="top-title" href="${pageContext.request.contextPath}/index.jsp">问卷调查系统</a> <a class="top-title" href="${pageContext.request.contextPath}/index.jsp">基于j2ee的问卷调查系统</a>
<ul class="top-nav"> <ul class="top-nav">
<li class="nav-item-full"> <li class="nav-item-full">
<a class="nav-link"> <a class="nav-link">

2
src/main/webapp/jsp/utils/baseUrl.jsp
Unescape View File

@ -1,7 +1,7 @@
<%@ page language="java" contentType="text/html; charset=UTF-8" <%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%> pageEncoding="UTF-8"%>
var baseUrl = "http://localhost:8080/jspm0c59i/"; var baseUrl = "http://localhost:8080/jspm0c59i/";
var projectName = "问卷调查系统" var projectName = "基于j2ee的问卷调查系统"
/** /**
* 网络请求 * 网络请求

Write Preview
Loading…
Cancel
Save