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

注释

Browse Source
hujiali_branch
hjl 8 months ago
parent 1e85e38192
commit 8945f4a85a
23 changed files with 1012 additions and 715 deletions
Show Stats Download Patch File Download Diff File

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

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

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

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

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

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

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

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

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

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

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

@ -1,35 +1,59 @@
package com.dao;
import com.entity.ForumEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.entity.ForumEntity; // 导入论坛实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 导入MyBatis-Plus的BaseMapper接口
import java.util.List;
import java.util.Map;
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 com.entity.vo.ForumVO;
import com.entity.view.ForumView;
import com.entity.vo.ForumVO; // 导入论坛VO类
import com.entity.view.ForumView; // 导入论坛视图类
/**
* 论坛表
* 论坛表 DAO 接口
* 该接口用于数据访问层，对ForumEntity实体的数据库操作
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface ForumDao extends BaseMapper<ForumEntity> {
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(@Param("ew") Wrapper<ForumEntity> wrapper);
List<ForumView> selectListView(Pagination page,@Param("ew") Wrapper<ForumEntity> wrapper);
ForumView selectView(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询论坛列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 论坛VO对象列表
*/
List<ForumVO> selectListVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询单个论坛，返回VO对象
* @param wrapper 查询条件包装器
* @return 论坛VO对象
*/
ForumVO selectVO(@Param("ew") Wrapper<ForumEntity> wrapper);
/**
* 查询论坛列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 论坛视图对象列表
*/
List<ForumView> selectListView(@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);
}

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

@ -1,35 +1,59 @@
package com.dao;
import com.entity.LeixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.LeixingEntity;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO;
import com.entity.view.LeixingView;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.LeixingVO; // 导入类型VO类
import com.entity.view.LeixingView;
/**
* 类型
* 类型 DAO 接口
* 该接口用于与数据库交互，操作LeixingEntity实体
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface LeixingDao extends BaseMapper<LeixingEntity> {
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(@Param("ew") Wrapper<LeixingEntity> wrapper);
List<LeixingView> selectListView(Pagination page,@Param("ew") Wrapper<LeixingEntity> wrapper);
LeixingView selectView(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 类型VO对象列表
*/
List<LeixingVO> selectListVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询单个类型，返回VO对象
* @param wrapper 查询条件包装器
* @return 单个类型VO对象
*/
LeixingVO selectVO(@Param("ew") Wrapper<LeixingEntity> wrapper);
/**
* 查询类型列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 类型视图对象列表
*/
List<LeixingView> selectListView(@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);
}

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

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

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

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

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

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

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

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

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

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

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

@ -24,13 +24,14 @@ public class LeixingView extends LeixingEntity implements Serializable {
public LeixingView(){
}
public LeixingView(LeixingEntity leixingEntity){
try {
// 接收 LeixingEntity 对象的构造函数
public LeixingView(LeixingEntity leixingEntity) {
try {
// 将LeixingEntity的属性复制到当前LeixingView对象
BeanUtils.copyProperties(this, leixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 异常处理，打印堆栈信息
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
*/
public class LeixingVO implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L;// 版本控制，用于序列化
}

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

@ -3,8 +3,8 @@ package com.service;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.IService;
import com.baomidou.mybatisplus.mapper.Wrapper;// 导入MyBatis-Plus的Wrapper接口，用于构建查询条件
import com.baomidou.mybatisplus.service.IService;// 导入MyBatis-Plus的服务接口
import com.entity.ConfigEntity;
import com.utils.PageUtils;
@ -13,5 +13,12 @@ import com.utils.PageUtils;
* 系统用户
*/
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);
}

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

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

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

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

@ -20,26 +20,70 @@ import com.entity.view.WenjuandafuView;
*/
public interface WenjuandafuService extends IService<WenjuandafuEntity> {
/**
* 查询分页数据
* @param params 查询参数
* @return 分页结果
*/
PageUtils queryPage(Map<String, Object> params);
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
PageUtils queryPage(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复列表，返回VO对象列表
* @param wrapper 查询条件包装器
* @return 问卷答复VO对象列表
*/
List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper);
List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询单个问卷答复，返回VO对象
* @param wrapper 查询条件包装器
* @return 问卷答复VO对象
*/
WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询问卷答复列表，返回视图对象列表
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象列表
*/
List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询单个问卷答复，返回视图对象
* @param wrapper 查询条件包装器
* @return 问卷答复视图对象
*/
WenjuandafuView selectView(@Param("ew") 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);
}
/**
* 根据时间统计查询问卷答复的值
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 时间统计值的Map列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper);
/**
* 查询分组统计数据
* @param params 查询参数
* @param wrapper 查询条件包装器
* @return 分组统计的Map列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> 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 {
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) {
// 使用MyBatis-Plus的selectPage方法进行分页查询
Page<ConfigEntity> page = this.selectPage(
new Query<ConfigEntity>(params).getPage(),
wrapper
new Query<ConfigEntity>(params).getPage(), // 获取分页参数
wrapper // 查询条件
);
return new PageUtils(page);
}
return new PageUtils(page); // 返回分页结果
}

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

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

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

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

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

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

Write Preview
Loading…
Cancel
Save