注 释 #5

Merged
p4vkf3rot merged 14 commits from zhangshuting_branch into main 9 months ago

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

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

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

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

@ -39,6 +39,7 @@ import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
/**
*
*
@ -46,139 +47,141 @@ import com.utils.CommonUtil;
* @email
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/yonghu")
@RestController // 标记这是一个REST控制器
@RequestMapping("/yonghu") // 设置请求路径的前缀为/yonghu
public class YonghuController {
@Autowired
private YonghuService yonghuService;
private YonghuService yonghuService; // 自动注入YonghuService服务
@Autowired
private TokenService tokenService; // 自动注入TokenService服务
@Autowired
private TokenService tokenService;
/**
*
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if(u==null || !u.getMima().equals(password)) {
return R.error("账号或密码不正确");
}
String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" );
return R.ok().put("token", token);
}
/**
*
*/
@IgnoreAuth // 忽略权限验证
@RequestMapping(value = "/login") // 设置请求路径为/login
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
// 验证用户名和密码
if(u==null || !u.getMima().equals(password)) {
return R.error("账号或密码不正确");
}
// 生成并返回token
String token = tokenService.generateToken(u.getId(), username,"yonghu", "用户" );
return R.ok().put("token", token);
}
/**
/**
*
*/
@IgnoreAuth
@RequestMapping("/register")
@IgnoreAuth // 忽略权限验证
@RequestMapping("/register") // 设置请求路径为/register
public R register(@RequestBody YonghuEntity yonghu){
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) {
return R.error("注册用户已存在");
}
Long uId = new Date().getTime();
yonghu.setId(uId);
// 检查用户是否已存在
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) {
return R.error("注册用户已存在");
}
// 生成用户ID并插入用户数据
Long uId = new Date().getTime();
yonghu.setId(uId);
yonghuService.insert(yonghu);
return R.ok();
}
/**
* 退
*/
@RequestMapping("/logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
/**
* 退
*/
@RequestMapping("/logout") // 设置请求路径为/logout
public R logout(HttpServletRequest request) {
// 使当前会话失效
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* session
*/
@RequestMapping("/session")
@RequestMapping("/session") // 设置请求路径为/session
public R getCurrUser(HttpServletRequest request){
Long id = (Long)request.getSession().getAttribute("userId");
// 从session中获取用户ID
Long id = (Long)request.getSession().getAttribute("userId");
// 根据ID查询用户信息
YonghuEntity u = yonghuService.selectById(id);
return R.ok().put("data", u);
}
/**
*
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
@IgnoreAuth // 忽略权限验证
@RequestMapping(value = "/resetPass") // 设置请求路径为/resetPass
public R resetPass(String username, HttpServletRequest request){
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if(u==null) {
return R.error("账号不存在");
}
// 根据用户名查询用户
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if(u==null) {
return R.error("账号不存在");
}
// 重置密码为123456
u.setMima("123456");
yonghuService.updateById(u);
return R.ok("密码已重置为123456");
}
/**
*
*/
@RequestMapping("/page")
@RequestMapping("/page") // 设置请求路径为/page
public R page(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request){
HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page);
// 分页查询用户列表
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
*
*/
@IgnoreAuth
@RequestMapping("/list")
@IgnoreAuth // 忽略权限验证
@RequestMapping("/list") // 设置请求路径为/list
public R list(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
HttpServletRequest request){
HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page);
// 分页查询用户列表
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
/**
*
*/
@RequestMapping("/lists")
@RequestMapping("/lists") // 设置请求路径为/lists
public R list( YonghuEntity yonghu){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
return R.ok().put("data", yonghuService.selectListView(ew));
}
/**
/**
*
*/
@RequestMapping("/query")
@RequestMapping("/query") // 设置请求路径为/query
public R query(YonghuEntity yonghu){
EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>();
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
YonghuView yonghuView = yonghuService.selectView(ew);
return R.ok("查询用户成功").put("data", yonghuView);
ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
YonghuView yonghuView = yonghuService.selectView(ew);
return R.ok("查询用户成功").put("data", yonghuView);
}
/**
*
*/
@RequestMapping("/info/{id}")
@RequestMapping("/info/{id}") // 设置请求路径为/info/{id}
public R info(@PathVariable("id") Long id){
YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu);
@ -187,126 +190,108 @@ public class YonghuController {
/**
*
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
@IgnoreAuth // 忽略权限验证
@RequestMapping("/detail/{id}") // 设置请求路径为/detail/{id}
public R detail(@PathVariable("id") Long id){
YonghuEntity yonghu = yonghuService.selectById(id);
return R.ok().put("data", yonghu);
}
/**
*
*/
@RequestMapping("/save")
@RequestMapping("/save") // 设置请求路径为/save
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
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()));
if(u!=null) {
return R.error("用户已存在");
}
yonghu.setId(new Date().getTime());
yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) {
return R.error("用户已存在");
}
yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu);
return R.ok();
}
/**
*
*/
@RequestMapping("/add")
@RequestMapping("/add") // 设置请求路径为/add
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
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()));
if(u!=null) {
return R.error("用户已存在");
}
yonghu.setId(new Date().getTime());
yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if(u!=null) {
return R.error("用户已存在");
}
yonghu.setId(new Date().getTime());
yonghuService.insert(yonghu);
return R.ok();
}
/**
*
*/
@RequestMapping("/update")
@Transactional
@RequestMapping("/update") // 设置请求路径为/update
@Transactional // 开启事务
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
//ValidatorUtils.validateEntity(yonghu);
yonghuService.updateById(yonghu);//全部更新
return R.ok();
}
/**
*
*/
@RequestMapping("/delete")
@RequestMapping("/delete") // 设置请求路径为/delete
public R delete(@RequestBody Long[] ids){
yonghuService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
*
*/
@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<YonghuEntity> wrapper = new EntityWrapper<YonghuEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yonghuService.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);
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<YonghuEntity> wrapper = new EntityWrapper<YonghuEntity>();
if(map.get("remindstart")!=null) {
wrapper.ge(columnName, map.get("remindstart"));
}
if(map.get("remindend")!=null) {
wrapper.le(columnName, map.get("remindend"));
}
int count = yonghuService.selectCount(wrapper);
return R.ok().put("count", count);
}
/**
*
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}")
@RequestMapping("/value/{xColumnName}/{yColumnName}") // 设置请求路径为/value/{xColumnName}/{yColumnName}
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("xColumn", xColumnName);
@ -327,7 +312,7 @@ public class YonghuController {
/**
*
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}") // 设置请求路径为/value/{xColumnName}/{yColumnName}/{timeStatType}
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>();
params.put("xColumn", xColumnName);
@ -345,11 +330,11 @@ public class YonghuController {
}
return R.ok().put("data", result);
}
/**
*
*/
@RequestMapping("/group/{columnName}")
@RequestMapping("/group/{columnName}") // 设置请求路径为/group/{columnName}
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName);
@ -366,18 +351,13 @@ public class YonghuController {
return R.ok().put("data", result);
}
/**
*
*/
@RequestMapping("/count")
@RequestMapping("/count") // 设置请求路径为/count
public R count(@RequestParam Map<String, Object> params,YonghuEntity yonghu, HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
return R.ok().put("data", count);
}
}

@ -11,25 +11,29 @@ import org.apache.ibatis.annotations.Param;
import com.entity.vo.NewsVO;
import com.entity.view.NewsView;
/**
*
* 访
*
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public interface NewsDao extends BaseMapper<NewsEntity> {
List<NewsVO> selectListVO(@Param("ew") Wrapper<NewsEntity> wrapper);
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
List<NewsView> selectListView(@Param("ew") Wrapper<NewsEntity> wrapper);
List<NewsView> selectListView(Pagination page,@Param("ew") Wrapper<NewsEntity> wrapper);
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择公告的信息列表并返回一个 NewsVO 对象的列表
List<NewsVO> selectListVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择单个公告的信息并返回一个 NewsVO 对象
NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择公告的信息视图列表并返回一个 NewsView 对象的列表
List<NewsView> selectListView(@Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper与分页信息选择公告的信息视图列表并返回一个 NewsView 对象的列表
List<NewsView> selectListView(Pagination page, @Param("ew") Wrapper<NewsEntity> wrapper);
// 根据查询条件Wrapper选择单个公告的信息视图并返回一个 NewsView 对象
NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
}

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

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

@ -9,14 +9,19 @@ import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.entity.UsersEntity;
/**
*
* 访
*/
public interface UsersDao extends BaseMapper<UsersEntity> {
List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
// 根据查询条件Wrapper选择用户列表并返回一个 UsersEntity 对象的列表
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);
}

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

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

@ -9,83 +9,73 @@ import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* entity
* ModelAndView model
* @author
* @email
* @date 2023-02-21 09:46:06
*/
public class NewsModel implements Serializable {
private static final long serialVersionUID = 1L;
public class NewsModel implements Serializable {
private static final long serialVersionUID = 1L; // 序列化版本号
/**
*
*/
private String introduction; // 存放公告的简介
/**
*
*/
private String picture; // 存放公告相关的图片
/**
*
*/
private String content; // 存放公告的详细内容
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction; // 设置简介字段
}
/**
*
*/
public String getIntroduction() {
return introduction; // 返回简介字段的值
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture; // 设置图片字段
}
/**
*
*/
public String getPicture() {
return picture; // 返回图片字段的值
}
/**
*
*/
public void setContent(String content) {
this.content = content; // 设置内容字段
}
/**
*
*/
private String introduction;
/**
*
*/
private String picture;
/**
*
*/
private String content;
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction;
}
/**
*
*/
public String getIntroduction() {
return introduction;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture;
}
/**
*
*/
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() {
return content;
}
/**
*
*/
public String getContent() {
return content; // 返回内容字段的值
}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -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"}'>
<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='{"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 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 :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>
<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">

@ -116,7 +116,7 @@
<!-- Main Content -->
<div id="home-container">
<div class="home-container-title">欢迎使用&nbsp;基于j2ee的问卷调查系统</div>
<div class="home-container-title">欢迎使用&nbsp;问卷调查系统</div>
<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','首页总数')">

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

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

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

Loading…
Cancel
Save