branch3
admin 4 months ago
parent f2f02e04b8
commit f9308845d6

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.DiscusshuodongxindeEntity;
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.DiscusshuodongxindeVO;
import com.entity.view.DiscusshuodongxindeView;
import com.entity.DiscusshuodongxindeEntity; // 引入活动心得评论表的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.DiscusshuodongxindeVO; // 引入活动心得评论表的 VO (View Object) 类
import com.entity.view.DiscusshuodongxindeView; // 引入活动心得评论表的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface DiscusshuodongxindeDao extends BaseMapper<DiscusshuodongxindeEntity> {
/**
* VO
* @param wrapper SQL
* @return DiscusshuodongxindeVO
*/
List<DiscusshuodongxindeVO> selectListVO(@Param("ew") Wrapper<DiscusshuodongxindeEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return DiscusshuodongxindeVO
*/
DiscusshuodongxindeVO selectVO(@Param("ew") Wrapper<DiscusshuodongxindeEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return DiscusshuodongxindeView
*/
List<DiscusshuodongxindeView> selectListView(@Param("ew") Wrapper<DiscusshuodongxindeEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return DiscusshuodongxindeView
*/
List<DiscusshuodongxindeView> selectListView(Pagination page,@Param("ew") Wrapper<DiscusshuodongxindeEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return DiscusshuodongxindeView
*/
DiscusshuodongxindeView selectView(@Param("ew") Wrapper<DiscusshuodongxindeEntity> wrapper);
}

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.HuodongbaomingEntity;
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.HuodongbaomingVO;
import com.entity.view.HuodongbaomingView;
import com.entity.HuodongbaomingEntity; // 引入活动报名表的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.HuodongbaomingVO; // 引入活动报名表的 VO (View Object) 类
import com.entity.view.HuodongbaomingView; // 引入活动报名表的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface HuodongbaomingDao extends BaseMapper<HuodongbaomingEntity> {
/**
* VO
* @param wrapper SQL
* @return HuodongbaomingVO
*/
List<HuodongbaomingVO> selectListVO(@Param("ew") Wrapper<HuodongbaomingEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return HuodongbaomingVO
*/
HuodongbaomingVO selectVO(@Param("ew") Wrapper<HuodongbaomingEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongbaomingView
*/
List<HuodongbaomingView> selectListView(@Param("ew") Wrapper<HuodongbaomingEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return HuodongbaomingView
*/
List<HuodongbaomingView> selectListView(Pagination page,@Param("ew") Wrapper<HuodongbaomingEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongbaomingView
*/
HuodongbaomingView selectView(@Param("ew") Wrapper<HuodongbaomingEntity> wrapper);
}

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.HuodongleixingEntity;
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.HuodongleixingVO;
import com.entity.view.HuodongleixingView;
import com.entity.HuodongleixingEntity; // 引入活动类型的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.HuodongleixingVO; // 引入活动类型的 VO (View Object) 类
import com.entity.view.HuodongleixingView; // 引入活动类型的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface HuodongleixingDao extends BaseMapper<HuodongleixingEntity> {
/**
* VO
* @param wrapper SQL
* @return HuodongleixingVO
*/
List<HuodongleixingVO> selectListVO(@Param("ew") Wrapper<HuodongleixingEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return HuodongleixingVO
*/
HuodongleixingVO selectVO(@Param("ew") Wrapper<HuodongleixingEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongleixingView
*/
List<HuodongleixingView> selectListView(@Param("ew") Wrapper<HuodongleixingEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return HuodongleixingView
*/
List<HuodongleixingView> selectListView(Pagination page,@Param("ew") Wrapper<HuodongleixingEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongleixingView
*/
HuodongleixingView selectView(@Param("ew") Wrapper<HuodongleixingEntity> wrapper);
}

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.HuodongtongzhiEntity;
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.HuodongtongzhiVO;
import com.entity.view.HuodongtongzhiView;
import com.entity.HuodongtongzhiEntity; // 引入活动通知表的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.HuodongtongzhiVO; // 引入活动通知表的 VO (View Object) 类
import com.entity.view.HuodongtongzhiView; // 引入活动通知表的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface HuodongtongzhiDao extends BaseMapper<HuodongtongzhiEntity> {
/**
* VO
* @param wrapper SQL
* @return HuodongtongzhiVO
*/
List<HuodongtongzhiVO> selectListVO(@Param("ew") Wrapper<HuodongtongzhiEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return HuodongtongzhiVO
*/
HuodongtongzhiVO selectVO(@Param("ew") Wrapper<HuodongtongzhiEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongtongzhiView
*/
List<HuodongtongzhiView> selectListView(@Param("ew") Wrapper<HuodongtongzhiEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return HuodongtongzhiView
*/
List<HuodongtongzhiView> selectListView(Pagination page,@Param("ew") Wrapper<HuodongtongzhiEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongtongzhiView
*/
HuodongtongzhiView selectView(@Param("ew") Wrapper<HuodongtongzhiEntity> wrapper);
}

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.HuodongxindeEntity;
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.HuodongxindeVO;
import com.entity.view.HuodongxindeView;
import com.entity.HuodongxindeEntity; // 引入活动心得表的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.HuodongxindeVO; // 引入活动心得表的 VO (View Object) 类
import com.entity.view.HuodongxindeView; // 引入活动心得表的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface HuodongxindeDao extends BaseMapper<HuodongxindeEntity> {
/**
* VO
* @param wrapper SQL
* @return HuodongxindeVO
*/
List<HuodongxindeVO> selectListVO(@Param("ew") Wrapper<HuodongxindeEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return HuodongxindeVO
*/
HuodongxindeVO selectVO(@Param("ew") Wrapper<HuodongxindeEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongxindeView
*/
List<HuodongxindeView> selectListView(@Param("ew") Wrapper<HuodongxindeEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return HuodongxindeView
*/
List<HuodongxindeView> selectListView(Pagination page,@Param("ew") Wrapper<HuodongxindeEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongxindeView
*/
HuodongxindeView selectView(@Param("ew") Wrapper<HuodongxindeEntity> wrapper);
}

@ -1,58 +1,35 @@
package com.dao; // 定义包路径,存放 DAO 层接口
package com.dao;
import com.entity.HuodongxinxiEntity;
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.HuodongxinxiVO;
import com.entity.view.HuodongxinxiView;
import com.entity.HuodongxinxiEntity; // 引入活动信息表的实体类
import com.baomidou.mybatisplus.mapper.BaseMapper; // 引入 MyBatis-Plus 的基础 Mapper 接口
import java.util.List; // 导入 List 接口,用于返回集合类型的数据
import java.util.Map; // 导入 Map 接口,用于存储键值对参数
import com.baomidou.mybatisplus.mapper.Wrapper; // 引入 MyBatis-Plus 的条件构造器
import com.baomidou.mybatisplus.plugins.pagination.Pagination; // 引入分页插件的 Pagination 类
import org.apache.ibatis.annotations.Param; // 引入 MyBatis 的 @Param 注解,用于绑定参数
import com.entity.vo.HuodongxinxiVO; // 引入活动信息表的 VO (View Object) 类
import com.entity.view.HuodongxinxiView; // 引入活动信息表的 View 类
/**
*
*
* @author []
* @email []
*
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public interface HuodongxinxiDao extends BaseMapper<HuodongxinxiEntity> {
/**
* VO
* @param wrapper SQL
* @return HuodongxinxiVO
*/
List<HuodongxinxiVO> selectListVO(@Param("ew") Wrapper<HuodongxinxiEntity> wrapper);
/**
* VO
* @param wrapper SQL
* @return HuodongxinxiVO
*/
HuodongxinxiVO selectVO(@Param("ew") Wrapper<HuodongxinxiEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongxinxiView
*/
List<HuodongxinxiView> selectListView(@Param("ew") Wrapper<HuodongxinxiEntity> wrapper);
/**
* View
* @param page
* @param wrapper SQL
* @return HuodongxinxiView
*/
List<HuodongxinxiView> selectListView(Pagination page,@Param("ew") Wrapper<HuodongxinxiEntity> wrapper);
/**
* View
* @param wrapper SQL
* @return HuodongxinxiView
*/
HuodongxinxiView selectView(@Param("ew") Wrapper<HuodongxinxiEntity> wrapper);
}

@ -1,197 +1,256 @@
package com.entity; // 定义包路径,存放实体类
package com.entity;
import com.baomidou.mybatisplus.annotations.TableId; // 引入 MyBatis-Plus 的 TableId 注解
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import javax.validation.constraints.NotBlank; // 引入校验注解
import javax.validation.constraints.NotEmpty; // 引入校验注解
import javax.validation.constraints.NotNull; // 引入校验注解
import com.baomidou.mybatisplus.annotations.TableId;
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; // 引入 Jackson 的忽略属性注解
import java.lang.reflect.InvocationTargetException; // 引入反射相关的异常类
import java.io.Serializable; // 引入 Serializable 接口
import java.util.Date; // 引入日期类
import java.util.List; // 引入 List 泛型接口
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;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
import com.baomidou.mybatisplus.enums.IdType;
import org.springframework.format.annotation.DateTimeFormat; // 引入 Spring 的日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 引入 Jackson 的日期格式注解
import org.apache.commons.beanutils.BeanUtils; // 引入 BeanUtils 工具类
import com.baomidou.mybatisplus.annotations.TableField; // 引入 MyBatis-Plus 的 TableField 注解
import com.baomidou.mybatisplus.enums.FieldFill; // 引入 MyBatis-Plus 的 FieldFill 枚举
import com.baomidou.mybatisplus.enums.IdType; // 引入 MyBatis-Plus 的 IdType 枚举
/**
*
*
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongbaoming") // 定义数据库表名
public class HuodongbaomingEntity<T> implements Serializable { // 定义活动报名实体类
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongbaoming")
public class HuodongbaomingEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
// 默认构造函数
public HuodongbaomingEntity() {
public HuodongbaomingEntity() {
}
// 带参数的构造函数,用于将泛型对象转换为实体类对象
public HuodongbaomingEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用 BeanUtils 工具类将泛型对象的属性复制到当前对象中
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* id
*/
@TableId(type = IdType.AUTO) // 定义主键类型为自动增长
private Long id; // 定义主键字段
@TableId
private Long id;
/**
*
*/
private String huodongmingcheng; // 定义活动名称字段
private String huodongmingcheng;
/**
*
*/
private String huodongleixing; // 定义活动类型字段
private String huodongleixing;
/**
*
*/
private Integer renshu; // 定义人数字段
private Integer renshu;
/**
*
*/
private String baomingshuoming; // 定义报名说明字段
private String baomingshuoming;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date baomingshijian; // 定义报名时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date baomingshijian;
/**
*
*/
private String xuehao; // 定义学号字段
private String xuehao;
/**
*
*/
private String xingming; // 定义姓名字段
private String xingming;
/**
*
*/
private String shouji; // 定义手机号字段
private String shouji;
/**
*
*/
private String sfsh; // 定义是否审核字段
private String sfsh;
/**
*
*/
private String shhf; // 定义审核回复字段
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date addtime; // 定义添加时间字段
private String shhf;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
// Getter 和 Setter 方法
public Date getAddtime() { // 获取添加时间的方法
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) { // 设置添加时间的方法
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public Long getId() { // 获取主键ID的方法
public Long getId() {
return id;
}
public void setId(Long id) { // 设置主键ID的方法
this.id = id;
}
public String getHuodongmingcheng() { // 获取活动名称的方法
return huodongmingcheng;
public void setId(Long id) {
this.id = id;
}
public void setHuodongmingcheng(String huodongmingcheng) { // 设置活动名称的方法
/**
*
*/
public void setHuodongmingcheng(String huodongmingcheng) {
this.huodongmingcheng = huodongmingcheng;
}
public String getHuodongleixing() { // 获取活动类型的方法
return huodongleixing;
/**
*
*/
public String getHuodongmingcheng() {
return huodongmingcheng;
}
public void setHuodongleixing(String huodongleixing) { // 设置活动类型的方法
/**
*
*/
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing;
}
public Integer getRenshu() { // 获取人数的方法
return renshu;
/**
*
*/
public String getHuodongleixing() {
return huodongleixing;
}
public void setRenshu(Integer renshu) { // 设置人数的方法
/**
*
*/
public void setRenshu(Integer renshu) {
this.renshu = renshu;
}
public String getBaomingshuoming() { // 获取报名说明的方法
return baomingshuoming;
/**
*
*/
public Integer getRenshu() {
return renshu;
}
public void setBaomingshuoming(String baomingshuoming) { // 设置报名说明的方法
/**
*
*/
public void setBaomingshuoming(String baomingshuoming) {
this.baomingshuoming = baomingshuoming;
}
public Date getBaomingshijian() { // 获取报名时间的方法
return baomingshijian;
/**
*
*/
public String getBaomingshuoming() {
return baomingshuoming;
}
public void setBaomingshijian(Date baomingshijian) { // 设置报名时间的方法
/**
*
*/
public void setBaomingshijian(Date baomingshijian) {
this.baomingshijian = baomingshijian;
}
public String getXuehao() { // 获取学号的方法
return xuehao;
/**
*
*/
public Date getBaomingshijian() {
return baomingshijian;
}
public void setXuehao(String xuehao) { // 设置学号的方法
/**
*
*/
public void setXuehao(String xuehao) {
this.xuehao = xuehao;
}
public String getXingming() { // 获取姓名的方法
return xingming;
/**
*
*/
public String getXuehao() {
return xuehao;
}
public void setXingming(String xingming) { // 设置姓名的方法
/**
*
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
public String getShouji() { // 获取手机号的方法
return shouji;
/**
*
*/
public String getXingming() {
return xingming;
}
public void setShouji(String shouji) { // 设置手机号的方法
/**
*
*/
public void setShouji(String shouji) {
this.shouji = shouji;
}
public String getSfsh() { // 获取是否审核的状态的方法
return sfsh;
/**
*
*/
public String getShouji() {
return shouji;
}
public void setSfsh(String sfsh) { // 设置是否审核的状态的方法
/**
*
*/
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
public String getShhf() { // 获取审核回复的方法
return shhf;
/**
*
*/
public String getSfsh() {
return sfsh;
}
public void setShhf(String shhf) { // 设置审核回复的方法
/**
*
*/
public void setShhf(String shhf) {
this.shhf = shhf;
}
/**
*
*/
public String getShhf() {
return shhf;
}
}

@ -1,125 +1,92 @@
package com.entity; // 定义包路径,存放实体类
package com.entity;
// 引入 MyBatis-Plus 的 TableId 注解,用于标识数据库中的主键字段
import com.baomidou.mybatisplus.annotations.TableId;
// 引入 MyBatis-Plus 的 TableName 注解,用于指定数据库中的表名
import com.baomidou.mybatisplus.annotations.TableName;
// 引入 Java Bean Validation 的 NotBlank 注解,用于验证字符串不能为空且不为空白
import javax.validation.constraints.NotBlank;
// 引入 Java Bean Validation 的 NotEmpty 注解,用于验证集合或数组不能为空
import javax.validation.constraints.NotEmpty;
// 引入 Java Bean Validation 的 NotNull 注解,用于验证对象不能为 null
import javax.validation.constraints.NotNull;
// 引入 Jackson 的 @JsonIgnoreProperties 注解,用于忽略 JSON 序列化和反序列化时的某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 引入 Java 反射相关的 InvocationTargetException 异常类
import java.lang.reflect.InvocationTargetException;
// 引入 Serializable 接口,使类能够被序列化
import java.io.Serializable;
// 引入 Date 类,用于表示日期和时间
import java.util.Date;
// 引入 List 泛型接口,用于表示动态数组
import java.util.List;
// 引入 Spring 的 DateTimeFormat 注解,用于格式化日期
import org.springframework.format.annotation.DateTimeFormat;
// 引入 Jackson 的 JsonFormat 注解,用于格式化日期
import com.fasterxml.jackson.annotation.JsonFormat;
// 引入 Apache Commons BeanUtils 工具类,用于操作 Java Bean
import org.apache.commons.beanutils.BeanUtils;
// 引入 MyBatis-Plus 的 TableField 注解,用于标识数据库中的字段
import com.baomidou.mybatisplus.annotations.TableField;
// 引入 MyBatis-Plus 的 FieldFill 枚举,用于标识字段的填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 引入 MyBatis-Plus 的 IdType 枚举,用于标识主键生成策略
import com.baomidou.mybatisplus.enums.IdType;
/**
*
*
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongleixing") // 定义数据库表名
public class HuodongleixingEntity<T> implements Serializable { // 定义活动类型实体类
@TableName("huodongleixing")
public class HuodongleixingEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
// 默认构造函数
public HuodongleixingEntity() {
}
// 带参数的构造函数,用于将泛型对象转换为实体类对象
public HuodongleixingEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用 BeanUtils 工具类将泛型对象的属性复制到当前对象中
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* id
*/
@TableId // 定义主键字段
private Long id; // 定义主键字段
@TableId
private Long id;
/**
*
*/
private String huodongleixing; // 定义活动类型字段
private String huodongleixing;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date addtime; // 定义添加时间字段
// Getter 方法:获取添加时间
public Date getAddtime() {
return addtime;
}
// Setter 方法:设置添加时间
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// Getter 方法获取主键ID
public Long getId() {
return id;
}
// Setter 方法设置主键ID
public void setId(Long id) {
this.id = id;
}
// Setter 方法:设置活动类型
/**
*
*/
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing;
}
// Getter 方法:获取活动类型
/**
*
*/
public String getHuodongleixing() {
return huodongleixing;
}
}

@ -1,202 +1,184 @@
package com.entity; // 定义包路径,存放实体类
package com.entity;
// 引入 MyBatis-Plus 的 TableId 注解,用于标识数据库中的主键字段
import com.baomidou.mybatisplus.annotations.TableId;
// 引入 MyBatis-Plus 的 TableName 注解,用于指定数据库中的表名
import com.baomidou.mybatisplus.annotations.TableName;
// 引入 Java Bean Validation 的 NotBlank 注解,用于验证字符串不能为空且不为空白
import javax.validation.constraints.NotBlank;
// 引入 Java Bean Validation 的 NotEmpty 注解,用于验证集合或数组不能为空
import javax.validation.constraints.NotEmpty;
// 引入 Java Bean Validation 的 NotNull 注解,用于验证对象不能为 null
import javax.validation.constraints.NotNull;
// 引入 Jackson 的 @JsonIgnoreProperties 注解,用于忽略 JSON 序列化和反序列化时的某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 引入 Java 反射相关的 InvocationTargetException 异常类
import java.lang.reflect.InvocationTargetException;
// 引入 Serializable 接口,使类能够被序列化
import java.io.Serializable;
// 引入 Date 类,用于表示日期和时间
import java.util.Date;
// 引入 List 泛型接口,用于表示动态数组
import java.util.List;
// 引入 Spring 的 DateTimeFormat 注解,用于格式化日期
import org.springframework.format.annotation.DateTimeFormat;
// 引入 Jackson 的 JsonFormat 注解,用于格式化日期
import com.fasterxml.jackson.annotation.JsonFormat;
// 引入 Apache Commons BeanUtils 工具类,用于操作 Java Bean
import org.apache.commons.beanutils.BeanUtils;
// 引入 MyBatis-Plus 的 TableField 注解,用于标识数据库中的字段
import com.baomidou.mybatisplus.annotations.TableField;
// 引入 MyBatis-Plus 的 FieldFill 枚举,用于标识字段的填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 引入 MyBatis-Plus 的 IdType 枚举,用于标识主键生成策略
import com.baomidou.mybatisplus.enums.IdType;
/**
*
*
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongtongzhi") // 定义数据库表名
public class HuodongtongzhiEntity<T> implements Serializable { // 定义活动通知实体类
@TableName("huodongtongzhi")
public class HuodongtongzhiEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
// 默认构造函数
public HuodongtongzhiEntity() {
}
// 带参数的构造函数,用于将泛型对象转换为实体类对象
public HuodongtongzhiEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用 BeanUtils 工具类将泛型对象的属性复制到当前对象中
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* id
*/
@TableId // 定义主键字段
private Long id; // 定义主键字段
@TableId
private Long id;
/**
*
*/
private String biaoti; // 定义标题字段
private String biaoti;
/**
*
*/
private String xuehao; // 定义学号字段
private String xuehao;
/**
*
*/
private String xingming; // 定义姓名字段
private String xingming;
/**
*
*/
private String shouji; // 定义手机号码字段
private String shouji;
/**
*
*/
private String tongzhineirong; // 定义通知内容字段
private String tongzhineirong;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date tongzhishijian; // 定义通知时间字段
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date addtime; // 定义添加时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date tongzhishijian;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
// Getter 方法:获取添加时间
public Date getAddtime() {
return addtime;
}
// Setter 方法:设置添加时间
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// Getter 方法获取主键ID
public Long getId() {
return id;
}
// Setter 方法设置主键ID
public void setId(Long id) {
this.id = id;
}
// Setter 方法:设置标题
/**
*
*/
public void setBiaoti(String biaoti) {
this.biaoti = biaoti;
}
// Getter 方法:获取标题
/**
*
*/
public String getBiaoti() {
return biaoti;
}
// Setter 方法:设置学号
/**
*
*/
public void setXuehao(String xuehao) {
this.xuehao = xuehao;
}
// Getter 方法:获取学号
/**
*
*/
public String getXuehao() {
return xuehao;
}
// Setter 方法:设置姓名
/**
*
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
// Getter 方法:获取姓名
/**
*
*/
public String getXingming() {
return xingming;
}
// Setter 方法:设置手机号码
/**
*
*/
public void setShouji(String shouji) {
this.shouji = shouji;
}
// Getter 方法:获取手机号码
/**
*
*/
public String getShouji() {
return shouji;
}
// Setter 方法:设置通知内容
/**
*
*/
public void setTongzhineirong(String tongzhineirong) {
this.tongzhineirong = tongzhineirong;
}
// Getter 方法:获取通知内容
/**
*
*/
public String getTongzhineirong() {
return tongzhineirong;
}
// Setter 方法:设置通知时间
/**
*
*/
public void setTongzhishijian(Date tongzhishijian) {
this.tongzhishijian = tongzhishijian;
}
// Getter 方法:获取通知时间
/**
*
*/
public Date getTongzhishijian() {
return tongzhishijian;
}
}

@ -1,202 +1,184 @@
package com.entity; // 定义包路径,存放实体类
package com.entity;
// 引入 MyBatis-Plus 的 TableId 注解,用于标识数据库中的主键字段
import com.baomidou.mybatisplus.annotations.TableId;
// 引入 MyBatis-Plus 的 TableName 注解,用于指定数据库中的表名
import com.baomidou.mybatisplus.annotations.TableName;
// 引入 Java Bean Validation 的 NotBlank 注解,用于验证字符串不能为空且不为空白
import javax.validation.constraints.NotBlank;
// 引入 Java Bean Validation 的 NotEmpty 注解,用于验证集合或数组不能为空
import javax.validation.constraints.NotEmpty;
// 引入 Java Bean Validation 的 NotNull 注解,用于验证对象不能为 null
import javax.validation.constraints.NotNull;
// 引入 Jackson 的 @JsonIgnoreProperties 注解,用于忽略 JSON 序列化和反序列化时的某些属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 引入 Java 反射相关的 InvocationTargetException 异常类
import java.lang.reflect.InvocationTargetException;
// 引入 Serializable 接口,使类能够被序列化
import java.io.Serializable;
// 引入 Date 类,用于表示日期和时间
import java.util.Date;
// 引入 List 泛型接口,用于表示动态数组
import java.util.List;
// 引入 Spring 的 DateTimeFormat 注解,用于格式化日期
import org.springframework.format.annotation.DateTimeFormat;
// 引入 Jackson 的 JsonFormat 注解,用于格式化日期
import com.fasterxml.jackson.annotation.JsonFormat;
// 引入 Apache Commons BeanUtils 工具类,用于操作 Java Bean
import org.apache.commons.beanutils.BeanUtils;
// 引入 MyBatis-Plus 的 TableField 注解,用于标识数据库中的字段
import com.baomidou.mybatisplus.annotations.TableField;
// 引入 MyBatis-Plus 的 FieldFill 枚举,用于标识字段的填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 引入 MyBatis-Plus 的 IdType 枚举,用于标识主键生成策略
import com.baomidou.mybatisplus.enums.IdType;
/**
*
*
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongxinde") // 定义数据库表名
public class HuodongxindeEntity<T> implements Serializable { // 定义活动心得实体类
@TableName("huodongxinde")
public class HuodongxindeEntity<T> implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 定义序列化版本号
// 默认构造函数
public HuodongxindeEntity() {
}
// 带参数的构造函数,用于将泛型对象转换为实体类对象
public HuodongxindeEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用 BeanUtils 工具类将泛型对象的属性复制到当前对象中
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* id
*/
@TableId // 定义主键字段
private Long id; // 定义主键字段
@TableId
private Long id;
/**
*
*/
private String huodongmingcheng; // 定义活动名称字段
private String huodongmingcheng;
/**
*
*/
private String huodongleixing; // 定义活动类型字段
private String huodongleixing;
/**
*
*/
private String tupian; // 定义图片字段
private String tupian;
/**
*
*/
private String xindefenxiang; // 定义心得分享字段
private String xindefenxiang;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date fabushijian; // 定义发布时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date fabushijian;
/**
* id
*/
private Long userid; // 定义用户ID字段
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 定义日期格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 定义日期格式
private Date addtime; // 定义添加时间字段
private Long userid;
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date addtime;
// Getter 方法:获取添加时间
public Date getAddtime() {
return addtime;
}
// Setter 方法:设置添加时间
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// Getter 方法获取主键ID
public Long getId() {
return id;
}
// Setter 方法设置主键ID
public void setId(Long id) {
this.id = id;
}
// Setter 方法:设置活动名称
/**
*
*/
public void setHuodongmingcheng(String huodongmingcheng) {
this.huodongmingcheng = huodongmingcheng;
}
// Getter 方法:获取活动名称
/**
*
*/
public String getHuodongmingcheng() {
return huodongmingcheng;
}
// Setter 方法:设置活动类型
/**
*
*/
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing;
}
// Getter 方法:获取活动类型
/**
*
*/
public String getHuodongleixing() {
return huodongleixing;
}
// Setter 方法:设置图片
/**
*
*/
public void setTupian(String tupian) {
this.tupian = tupian;
}
// Getter 方法:获取图片
/**
*
*/
public String getTupian() {
return tupian;
}
// Setter 方法:设置心得分享
/**
*
*/
public void setXindefenxiang(String xindefenxiang) {
this.xindefenxiang = xindefenxiang;
}
// Getter 方法:获取心得分享
/**
*
*/
public String getXindefenxiang() {
return xindefenxiang;
}
// Setter 方法:设置发布时间
/**
*
*/
public void setFabushijian(Date fabushijian) {
this.fabushijian = fabushijian;
}
// Getter 方法:获取发布时间
/**
*
*/
public Date getFabushijian() {
return fabushijian;
}
// Setter 方法设置用户ID
/**
* id
*/
public void setUserid(Long userid) {
this.userid = userid;
}
// Getter 方法获取用户ID
/**
* id
*/
public Long getUserid() {
return userid;
}
}

@ -1,95 +1,114 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import javax.validation.constraints.NotNull; // 导入注解,用于字段校验
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.DiscusshuodongxindeEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @version 1.0 // 版本号
* @date 2023-10-01 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class DiscusshuodongxindeModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class DiscusshuodongxindeModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
* ID
* id
*/
@NotNull(message = "用户ID不能为空") // 注解确保用户ID不为空
private Long userid; // 用户ID字段
private Long userid;
/**
*
*/
private String nickname; // 用户名字段
private String nickname;
/**
*
*/
@NotNull(message = "评论内容不能为空") // 注解,确保评论内容不为空
private String content; // 评论内容字段
private String content;
/**
*
*/
private String reply; // 回复内容字段
private String reply;
/**
* id
*/
public void setUserid(Long userid) { // 设置用户ID的方法
this.userid = userid; // 将传入的值赋给字段
public void setUserid(Long userid) {
this.userid = userid;
}
/**
* id
*/
public Long getUserid() { // 获取用户ID的方法
return userid; // 返回用户ID字段的值
public Long getUserid() {
return userid;
}
/**
*
*/
public void setNickname(String nickname) { // 设置用户名的方法
this.nickname = nickname; // 将传入的值赋给字段
public void setNickname(String nickname) {
this.nickname = nickname;
}
/**
*
*/
public String getNickname() { // 获取用户名的方法
return nickname; // 返回用户名字段的值
public String getNickname() {
return nickname;
}
/**
*
*/
public void setContent(String content) { // 设置评论内容的方法
this.content = content; // 将传入的值赋给字段
public void setContent(String content) {
this.content = content;
}
/**
*
*/
public String getContent() { // 获取评论内容的方法
return content; // 返回评论内容字段的值
public String getContent() {
return content;
}
/**
*
*/
public void setReply(String reply) { // 设置回复内容的方法
this.reply = reply; // 将传入的值赋给字段
public void setReply(String reply) {
this.reply = reply;
}
/**
*
*/
public String getReply() { // 获取回复内容的方法
return reply; // 返回回复内容字段的值
public String getReply() {
return reply;
}
}

@ -1,195 +1,226 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.HuodongbaomingEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.HuodongbaomingEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class HuodongbaomingModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class HuodongbaomingModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String huodongleixing; // 活动类型的字段
private String huodongleixing;
/**
*
*/
private Integer renshu; // 人数字段
private Integer renshu;
/**
*
*/
private String baomingshuoming; // 报名说明字段
private String baomingshuoming;
/**
*
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 格式化日期时间
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") // 设置日期格式
private Date baomingshijian; // 报名时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date baomingshijian;
/**
*
*/
private String xuehao; // 学号字段
private String xuehao;
/**
*
*/
private String xingming; // 姓名字段
private String xingming;
/**
*
*/
private String shouji; // 手机号码字段
private String shouji;
/**
*
*/
private String sfsh; // 是否审核字段
private String sfsh;
/**
*
*/
private String shhf; // 审核回复字段
private String shhf;
/**
*
*/
public void setHuodongleixing(String huodongleixing) { // 设置活动类型的 setter 方法
this.huodongleixing = huodongleixing; // 将传入的值赋给字段
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing;
}
/**
*
*/
public String getHuodongleixing() { // 获取活动类型的 getter 方法
return huodongleixing; // 返回活动类型字段的值
public String getHuodongleixing() {
return huodongleixing;
}
/**
*
*/
public void setRenshu(Integer renshu) { // 设置人数的 setter 方法
this.renshu = renshu; // 将传入的值赋给字段
public void setRenshu(Integer renshu) {
this.renshu = renshu;
}
/**
*
*/
public Integer getRenshu() { // 获取人数的 getter 方法
return renshu; // 返回人数字段的值
public Integer getRenshu() {
return renshu;
}
/**
*
*/
public void setBaomingshuoming(String baomingshuoming) { // 设置报名说明的 setter 方法
this.baomingshuoming = baomingshuoming; // 将传入的值赋给字段
public void setBaomingshuoming(String baomingshuoming) {
this.baomingshuoming = baomingshuoming;
}
/**
*
*/
public String getBaomingshuoming() { // 获取报名说明的 getter 方法
return baomingshuoming; // 返回报名说明字段的值
public String getBaomingshuoming() {
return baomingshuoming;
}
/**
*
*/
public void setBaomingshijian(Date baomingshijian) { // 设置报名时间的 setter 方法
this.baomingshijian = baomingshijian; // 将传入的值赋给字段
public void setBaomingshijian(Date baomingshijian) {
this.baomingshijian = baomingshijian;
}
/**
*
*/
public Date getBaomingshijian() { // 获取报名时间的 getter 方法
return baomingshijian; // 返回报名时间字段的值
public Date getBaomingshijian() {
return baomingshijian;
}
/**
*
*/
public void setXuehao(String xuehao) { // 设置学号的 setter 方法
this.xuehao = xuehao; // 将传入的值赋给字段
public void setXuehao(String xuehao) {
this.xuehao = xuehao;
}
/**
*
*/
public String getXuehao() { // 获取学号的 getter 方法
return xuehao; // 返回学号字段的值
public String getXuehao() {
return xuehao;
}
/**
*
*/
public void setXingming(String xingming) { // 设置姓名的 setter 方法
this.xingming = xingming; // 将传入的值赋给字段
public void setXingming(String xingming) {
this.xingming = xingming;
}
/**
*
*/
public String getXingming() { // 获取姓名的 getter 方法
return xingming; // 返回姓名字段的值
public String getXingming() {
return xingming;
}
/**
*
*/
public void setShouji(String shouji) { // 设置手机号码的 setter 方法
this.shouji = shouji; // 将传入的值赋给字段
public void setShouji(String shouji) {
this.shouji = shouji;
}
/**
*
*/
public String getShouji() { // 获取手机号码的 getter 方法
return shouji; // 返回手机号码字段的值
public String getShouji() {
return shouji;
}
/**
*
*/
public void setSfsh(String sfsh) { // 设置是否审核的 setter 方法
this.sfsh = sfsh; // 将传入的值赋给字段
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
/**
*
*/
public String getSfsh() { // 获取是否审核的 getter 方法
return sfsh; // 返回是否审核字段的值
public String getSfsh() {
return sfsh;
}
/**
*
*/
public void setShhf(String shhf) { // 设置审核回复的 setter 方法
this.shhf = shhf; // 将传入的值赋给字段
public void setShhf(String shhf) {
this.shhf = shhf;
}
/**
*
*/
public String getShhf() { // 获取审核回复的 getter 方法
return shhf; // 返回审核回复字段的值
public String getShhf() {
return shhf;
}
}

@ -1,118 +1,138 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.HuodongtongzhiEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.HuodongtongzhiEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class HuodongtongzhiModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class HuodongtongzhiModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String xuehao; // 学号字段,用于存储学生的学号信息
private String xuehao;
/**
*
*/
private String xingming; // 姓名字段,用于存储学生的名字
private String xingming;
/**
*
*/
private String shouji; // 手机字段,用于存储学生的手机号码
private String shouji;
/**
*
*/
private String tongzhineirong; // 通知内容字段,用于存储活动通知的具体内容
private String tongzhineirong;
/**
*
*/
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") // 格式化日期时间为中文格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 设置日期格式为 yyyy-MM-dd HH:mm:ss
private Date tongzhishijian; // 通知时间字段,用于存储活动通知的时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date tongzhishijian;
/**
*
*/
public void setXuehao(String xuehao) {
this.xuehao = xuehao; // 设置学号值
this.xuehao = xuehao;
}
/**
*
*/
public String getXuehao() {
return xuehao; // 返回学号值
return xuehao;
}
/**
*
*/
public void setXingming(String xingming) {
this.xingming = xingming; // 设置姓名值
this.xingming = xingming;
}
/**
*
*/
public String getXingming() {
return xingming; // 返回姓名值
return xingming;
}
/**
*
*/
public void setShouji(String shouji) {
this.shouji = shouji; // 设置手机号码值
this.shouji = shouji;
}
/**
*
*/
public String getShouji() {
return shouji; // 返回手机号码值
return shouji;
}
/**
*
*/
public void setTongzhineirong(String tongzhineirong) {
this.tongzhineirong = tongzhineirong; // 设置通知内容值
this.tongzhineirong = tongzhineirong;
}
/**
*
*/
public String getTongzhineirong() {
return tongzhineirong; // 返回通知内容值
return tongzhineirong;
}
/**
*
*/
public void setTongzhishijian(Date tongzhishijian) {
this.tongzhishijian = tongzhishijian; // 设置通知时间值
this.tongzhishijian = tongzhishijian;
}
/**
*
*/
public Date getTongzhishijian() {
return tongzhishijian; // 返回通知时间值
return tongzhishijian;
}
}

@ -1,118 +1,138 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.HuodongxindeEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.HuodongxindeEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class HuodongxindeModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class HuodongxindeModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String huodongleixing; // 活动类型字段,用于存储活动的类型信息
private String huodongleixing;
/**
*
*/
private String tupian; // 图片字段,用于存储活动相关的图片链接或路径
private String tupian;
/**
*
*/
private String xindefenxiang; // 心得分享字段,用于存储用户的心得分享内容
private String xindefenxiang;
/**
*
*/
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") // 格式化日期时间为中文格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 设置日期格式为 yyyy-MM-dd HH:mm:ss
private Date fabushijian; // 发布时间字段,用于存储活动心得的发布时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date fabushijian;
/**
* id
*/
private Long userid; // 用户id字段用于存储发布活动心得的用户的唯一标识
private Long userid;
/**
*
*/
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing; // 设置活动类型的值
this.huodongleixing = huodongleixing;
}
/**
*
*/
public String getHuodongleixing() {
return huodongleixing; // 返回活动类型的值
return huodongleixing;
}
/**
*
*/
public void setTupian(String tupian) {
this.tupian = tupian; // 设置图片链接或路径的值
this.tupian = tupian;
}
/**
*
*/
public String getTupian() {
return tupian; // 返回图片链接或路径的值
return tupian;
}
/**
*
*/
public void setXindefenxiang(String xindefenxiang) {
this.xindefenxiang = xindefenxiang; // 设置心得分享内容的值
this.xindefenxiang = xindefenxiang;
}
/**
*
*/
public String getXindefenxiang() {
return xindefenxiang; // 返回心得分享内容的值
return xindefenxiang;
}
/**
*
*/
public void setFabushijian(Date fabushijian) {
this.fabushijian = fabushijian; // 设置发布时间的值
this.fabushijian = fabushijian;
}
/**
*
*/
public Date getFabushijian() {
return fabushijian; // 返回发布时间的值
return fabushijian;
}
/**
* id
*/
public void setUserid(Long userid) {
this.userid = userid; // 设置用户id的值
this.userid = userid;
}
/**
* id
*/
public Long getUserid() {
return userid; // 返回用户id的值
return userid;
}
}

@ -1,175 +1,204 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.HuodongxinxiEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.HuodongxinxiEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class HuodongxinxiModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class HuodongxinxiModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String huodongleixing; // 活动类型字段,用于存储活动的类型信息
private String huodongleixing;
/**
*
*/
private String tupian; // 图片字段,用于存储活动相关的图片链接或路径
private String tupian;
/**
*
*/
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") // 格式化日期时间为中文格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 设置日期格式为 yyyy-MM-dd HH:mm:ss
private Date huodongshijian; // 活动时间字段,用于存储活动的时间信息
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date huodongshijian;
/**
*
*/
private Integer renshu; // 人数字段,用于存储活动参与的人数
private Integer renshu;
/**
*
*/
private String huodongchangdi; // 活动场地字段,用于存储活动的场地信息
private String huodongchangdi;
/**
*
*/
private String huodongjieshao; // 活动介绍字段,用于存储活动的详细介绍
private String huodongjieshao;
/**
*
*/
private String sfsh; // 是否审核字段,用于标记活动是否已通过审核
private String sfsh;
/**
*
*/
private String shhf; // 审核回复字段,用于存储审核人员的回复内容
private String shhf;
/**
*
*/
public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing; // 设置活动类型的值
this.huodongleixing = huodongleixing;
}
/**
*
*/
public String getHuodongleixing() {
return huodongleixing; // 返回活动类型的值
return huodongleixing;
}
/**
*
*/
public void setTupian(String tupian) {
this.tupian = tupian; // 设置图片链接或路径的值
this.tupian = tupian;
}
/**
*
*/
public String getTupian() {
return tupian; // 返回图片链接或路径的值
return tupian;
}
/**
*
*/
public void setHuodongshijian(Date huodongshijian) {
this.huodongshijian = huodongshijian; // 设置活动时间的值
this.huodongshijian = huodongshijian;
}
/**
*
*/
public Date getHuodongshijian() {
return huodongshijian; // 返回活动时间的值
return huodongshijian;
}
/**
*
*/
public void setRenshu(Integer renshu) {
this.renshu = renshu; // 设置活动人数的值
this.renshu = renshu;
}
/**
*
*/
public Integer getRenshu() {
return renshu; // 返回活动人数的值
return renshu;
}
/**
*
*/
public void setHuodongchangdi(String huodongchangdi) {
this.huodongchangdi = huodongchangdi; // 设置活动场地的值
this.huodongchangdi = huodongchangdi;
}
/**
*
*/
public String getHuodongchangdi() {
return huodongchangdi; // 返回活动场地的值
return huodongchangdi;
}
/**
*
*/
public void setHuodongjieshao(String huodongjieshao) {
this.huodongjieshao = huodongjieshao; // 设置活动介绍的值
this.huodongjieshao = huodongjieshao;
}
/**
*
*/
public String getHuodongjieshao() {
return huodongjieshao; // 返回活动介绍的值
return huodongjieshao;
}
/**
*
*/
public void setSfsh(String sfsh) {
this.sfsh = sfsh; // 设置是否审核的值
this.sfsh = sfsh;
}
/**
*
*/
public String getSfsh() {
return sfsh; // 返回是否审核的值
return sfsh;
}
/**
*
*/
public void setShhf(String shhf) {
this.shhf = shhf; // 设置审核回复的值
this.shhf = shhf;
}
/**
*
*/
public String getShhf() {
return shhf; // 返回审核回复的值
return shhf;
}
}

@ -1,116 +1,136 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.MessagesEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.MessagesEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class MessagesModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
public class MessagesModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String username; // 用户名字段,用于存储用户的唯一标识
private String username;
/**
*
*/
private String content; // 留言内容字段,用于存储用户留下的文字内容
private String content;
/**
*
*/
private String cpicture; // 留言图片字段,用于存储与留言相关的图片链接或路径
private String cpicture;
/**
*
*/
private String reply; // 回复内容字段,用于存储管理员或其他用户对留言的回复内容
private String reply;
/**
*
*/
private String rpicture; // 回复图片字段,用于存储与回复相关的图片链接或路径
private String rpicture;
/**
*
*/
public void setUsername(String username) {
this.username = username; // 设置用户名的值
this.username = username;
}
/**
*
*/
public String getUsername() {
return username; // 返回用户名的值
return username;
}
/**
*
*/
public void setContent(String content) {
this.content = content; // 设置留言内容的值
this.content = content;
}
/**
*
*/
public String getContent() {
return content; // 返回留言内容的值
return content;
}
/**
*
*/
public void setCpicture(String cpicture) {
this.cpicture = cpicture; // 设置留言图片链接或路径的值
this.cpicture = cpicture;
}
/**
*
*/
public String getCpicture() {
return cpicture; // 返回留言图片链接或路径的值
return cpicture;
}
/**
*
*/
public void setReply(String reply) {
this.reply = reply; // 设置回复内容的值
this.reply = reply;
}
/**
*
*/
public String getReply() {
return reply; // 返回回复内容的值
return reply;
}
/**
*
*/
public void setRpicture(String rpicture) {
this.rpicture = rpicture; // 设置回复图片链接或路径的值
this.rpicture = rpicture;
}
/**
*
*/
public String getRpicture() {
return rpicture; // 返回回复图片链接或路径的值
return rpicture;
}
}

@ -1,78 +1,92 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.NewsEntity; // 导入实体类,可能用于数据映射
import com.baomidou.mybatisplus.annotations.TableName; // 导入 MyBatis-Plus 表注解
import java.util.Date; // 导入日期类,用于处理时间字段
import org.springframework.format.annotation.DateTimeFormat; // 导入日期格式注解
import com.fasterxml.jackson.annotation.JsonFormat; // 导入 JSON 格式化注解
import java.io.Serializable; // 导入接口,支持对象序列化
import com.entity.NewsEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
* ModelAndView model
* @author [Your Name] // 作者信息
* @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 // 创建日期
*
* entity
* ModelAndView model
* @author
* @email
* @date 2022-05-06 08:33:49
*/
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 introduction;
/**
*
*/
private String picture; // 公告相关的图片链接或路径,用于展示视觉内容
private String picture;
/**
*
*/
private String content; // 公告的具体内容,可以是较长的文字描述
private String content;
/**
*
*/
public void setIntroduction(String introduction) {
this.introduction = introduction; // 设置公告的简介
this.introduction = introduction;
}
/**
*
*/
public String getIntroduction() {
return introduction; // 返回公告的简介
return introduction;
}
/**
*
*/
public void setPicture(String picture) {
this.picture = picture; // 设置公告图片的链接或路径
this.picture = picture;
}
/**
*
*/
public String getPicture() {
return picture; // 返回公告图片的链接或路径
return picture;
}
/**
*
*/
public void setContent(String content) {
this.content = content; // 设置公告的具体内容
this.content = content;
}
/**
*
*/
public String getContent() {
return content; // 返回公告的具体内容
return content;
}
}

@ -1,152 +1,246 @@
package com.entity.model; // 定义包路径,存放模型类
package com.entity.model;
import com.entity.ZhiyuanzheEntity; // 引入志愿者实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import java.util.Date; // 引入 Date 类
import org.springframework.format.annotation.DateTimeFormat; // 引入日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat; // 引入 JSON 格式化注解
import java.io.Serializable; // 引入 Serializable 接口
import com.entity.ZhiyuanzheEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serializable;
/**
*
*
* entity
*
* entity
* ModelAndView model
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
public class ZhiyuanzheModel implements Serializable { // 定义志愿者模型类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
// 密码字段
public class ZhiyuanzheModel implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
private String mima;
// 姓名字段
/**
*
*/
private String xingming;
// 性别字段
/**
*
*/
private String xingbie;
// 头像字段
/**
*
*/
private String touxiang;
// 年龄字段
/**
*
*/
private String nianling;
// 班级字段
/**
*
*/
private String banji;
// 邮箱字段
/**
*
*/
private String youxiang;
// 手机字段
/**
*
*/
private String shouji;
// 是否审核字段
/**
*
*/
private String sfsh;
// 审核回复字段
/**
*
*/
private String shhf;
// 设置密码的方法
/**
*
*/
public void setMima(String mima) {
this.mima = mima;
}
// 获取密码的方法
/**
*
*/
public String getMima() {
return mima;
}
// 设置姓名的方法
/**
*
*/
public void setXingming(String xingming) {
this.xingming = xingming;
}
// 获取姓名的方法
/**
*
*/
public String getXingming() {
return xingming;
}
// 设置性别的方法
/**
*
*/
public void setXingbie(String xingbie) {
this.xingbie = xingbie;
}
// 获取性别的方法
/**
*
*/
public String getXingbie() {
return xingbie;
}
// 设置头像的方法
/**
*
*/
public void setTouxiang(String touxiang) {
this.touxiang = touxiang;
}
// 获取头像的方法
/**
*
*/
public String getTouxiang() {
return touxiang;
}
// 设置年龄的方法
/**
*
*/
public void setNianling(String nianling) {
this.nianling = nianling;
}
// 获取年龄的方法
/**
*
*/
public String getNianling() {
return nianling;
}
// 设置班级的方法
/**
*
*/
public void setBanji(String banji) {
this.banji = banji;
}
// 获取班级的方法
/**
*
*/
public String getBanji() {
return banji;
}
// 设置邮箱的方法
/**
*
*/
public void setYouxiang(String youxiang) {
this.youxiang = youxiang;
}
// 获取邮箱的方法
/**
*
*/
public String getYouxiang() {
return youxiang;
}
// 设置手机的方法
/**
*
*/
public void setShouji(String shouji) {
this.shouji = shouji;
}
// 获取手机的方法
/**
*
*/
public String getShouji() {
return shouji;
}
// 设置是否审核的方法
/**
*
*/
public void setSfsh(String sfsh) {
this.sfsh = sfsh;
}
// 获取是否审核的方法
/**
*
*/
public String getSfsh() {
return sfsh;
}
// 设置审核回复的方法
/**
*
*/
public void setShhf(String shhf) {
this.shhf = shhf;
}
// 获取审核回复的方法
/**
*
*/
public String getShhf() {
return shhf;
}
}

@ -1,33 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.HuodongbaomingEntity; // 引入活动报名表的实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 Apache Commons BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射异常类
import java.io.Serializable; // 引入 Serializable 接口,使类支持序列化
import com.entity.HuodongbaomingEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongbaoming") // 设置数据库表名
public class HuodongbaomingView extends HuodongbaomingEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongbaoming")
public class HuodongbaomingView extends HuodongbaomingEntity implements Serializable {
private static final long serialVersionUID = 1L;
public HuodongbaomingView(){ // 无参构造函数
public HuodongbaomingView(){
}
public HuodongbaomingView(HuodongbaomingEntity huodongbaomingEntity){ // 有参构造函数
try {
BeanUtils.copyProperties(this, huodongbaomingEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
public HuodongbaomingView(HuodongbaomingEntity huodongbaomingEntity){
try {
BeanUtils.copyProperties(this, huodongbaomingEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,33 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.HuodongleixingEntity; // 引入活动类型的实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 Apache Commons BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射异常类
import java.io.Serializable; // 引入 Serializable 接口,使类支持序列化
import com.entity.HuodongleixingEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongleixing") // 设置数据库表名
public class HuodongleixingView extends HuodongleixingEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongleixing")
public class HuodongleixingView extends HuodongleixingEntity implements Serializable {
private static final long serialVersionUID = 1L;
public HuodongleixingView(){ // 无参构造函数
public HuodongleixingView(){
}
public HuodongleixingView(HuodongleixingEntity huodongleixingEntity){ // 有参构造函数
try {
BeanUtils.copyProperties(this, huodongleixingEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
public HuodongleixingView(HuodongleixingEntity huodongleixingEntity){
try {
BeanUtils.copyProperties(this, huodongleixingEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,33 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.HuodongtongzhiEntity; // 引入活动通知的实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 Apache Commons BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射异常类
import java.io.Serializable; // 引入 Serializable 接口,使类支持序列化
import com.entity.HuodongtongzhiEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongtongzhi") // 设置数据库表名
public class HuodongtongzhiView extends HuodongtongzhiEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongtongzhi")
public class HuodongtongzhiView extends HuodongtongzhiEntity implements Serializable {
private static final long serialVersionUID = 1L;
public HuodongtongzhiView(){ // 无参构造函数
public HuodongtongzhiView(){
}
public HuodongtongzhiView(HuodongtongzhiEntity huodongtongzhiEntity){ // 有参构造函数
try {
BeanUtils.copyProperties(this, huodongtongzhiEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
public HuodongtongzhiView(HuodongtongzhiEntity huodongtongzhiEntity){
try {
BeanUtils.copyProperties(this, huodongtongzhiEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,33 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.HuodongxindeEntity; // 引入活动心得的实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 Apache Commons BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射异常类
import java.io.Serializable; // 引入 Serializable 接口,使类支持序列化
import com.entity.HuodongxindeEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongxinde") // 设置数据库表名
public class HuodongxindeView extends HuodongxindeEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongxinde")
public class HuodongxindeView extends HuodongxindeEntity implements Serializable {
private static final long serialVersionUID = 1L;
public HuodongxindeView(){ // 无参构造函数
public HuodongxindeView(){
}
public HuodongxindeView(HuodongxindeEntity huodongxindeEntity){ // 有参构造函数
try {
BeanUtils.copyProperties(this, huodongxindeEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
public HuodongxindeView(HuodongxindeEntity huodongxindeEntity){
try {
BeanUtils.copyProperties(this, huodongxindeEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,33 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.HuodongxinxiEntity; // 引入活动信息的实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 Apache Commons BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射异常类
import java.io.Serializable; // 引入 Serializable 接口,使类支持序列化
import com.entity.HuodongxinxiEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("huodongxinxi") // 设置数据库表名
public class HuodongxinxiView extends HuodongxinxiEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("huodongxinxi")
public class HuodongxinxiView extends HuodongxinxiEntity implements Serializable {
private static final long serialVersionUID = 1L;
public HuodongxinxiView(){ // 无参构造函数
public HuodongxinxiView(){
}
public HuodongxinxiView(HuodongxinxiEntity huodongxinxiEntity){ // 有参构造函数
try {
BeanUtils.copyProperties(this, huodongxinxiEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
public HuodongxinxiView(HuodongxinxiEntity huodongxinxiEntity){
try {
BeanUtils.copyProperties(this, huodongxinxiEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace(); // 打印异常堆栈信息
e.printStackTrace();
}
}
}

@ -1,35 +1,36 @@
package com.entity.view; // 定义包路径,存放视图实体类
package com.entity.view;
import com.entity.ZhiyuanzheEntity; // 引入志愿者实体类
import com.baomidou.mybatisplus.annotations.TableName; // 引入 MyBatis-Plus 的 TableName 注解
import org.apache.commons.beanutils.BeanUtils; // 引入 BeanUtils 工具类
import java.lang.reflect.InvocationTargetException; // 引入反射相关的异常类
import java.io.Serializable; // 引入 Serializable 接口
import com.entity.ZhiyuanzheEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;
import java.lang.reflect.InvocationTargetException;
import java.io.Serializable;
/**
*
*
*
* 使
* @author []
* @email []
* @author
* @email
* @date 2022-05-06 08:33:49
*/
@TableName("zhiyuanzhe") // 定义数据库表名
public class ZhiyuanzheView extends ZhiyuanzheEntity implements Serializable { // 定义志愿者视图类,并继承志愿者实体类
private static final long serialVersionUID = 1L; // 定义序列化版本号
@TableName("zhiyuanzhe")
public class ZhiyuanzheView extends ZhiyuanzheEntity implements Serializable {
private static final long serialVersionUID = 1L;
// 默认构造函数
public ZhiyuanzheView(){
}
// 带参数的构造函数,用于将 ZhiyuanzheEntity 对象转换为 ZhiyuanzheView 对象
public ZhiyuanzheView(ZhiyuanzheEntity zhiyuanzheEntity){
try {
// 使用 BeanUtils 工具类将 ZhiyuanzheEntity 的属性复制到 ZhiyuanzheView 中
public ZhiyuanzheView(ZhiyuanzheEntity zhiyuanzheEntity){
try {
BeanUtils.copyProperties(this, zhiyuanzheEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 捕获并打印异常
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

@ -1,84 +1,64 @@
package com.service.impl; // 定义包路径,存放服务实现类
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
package com.service.impl;
import org.springframework.beans.factory.annotation.Autowired; // 导入 Spring 的 Autowired 注解,用于自动注入依赖
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import com.dao.CommonDao; // 导入 DAO 层接口,用于操作数据库
import com.service.CommonService; // 导入服务接口,定义服务层方法
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dao.CommonDao;
import com.service.CommonService;
/**
*
*/
@Service("commonService") // 定义服务类,并通过名称 commonService 注册到 Spring 容器中
public class CommonServiceImpl implements CommonService { // 定义服务实现类
@Service("commonService")
public class CommonServiceImpl implements CommonService {
@Autowired
private CommonDao commonDao;
@Autowired // 自动注入 CommonDao 对象
private CommonDao commonDao; // 定义 DAO 层对象,用于操作数据库
/**
*
*/
@Override
public List<String> getOption(Map<String, Object> params) {
return commonDao.getOption(params); // 调用 DAO 层方法,获取选项列表
return commonDao.getOption(params);
}
/**
*
*/
@Override
public Map<String, Object> getFollowByOption(Map<String, Object> params) {
return commonDao.getFollowByOption(params); // 调用 DAO 层方法,获取关注信息
return commonDao.getFollowByOption(params);
}
/**
*
*/
@Override
public void sh(Map<String, Object> params) {
commonDao.sh(params); // 调用 DAO 层方法,执行操作
commonDao.sh(params);
}
/**
*
*/
@Override
public int remindCount(Map<String, Object> params) {
return commonDao.remindCount(params); // 调用 DAO 层方法,获取提醒数量
return commonDao.remindCount(params);
}
/**
*
*/
@Override
public Map<String, Object> selectCal(Map<String, Object> params) {
return commonDao.selectCal(params); // 调用 DAO 层方法,查询日历数据
return commonDao.selectCal(params);
}
/**
*
*/
@Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
return commonDao.selectGroup(params); // 调用 DAO 层方法,查询分组数据
return commonDao.selectGroup(params);
}
/**
*
*/
@Override
public List<Map<String, Object>> selectValue(Map<String, Object> params) {
return commonDao.selectValue(params); // 调用 DAO 层方法,查询值数据
return commonDao.selectValue(params);
}
/**
*
*/
@Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) {
return commonDao.selectTimeStatValue(params); // 调用 DAO 层方法,查询时间统计值数据
return commonDao.selectTimeStatValue(params);
}
}

@ -1,89 +1,63 @@
package com.service.impl; // 定义包路径,存放服务实现类
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
// 导入 MyBatis-Plus 相关工具类
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入 Wrapper 抽象类,用于构建条件表达式
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入 EntityWrapper 类,用于构建实体对象的条件表达式
import com.baomidou.mybatisplus.plugins.Page; // 导入分页插件的 Page 类
import com.baomidou.mybatisplus.service.impl.ServiceImpl; // 导入 MyBatis-Plus 提供的 ServiceImpl 基类
// 导入自定义工具类和实体类
import com.utils.PageUtils; // 导入自定义的分页工具类
import com.utils.Query; // 导入自定义的分页查询工具类
import com.dao.HuodongbaomingDao; // 导入 DAO 层接口,用于操作数据库
import com.entity.HuodongbaomingEntity; // 导入实体类,表示活动报名表的数据模型
import com.service.HuodongbaomingService; // 导入服务接口,定义服务层方法
import com.entity.vo.HuodongbaomingVO; // 导入 VO视图对象表示返回给前端的数据结构
import com.entity.view.HuodongbaomingView; // 导入 View视图对象表示复杂查询结果的数据结构
@Service("huodongbaomingService") // 定义服务类,并通过名称 huodongbaomingService 注册到 Spring 容器中
public class HuodongbaomingServiceImpl extends ServiceImpl<HuodongbaomingDao, HuodongbaomingEntity> implements HuodongbaomingService { // 定义服务实现类
/**
*
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建分页对象,并设置查询条件
Page<HuodongbaomingEntity> page = this.selectPage(
new Query<HuodongbaomingEntity>(params).getPage(), // 获取分页参数
new EntityWrapper<HuodongbaomingEntity>() // 构建默认条件
);
// 将分页结果包装为自定义的分页工具类
return new PageUtils(page);
}
/**
*
*/
@Override
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.HuodongbaomingDao;
import com.entity.HuodongbaomingEntity;
import com.service.HuodongbaomingService;
import com.entity.vo.HuodongbaomingVO;
import com.entity.view.HuodongbaomingView;
@Service("huodongbaomingService")
public class HuodongbaomingServiceImpl extends ServiceImpl<HuodongbaomingDao, HuodongbaomingEntity> implements HuodongbaomingService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<HuodongbaomingEntity> page = this.selectPage(
new Query<HuodongbaomingEntity>(params).getPage(),
new EntityWrapper<HuodongbaomingEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<HuodongbaomingEntity> wrapper) {
// 创建分页对象,并设置查询条件
Page<HuodongbaomingView> page = new Query<HuodongbaomingView>(params).getPage();
// 执行自定义查询,将结果填充到分页对象中
page.setRecords(baseMapper.selectListView(page, wrapper)); // 调用自定义 SQL 查询
// 将分页结果包装为自定义的分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
*/
@Override
Page<HuodongbaomingView> page =new Query<HuodongbaomingView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<HuodongbaomingVO> selectListVO(Wrapper<HuodongbaomingEntity> wrapper) {
// 调用自定义 SQL 查询,返回 VO 对象列表
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListVO(wrapper);
}
/**
*
*/
@Override
public HuodongbaomingVO selectVO(Wrapper<HuodongbaomingEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 VO 对象
return baseMapper.selectVO(wrapper);
return baseMapper.selectVO(wrapper);
}
/**
*
*/
@Override
public List<HuodongbaomingView> selectListView(Wrapper<HuodongbaomingEntity> wrapper) {
// 调用自定义 SQL 查询,返回 View 对象列表
return baseMapper.selectListView(wrapper);
}
/**
*
*/
@Override
public HuodongbaomingView selectView(Wrapper<HuodongbaomingEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 View 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,89 +1,63 @@
package com.service.impl; // 定义包路径,存放服务实现类
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
// 导入 MyBatis-Plus 相关工具类
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入 Wrapper 抽象类,用于构建条件表达式
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入 EntityWrapper 类,用于构建实体对象的条件表达式
import com.baomidou.mybatisplus.plugins.Page; // 导入分页插件的 Page 类
import com.baomidou.mybatisplus.service.impl.ServiceImpl; // 导入 MyBatis-Plus 提供的 ServiceImpl 基类
// 导入自定义工具类和实体类
import com.utils.PageUtils; // 导入自定义的分页工具类
import com.utils.Query; // 导入自定义的分页查询工具类
import com.dao.HuodongleixingDao; // 导入 DAO 层接口,用于操作数据库
import com.entity.HuodongleixingEntity; // 导入实体类,表示活动类型的实体对象
import com.service.HuodongleixingService; // 导入服务接口,定义服务层方法
import com.entity.vo.HuodongleixingVO; // 导入 VO视图对象表示返回给前端的数据结构
import com.entity.view.HuodongleixingView; // 导入 View视图对象表示复杂查询结果的数据结构
@Service("huodongleixingService") // 定义服务类,并通过名称 huodongleixingService 注册到 Spring 容器中
public class HuodongleixingServiceImpl extends ServiceImpl<HuodongleixingDao, HuodongleixingEntity> implements HuodongleixingService { // 定义服务实现类
/**
*
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建分页对象,并设置查询条件
Page<HuodongleixingEntity> page = this.selectPage(
new Query<HuodongleixingEntity>(params).getPage(), // 获取分页参数
new EntityWrapper<HuodongleixingEntity>() // 构建默认条件
);
// 将分页结果包装为自定义的分页工具类
return new PageUtils(page);
}
/**
*
*/
@Override
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.HuodongleixingDao;
import com.entity.HuodongleixingEntity;
import com.service.HuodongleixingService;
import com.entity.vo.HuodongleixingVO;
import com.entity.view.HuodongleixingView;
@Service("huodongleixingService")
public class HuodongleixingServiceImpl extends ServiceImpl<HuodongleixingDao, HuodongleixingEntity> implements HuodongleixingService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<HuodongleixingEntity> page = this.selectPage(
new Query<HuodongleixingEntity>(params).getPage(),
new EntityWrapper<HuodongleixingEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<HuodongleixingEntity> wrapper) {
// 创建分页对象,并设置查询条件
Page<HuodongleixingView> page = new Query<HuodongleixingView>(params).getPage();
// 执行自定义查询,将结果填充到分页对象中
page.setRecords(baseMapper.selectListView(page, wrapper)); // 调用自定义 SQL 查询
// 将分页结果包装为自定义的分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
*/
@Override
Page<HuodongleixingView> page =new Query<HuodongleixingView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<HuodongleixingVO> selectListVO(Wrapper<HuodongleixingEntity> wrapper) {
// 调用自定义 SQL 查询,返回 VO 对象列表
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListVO(wrapper);
}
/**
*
*/
@Override
public HuodongleixingVO selectVO(Wrapper<HuodongleixingEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 VO 对象
return baseMapper.selectVO(wrapper);
return baseMapper.selectVO(wrapper);
}
/**
*
*/
@Override
public List<HuodongleixingView> selectListView(Wrapper<HuodongleixingEntity> wrapper) {
// 调用自定义 SQL 查询,返回 View 对象列表
return baseMapper.selectListView(wrapper);
}
/**
*
*/
@Override
public HuodongleixingView selectView(Wrapper<HuodongleixingEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 View 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,89 +1,63 @@
package com.service.impl; // 定义包路径,存放服务实现类
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
// 导入 MyBatis-Plus 相关工具类
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入 Wrapper 抽象类,用于构建条件表达式
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入 EntityWrapper 类,用于构建实体对象的条件表达式
import com.baomidou.mybatisplus.plugins.Page; // 导入分页插件的 Page 类
import com.baomidou.mybatisplus.service.impl.ServiceImpl; // 导入 MyBatis-Plus 提供的 ServiceImpl 基类
// 导入自定义工具类和实体类
import com.utils.PageUtils; // 导入自定义的分页工具类
import com.utils.Query; // 导入自定义的分页查询工具类
import com.dao.HuodongtongzhiDao; // 导入 DAO 层接口,用于操作数据库
import com.entity.HuodongtongzhiEntity; // 导入实体类,表示活动通知的实体对象
import com.service.HuodongtongzhiService; // 导入服务接口,定义服务层方法
import com.entity.vo.HuodongtongzhiVO; // 导入 VO视图对象表示返回给前端的数据结构
import com.entity.view.HuodongtongzhiView; // 导入 View视图对象表示复杂查询结果的数据结构
@Service("huodongtongzhiService") // 定义服务类,并通过名称 huodongtongzhiService 注册到 Spring 容器中
public class HuodongtongzhiServiceImpl extends ServiceImpl<HuodongtongzhiDao, HuodongtongzhiEntity> implements HuodongtongzhiService { // 定义服务实现类
/**
*
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建分页对象,并设置查询条件
Page<HuodongtongzhiEntity> page = this.selectPage(
new Query<HuodongtongzhiEntity>(params).getPage(), // 获取分页参数
new EntityWrapper<HuodongtongzhiEntity>() // 构建默认条件
);
// 将分页结果包装为自定义的分页工具类
return new PageUtils(page);
}
/**
*
*/
@Override
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.HuodongtongzhiDao;
import com.entity.HuodongtongzhiEntity;
import com.service.HuodongtongzhiService;
import com.entity.vo.HuodongtongzhiVO;
import com.entity.view.HuodongtongzhiView;
@Service("huodongtongzhiService")
public class HuodongtongzhiServiceImpl extends ServiceImpl<HuodongtongzhiDao, HuodongtongzhiEntity> implements HuodongtongzhiService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<HuodongtongzhiEntity> page = this.selectPage(
new Query<HuodongtongzhiEntity>(params).getPage(),
new EntityWrapper<HuodongtongzhiEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<HuodongtongzhiEntity> wrapper) {
// 创建分页对象,并设置查询条件
Page<HuodongtongzhiView> page = new Query<HuodongtongzhiView>(params).getPage();
// 执行自定义查询,将结果填充到分页对象中
page.setRecords(baseMapper.selectListView(page, wrapper)); // 调用自定义 SQL 查询
// 将分页结果包装为自定义的分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
*/
@Override
Page<HuodongtongzhiView> page =new Query<HuodongtongzhiView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<HuodongtongzhiVO> selectListVO(Wrapper<HuodongtongzhiEntity> wrapper) {
// 调用自定义 SQL 查询,返回 VO 对象列表
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListVO(wrapper);
}
/**
*
*/
@Override
public HuodongtongzhiVO selectVO(Wrapper<HuodongtongzhiEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 VO 对象
return baseMapper.selectVO(wrapper);
return baseMapper.selectVO(wrapper);
}
/**
*
*/
@Override
public List<HuodongtongzhiView> selectListView(Wrapper<HuodongtongzhiEntity> wrapper) {
// 调用自定义 SQL 查询,返回 View 对象列表
return baseMapper.selectListView(wrapper);
}
/**
*
*/
@Override
public HuodongtongzhiView selectView(Wrapper<HuodongtongzhiEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 View 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,89 +1,63 @@
package com.service.impl; // 定义包路径,存放服务实现类
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
// 导入 MyBatis-Plus 相关工具类
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入 Wrapper 抽象类,用于构建条件表达式
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入 EntityWrapper 类,用于构建实体对象的条件表达式
import com.baomidou.mybatisplus.plugins.Page; // 导入分页插件的 Page 类
import com.baomidou.mybatisplus.service.impl.ServiceImpl; // 导入 MyBatis-Plus 提供的 ServiceImpl 基类
// 导入自定义工具类和实体类
import com.utils.PageUtils; // 导入自定义的分页工具类
import com.utils.Query; // 导入自定义的分页查询工具类
import com.dao.HuodongxindeDao; // 导入 DAO 层接口,用于操作数据库
import com.entity.HuodongxindeEntity; // 导入实体类,表示活动新闻的实体对象
import com.service.HuodongxindeService; // 导入服务接口,定义服务层方法
import com.entity.vo.HuodongxindeVO; // 导入 VO视图对象表示返回给前端的数据结构
import com.entity.view.HuodongxindeView; // 导入 View视图对象表示复杂查询结果的数据结构
@Service("huodongxindeService") // 定义服务类,并通过名称 huodongxindeService 注册到 Spring 容器中
public class HuodongxindeServiceImpl extends ServiceImpl<HuodongxindeDao, HuodongxindeEntity> implements HuodongxindeService { // 定义服务实现类
/**
*
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建分页对象,并设置查询条件
Page<HuodongxindeEntity> page = this.selectPage(
new Query<HuodongxindeEntity>(params).getPage(), // 获取分页参数
new EntityWrapper<HuodongxindeEntity>() // 构建默认条件
);
// 将分页结果包装为自定义的分页工具类
return new PageUtils(page);
}
/**
*
*/
@Override
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.HuodongxindeDao;
import com.entity.HuodongxindeEntity;
import com.service.HuodongxindeService;
import com.entity.vo.HuodongxindeVO;
import com.entity.view.HuodongxindeView;
@Service("huodongxindeService")
public class HuodongxindeServiceImpl extends ServiceImpl<HuodongxindeDao, HuodongxindeEntity> implements HuodongxindeService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<HuodongxindeEntity> page = this.selectPage(
new Query<HuodongxindeEntity>(params).getPage(),
new EntityWrapper<HuodongxindeEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<HuodongxindeEntity> wrapper) {
// 创建分页对象,并设置查询条件
Page<HuodongxindeView> page = new Query<HuodongxindeView>(params).getPage();
// 执行自定义查询,将结果填充到分页对象中
page.setRecords(baseMapper.selectListView(page, wrapper)); // 调用自定义 SQL 查询
// 将分页结果包装为自定义的分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
*/
@Override
Page<HuodongxindeView> page =new Query<HuodongxindeView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<HuodongxindeVO> selectListVO(Wrapper<HuodongxindeEntity> wrapper) {
// 调用自定义 SQL 查询,返回 VO 对象列表
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListVO(wrapper);
}
/**
*
*/
@Override
public HuodongxindeVO selectVO(Wrapper<HuodongxindeEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 VO 对象
return baseMapper.selectVO(wrapper);
return baseMapper.selectVO(wrapper);
}
/**
*
*/
@Override
public List<HuodongxindeView> selectListView(Wrapper<HuodongxindeEntity> wrapper) {
// 调用自定义 SQL 查询,返回 View 对象列表
return baseMapper.selectListView(wrapper);
}
/**
*
*/
@Override
public HuodongxindeView selectView(Wrapper<HuodongxindeEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 View 对象
return baseMapper.selectView(wrapper);
}
}

@ -1,89 +1,63 @@
package com.service.impl; // 定义包路径,存放服务实现类
import org.springframework.stereotype.Service; // 导入 Spring 的 Service 注解,用于标识服务层组件
import java.util.Map; // 导入 Map 接口,用于表示键值对集合
import java.util.List; // 导入 List 泛型接口,用于表示动态数组
// 导入 MyBatis-Plus 相关工具类
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入 Wrapper 抽象类,用于构建条件表达式
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入 EntityWrapper 类,用于构建实体对象的条件表达式
import com.baomidou.mybatisplus.plugins.Page; // 导入分页插件的 Page 类
import com.baomidou.mybatisplus.service.impl.ServiceImpl; // 导入 MyBatis-Plus 提供的 ServiceImpl 基类
// 导入自定义工具类和实体类
import com.utils.PageUtils; // 导入自定义的分页工具类
import com.utils.Query; // 导入自定义的分页查询工具类
import com.dao.HuodongxinxiDao; // 导入 DAO 层接口,用于操作数据库
import com.entity.HuodongxinxiEntity; // 导入实体类,表示活动信息的实体对象
import com.service.HuodongxinxiService; // 导入服务接口,定义服务层方法
import com.entity.vo.HuodongxinxiVO; // 导入 VO视图对象表示返回给前端的数据结构
import com.entity.view.HuodongxinxiView; // 导入 View视图对象表示复杂查询结果的数据结构
@Service("huodongxinxiService") // 定义服务类,并通过名称 huodongxinxiService 注册到 Spring 容器中
public class HuodongxinxiServiceImpl extends ServiceImpl<HuodongxinxiDao, HuodongxinxiEntity> implements HuodongxinxiService { // 定义服务实现类
/**
*
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 创建分页对象,并设置查询条件
Page<HuodongxinxiEntity> page = this.selectPage(
new Query<HuodongxinxiEntity>(params).getPage(), // 获取分页参数
new EntityWrapper<HuodongxinxiEntity>() // 构建默认条件
);
// 将分页结果包装为自定义的分页工具类
return new PageUtils(page);
}
/**
*
*/
@Override
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.List;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.HuodongxinxiDao;
import com.entity.HuodongxinxiEntity;
import com.service.HuodongxinxiService;
import com.entity.vo.HuodongxinxiVO;
import com.entity.view.HuodongxinxiView;
@Service("huodongxinxiService")
public class HuodongxinxiServiceImpl extends ServiceImpl<HuodongxinxiDao, HuodongxinxiEntity> implements HuodongxinxiService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<HuodongxinxiEntity> page = this.selectPage(
new Query<HuodongxinxiEntity>(params).getPage(),
new EntityWrapper<HuodongxinxiEntity>()
);
return new PageUtils(page);
}
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<HuodongxinxiEntity> wrapper) {
// 创建分页对象,并设置查询条件
Page<HuodongxinxiView> page = new Query<HuodongxinxiView>(params).getPage();
// 执行自定义查询,将结果填充到分页对象中
page.setRecords(baseMapper.selectListView(page, wrapper)); // 调用自定义 SQL 查询
// 将分页结果包装为自定义的分页工具类
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
*
*/
@Override
Page<HuodongxinxiView> page =new Query<HuodongxinxiView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
@Override
public List<HuodongxinxiVO> selectListVO(Wrapper<HuodongxinxiEntity> wrapper) {
// 调用自定义 SQL 查询,返回 VO 对象列表
return baseMapper.selectListVO(wrapper);
return baseMapper.selectListVO(wrapper);
}
/**
*
*/
@Override
public HuodongxinxiVO selectVO(Wrapper<HuodongxinxiEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 VO 对象
return baseMapper.selectVO(wrapper);
return baseMapper.selectVO(wrapper);
}
/**
*
*/
@Override
public List<HuodongxinxiView> selectListView(Wrapper<HuodongxinxiEntity> wrapper) {
// 调用自定义 SQL 查询,返回 View 对象列表
return baseMapper.selectListView(wrapper);
}
/**
*
*/
@Override
public HuodongxinxiView selectView(Wrapper<HuodongxinxiEntity> wrapper) {
// 调用自定义 SQL 查询,返回单个 View 对象
return baseMapper.selectView(wrapper);
}
}

Loading…
Cancel
Save