branch3
admin 4 months ago
parent f9308845d6
commit 42e0abed18

@ -4,7 +4,7 @@ import java.lang.annotation.ElementType;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; import java.lang.annotation.Target;
//11111
@Target(ElementType.PARAMETER) @Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
public @interface APPLoginUser { public @interface APPLoginUser {

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

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

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

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

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

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

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

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

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

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

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

@ -1,226 +1,195 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class HuodongbaomingModel implements Serializable { public class HuodongbaomingModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; 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") // 格式化日期时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss") // 设置日期格式
@DateTimeFormat private Date baomingshijian; // 报名时间字段
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 方法
public void setHuodongleixing(String huodongleixing) { this.huodongleixing = huodongleixing; // 将传入的值赋给字段
this.huodongleixing = huodongleixing;
} }
/** /**
* *
*/ */
public String getHuodongleixing() { public String getHuodongleixing() { // 获取活动类型的 getter 方法
return huodongleixing; return huodongleixing; // 返回活动类型字段的值
} }
/** /**
* *
*/ */
public void setRenshu(Integer renshu) { // 设置人数的 setter 方法
public void setRenshu(Integer renshu) { this.renshu = renshu; // 将传入的值赋给字段
this.renshu = renshu;
} }
/** /**
* *
*/ */
public Integer getRenshu() { public Integer getRenshu() { // 获取人数的 getter 方法
return renshu; return renshu; // 返回人数字段的值
} }
/** /**
* *
*/ */
public void setBaomingshuoming(String baomingshuoming) { // 设置报名说明的 setter 方法
public void setBaomingshuoming(String baomingshuoming) { this.baomingshuoming = baomingshuoming; // 将传入的值赋给字段
this.baomingshuoming = baomingshuoming;
} }
/** /**
* *
*/ */
public String getBaomingshuoming() { public String getBaomingshuoming() { // 获取报名说明的 getter 方法
return baomingshuoming; return baomingshuoming; // 返回报名说明字段的值
} }
/** /**
* *
*/ */
public void setBaomingshijian(Date baomingshijian) { // 设置报名时间的 setter 方法
public void setBaomingshijian(Date baomingshijian) { this.baomingshijian = baomingshijian; // 将传入的值赋给字段
this.baomingshijian = baomingshijian;
} }
/** /**
* *
*/ */
public Date getBaomingshijian() { public Date getBaomingshijian() { // 获取报名时间的 getter 方法
return baomingshijian; return baomingshijian; // 返回报名时间字段的值
} }
/** /**
* *
*/ */
public void setXuehao(String xuehao) { // 设置学号的 setter 方法
public void setXuehao(String xuehao) { this.xuehao = xuehao; // 将传入的值赋给字段
this.xuehao = xuehao;
} }
/** /**
* *
*/ */
public String getXuehao() { public String getXuehao() { // 获取学号的 getter 方法
return xuehao; return xuehao; // 返回学号字段的值
} }
/** /**
* *
*/ */
public void setXingming(String xingming) { // 设置姓名的 setter 方法
public void setXingming(String xingming) { this.xingming = xingming; // 将传入的值赋给字段
this.xingming = xingming;
} }
/** /**
* *
*/ */
public String getXingming() { public String getXingming() { // 获取姓名的 getter 方法
return xingming; return xingming; // 返回姓名字段的值
} }
/** /**
* *
*/ */
public void setShouji(String shouji) { // 设置手机号码的 setter 方法
public void setShouji(String shouji) { this.shouji = shouji; // 将传入的值赋给字段
this.shouji = shouji;
} }
/** /**
* *
*/ */
public String getShouji() { public String getShouji() { // 获取手机号码的 getter 方法
return shouji; return shouji; // 返回手机号码字段的值
} }
/** /**
* *
*/ */
public void setSfsh(String sfsh) { // 设置是否审核的 setter 方法
public void setSfsh(String sfsh) { this.sfsh = sfsh; // 将传入的值赋给字段
this.sfsh = sfsh;
} }
/** /**
* *
*/ */
public String getSfsh() { public String getSfsh() { // 获取是否审核的 getter 方法
return sfsh; return sfsh; // 返回是否审核字段的值
} }
/** /**
* *
*/ */
public void setShhf(String shhf) { // 设置审核回复的 setter 方法
public void setShhf(String shhf) { this.shhf = shhf; // 将传入的值赋给字段
this.shhf = shhf;
} }
/** /**
* *
*/ */
public String getShhf() { public String getShhf() { // 获取审核回复的 getter 方法
return shhf; return shhf; // 返回审核回复字段的值
} }
} }

@ -1,138 +1,118 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class HuodongtongzhiModel implements Serializable { public class HuodongtongzhiModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; 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") // 格式化日期时间为中文格式
@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
@DateTimeFormat private Date tongzhishijian; // 通知时间字段,用于存储活动通知的时间
private Date tongzhishijian;
/** /**
* *
*/ */
public void setXuehao(String xuehao) { public void setXuehao(String xuehao) {
this.xuehao = xuehao; this.xuehao = xuehao; // 设置学号值
} }
/** /**
* *
*/ */
public String getXuehao() { public String getXuehao() {
return xuehao; return xuehao; // 返回学号值
} }
/** /**
* *
*/ */
public void setXingming(String xingming) { public void setXingming(String xingming) {
this.xingming = xingming; this.xingming = xingming; // 设置姓名值
} }
/** /**
* *
*/ */
public String getXingming() { public String getXingming() {
return xingming; return xingming; // 返回姓名值
} }
/** /**
* *
*/ */
public void setShouji(String shouji) { public void setShouji(String shouji) {
this.shouji = shouji; this.shouji = shouji; // 设置手机号码值
} }
/** /**
* *
*/ */
public String getShouji() { public String getShouji() {
return shouji; return shouji; // 返回手机号码值
} }
/** /**
* *
*/ */
public void setTongzhineirong(String tongzhineirong) { public void setTongzhineirong(String tongzhineirong) {
this.tongzhineirong = tongzhineirong; this.tongzhineirong = tongzhineirong; // 设置通知内容值
} }
/** /**
* *
*/ */
public String getTongzhineirong() { public String getTongzhineirong() {
return tongzhineirong; return tongzhineirong; // 返回通知内容值
} }
/** /**
* *
*/ */
public void setTongzhishijian(Date tongzhishijian) { public void setTongzhishijian(Date tongzhishijian) {
this.tongzhishijian = tongzhishijian; this.tongzhishijian = tongzhishijian; // 设置通知时间值
} }
/** /**
* *
*/ */
public Date getTongzhishijian() { public Date getTongzhishijian() {
return tongzhishijian; return tongzhishijian; // 返回通知时间值
} }
} }

@ -1,138 +1,118 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class HuodongxindeModel implements Serializable { public class HuodongxindeModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; 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") // 格式化日期时间为中文格式
@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
@DateTimeFormat private Date fabushijian; // 发布时间字段,用于存储活动心得的发布时间
private Date fabushijian;
/** /**
* id * id
*/ */
private Long userid; // 用户id字段用于存储发布活动心得的用户的唯一标识
private Long userid;
/** /**
* *
*/ */
public void setHuodongleixing(String huodongleixing) { public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing; this.huodongleixing = huodongleixing; // 设置活动类型的值
} }
/** /**
* *
*/ */
public String getHuodongleixing() { public String getHuodongleixing() {
return huodongleixing; return huodongleixing; // 返回活动类型的值
} }
/** /**
* *
*/ */
public void setTupian(String tupian) { public void setTupian(String tupian) {
this.tupian = tupian; this.tupian = tupian; // 设置图片链接或路径的值
} }
/** /**
* *
*/ */
public String getTupian() { public String getTupian() {
return tupian; return tupian; // 返回图片链接或路径的值
} }
/** /**
* *
*/ */
public void setXindefenxiang(String xindefenxiang) { public void setXindefenxiang(String xindefenxiang) {
this.xindefenxiang = xindefenxiang; this.xindefenxiang = xindefenxiang; // 设置心得分享内容的值
} }
/** /**
* *
*/ */
public String getXindefenxiang() { public String getXindefenxiang() {
return xindefenxiang; return xindefenxiang; // 返回心得分享内容的值
} }
/** /**
* *
*/ */
public void setFabushijian(Date fabushijian) { public void setFabushijian(Date fabushijian) {
this.fabushijian = fabushijian; this.fabushijian = fabushijian; // 设置发布时间的值
} }
/** /**
* *
*/ */
public Date getFabushijian() { public Date getFabushijian() {
return fabushijian; return fabushijian; // 返回发布时间的值
} }
/** /**
* id * id
*/ */
public void setUserid(Long userid) { public void setUserid(Long userid) {
this.userid = userid; this.userid = userid; // 设置用户id的值
} }
/** /**
* id * id
*/ */
public Long getUserid() { public Long getUserid() {
return userid; return userid; // 返回用户id的值
} }
} }

@ -1,204 +1,175 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class HuodongxinxiModel implements Serializable { public class HuodongxinxiModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; 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") // 格式化日期时间为中文格式
@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
@DateTimeFormat private Date huodongshijian; // 活动时间字段,用于存储活动的时间信息
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) { public void setHuodongleixing(String huodongleixing) {
this.huodongleixing = huodongleixing; this.huodongleixing = huodongleixing; // 设置活动类型的值
} }
/** /**
* *
*/ */
public String getHuodongleixing() { public String getHuodongleixing() {
return huodongleixing; return huodongleixing; // 返回活动类型的值
} }
/** /**
* *
*/ */
public void setTupian(String tupian) { public void setTupian(String tupian) {
this.tupian = tupian; this.tupian = tupian; // 设置图片链接或路径的值
} }
/** /**
* *
*/ */
public String getTupian() { public String getTupian() {
return tupian; return tupian; // 返回图片链接或路径的值
} }
/** /**
* *
*/ */
public void setHuodongshijian(Date huodongshijian) { public void setHuodongshijian(Date huodongshijian) {
this.huodongshijian = huodongshijian; this.huodongshijian = huodongshijian; // 设置活动时间的值
} }
/** /**
* *
*/ */
public Date getHuodongshijian() { public Date getHuodongshijian() {
return huodongshijian; return huodongshijian; // 返回活动时间的值
} }
/** /**
* *
*/ */
public void setRenshu(Integer renshu) { public void setRenshu(Integer renshu) {
this.renshu = renshu; this.renshu = renshu; // 设置活动人数的值
} }
/** /**
* *
*/ */
public Integer getRenshu() { public Integer getRenshu() {
return renshu; return renshu; // 返回活动人数的值
} }
/** /**
* *
*/ */
public void setHuodongchangdi(String huodongchangdi) { public void setHuodongchangdi(String huodongchangdi) {
this.huodongchangdi = huodongchangdi; this.huodongchangdi = huodongchangdi; // 设置活动场地的值
} }
/** /**
* *
*/ */
public String getHuodongchangdi() { public String getHuodongchangdi() {
return huodongchangdi; return huodongchangdi; // 返回活动场地的值
} }
/** /**
* *
*/ */
public void setHuodongjieshao(String huodongjieshao) { public void setHuodongjieshao(String huodongjieshao) {
this.huodongjieshao = huodongjieshao; this.huodongjieshao = huodongjieshao; // 设置活动介绍的值
} }
/** /**
* *
*/ */
public String getHuodongjieshao() { public String getHuodongjieshao() {
return huodongjieshao; return huodongjieshao; // 返回活动介绍的值
} }
/** /**
* *
*/ */
public void setSfsh(String sfsh) { public void setSfsh(String sfsh) {
this.sfsh = sfsh; this.sfsh = sfsh; // 设置是否审核的值
} }
/** /**
* *
*/ */
public String getSfsh() { public String getSfsh() {
return sfsh; return sfsh; // 返回是否审核的值
} }
/** /**
* *
*/ */
public void setShhf(String shhf) { public void setShhf(String shhf) {
this.shhf = shhf; this.shhf = shhf; // 设置审核回复的值
} }
/** /**
* *
*/ */
public String getShhf() { public String getShhf() {
return shhf; return shhf; // 返回审核回复的值
} }
} }

@ -1,136 +1,116 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class MessagesModel implements Serializable { public class MessagesModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; 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) { public void setUsername(String username) {
this.username = username; this.username = username; // 设置用户名的值
} }
/** /**
* *
*/ */
public String getUsername() { public String getUsername() {
return username; return username; // 返回用户名的值
} }
/** /**
* *
*/ */
public void setContent(String content) { public void setContent(String content) {
this.content = content; this.content = content; // 设置留言内容的值
} }
/** /**
* *
*/ */
public String getContent() { public String getContent() {
return content; return content; // 返回留言内容的值
} }
/** /**
* *
*/ */
public void setCpicture(String cpicture) { public void setCpicture(String cpicture) {
this.cpicture = cpicture; this.cpicture = cpicture; // 设置留言图片链接或路径的值
} }
/** /**
* *
*/ */
public String getCpicture() { public String getCpicture() {
return cpicture; return cpicture; // 返回留言图片链接或路径的值
} }
/** /**
* *
*/ */
public void setReply(String reply) { public void setReply(String reply) {
this.reply = reply; this.reply = reply; // 设置回复内容的值
} }
/** /**
* *
*/ */
public String getReply() { public String getReply() {
return reply; return reply; // 返回回复内容的值
} }
/** /**
* *
*/ */
public void setRpicture(String rpicture) { public void setRpicture(String rpicture) {
this.rpicture = rpicture; this.rpicture = rpicture; // 设置回复图片链接或路径的值
} }
/** /**
* *
*/ */
public String getRpicture() { public String getRpicture() {
return rpicture; return rpicture; // 返回回复图片链接或路径的值
} }
} }

@ -1,92 +1,78 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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; // 导入接口,支持对象序列化
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author [Your Name] // 作者信息
* @email * @email [Your Email] // 作者邮箱
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49 // 创建日期
*/ */
public class NewsModel implements Serializable { public class NewsModel implements Serializable { // 定义实体类,实现序列化接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号,确保反序列化时兼容性
/** /**
* *
*/ */
private String introduction; // 公告的简短描述,用于概述主要内容
private String introduction;
/** /**
* *
*/ */
private String picture; // 公告相关的图片链接或路径,用于展示视觉内容
private String picture;
/** /**
* *
*/ */
private String content; // 公告的具体内容,可以是较长的文字描述
private String content;
/** /**
* *
*/ */
public void setIntroduction(String introduction) { public void setIntroduction(String introduction) {
this.introduction = introduction; this.introduction = introduction; // 设置公告的简介
} }
/** /**
* *
*/ */
public String getIntroduction() { public String getIntroduction() {
return introduction; return introduction; // 返回公告的简介
} }
/** /**
* *
*/ */
public void setPicture(String picture) { public void setPicture(String picture) {
this.picture = picture; this.picture = picture; // 设置公告图片的链接或路径
} }
/** /**
* *
*/ */
public String getPicture() { public String getPicture() {
return picture; return picture; // 返回公告图片的链接或路径
} }
/** /**
* *
*/ */
public void setContent(String content) { public void setContent(String content) {
this.content = content; this.content = content; // 设置公告的具体内容
} }
/** /**
* *
*/ */
public String getContent() { public String getContent() {
return content; return content; // 返回公告的具体内容
} }
} }

@ -1,244 +1,150 @@
package com.entity.model; package com.entity.model; // 定义包路径,存放模型类
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;
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 接口
/** /**
* *
* *
* entity * entity
* ModelAndView model * ModelAndView model
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
public class ZhiyuanzheModel implements Serializable { public class ZhiyuanzheModel implements Serializable { // 定义志愿者模型类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
/**
*
*/
// 密码字段
private String mima; private String mima;
/** // 姓名字段
*
*/
private String xingming; private String xingming;
/** // 性别字段
*
*/
private String xingbie; private String xingbie;
/** // 头像字段
*
*/
private String touxiang; private String touxiang;
/** // 年龄字段
*
*/
private String nianling; private String nianling;
/** // 班级字段
*
*/
private String banji; private String banji;
/** // 邮箱字段
*
*/
private String youxiang; private String youxiang;
/** // 手机字段
*
*/
private String shouji; private String shouji;
/** // 是否审核字段
*
*/
private String sfsh; private String sfsh;
/** // 审核回复字段
*
*/
private String shhf; private String shhf;
// 设置密码的方法
/**
*
*/
public void setMima(String mima) { public void setMima(String mima) {
this.mima = mima; this.mima = mima;
} }
/** // 获取密码的方法
*
*/
public String getMima() { public String getMima() {
return mima; return mima;
} }
// 设置姓名的方法
/**
*
*/
public void setXingming(String xingming) { public void setXingming(String xingming) {
this.xingming = xingming; this.xingming = xingming;
} }
/** // 获取姓名的方法
*
*/
public String getXingming() { public String getXingming() {
return xingming; return xingming;
} }
// 设置性别的方法
/**
*
*/
public void setXingbie(String xingbie) { public void setXingbie(String xingbie) {
this.xingbie = xingbie; this.xingbie = xingbie;
} }
/** // 获取性别的方法
*
*/
public String getXingbie() { public String getXingbie() {
return xingbie; return xingbie;
} }
// 设置头像的方法
/**
*
*/
public void setTouxiang(String touxiang) { public void setTouxiang(String touxiang) {
this.touxiang = touxiang; this.touxiang = touxiang;
} }
/** // 获取头像的方法
*
*/
public String getTouxiang() { public String getTouxiang() {
return touxiang; return touxiang;
} }
// 设置年龄的方法
/**
*
*/
public void setNianling(String nianling) { public void setNianling(String nianling) {
this.nianling = nianling; this.nianling = nianling;
} }
/** // 获取年龄的方法
*
*/
public String getNianling() { public String getNianling() {
return nianling; return nianling;
} }
// 设置班级的方法
/**
*
*/
public void setBanji(String banji) { public void setBanji(String banji) {
this.banji = banji; this.banji = banji;
} }
/** // 获取班级的方法
*
*/
public String getBanji() { public String getBanji() {
return banji; return banji;
} }
// 设置邮箱的方法
/**
*
*/
public void setYouxiang(String youxiang) { public void setYouxiang(String youxiang) {
this.youxiang = youxiang; this.youxiang = youxiang;
} }
/** // 获取邮箱的方法
*
*/
public String getYouxiang() { public String getYouxiang() {
return youxiang; return youxiang;
} }
// 设置手机的方法
/**
*
*/
public void setShouji(String shouji) { public void setShouji(String shouji) {
this.shouji = shouji; this.shouji = shouji;
} }
/** // 获取手机的方法
*
*/
public String getShouji() { public String getShouji() {
return shouji; return shouji;
} }
// 设置是否审核的方法
/**
*
*/
public void setSfsh(String sfsh) { public void setSfsh(String sfsh) {
this.sfsh = sfsh; this.sfsh = sfsh;
} }
/** // 获取是否审核的方法
*
*/
public String getSfsh() { public String getSfsh() {
return sfsh; return sfsh;
} }
// 设置审核回复的方法
/**
*
*/
public void setShhf(String shhf) { public void setShhf(String shhf) {
this.shhf = shhf; this.shhf = shhf;
} }
/** // 获取审核回复的方法
*
*/
public String getShhf() { public String getShhf() {
return shhf; return shhf;
} }

@ -1,35 +1,32 @@
package com.entity.view; package com.entity.view; // 定义包路径,存放视图实体类
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;
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 接口,使类支持序列化
/** /**
* *
* *
* 使 * 使
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
@TableName("huodongbaoming") @TableName("huodongbaoming") // 设置数据库表名
public class HuodongbaomingView extends HuodongbaomingEntity implements Serializable { public class HuodongbaomingView extends HuodongbaomingEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
public HuodongbaomingView(){ public HuodongbaomingView(){ // 无参构造函数
} }
public HuodongbaomingView(HuodongbaomingEntity huodongbaomingEntity){ public HuodongbaomingView(HuodongbaomingEntity huodongbaomingEntity){ // 有参构造函数
try { try {
BeanUtils.copyProperties(this, huodongbaomingEntity); BeanUtils.copyProperties(this, huodongbaomingEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} }
} }

@ -1,35 +1,32 @@
package com.entity.view; package com.entity.view; // 定义包路径,存放视图实体类
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;
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 接口,使类支持序列化
/** /**
* *
* *
* 使 * 使
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
@TableName("huodongleixing") @TableName("huodongleixing") // 设置数据库表名
public class HuodongleixingView extends HuodongleixingEntity implements Serializable { public class HuodongleixingView extends HuodongleixingEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
public HuodongleixingView(){ public HuodongleixingView(){ // 无参构造函数
} }
public HuodongleixingView(HuodongleixingEntity huodongleixingEntity){ public HuodongleixingView(HuodongleixingEntity huodongleixingEntity){ // 有参构造函数
try { try {
BeanUtils.copyProperties(this, huodongleixingEntity); BeanUtils.copyProperties(this, huodongleixingEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} }
} }

@ -1,35 +1,32 @@
package com.entity.view; package com.entity.view; // 定义包路径,存放视图实体类
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;
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 接口,使类支持序列化
/** /**
* *
* *
* 使 * 使
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
@TableName("huodongtongzhi") @TableName("huodongtongzhi") // 设置数据库表名
public class HuodongtongzhiView extends HuodongtongzhiEntity implements Serializable { public class HuodongtongzhiView extends HuodongtongzhiEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
public HuodongtongzhiView(){ public HuodongtongzhiView(){ // 无参构造函数
} }
public HuodongtongzhiView(HuodongtongzhiEntity huodongtongzhiEntity){ public HuodongtongzhiView(HuodongtongzhiEntity huodongtongzhiEntity){ // 有参构造函数
try { try {
BeanUtils.copyProperties(this, huodongtongzhiEntity); BeanUtils.copyProperties(this, huodongtongzhiEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} }
} }

@ -1,35 +1,32 @@
package com.entity.view; package com.entity.view; // 定义包路径,存放视图实体类
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;
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 接口,使类支持序列化
/** /**
* *
* *
* 使 * 使
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
@TableName("huodongxinde") @TableName("huodongxinde") // 设置数据库表名
public class HuodongxindeView extends HuodongxindeEntity implements Serializable { public class HuodongxindeView extends HuodongxindeEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
public HuodongxindeView(){ public HuodongxindeView(){ // 无参构造函数
} }
public HuodongxindeView(HuodongxindeEntity huodongxindeEntity){ public HuodongxindeView(HuodongxindeEntity huodongxindeEntity){ // 有参构造函数
try { try {
BeanUtils.copyProperties(this, huodongxindeEntity); BeanUtils.copyProperties(this, huodongxindeEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} }
} }

@ -1,35 +1,32 @@
package com.entity.view; package com.entity.view; // 定义包路径,存放视图实体类
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;
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 接口,使类支持序列化
/** /**
* *
* *
* 使 * 使
* @author * @author []
* @email * @email []
* @date 2022-05-06 08:33:49 * @date 2022-05-06 08:33:49
*/ */
@TableName("huodongxinxi") @TableName("huodongxinxi") // 设置数据库表名
public class HuodongxinxiView extends HuodongxinxiEntity implements Serializable { public class HuodongxinxiView extends HuodongxinxiEntity implements Serializable { // 继承实体类并实现 Serializable 接口
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L; // 定义序列化版本号
public HuodongxinxiView(){ public HuodongxinxiView(){ // 无参构造函数
} }
public HuodongxinxiView(HuodongxinxiEntity huodongxinxiEntity){ public HuodongxinxiView(HuodongxinxiEntity huodongxinxiEntity){ // 有参构造函数
try { try {
BeanUtils.copyProperties(this, huodongxinxiEntity); BeanUtils.copyProperties(this, huodongxinxiEntity); // 使用 BeanUtils 工具类将实体类的属性复制到视图类中
} catch (IllegalAccessException | InvocationTargetException e) { } catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace(); // 打印异常堆栈信息
} }
} }

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

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

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

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

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

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

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

Loading…
Cancel
Save