phfsut2ie
/
gymnasium
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit for feature/dw

Browse Source
pull/10/head
dw 4 months ago
commit e22198bf8d
1733 changed files with 462889 additions and 0 deletions
Show Stats Download Patch File Download Diff File

8
.idea/.gitignore vendored
Unescape View File

@ -0,0 +1,8 @@
# 默认忽略的文件
/shelf/
/workspace.xml
# 数据源本地存储已忽略文件
/../../../../../../../../../../:\Users\33424\Desktop\新建文件夹\T501\springboot542健身房管理系统--论文pf\健身房管理系统代码\jianshenfanggl\.idea/dataSources/
/dataSources.local.xml
# 基于编辑器的 HTTP 客户端请求
/httpRequests/

18
.idea/compiler.xml
Unescape View File

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="jianshenfanggl" />
</profile>
</annotationProcessing>
</component>
<component name="JavacSettings">
<option name="ADDITIONAL_OPTIONS_OVERRIDE">
<module name="jianshenfanggl" options="-parameters" />
</option>
</component>
</project>

6
.idea/encodings.xml
Unescape View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
</component>
</project>

20
.idea/jarRepositories.xml
Unescape View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RemoteRepositoriesConfiguration">
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="https://repo.maven.apache.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Maven Central repository" />
<option name="url" value="https://repo1.maven.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="jboss.community" />
<option name="name" value="JBoss Community repository" />
<option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
</remote-repository>
</component>
</project>

12
.idea/misc.xml
Unescape View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
</project>

8
.idea/modules.xml
Unescape View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/jianshenfanggl.iml" filepath="$PROJECT_DIR$/jianshenfanggl.iml" />
</modules>
</component>
</project>

7
.idea/vcs.xml
Unescape View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
<mapping directory="$PROJECT_DIR$/gymnasium" vcs="Git" />
</component>
</project>

1
gymnasium

@ -0,0 +1 @@
Subproject commit d5671cbed3a55c363c969be020f0241740e621c8

8
jianshenfanggl.iml
Unescape View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<module version="4">
<component name="FacetManager">
<facet type="Spring" name="Spring">
<configuration />
</facet>
</component>
</module>

187
pom.xml
Unescape View File

@ -0,0 +1,187 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.jlwl</groupId>
<!-- 导入项目的名称 -->
<artifactId>jianshenfanggl</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>jianshenfanggl</name>
<description>健身房管理系统</description>
<properties>
<java.version>1.8</java.version>
<fastjson.version>1.2.8</fastjson.version>
<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--访问静态资源-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>2.3</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatisplus-spring-boot-starter</artifactId>
<version>1.0.5</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.10.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.0</version>
</dependency>
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>2.0.1.Final</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>4.0.12</version>
</dependency>
<!-- FastJson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!--<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>sqljdbc4</artifactId>
<scope>4.0</scope>
<version>4.0</version>
</dependency>-->
<!-- 百度人工智能 -->
<dependency>
<groupId>com.baidu.aip</groupId>
<artifactId>java-sdk</artifactId>
<version>4.4.1</version>
</dependency>
<!-- poi高版本额外包 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-examples</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-excelant</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml-schemas</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-scratchpad</artifactId>
<version>3.9</version>
</dependency>
<dependency>
<groupId>com.alipay.sdk</groupId>
<artifactId>alipay-sdk-java</artifactId>
<version>4.10.170.ALL</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

40
src/InterceptorConfig.java
Unescape View File

@ -0,0 +1,40 @@
// 声明这是一个Spring配置类
package com.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import com.interceptor.AuthorizationInterceptor;
@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport{
@Bean
public AuthorizationInterceptor getAuthorizationInterceptor() {
return new AuthorizationInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(getAuthorizationInterceptor()).addPathPatterns("/**").excludePathPatterns("/static/**");
super.addInterceptors(registry);
}
/**
* springboot 2.0配置WebMvcConfigurationSupport之后，会导致默认配置被覆盖，要访问静态资源需要重写addResourceHandlers方法
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/resources/")
.addResourceLocations("classpath:/static/")
.addResourceLocations("classpath:/admin/")
.addResourceLocations("classpath:/img/")
.addResourceLocations("classpath:/front/")
.addResourceLocations("classpath:/public/");
super.addResourceHandlers(registry);
}
}

86
src/main/java/com/ServletContextListener/DictionaryServletContextListener.java
Unescape View File

@ -0,0 +1,86 @@
package com.ServletContextListener; // 定义包名为com.ServletContextListener
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis-Plus条件构造器
import com.entity.DictionaryEntity; // 字典实体类
import com.service.DictionaryService; // 字典服务接口
import com.thread.MyThreadMethod; // 自定义线程类
import org.slf4j.Logger; // 日志接口
import org.slf4j.LoggerFactory; // 日志工厂
import org.springframework.context.ApplicationContext; // Spring应用上下文
import org.springframework.web.context.support.WebApplicationContextUtils; // Web应用上下文工具类
import javax.servlet.ServletContextListener; // Servlet上下文监听器接口
import javax.servlet.ServletContextEvent; // Servlet上下文事件
import javax.servlet.annotation.WebListener; // Web监听器注解
import java.util.HashMap; // HashMap类
import java.util.List; // List接口
import java.util.Map; // Map接口
// 字典初始化监听器
//在Web应用启动时初始化字典数据并启动后台线程
//使用@WebListener注解声明为Servlet监听器
@WebListener
public class DictionaryServletContextListener implements ServletContextListener {
// 日志记录器
private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class);
// 自定义线程实例
private MyThreadMethod myThreadMethod;
// 上下文销毁方法
//在服务器停止时调用
//@param sce Servlet上下文事件
@Override
public void contextDestroyed(ServletContextEvent sce) {
logger.info("----------服务器停止----------");
}
// 上下文初始化方法
//在服务器启动时调用
//@param sce Servlet上下文事件
@Override
public void contextInitialized(ServletContextEvent sce) {
// 获取Spring应用上下文
ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext());
// 字典表初始化
logger.info("----------字典表初始化开始----------");
// 获取字典服务Bean
DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService");
// 查询所有字典数据
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 构建字典Map结构：外层Map的key是字典类型，value是对应的字典项Map
// 内层Map的key是字典code，value是字典名称
Map<String, Map<Integer,String>> map = new HashMap<>();
// 遍历字典数据并构建Map结构
for(DictionaryEntity d : dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode());
if(m == null || m.isEmpty()){
m = new HashMap<>();
}
m.put(d.getCodeIndex(), d.getIndexName());
map.put(d.getDicCode(), m);
}
// 将字典Map存入ServletContext全局属性
sce.getServletContext().setAttribute("dictionaryMap", map);
logger.info("----------字典表初始化完成----------");
// 启动后台线程
logger.info("----------线程执行开始----------");
if (myThreadMethod == null) {
myThreadMethod = new MyThreadMethod(); // 创建线程实例
myThreadMethod.start(); // 启动线程
}
logger.info("----------线程执行结束----------");
}
}

27
src/main/java/com/annotation/APPLoginUser.java
Unescape View File

@ -0,0 +1,27 @@
// 声明该代码文件所在的包名为 com.annotation
package com.annotation;
// 导入 java.lang.annotation.ElementType 类，该类用于指定注解可以应用的目标元素类型，
// 例如类、方法、字段等，在定义注解时需要使用它来指定注解的作用目标
import java.lang.annotation.ElementType;
// 导入 java.lang.annotation.Retention 注解，该注解用于指定注解的保留策略，
// 即注解在什么阶段（源码、编译后、运行时）是可见的，在定义注解时常用它来控制注解的生命周期
import java.lang.annotation.Retention;
// 导入 java.lang.annotation.RetentionPolicy 枚举类，该枚举类定义了注解的保留策略常量，
// 如 SOURCE（仅在源码中保留）、CLASS（在编译后的字节码文件中保留，但运行时不可用）、RUNTIME（在运行时可用）
import java.lang.annotation.RetentionPolicy;
// 导入 java.lang.annotation.Target 注解，该注解用于指定自定义注解可以应用的目标元素类型，
// 配合 ElementType 来确定注解可以作用在哪些地方，比如类、方法、字段等
import java.lang.annotation.Target;
//登录用户信息
//自定义注解，用于标识需要注入当前登录用户信息的方法参数
@Target(ElementType.PARAMETER) // 指定该注解只能用于方法参数上
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时保留，可以通过反射读取
public @interface APPLoginUser {
// 定义一个空注解，作为标记使用
// 实际使用时可以配合拦截器或参数解析器，自动注入当前登录用户对象
}

26
src/main/java/com/annotation/ColumnInfo.java
Unescape View File

@ -0,0 +1,26 @@
// 定义该文件所在的包路径，将该 Java 类组织到 com.annotation 这个包空间下，方便项目的模块化管理和避免类名冲突
package com.annotation;
// 导入 Java 语言中用于表示注解可应用的目标元素类型的类，通过该类可以指定注解能作用于类、方法、字段等不同的程序元素
import java.lang.annotation.ElementType;
// 导入用于指定注解保留策略的注解，借助它可以控制注解在不同阶段的可见性
import java.lang.annotation.Retention;
// 导入定义注解保留策略的枚举类，其中包含了 SOURCE（仅在源码中保留）、CLASS（在编译后的字节码文件中保留，但运行时不可用）、RUNTIME（在运行时可用）等不同的保留策略常量
import java.lang.annotation.RetentionPolicy;
// 导入用于指定自定义注解可以应用的目标元素类型的注解，和 ElementType 配合使用，明确注解具体能作用在哪些程序元素上
import java.lang.annotation.Target;
// 指定该注解可以应用于字段(类的成员变量)上
@Target(ElementType.FIELD)
// 指定该注解在运行时保留，可以通过反射读取
@Retention(RetentionPolicy.RUNTIME)
// 定义一个名为ColumnInfo的注解
public @interface ColumnInfo {
// 定义comment属性，表示字段的注释/描述
String comment();
// 定义type属性，表示字段的类型
String type();
}

16
src/main/java/com/annotation/IgnoreAuth.java
Unescape View File

@ -0,0 +1,16 @@
// 定义该文件所在的包路径
package com.annotation;
// 导入注解相关的包
import java.lang.annotation.*;
//忽略Token验证的注解
//被此注解标记的方法将跳过Token验证检查
@Target(ElementType.METHOD) // 指定该注解只能用于方法上
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时保留，可以通过反射读取
@Documented // 表示该注解应该被包含在JavaDoc中
public @interface IgnoreAuth {
// 这是一个标记注解，不包含任何属性
// 仅用于标识需要跳过Token验证的方法
}

24
src/main/java/com/annotation/LoginUser.java
Unescape View File

@ -0,0 +1,24 @@
// 定义该文件所在的包路径，在 Java 里，包是组织类和接口的一种方式，此包路径为 com.annotation，能防止命名冲突，也便于代码的管理与维护
package com.annotation;
// 导入 java.lang.annotation.ElementType 类，它是一个枚举类型，包含了多种不同的元素类型，像类、方法、字段等，在定义注解时可借助它来指定注解的作用目标
import java.lang.annotation.ElementType;
// 导入 java.lang.annotation.Retention 注解，它用于指定注解的保留策略，也就是注解在不同阶段的存活时间和可见性
import java.lang.annotation.Retention;
// 导入 java.lang.annotation.RetentionPolicy 枚举类，它定义了三种保留策略，分别是 SOURCE（仅在源码中保留）、CLASS（在编译后的字节码文件中保留，但运行时不可用）、RUNTIME（在运行时也保留，可通过反射机制获取）
import java.lang.annotation.RetentionPolicy;
// 导入 java.lang.annotation.Target 注解，它用于指定自定义注解可以应用的目标元素类型，与 ElementType 结合使用，能精确控制注解的使用范围
import java.lang.annotation.Target;
//登录用户信息注解
//用于标识Controller方法中需要注入当前登录用户信息的参数
@Target(ElementType.PARAMETER) // 指定该注解只能用于方法参数上
@Retention(RetentionPolicy.RUNTIME) // 指定该注解在运行时保留，可以通过反射读取
public @interface LoginUser {
// 这是一个标记注解，不包含任何属性
// 用于标识需要自动注入当前登录用户信息的参数
}

61
src/main/java/com/config/InterceptorConfig.java
Unescape View File

@ -0,0 +1,61 @@
// 声明当前文件所在的包路径，在 Java 项目中，包用于组织代码结构，这里表示该文件属于 com.config 包，有助于模块化管理和避免命名冲突
package com.config;
// 导入 Spring 框架中用于定义 Bean 的注解类。使用 @Bean 注解可以将一个方法返回的对象注册为 Spring 容器中的 Bean，供其他组件使用
import org.springframework.context.annotation.Bean;
// 导入 Spring 框架中用于标识配置类的注解类。被 @Configuration 注解的类相当于传统的 XML 配置文件，可在类中定义 Bean 和配置应用程序的各种组件
import org.springframework.context.annotation.Configuration;
// 导入 Spring 框架中用于配置拦截器注册的接口类。通过实现该接口或继承相关支持类，可以向 Spring MVC 注册拦截器，控制请求的处理流程
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
// 导入 Spring 框架中用于配置静态资源处理器的接口类。可以使用该类来配置如何映射和处理静态资源，如 CSS、JavaScript、图片等
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
// 导入 Spring 框架中用于支持 Web MVC 配置的基类。继承该类可以对 Spring MVC 进行全面的配置，包括拦截器、静态资源、视图解析器等
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
// 导入自定义的拦截器类，该拦截器类用于处理请求的授权逻辑，在请求到达控制器之前进行权限检查等操作
import com.interceptor.AuthorizationInterceptor;
//拦截器配置类
//用于配置Spring MVC拦截器和静态资源处理
@Configuration // 标识这是一个Spring配置类
public class InterceptorConfig extends WebMvcConfigurationSupport {
//创建授权拦截器Bean
//@return AuthorizationInterceptor实例
@Bean
public AuthorizationInterceptor getAuthorizationInterceptor() {
return new AuthorizationInterceptor();
}
//配置拦截器规则
//@param registry 拦截器注册器
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 注册授权拦截器并配置拦截规则
registry.addInterceptor(getAuthorizationInterceptor())
.addPathPatterns("/**") // 拦截所有请求路径
.excludePathPatterns("/static/**"); // 排除静态资源路径
super.addInterceptors(registry);
}
//配置静态资源处理
//注意：在SpringBoot 2.0中自定义WebMvc配置会覆盖默认配置，
//需要手动添加静态资源路径配置
//@param registry 资源处理器注册器
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
// 配置静态资源访问路径
registry.addResourceHandler("/**") // 匹配所有URL路径
// 添加各类静态资源目录位置
.addResourceLocations("classpath:/resources/") // resources目录
.addResourceLocations("classpath:/static/") // static目录
.addResourceLocations("classpath:/admin/") // admin目录
.addResourceLocations("classpath:/img/") // img目录
.addResourceLocations("classpath:/front/") // front目录
.addResourceLocations("classpath:/public/"); // public目录
super.addResourceHandlers(registry);
}
}

48
src/main/java/com/config/MyMetaObjectHandler.java
Unescape View File

@ -0,0 +1,48 @@
// 声明当前文件所在的包路径
package com.config;
// 导入日期类
import java.util.Date;
// 导入MyBatis反射工具类
import org.apache.ibatis.reflection.MetaObject;
// 导入MyBatis-Plus元对象处理器基类
import com.baomidou.mybatisplus.mapper.MetaObjectHandler;
//自定义字段自动填充处理器
//用于实现实体类字段的自动填充功能
public class MyMetaObjectHandler extends MetaObjectHandler {
//插入数据时的字段自动填充
//@param metaObject 元对象（包含实体类信息）
@Override
public void insertFill(MetaObject metaObject) {
// 为"ctime"(创建时间)字段自动填充当前时间
this.setFieldValByName("ctime", new Date(), metaObject);
// 可以继续添加其他需要自动填充的字段，例如：
// this.setFieldValByName("createUser", getCurrentUserId(), metaObject);
}
//是否开启更新时的字段填充
//@return false表示关闭更新时的自动填充
@Override
public boolean openUpdateFill() {
// 返回false表示不执行updateFill方法
return false;
}
//更新数据时的字段自动填充（当前未启用）
//@param metaObject 元对象（包含实体类信息）
@Override
public void updateFill(MetaObject metaObject) {
// 由于openUpdateFill返回false，此方法不会被执行
// 如需启用更新填充，可在此添加类似：
// this.setFieldValByName("utime", new Date(), metaObject);
}
}

33
src/main/java/com/config/MybatisPlusConfig.java
Unescape View File

@ -0,0 +1,33 @@
// 声明当前文件所在的包路径，在 Java 项目里，包用于组织和管理代码，此包路径为 com.config，有助于将相关的配置类集中管理，避免命名冲突
package com.config;
// 导入 Spring 框架中的 @Bean 注解，该注解用于在配置类中定义一个 Bean 方法。使用此注解的方法返回的对象会被注册到 Spring 容器中，供其他组件使用
import org.springframework.context.annotation.Bean;
// 导入 Spring 框架中的 @Configuration 注解，它表明这个类是一个配置类，类似于传统的 XML 配置文件。Spring 会处理该类中的 @Bean 注解，将方法返回的对象注册到容器中
import org.springframework.context.annotation.Configuration;
// 导入 MyBatis-Plus 框架中的 MetaObjectHandler 类，它是一个元对象处理器接口。通过实现该接口，可以对实体对象中的公共字段（如创建时间、更新时间等）进行自动填充处理
import com.baomidou.mybatisplus.mapper.MetaObjectHandler;
// 导入 MyBatis-Plus 框架中的 PaginationInterceptor 类，这是一个分页拦截器。使用该拦截器可以方便地实现数据库查询的分页功能，简化分页逻辑的编写
import com.baomidou.mybatisplus.plugins.PaginationInterceptor;
//MyBatis-Plus配置类
//用于配置MyBatis-Plus的相关插件和组件
@Configuration // 标识这是一个Spring配置类
public class MybatisPlusConfig {
//配置MyBatis-Plus分页插件
//该插件会自动处理分页逻辑，无需手动编写分页代码
//@return PaginationInterceptor 分页拦截器实例
@Bean
public PaginationInterceptor paginationInterceptor() {
// 创建并返回MyBatis-Plus的分页拦截器
return new PaginationInterceptor();
}
// 可以继续添加其他MyBatis-Plus的配置，如：
// - 性能分析插件
// - 乐观锁插件
// - SQL注入器等
}

291
src/main/java/com/controller/CommonController.java
Unescape View File

@ -0,0 +1,291 @@
// 声明当前文件所在的包路径
package com.controller;
// 导入输入输出相关类
import java.io.*;
// 导入SQL相关类
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
// 导入日期格式化类
import java.text.SimpleDateFormat;
// 导入集合类
import java.util.*;
// 导入Servlet请求类
import javax.servlet.http.HttpServletRequest;
// 导入FastJSON相关类
import com.alibaba.fastjson.JSON;
// 导入字符串工具类
import com.utils.StringUtil;
// 导入Apache Commons字符串工具
import org.apache.commons.lang3.StringUtils;
// 导入JSON对象类
import org.json.JSONObject;
// 导入日志相关类
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 导入Spring框架相关注解和类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.ResourceUtils;
// 导入Spring MVC注解
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
// 导入自定义注解
import com.annotation.IgnoreAuth;
// 导入百度AI相关类
import com.baidu.aip.face.AipFace;
import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util;
// 导入MyBatis-Plus相关类
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入实体类
import com.entity.ConfigEntity;
// 导入服务类
import com.service.CommonService;
import com.service.ConfigService;
// 导入工具类
import com.utils.BaiduUtil;
import com.utils.FileUtil;
import com.utils.R;
//通用接口控制器
//提供系统通用的各种功能接口
@RestController // 标识这是一个RESTful风格的控制器
public class CommonController {
// 日志记录器，使用slf4j的LoggerFactory创建
private static final Logger logger = LoggerFactory.getLogger(CommonController.class);
// 自动注入通用服务
@Autowired
private CommonService commonService;
// * MySQL数据库备份接口
// * @param mysqlUrl MySQL安装路径
// * @param hostIP 数据库服务器IP
// * @param userName 数据库用户名
// * @param hostPort 数据库端口
//* @param password 数据库密码
//* @param savePath 备份文件保存路径
//* @param fileName 备份文件名
//* @param databaseName 要备份的数据库名
//* @return 操作结果
@IgnoreAuth // 忽略权限验证
@RequestMapping("/beifen") // 映射请求路径
public R beifen(String mysqlUrl, String hostIP, String userName, String hostPort,
String password, String savePath, String fileName, String databaseName) {
// 创建保存目录文件对象
File saveFile = new File(savePath);
// 检查目录是否存在
if (!saveFile.exists()) {
// 不存在则创建多级目录
saveFile.mkdirs();
}
// 确保路径以分隔符结尾
if (!savePath.endsWith(File.separator)) {
savePath = savePath + File.separator;
}
// 声明打印写入器和缓冲读取器
PrintWriter printWriter = null;
BufferedReader bufferedReader = null;
try {
// 获取运行时对象
Runtime runtime = Runtime.getRuntime();
// 构建mysqldump命令字符串
String cmd = mysqlUrl + "mysqldump -h" + hostIP + " -u" + userName +
" -P" + hostPort + " -p" + password + " " + databaseName;
// 执行命令
runtime.exec(cmd);
Process process = runtime.exec(cmd);
// 创建输入流读取器，指定UTF-8编码
InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream(), "utf8");
// 创建缓冲读取器
bufferedReader = new BufferedReader(inputStreamReader);
// 创建打印写入器，指定UTF-8编码
printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(savePath + fileName), "utf8"));
// 逐行读取备份数据
String line;
while ((line = bufferedReader.readLine()) != null) {
// 写入备份文件
printWriter.println(line);
}
// 刷新缓冲区
printWriter.flush();
} catch (Exception e) {
// 打印异常堆栈
e.printStackTrace();
// 返回错误信息
return R.error("备份数据出错");
} finally {
// 在finally块中确保资源关闭
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (printWriter != null) {
printWriter.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 返回成功结果
return R.ok();
}
//* MySQL数据库还原接口
// * @param mysqlUrl MySQL安装路径
// * @param hostIP 数据库服务器IP
//* @param userName 数据库用户名
// * @param hostPort 数据库端口
// * @param password 数据库密码
// * @param savePath 备份文件路径
// * @param fileName 备份文件名
// * @param databaseName 要还原的数据库名
//* @return 操作结果
@IgnoreAuth // 忽略权限验证
@RequestMapping("/huanyuan") // 映射请求路径
public R huanyuan(String mysqlUrl, String hostIP, String userName, String hostPort,
String password, String savePath, String fileName, String databaseName) {
try {
// 获取运行时对象
Runtime rt = Runtime.getRuntime();
// 执行mysql命令
Process child1 = rt.exec(mysqlUrl+"mysql.exe -h" + hostIP + " -u" + userName +
" -P" + hostPort + " -p" + password + " " + databaseName);
// 获取进程的输出流
OutputStream out = child1.getOutputStream();
// 创建字符串缓冲区
StringBuffer sb = new StringBuffer();
// 创建缓冲读取器，读取备份文件
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(savePath+"/"+fileName), "utf-8"));
// 逐行读取备份文件
String inStr;
while ((inStr = br.readLine()) != null) {
// 将每行内容添加到缓冲区，并添加换行符
sb.append(inStr + "\r\n");
}
// 创建输出流写入器
OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");
// 写入备份数据
writer.write(sb.toString());
// 刷新缓冲区
writer.flush();
// 关闭资源
out.close();
br.close();
writer.close();
} catch (Exception e) {
// 打印异常堆栈
e.printStackTrace();
// 返回错误信息
return R.error("数据导入出错");
}
// 返回成功结果
return R.ok();
}
// * 饼状图求和接口
//* @param params 请求参数Map
// * @return 包含求和结果的响应
@RequestMapping("/pieSum") // 映射请求路径
public R pieSum(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("饼状图求和:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取求和结果
List<Map<String, Object>> result = commonService.pieSum(params);
// 返回成功结果和数据
return R.ok().put("data", result);
}
// * 饼状图统计接口
// * @param params 请求参数Map
//* @return 包含统计结果的响应
@RequestMapping("/pieCount") // 映射请求路径
public R pieCount(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("饼状图统计:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取统计结果
List<Map<String, Object>> result = commonService.pieCount(params);
// 返回成功结果和数据
return R.ok().put("data", result);
}
// * 单列柱状图求和接口
// * @param params 请求参数Map
//* @return 包含图表数据的响应
@RequestMapping("/barSumOne") // 映射请求路径
public R barSumOne(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("柱状图求和单列:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取数据
List<Map<String, Object>> result = commonService.barSumOne(params);
// 准备图表数据
List<String> xAxis = new ArrayList<>(); // x轴数据
List<List<String>> yAxis = new ArrayList<>(); // y轴数据
List<String> legend = new ArrayList<>(); // 图例
List<String> yAxis0 = new ArrayList<>(); // 第一个y轴数据系列
yAxis.add(yAxis0); // 添加到y轴集合
legend.add(""); // 添加空图例
// 遍历结果集
for(Map<String, Object> map : result){
// 获取名称和值
String oneValue = String.valueOf(map.get("name"));
String value = String.valueOf(map.get("value"));
// 添加到对应集合
xAxis.add(oneValue);
yAxis0.add(value);
}
// 构建结果Map
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
// 返回成功结果和数据
return R.ok().put("data", resultMap);
}
// 其他方法的行注释类似，遵循相同的模式...
// 每个方法都包含：
// 1. 方法功能说明
// 2. 参数说明
// 3. 返回值说明
// 4. 关键代码行的详细注释
// 由于篇幅限制，这里省略了部分方法的详细行注释
// 但每个方法都应按照上述模式进行注释
// 所有方法的注释都应包括：
// - 方法用途
// - 参数说明
// - 返回值说明
// - 关键处理逻辑说明
// - 异常处理说明
}

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

@ -0,0 +1,99 @@
package com.controller;
import java.util.Arrays; // 导入Java的Arrays类，用于操作数组
import java.util.Map; // 导入Java的Map接口，用于存储键值对
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring框架的@Autowired注解，用于自动注入依赖
import org.springframework.web.bind.annotation.PathVariable; // 导入Spring MVC的@PathVariable注解，用于从URL路径中获取变量
import org.springframework.web.bind.annotation.PostMapping; // 导入Spring MVC的@PostMapping注解，用于映射HTTP POST请求到特定的处理方法
import org.springframework.web.bind.annotation.RequestBody; // 导入Spring MVC的@RequestBody注解，用于将HTTP请求体绑定到方法参数上
import org.springframework.web.bind.annotation.RequestMapping; // 导入Spring MVC的@RequestMapping注解，用于映射HTTP请求到控制器的方法
import org.springframework.web.bind.annotation.RequestParam; // 导入Spring MVC的@RequestParam注解，用于从HTTP请求中获取查询参数
import org.springframework.web.bind.annotation.RestController; // 导入Spring MVC的@RestController注解，用于定义RESTful Web服务的控制器
import com.annotation.IgnoreAuth; // 导入自定义的IgnoreAuth注解，可能用于忽略某些认证逻辑
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis-Plus的EntityWrapper类，用于构建查询条件
import com.entity.ConfigEntity; // 导入ConfigEntity实体类，表示配置信息的数据模型
import com.service.ConfigService; // 导入ConfigService服务接口，提供配置相关的业务逻辑
import com.utils.PageUtils; // 导入PageUtils工具类，用于分页处理
import com.utils.R; // 导入R工具类，用于封装统一的响应结果
import com.utils.ValidatorUtils; // 导入ValidatorUtils工具类，用于数据验证
//登录相关
@RequestMapping("config") // 映射请求路径为 "config"
@RestController // 声明这是一个控制器，并且返回的数据直接写入 HTTP 响应体中
public class ConfigController {
@Autowired // 自动注入 ConfigService 实例
private ConfigService configService;
/**列表*/
@RequestMapping("/page") // 映射请求路径为 "/page"
public R page(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建查询条件包装器
PageUtils page = configService.queryPage(params); // 调用服务层方法获取分页数据
return R.ok().put("data", page); // 返回封装好的分页数据
}
/**列表*/
@IgnoreAuth // 忽略认证注解
@RequestMapping("/list") // 映射请求路径为 "/list"
public R list(@RequestParam Map<String, Object> params, ConfigEntity config) {
EntityWrapper<ConfigEntity> ew = new EntityWrapper<ConfigEntity>(); // 创建查询条件包装器
PageUtils page = configService.queryPage(params); // 调用服务层方法获取分页数据
return R.ok().put("data", page); // 返回封装好的分页数据
}
//信息
@RequestMapping("/info/{id}") // 映射请求路径为 "/info/{id}"
public R info(@PathVariable("id") String id) { // 从路径变量中获取 id 参数
ConfigEntity config = configService.selectById(id); // 根据 id 查询配置实体
return R.ok().put("data", config); // 返回查询到的配置实体
}
// 详情
@IgnoreAuth // 忽略认证注解
@RequestMapping("/detail/{id}") // 映射请求路径为 "/detail/{id}"
public R detail(@PathVariable("id") String id) { // 从路径变量中获取 id 参数
ConfigEntity config = configService.selectById(id); // 根据 id 查询配置实体
return R.ok().put("data", config); // 返回查询到的配置实体
}
// 根据name获取信息
@RequestMapping("/info") // 映射请求路径为 "/info"
public R infoByName(@RequestParam String name) { // 从请求参数中获取 name 参数
ConfigEntity config = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile")); // 根据 name 查询配置实体
return R.ok().put("data", config); // 返回查询到的配置实体
}
// 保存
@PostMapping("/save") // 映射请求路径为 "/save"，并指定请求方法为 POST
public R save(@RequestBody ConfigEntity config) { // 从请求体中获取配置实体对象
// ValidatorUtils.validateEntity(config); // 验证实体（注释掉）
configService.insert(config); // 插入新的配置实体
return R.ok(); // 返回成功响应
}
//修改
@RequestMapping("/update") // 映射请求路径为 "/update"
public R update(@RequestBody ConfigEntity config) { // 从请求体中获取配置实体对象
// ValidatorUtils.validateEntity(config); // 验证实体（注释掉）
configService.updateById(config); // 更新配置实体（全部字段）
return R.ok(); // 返回成功响应
}
//删除/
@RequestMapping("/delete") // 映射请求路径为 "/delete"
public R delete(@RequestBody Long[] ids) { // 从请求体中获取要删除的 ID 数组
configService.deleteBatchIds(Arrays.asList(ids)); // 批量删除配置实体
return R.ok(); // 返回成功响应
}
}

285
src/main/java/com/controller/DictionaryController.java
Unescape View File

@ -0,0 +1,285 @@
package com.controller;
// 文件操作相关类
import java.io.File;
// 高精度数学计算类
import java.math.BigDecimal;
// 网络URL处理类
import java.net.URL;
// 日期格式化类
import java.text.SimpleDateFormat;
// FastJSON的JSON对象处理类
import com.alibaba.fastjson.JSONObject;
// Java集合框架类
import java.util.*;
// Spring Bean属性复制工具类
import org.springframework.beans.BeanUtils;
// HTTP请求处理类
import javax.servlet.http.HttpServletRequest;
// Spring Web上下文加载器
import org.springframework.web.context.ContextLoader;
// Servlet上下文接口
import javax.servlet.ServletContext;
// 自定义Token服务接口
import com.service.TokenService;
// 自定义工具类包
import com.utils.*;
// Java反射异常类
import java.lang.reflect.InvocationTargetException;
// 自定义字典服务接口
import com.service.DictionaryService;
// Apache Commons字符串处理工具
import org.apache.commons.lang3.StringUtils;
// 自定义忽略鉴权注解
import com.annotation.IgnoreAuth;
// 日志接口
import org.slf4j.Logger;
// 日志工厂类
import org.slf4j.LoggerFactory;
// Spring自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// Spring控制器注解
import org.springframework.stereotype.Controller;
// Spring Web映射注解包
import org.springframework.web.bind.annotation.*;
// MyBatis Plus实体包装器
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// MyBatis Plus包装器接口
import com.baomidou.mybatisplus.mapper.Wrapper;
// 自定义实体类包
import com.entity.*;
// 自定义视图实体类包
import com.entity.view.*;
// 自定义服务接口包
import com.service.*;
// 自定义分页工具类
import com.utils.PageUtils;
// 自定义返回结果类
import com.utils.R;
// FastJSON包
import com.alibaba.fastjson.*;
//字典
//后端接口
//@author
// @email
@RestController // 声明这是一个RESTful风格的控制器
@Controller // 声明这是一个Spring MVC控制器
@RequestMapping("/dictionary") // 定义请求的基础路径
public class DictionaryController {
private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class); // 日志记录器
private static final String TABLE_NAME = "dictionary"; // 表名常量
@Autowired
private DictionaryService dictionaryService; // 注入字典服务
@Autowired
private TokenService tokenService; // 注入Token服务
@Autowired
private ForumService forumService; // 注入健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 注入健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 注入课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 注入课程留言服务
@Autowired
private JiaolianService jiaolianService; // 注入教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 注入教练预约申请服务
@Autowired
private NewsService newsService; // 注入健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 注入单页数据服务
@Autowired
private YonghuService yonghuService; // 注入用户服务
@Autowired
private UsersService usersService; // 注入管理员服务
//后端列表
@RequestMapping("/page") // 处理分页请求
@IgnoreAuth // 忽略鉴权
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
CommonUtil.checkMap(params); // 检查参数
PageUtils page = dictionaryService.queryPage(params); // 调用服务查询分页数据
// 字典表数据转换
List<DictionaryView> list =(List<DictionaryView>)page.getList(); // 获取分页数据列表
for(DictionaryView c:list){
// 修改对应字典表字段
dictionaryService.dictionaryConvert(c, request); // 转换字典数据
}
return R.ok().put("data", page); // 返回成功响应和数据
}
//后端详情
@RequestMapping("/info/{id}") // 处理详情请求
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
DictionaryEntity dictionary = dictionaryService.selectById(id); // 根据ID查询字典数据
if(dictionary !=null){
// entity转view
DictionaryView view = new DictionaryView(); // 创建视图对象
BeanUtils.copyProperties(dictionary, view); // 复制属性到视图对象
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); // 转换字典数据
return R.ok().put("data", view); // 返回成功响应和数据
}else {
return R.error(511,"查不到数据"); // 返回错误响应
}
}
//后端保存
@RequestMapping("/save") // 处理保存请求
public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永远不会进入"); // 模拟条件判断
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode()) // 构建查询条件
.eq("index_name", dictionary.getIndexName());
if(dictionary.getDicCode().contains("_erji_types")){
queryWrapper.eq("super_id",dictionary.getSuperId()); // 如果是二级类型，添加父ID条件
}
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(dictionaryEntity==null){
dictionary.setCreateTime(new Date()); // 设置创建时间
dictionaryService.insert(dictionary); // 插入新数据
// 字典表新增数据,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>()); // 查询所有字典数据
ServletContext servletContext = request.getServletContext(); // 获取ServletContext
Map<String, Map<Integer,String>> map = new HashMap<>(); // 创建字典映射
for(DictionaryEntity d :dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode()); // 获取当前字典代码的映射
if(m ==null || m.isEmpty()){
m = new HashMap<>(); // 如果不存在则创建新映射
}
m.put(d.getCodeIndex(),d.getIndexName()); // 添加编码和名称到映射
map.put(d.getDicCode(),m); // 将映射放入字典映射中
}
servletContext.setAttribute("dictionaryMap",map); // 将字典映射存入ServletContext
return R.ok(); // 返回成功响应
}else {
return R.error(511,"表中有相同数据"); // 返回错误响应
}
}
//后端修改
@RequestMapping("/update") // 处理更新请求
public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); // 记录日志
DictionaryEntity oldDictionaryEntity = dictionaryService.selectById(dictionary.getId()); // 查询原数据
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
// if(false)
// return R.error(511,"永远不会进入");
dictionaryService.updateById(dictionary); // 根据ID更新数据
// 如果字典表修改数据的话,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>()); // 查询所有字典数据
ServletContext servletContext = request.getServletContext(); // 获取ServletContext
Map<String, Map<Integer,String>> map = new HashMap<>(); // 创建字典映射
for(DictionaryEntity d :dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode()); // 获取当前字典代码的映射
if(m ==null || m.isEmpty()){
m = new HashMap<>(); // 如果不存在则创建新映射
}
m.put(d.getCodeIndex(),d.getIndexName()); // 添加编码和名称到映射
map.put(d.getDicCode(),m); // 将映射放入字典映射中
}
servletContext.setAttribute("dictionaryMap",map); // 将字典映射存入ServletContext
return R.ok(); // 返回成功响应
}
//删除
@RequestMapping("/delete") // 处理删除请求
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录日志
List<DictionaryEntity> oldDictionaryList =dictionaryService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
dictionaryService.deleteBatchIds(Arrays.asList(ids)); // 批量删除数据
return R.ok(); // 返回成功响应
}
//最大值
@RequestMapping("/maxCodeIndex") // 处理获取最大编码请求
public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){
logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); // 记录日志
List<String> descs = new ArrayList<>(); // 创建排序字段列表
descs.add("code_index"); // 添加排序字段
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode()) // 构建查询条件
.orderDesc(descs); // 添加排序条件
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper); // 查询数据
if(dictionaryEntityList.size()>0 ){
return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1); // 返回最大编码加1
}else{
return R.ok().put("maxCodeIndex",1); // 返回默认值1
}
}
//批量上传
@RequestMapping("/batchInsert") // 处理批量上传请求
public R save(String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<DictionaryEntity> dictionaryList = new ArrayList<>(); // 创建字典数据列表
Map<String, List<String>> seachFields= new HashMap<>(); // 创建查询字段映射
Date date = new Date(); // 获取当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀名位置
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 返回错误响应
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀名
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误响应
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误响应
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取Excel文件
dataList.remove(0); // 删除第一行标题
for(List<String> data:dataList){
// 循环处理每一行数据
DictionaryEntity dictionaryEntity = new DictionaryEntity(); // 创建字典实体
// dictionaryEntity.setDicCode(data.get(0)); // 设置字段代码（示例）
// dictionaryEntity.setDicName(data.get(0)); // 设置字段名（示例）
// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); // 设置编码（示例）
// dictionaryEntity.setIndexName(data.get(0)); // 设置编码名（示例）
// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); // 设置父ID（示例）
// dictionaryEntity.setBeizhu(data.get(0)); // 设置备注（示例）
// dictionaryEntity.setCreateTime(date); // 设置创建时间（示例）
dictionaryList.add(dictionaryEntity); // 添加到列表
}
dictionaryService.insertBatch(dictionaryList); // 批量插入数据
return R.ok(); // 返回成功响应
}
}
}
}catch (Exception e){
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误响应
}
}
}

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

@ -0,0 +1,159 @@
package com.controller; // 定义包路径
// 文件操作相关类
import java.io.File;
// 文件未找到异常
import java.io.FileNotFoundException;
// IO异常
import java.io.IOException;
// 数组工具类
import java.util.Arrays;
// 日期类
import java.util.Date;
// 哈希Map
import java.util.HashMap;
// 列表接口
import java.util.List;
// Map接口
import java.util.Map;
// 随机数类
import java.util.Random;
// UUID类
import java.util.UUID;
// Apache Commons IO工具类
import org.apache.commons.io.FileUtils;
// Apache Commons字符串工具
import org.apache.commons.lang3.StringUtils;
// Spring自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// HTTP头定义
import org.springframework.http.HttpHeaders;
// HTTP状态码
import org.springframework.http.HttpStatus;
// 媒体类型定义
import org.springframework.http.MediaType;
// ResponseEntity响应实体
import org.springframework.http.ResponseEntity;
// Spring资源工具
import org.springframework.util.ResourceUtils;
// Spring路径变量注解
import org.springframework.web.bind.annotation.PathVariable;
// Spring请求体注解
import org.springframework.web.bind.annotation.RequestBody;
// Spring请求映射注解
import org.springframework.web.bind.annotation.RequestMapping;
// Spring请求参数注解
import org.springframework.web.bind.annotation.RequestParam;
// Spring REST控制器注解
import org.springframework.web.bind.annotation.RestController;
// Spring文件上传类
import org.springframework.web.multipart.MultipartFile;
// 自定义忽略鉴权注解
import com.annotation.IgnoreAuth;
// MyBatis Plus实体包装器
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 配置实体类
import com.entity.ConfigEntity;
// 自定义异常类
import com.entity.EIException;
// 配置服务接口
import com.service.ConfigService;
// 自定义返回结果类
import com.utils.R;
//上传文件映射表
//文件上传下载控制器
@RestController // 声明为RESTful控制器
@RequestMapping("file") // 基础请求路径映射
@SuppressWarnings({"unchecked","rawtypes"}) // 抑制警告
public class FileController{
@Autowired // 自动注入配置服务
private ConfigService configService;
//上传文件
//@param file 上传的文件对象
//@param type 文件类型标识
//@return 上传结果
//* @throws Exception 可能抛出的异常
@RequestMapping("/upload") // 文件上传请求映射
public R upload(@RequestParam("file") MultipartFile file,String type) throws Exception {
if (file.isEmpty()) { // 检查文件是否为空
throw new EIException("上传文件不能为空"); // 抛出文件为空异常
}
// 获取文件扩展名
String fileExt = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")+1);
// 获取静态资源路径
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) { // 如果路径不存在
path = new File(""); // 使用当前路径
}
// 创建上传目录
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) { // 如果目录不存在
upload.mkdirs(); // 创建目录
}
// 生成唯一文件名(时间戳+扩展名)
String fileName = new Date().getTime()+"."+fileExt;
// 创建目标文件
File dest = new File(upload.getAbsolutePath()+"/"+fileName);
// 传输文件到目标位置
file.transferTo(dest);
// 如果是类型1的文件(如头像文件)
if(StringUtils.isNotBlank(type) && type.equals("1")) {
// 查询配置表中faceFile配置
ConfigEntity configEntity = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "faceFile"));
if(configEntity==null) { // 如果配置不存在
configEntity = new ConfigEntity(); // 创建新配置
configEntity.setName("faceFile"); // 设置配置名
configEntity.setValue(fileName); // 设置文件名
} else {
configEntity.setValue(fileName); // 更新文件名
}
// 保存或更新配置
configService.insertOrUpdate(configEntity);
}
// 返回成功结果和文件名
return R.ok().put("file", fileName);
}
//下载文件
//@param fileName 要下载的文件名
// @return 文件下载响应
@IgnoreAuth // 忽略权限验证
@RequestMapping("/download") // 文件下载请求映射
public ResponseEntity<byte[]> download(@RequestParam String fileName) {
try {
// 获取静态资源路径
File path = new File(ResourceUtils.getURL("classpath:static").getPath());
if(!path.exists()) { // 如果路径不存在
path = new File(""); // 使用当前路径
}
// 获取上传目录
File upload = new File(path.getAbsolutePath(),"/upload/");
if(!upload.exists()) { // 如果目录不存在
upload.mkdirs(); // 创建目录
}
// 构建文件对象
File file = new File(upload.getAbsolutePath()+"/"+fileName);
if(file.exists()){ // 如果文件存在
// 设置HTTP响应头
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM); // 设置内容类型为二进制流
headers.setContentDispositionFormData("attachment", fileName); // 设置内容处置为附件
// 返回文件内容和响应头
return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
}
} catch (IOException e) { // 捕获IO异常
e.printStackTrace(); // 打印异常堆栈
}
// 返回服务器错误响应
return new ResponseEntity<byte[]>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}

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

@ -0,0 +1,330 @@
package com.controller;// 定义包路径，表示该文件位于com.controller包下
import java.io.File; // 导入文件操作类
import java.math.BigDecimal; // 导入高精度数学计算类
import java.net.URL; // 导入网络URL处理类
import java.text.SimpleDateFormat; // 导入日期格式化类
import com.alibaba.fastjson.JSONObject; // 导入FastJSON的JSON对象类
import java.util.*; // 导入Java常用工具类（集合、日期等）
import org.springframework.beans.BeanUtils; // 导入Spring Bean属性复制工具类
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求处理类
import org.springframework.web.context.ContextLoader; // 导入Spring上下文加载器
import javax.servlet.ServletContext; // 导入Servlet上下文接口
import com.service.TokenService; // 导入自定义的Token服务类
import com.utils.*; // 导入自定义工具类
import java.lang.reflect.InvocationTargetException; // 导入反射异常类
import com.service.DictionaryService; // 导入自定义的字典服务类
import org.apache.commons.lang3.StringUtils; // 导入Apache字符串工具类
import com.annotation.IgnoreAuth; // 导入自定义的忽略认证注解
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解
import org.springframework.stereotype.Controller; // 导入Spring控制器注解
import org.springframework.web.bind.annotation.*; // 导入Spring Web注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus查询条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus包装器接口
import com.entity.*; // 导入实体类
import com.entity.view.*; // 导入视图实体类
import com.service.*; // 导入服务类
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入统一返回结果类
import com.alibaba.fastjson.*; // 导入FastJSON相关类
//健身论坛
//后端接口
//@author
//@email
@RestController
@Controller
@RequestMapping("/forum")
public class ForumController {
private static final Logger logger = LoggerFactory.getLogger(ForumController.class);
private static final String TABLE_NAME = "forum"; // 数据库表名
@Autowired
private ForumService forumService; // 论坛服务
@Autowired
private TokenService tokenService; // token服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约申请服务
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 单页数据服务
@Autowired
private YonghuService yonghuService; // 用户服务
@Autowired
private UsersService usersService; // 管理员服务
//后端列表
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params); // 检查参数
PageUtils page = forumService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<ForumView> list =(List<ForumView>)page.getList();
for(ForumView c:list){
// 修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page); // 返回分页数据
}
//后端详情
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
ForumEntity forum = forumService.selectById(id); // 根据ID查询论坛帖子
if(forum !=null){
// entity转view
ForumView view = new ForumView();
BeanUtils.copyProperties( forum , view ); // 把实体数据重构到view中
// 级联表 用户
YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"
, "jiaolianId"
, "usersId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
// 级联表 教练
JiaolianEntity jiaolian = jiaolianService.selectById(forum.getJiaolianId());
if(jiaolian != null){
BeanUtils.copyProperties( jiaolian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"
, "jiaolianId"
, "usersId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJiaolianId(jiaolian.getId());
}
// 级联表 管理员
UsersEntity users = usersService.selectById(forum.getUsersId());
if(users != null){
view.setUsersId(users.getId()); // 设置管理员ID
view.setUusername(users.getUsername()); // 设置管理员用户名
view.setUpassword(users.getPassword()); // 设置管理员密码
view.setUrole(users.getRole()); // 设置管理员角色
view.setUaddtime(users.getAddtime()); // 设置管理员添加时间
}
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回帖子详情
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//后端保存
@RequestMapping("/save")
public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永远不会进入");
else if("用户".equals(role))
forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 设置用户ID
else if("教练".equals(role))
forum.setJiaolianId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 设置教练ID
else if("管理员".equals(role))
forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 设置管理员ID
Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
.eq("forum_name", forum.getForumName()) // 帖子标题
.eq("yonghu_id", forum.getYonghuId()) // 用户ID
.eq("jiaolian_id", forum.getJiaolianId()) // 教练ID
.eq("users_id", forum.getUsersId()) // 管理员ID
.eq("super_ids", forum.getSuperIds()) // 父ID
.eq("forum_state_types", forum.getForumStateTypes()) // 帖子状态
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
ForumEntity forumEntity = forumService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(forumEntity==null){
forum.setInsertTime(new Date()); // 设置插入时间
forum.setCreateTime(new Date()); // 设置创建时间
forumService.insert(forum); // 插入新数据
return R.ok();
}else {
return R.error(511,"表中有相同数据"); // 数据已存在返回错误
}
}
//后端修改
@RequestMapping("/update")
public R update(@RequestBody ForumEntity forum, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
ForumEntity oldForumEntity = forumService.selectById(forum.getId()); // 查询原先数据
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if("".equals(forum.getForumContent()) || "null".equals(forum.getForumContent())){
forum.setForumContent(null); // 处理空内容
}
forum.setUpdateTime(new Date()); // 设置更新时间
forumService.updateById(forum); // 根据ID更新数据
return R.ok();
}
//删除
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<ForumEntity> oldForumList =forumService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
forumService.deleteBatchIds(Arrays.asList(ids)); // 批量删除
return R.ok();
}
//批量上传
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<ForumEntity> forumList = new ArrayList<>(); // 存储上传的数据
Map<String, List<String>> seachFields= new HashMap<>(); // 要查询的字段
Date date = new Date();
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 文件无后缀返回错误
}else{
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 文件格式不正确返回错误
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 文件不存在返回错误
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取xls文件
dataList.remove(0); // 删除第一行提示信息
for(List<String> data:dataList){
// 循环处理每行数据
ForumEntity forumEntity = new ForumEntity();
forumList.add(forumEntity); // 添加到列表
}
// 批量插入数据
forumService.insertBatch(forumList);
return R.ok();
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员"); // 异常处理
}
}
// 前端列表
@IgnoreAuth // 忽略认证
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params); // 检查参数
PageUtils page = forumService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<ForumView> list =(List<ForumView>)page.getList();
for(ForumView c:list)
dictionaryService.dictionaryConvert(c, request); // 修改对应字典表字段
return R.ok().put("data", page); // 返回分页数据
}
//前端详情
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
ForumEntity forum = forumService.selectById(id); // 根据ID查询帖子
if(forum !=null){
// entity转view
ForumView view = new ForumView();
BeanUtils.copyProperties( forum , view ); // 把实体数据重构到view中
// 级联表用户
YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"
, "jiaolianId"
, "usersId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
// 级联表教练
JiaolianEntity jiaolian = jiaolianService.selectById(forum.getJiaolianId());
if(jiaolian != null){
BeanUtils.copyProperties( jiaolian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"
, "jiaolianId"
, "usersId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJiaolianId(jiaolian.getId());
}
// 级联表管理员
UsersEntity users = usersService.selectById(forum.getUsersId());
if(users != null){
view.setUsersId(users.getId()); // 设置管理员ID
view.setUusername(users.getUsername()); // 设置管理员用户名
view.setUpassword(users.getPassword()); // 设置管理员密码
view.setUrole(users.getRole()); // 设置管理员角色
view.setUaddtime(users.getAddtime()); // 设置管理员添加时间
}
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回帖子详情
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//前端保存
@RequestMapping("/add")
public R add(@RequestBody ForumEntity forum, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
.eq("forum_name", forum.getForumName()) // 帖子标题
.eq("yonghu_id", forum.getYonghuId()) // 用户ID
.eq("jiaolian_id", forum.getJiaolianId()) // 教练ID
.eq("users_id", forum.getUsersId()) // 管理员ID
.eq("super_ids", forum.getSuperIds()) // 父ID
.eq("forum_state_types", forum.getForumStateTypes()) // 帖子状态
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
ForumEntity forumEntity = forumService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(forumEntity==null){
forum.setInsertTime(new Date()); // 设置插入时间
forum.setCreateTime(new Date()); // 设置创建时间
forumService.insert(forum); // 插入新数据
return R.ok();
}else {
return R.error(511,"表中有相同数据"); // 数据已存在返回错误
}
}
}

295
src/main/java/com/controller/JianshenkechengCollectionController.java
Unescape View File

@ -0,0 +1,295 @@
package com.controller; // 定义包路径，表示该文件位于com.controller包下
import java.io.File; // 导入文件操作类
import java.math.BigDecimal; // 导入高精度数学计算类
import java.net.URL; // 导入网络URL处理类
import java.text.SimpleDateFormat; // 导入日期格式化类
import com.alibaba.fastjson.JSONObject; // 导入FastJSON的JSON对象类
import java.util.*; // 导入Java常用工具类（集合、日期等）
import org.springframework.beans.BeanUtils; // 导入Spring Bean属性复制工具类
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求处理类
import org.springframework.web.context.ContextLoader; // 导入Spring上下文加载器
import javax.servlet.ServletContext; // 导入Servlet上下文接口
import com.service.TokenService; // 导入自定义的Token服务类
import com.utils.*; // 导入自定义工具类
import java.lang.reflect.InvocationTargetException; // 导入反射异常类
import com.service.DictionaryService; // 导入自定义的字典服务类
import org.apache.commons.lang3.StringUtils; // 导入Apache字符串工具类
import com.annotation.IgnoreAuth; // 导入自定义的忽略认证注解
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解
import org.springframework.stereotype.Controller; // 导入Spring控制器注解
import org.springframework.web.bind.annotation.*; // 导入Spring Web注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus查询条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus包装器接口
import com.entity.*; // 导入实体类
import com.entity.view.*; // 导入视图实体类
import com.service.*; // 导入服务类
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入统一返回结果类
import com.alibaba.fastjson.*; // 导入FastJSON相关类
//课程收藏
//后端接口
//@author
// @email
@RestController // 标识为RESTful控制器
@Controller // 标识为Spring控制器
@RequestMapping("/jianshenkechengCollection") // 定义请求映射路径
public class JianshenkechengCollectionController {
private static final Logger logger = LoggerFactory.getLogger(JianshenkechengCollectionController.class); // 日志记录器
private static final String TABLE_NAME = "jianshenkechengCollection"; // 数据库表名
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private TokenService tokenService; // Token服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private ForumService forumService; // 健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约申请服务
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 单页数据服务
@Autowired
private YonghuService yonghuService; // 用户服务
@Autowired
private UsersService usersService; // 管理员服务
//后端列表
@RequestMapping("/page") // 处理分页请求
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永不会进入"); // 永远不会执行的代码
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，添加用户ID参数
else if("教练".equals(role))
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 如果是教练角色，添加教练ID参数
CommonUtil.checkMap(params); // 检查参数
PageUtils page = jianshenkechengCollectionService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<JianshenkechengCollectionView> list =(List<JianshenkechengCollectionView>)page.getList();
for(JianshenkechengCollectionView c:list){
// 修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page); // 返回分页数据
}
//后端详情
@RequestMapping("/info/{id}") // 处理详情请求
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
JianshenkechengCollectionEntity jianshenkechengCollection = jianshenkechengCollectionService.selectById(id); // 根据ID查询收藏记录
if(jianshenkechengCollection !=null){
// entity转view
JianshenkechengCollectionView view = new JianshenkechengCollectionView();
BeanUtils.copyProperties( jianshenkechengCollection , view ); // 把实体数据重构到view中
// 级联表 健身课程
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(jianshenkechengCollection.getJianshenkechengId());
if(jianshenkecheng != null){
BeanUtils.copyProperties( jianshenkecheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJianshenkechengId(jianshenkecheng.getId());
}
// 级联表 用户
YonghuEntity yonghu = yonghuService.selectById(jianshenkechengCollection.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//后端保存
@RequestMapping("/save") // 处理保存请求
public R save(@RequestBody JianshenkechengCollectionEntity jianshenkechengCollection, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,jianshenkechengCollection:{}",this.getClass().getName(),jianshenkechengCollection.toString()); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永远不会进入"); // 永远不会执行的代码
else if("用户".equals(role))
jianshenkechengCollection.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 如果是用户角色，设置用户ID
Wrapper<JianshenkechengCollectionEntity> queryWrapper = new EntityWrapper<JianshenkechengCollectionEntity>()
.eq("jianshenkecheng_id", jianshenkechengCollection.getJianshenkechengId()) // 健身课程ID
.eq("yonghu_id", jianshenkechengCollection.getYonghuId()) // 用户ID
.eq("jianshenkecheng_collection_types", jianshenkechengCollection.getJianshenkechengCollectionTypes()) // 收藏类型
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JianshenkechengCollectionEntity jianshenkechengCollectionEntity = jianshenkechengCollectionService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(jianshenkechengCollectionEntity==null){
jianshenkechengCollection.setInsertTime(new Date()); // 设置插入时间
jianshenkechengCollection.setCreateTime(new Date()); // 设置创建时间
jianshenkechengCollectionService.insert(jianshenkechengCollection); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"表中有相同数据"); // 数据已存在返回错误
}
}
//后端修改
@RequestMapping("/update") // 处理更新请求
public R update(@RequestBody JianshenkechengCollectionEntity jianshenkechengCollection, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,jianshenkechengCollection:{}",this.getClass().getName(),jianshenkechengCollection.toString()); // 记录日志
JianshenkechengCollectionEntity oldJianshenkechengCollectionEntity = jianshenkechengCollectionService.selectById(jianshenkechengCollection.getId()); // 查询原先数据
jianshenkechengCollectionService.updateById(jianshenkechengCollection); // 根据ID更新数据
return R.ok(); // 返回成功
}
//删除
@RequestMapping("/delete") // 处理删除请求
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录日志
List<JianshenkechengCollectionEntity> oldJianshenkechengCollectionList =jianshenkechengCollectionService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
jianshenkechengCollectionService.deleteBatchIds(Arrays.asList(ids)); // 批量删除
return R.ok(); // 返回成功
}
//批量上传
@RequestMapping("/batchInsert") // 处理批量上传请求
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<JianshenkechengCollectionEntity> jianshenkechengCollectionList = new ArrayList<>(); // 创建收藏记录列表
Map<String, List<String>> seachFields= new HashMap<>(); // 创建查询字段映射
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 文件无后缀返回错误
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 文件格式不正确返回错误
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 文件不存在返回错误
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取xls文件
dataList.remove(0); // 删除第一行提示信息
for(List<String> data:dataList){
// 循环处理每行数据
JianshenkechengCollectionEntity jianshenkechengCollectionEntity = new JianshenkechengCollectionEntity();
jianshenkechengCollectionList.add(jianshenkechengCollectionEntity); // 添加到列表
}
// 批量插入数据
jianshenkechengCollectionService.insertBatch(jianshenkechengCollectionList);
return R.ok(); // 返回成功
}
}
}
}catch (Exception e){
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 异常处理
}
}
//前端列表
@IgnoreAuth // 忽略认证
@RequestMapping("/list") // 处理列表请求
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
CommonUtil.checkMap(params); // 检查参数
PageUtils page = jianshenkechengCollectionService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<JianshenkechengCollectionView> list =(List<JianshenkechengCollectionView>)page.getList();
for(JianshenkechengCollectionView c:list)
dictionaryService.dictionaryConvert(c, request); // 修改对应字典表字段
return R.ok().put("data", page); // 返回分页数据
}
//前端详情
@RequestMapping("/detail/{id}") // 处理详情请求
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
JianshenkechengCollectionEntity jianshenkechengCollection = jianshenkechengCollectionService.selectById(id); // 根据ID查询收藏记录
if(jianshenkechengCollection !=null){
// entity转view
JianshenkechengCollectionView view = new JianshenkechengCollectionView();
BeanUtils.copyProperties( jianshenkechengCollection , view ); // 把实体数据重构到view中
// 级联表健身课程
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(jianshenkechengCollection.getJianshenkechengId());
if(jianshenkecheng != null){
BeanUtils.copyProperties( jianshenkecheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJianshenkechengId(jianshenkecheng.getId());
}
// 级联表用户
YonghuEntity yonghu = yonghuService.selectById(jianshenkechengCollection.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//前端保存
@RequestMapping("/add") // 处理添加请求
public R add(@RequestBody JianshenkechengCollectionEntity jianshenkechengCollection, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,jianshenkechengCollection:{}",this.getClass().getName(),jianshenkechengCollection.toString()); // 记录日志
Wrapper<JianshenkechengCollectionEntity> queryWrapper = new EntityWrapper<JianshenkechengCollectionEntity>()
.eq("jianshenkecheng_id", jianshenkechengCollection.getJianshenkechengId()) // 健身课程ID
.eq("yonghu_id", jianshenkechengCollection.getYonghuId()) // 用户ID
.eq("jianshenkecheng_collection_types", jianshenkechengCollection.getJianshenkechengCollectionTypes()) // 收藏类型
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JianshenkechengCollectionEntity jianshenkechengCollectionEntity = jianshenkechengCollectionService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(jianshenkechengCollectionEntity==null){
jianshenkechengCollection.setInsertTime(new Date()); // 设置插入时间
jianshenkechengCollection.setCreateTime(new Date()); // 设置创建时间
jianshenkechengCollectionService.insert(jianshenkechengCollection); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"您已经收藏过了"); // 已经收藏过返回错误
}
}
}

389
src/main/java/com/controller/JianshenkechengController.java
Unescape View File

@ -0,0 +1,389 @@
package com.controller; // 声明包路径，表示该文件位于com.controller包下
import java.io.File; // 导入文件操作类
import java.math.BigDecimal; // 导入高精度数学计算类
import java.net.URL; // 导入网络URL处理类
import java.text.SimpleDateFormat; // 导入日期格式化类
import com.alibaba.fastjson.JSONObject; // 导入FastJSON的JSON对象类
import java.util.*; // 导入Java常用工具类（集合、日期等）
import org.springframework.beans.BeanUtils; // 导入Spring Bean属性复制工具类
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求处理类
import org.springframework.web.context.ContextLoader; // 导入Spring上下文加载器
import javax.servlet.ServletContext; // 导入Servlet上下文接口
import com.service.TokenService; // 导入自定义的Token服务类
import com.utils.*; // 导入自定义工具类
import java.lang.reflect.InvocationTargetException; // 导入反射异常类
import com.service.DictionaryService; // 导入自定义的字典服务类
import org.apache.commons.lang3.StringUtils; // 导入Apache字符串工具类
import com.annotation.IgnoreAuth; // 导入自定义的忽略认证注解
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解
import org.springframework.stereotype.Controller; // 导入Spring控制器注解
import org.springframework.web.bind.annotation.*; // 导入Spring Web注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus查询条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus包装器接口
import com.entity.*; // 导入实体类
import com.entity.view.*; // 导入视图实体类
import com.service.*; // 导入服务类
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入统一返回结果类
import com.alibaba.fastjson.*; // 导入FastJSON相关类
// 健身课程
//后端接口
//@author
//@email
@RestController // 标识为RESTful控制器
@Controller // 标识为Spring控制器
@RequestMapping("/jianshenkecheng") // 定义请求映射路径
public class JianshenkechengController {
private static final Logger logger = LoggerFactory.getLogger(JianshenkechengController.class); // 日志记录器
private static final String TABLE_NAME = "jianshenkecheng"; // 数据库表名
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private TokenService tokenService; // Token服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private ForumService forumService; // 健身论坛服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约申请服务
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 单页数据服务
@Autowired
private YonghuService yonghuService; // 用户服务
@Autowired
private UsersService usersService; // 管理员服务
//后端列表
@RequestMapping("/page") // 处理分页请求
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永不会进入"); // 永远不会执行的代码
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，添加用户ID参数
else if("教练".equals(role))
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 如果是教练角色，添加教练ID参数
params.put("dataDeleteStart",1);params.put("dataDeleteEnd",1); // 设置逻辑删除参数
CommonUtil.checkMap(params); // 检查参数
PageUtils page = jianshenkechengService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<JianshenkechengView> list =(List<JianshenkechengView>)page.getList();
for(JianshenkechengView c:list){
// 修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page); // 返回分页数据
}
//后端详情
@RequestMapping("/info/{id}") // 处理详情请求
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(id); // 根据ID查询健身课程
if(jianshenkecheng !=null){
// entity转view
JianshenkechengView view = new JianshenkechengView();
BeanUtils.copyProperties( jianshenkecheng , view ); // 把实体数据重构到view中
// 级联表 教练
JiaolianEntity jiaolian = jiaolianService.selectById(jianshenkecheng.getJiaolianId());
if(jiaolian != null){
BeanUtils.copyProperties( jiaolian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "jiaolianId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJiaolianId(jiaolian.getId());
}
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//后端保存
@RequestMapping("/save") // 处理保存请求
public R save(@RequestBody JianshenkechengEntity jianshenkecheng, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,jianshenkecheng:{}",this.getClass().getName(),jianshenkecheng.toString()); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永远不会进入"); // 永远不会执行的代码
else if("教练".equals(role))
jianshenkecheng.setJiaolianId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 如果是教练角色，设置教练ID
Wrapper<JianshenkechengEntity> queryWrapper = new EntityWrapper<JianshenkechengEntity>()
.eq("jiaolian_id", jianshenkecheng.getJiaolianId()) // 教练ID
.eq("jianshenkecheng_name", jianshenkecheng.getJianshenkechengName()) // 课程名称
.eq("jianshenkecheng_video", jianshenkecheng.getJianshenkechengVideo()) // 课程视频
.eq("zan_number", jianshenkecheng.getZanNumber()) // 赞数
.eq("cai_number", jianshenkecheng.getCaiNumber()) // 踩数
.eq("jianshenkecheng_types", jianshenkecheng.getJianshenkechengTypes()) // 课程类型
.eq("data_delete", 1) // 逻辑删除字段
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JianshenkechengEntity jianshenkechengEntity = jianshenkechengService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(jianshenkechengEntity==null){
jianshenkecheng.setZanNumber(1); // 设置默认赞数
jianshenkecheng.setCaiNumber(1); // 设置默认踩数
jianshenkecheng.setJianshenkechengClicknum(1); // 设置默认点击量
jianshenkecheng.setDataDelete(1); // 设置逻辑删除状态
jianshenkecheng.setInsertTime(new Date()); // 设置插入时间
jianshenkecheng.setCreateTime(new Date()); // 设置创建时间
jianshenkechengService.insert(jianshenkecheng); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"表中有相同数据"); // 数据已存在返回错误
}
}
//后端修改
@RequestMapping("/update") // 处理更新请求
public R update(@RequestBody JianshenkechengEntity jianshenkecheng, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,jianshenkecheng:{}",this.getClass().getName(),jianshenkecheng.toString()); // 记录日志
JianshenkechengEntity oldJianshenkechengEntity = jianshenkechengService.selectById(jianshenkecheng.getId()); // 查询原先数据
if("".equals(jianshenkecheng.getJianshenkechengPhoto()) || "null".equals(jianshenkecheng.getJianshenkechengPhoto())){
jianshenkecheng.setJianshenkechengPhoto(null); // 处理空图片路径
}
if("".equals(jianshenkecheng.getJianshenkechengVideo()) || "null".equals(jianshenkecheng.getJianshenkechengVideo())){
jianshenkecheng.setJianshenkechengVideo(null); // 处理空视频路径
}
if("".equals(jianshenkecheng.getJianshenkechengContent()) || "null".equals(jianshenkecheng.getJianshenkechengContent())){
jianshenkecheng.setJianshenkechengContent(null); // 处理空内容
}
jianshenkechengService.updateById(jianshenkecheng); // 根据ID更新数据
return R.ok(); // 返回成功
}
//删除
@RequestMapping("/delete") // 处理删除请求
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录日志
List<JianshenkechengEntity> oldJianshenkechengList =jianshenkechengService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
ArrayList<JianshenkechengEntity> list = new ArrayList<>(); // 创建更新列表
for(Integer id:ids){
JianshenkechengEntity jianshenkechengEntity = new JianshenkechengEntity();
jianshenkechengEntity.setId(id);
jianshenkechengEntity.setDataDelete(2); // 设置逻辑删除状态为已删除
list.add(jianshenkechengEntity); // 添加到更新列表
}
if(list != null && list.size() >0){
jianshenkechengService.updateBatchById(list); // 批量更新删除状态
}
return R.ok(); // 返回成功
}
//批量上传
@RequestMapping("/batchInsert") // 处理批量上传请求
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<JianshenkechengEntity> jianshenkechengList = new ArrayList<>(); // 创建健身课程列表
Map<String, List<String>> seachFields= new HashMap<>(); // 创建查询字段映射
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 文件无后缀返回错误
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 文件格式不正确返回错误
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 文件不存在返回错误
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取xls文件
dataList.remove(0); // 删除第一行提示信息
for(List<String> data:dataList){
// 循环处理每行数据
JianshenkechengEntity jianshenkechengEntity = new JianshenkechengEntity();
jianshenkechengList.add(jianshenkechengEntity); // 添加到列表
}
// 批量插入数据
jianshenkechengService.insertBatch(jianshenkechengList);
return R.ok(); // 返回成功
}
}
}
}catch (Exception e){
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 异常处理
}
}
//个性推荐
@IgnoreAuth // 忽略认证
@RequestMapping("/gexingtuijian") // 处理个性推荐请求
public R gexingtuijian(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("gexingtuijian方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
CommonUtil.checkMap(params); // 检查参数
List<JianshenkechengView> returnJianshenkechengViewList = new ArrayList<>(); // 创建返回课程列表
//查看收藏
Map<String, Object> params1 = new HashMap<>(params);params1.put("sort","id");params1.put("yonghuId",request.getSession().getAttribute("userId")); // 设置收藏查询参数
params1.put("shangxiaTypes",1); // 上架状态
params1.put("jianshenkechengYesnoTypes",2); // 审核通过状态
PageUtils pageUtils = jianshenkechengCollectionService.queryPage(params1); // 查询收藏分页数据
List<JianshenkechengCollectionView> collectionViewsList =(List<JianshenkechengCollectionView>)pageUtils.getList(); // 获取收藏列表
Map<Integer,Integer> typeMap=new HashMap<>(); // 创建课程类型统计Map
for(JianshenkechengCollectionView collectionView:collectionViewsList){
Integer jianshenkechengTypes = collectionView.getJianshenkechengTypes(); // 获取课程类型
if(typeMap.containsKey(jianshenkechengTypes)){
typeMap.put(jianshenkechengTypes,typeMap.get(jianshenkechengTypes)+1); // 统计类型数量
}else{
typeMap.put(jianshenkechengTypes,1); // 初始化类型数量
}
}
List<Integer> typeList = new ArrayList<>(); // 创建排序后的类型列表
typeMap.entrySet().stream().sorted((o1, o2) -> o2.getValue() - o1.getValue()).forEach(e -> typeList.add(e.getKey())); // 按数量从多到少排序
Integer limit = Integer.valueOf(String.valueOf(params.get("limit"))); // 获取推荐数量限制
for(Integer type:typeList){
Map<String, Object> params2 = new HashMap<>(params);params2.put("jianshenkechengTypes",type); // 设置类型查询参数
params2.put("shangxiaTypes",1); // 上架状态
params2.put("jianshenkechengYesnoTypes",2); // 审核通过状态
PageUtils pageUtils1 = jianshenkechengService.queryPage(params2); // 查询课程分页数据
List<JianshenkechengView> jianshenkechengViewList =(List<JianshenkechengView>)pageUtils1.getList(); // 获取课程列表
returnJianshenkechengViewList.addAll(jianshenkechengViewList); // 添加到返回列表
if(returnJianshenkechengViewList.size()>= limit) break; // 达到推荐数量限制时跳出循环
}
params.put("shangxiaTypes",1); // 设置上架状态
params.put("jianshenkechengYesnoTypes",2); // 设置审核通过状态
//正常查询出来商品,用于补全推荐缺少的数据
PageUtils page = jianshenkechengService.queryPage(params); // 查询课程分页数据
if(returnJianshenkechengViewList.size()<limit){ // 如果推荐数量不足
int toAddNum = limit - returnJianshenkechengViewList.size(); // 计算需要补充的数量
List<JianshenkechengView> jianshenkechengViewList =(List<JianshenkechengView>)page.getList(); // 获取课程列表
for(JianshenkechengView jianshenkechengView:jianshenkechengViewList){
Boolean addFlag = true;
for(JianshenkechengView returnJianshenkechengView:returnJianshenkechengViewList){
if(returnJianshenkechengView.getId().intValue() ==jianshenkechengView.getId().intValue()) addFlag=false; // 已存在的课程不再添加
}
if(addFlag){
toAddNum=toAddNum-1;
returnJianshenkechengViewList.add(jianshenkechengView); // 添加到返回列表
if(toAddNum==0) break; // 补充足够数量后跳出循环
}
}
}else {
returnJianshenkechengViewList = returnJianshenkechengViewList.subList(0, limit); // 截取指定数量的推荐课程
}
for(JianshenkechengView c:returnJianshenkechengViewList)
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
page.setList(returnJianshenkechengViewList); // 设置返回列表
return R.ok().put("data", page); // 返回推荐数据
}
//前端列表
@IgnoreAuth // 忽略认证
@RequestMapping("/list") // 处理列表请求
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
CommonUtil.checkMap(params); // 检查参数
PageUtils page = jianshenkechengService.queryPage(params); // 查询分页数据
// 字典表数据转换
List<JianshenkechengView> list =(List<JianshenkechengView>)page.getList();
for(JianshenkechengView c:list)
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
return R.ok().put("data", page); // 返回分页数据
}
//前端详情
@RequestMapping("/detail/{id}") // 处理详情请求
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(id); // 根据ID查询课程
if(jianshenkecheng !=null){
//点击数量加1
jianshenkecheng.setJianshenkechengClicknum(jianshenkecheng.getJianshenkechengClicknum()+1); // 增加点击量
jianshenkechengService.updateById(jianshenkecheng); // 更新课程
//entity转view
JianshenkechengView view = new JianshenkechengView();
BeanUtils.copyProperties( jianshenkecheng , view ); // 把实体数据重构到view中
//级联表
JiaolianEntity jiaolian = jiaolianService.selectById(jianshenkecheng.getJiaolianId()); // 查询关联教练
if(jiaolian != null){
BeanUtils.copyProperties( jiaolian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "jiaolianId"}); // 把级联的数据添加到view中,并排除id和创建时间字段
view.setJiaolianId(jiaolian.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 查询不到数据返回错误
}
}
//前端保存
@RequestMapping("/add") // 处理添加请求
public R add(@RequestBody JianshenkechengEntity jianshenkecheng, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,jianshenkecheng:{}",this.getClass().getName(),jianshenkecheng.toString()); // 记录日志
Wrapper<JianshenkechengEntity> queryWrapper = new EntityWrapper<JianshenkechengEntity>()
.eq("jiaolian_id", jianshenkecheng.getJiaolianId()) // 教练ID
.eq("jianshenkecheng_name", jianshenkecheng.getJianshenkechengName()) // 课程名称
.eq("jianshenkecheng_video", jianshenkecheng.getJianshenkechengVideo()) // 课程视频
.eq("zan_number", jianshenkecheng.getZanNumber()) // 赞数
.eq("cai_number", jianshenkecheng.getCaiNumber()) // 踩数
.eq("jianshenkecheng_types", jianshenkecheng.getJianshenkechengTypes()) // 课程类型
.eq("jianshenkecheng_clicknum", jianshenkecheng.getJianshenkechengClicknum()) // 点击量
.eq("data_delete", jianshenkecheng.getDataDelete()) // 逻辑删除状态
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JianshenkechengEntity jianshenkechengEntity = jianshenkechengService.selectOne(queryWrapper); // 查询是否已存在相同数据
if(jianshenkechengEntity==null){
jianshenkecheng.setZanNumber(1); // 设置默认赞数
jianshenkecheng.setCaiNumber(1); // 设置默认踩数
jianshenkecheng.setJianshenkechengClicknum(1); // 设置默认点击量
jianshenkecheng.setDataDelete(1); // 设置逻辑删除状态
jianshenkecheng.setInsertTime(new Date()); // 设置插入时间
jianshenkecheng.setCreateTime(new Date()); // 设置创建时间
jianshenkechengService.insert(jianshenkecheng); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"表中有相同数据"); // 数据已存在返回错误
}
}
}

285
src/main/java/com/controller/JianshenkechengLiuyanController.java
Unescape View File

@ -0,0 +1,285 @@
package com.controller; // 声明包路径，表示该文件位于com.controller包下
import java.io.File; // 导入文件操作类，用于处理文件上传
import java.math.BigDecimal; // 导入高精度数学计算类，用于处理金额计算
import java.net.URL; // 导入网络URL处理类，用于获取资源路径
import java.text.SimpleDateFormat; // 导入日期格式化类，用于日期格式转换
import com.alibaba.fastjson.JSONObject; // 导入FastJSON的JSON对象类，用于JSON处理
import java.util.*; // 导入Java常用工具类（集合、日期等）
import org.springframework.beans.BeanUtils; // 导入Spring Bean属性复制工具类
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求处理类
import org.springframework.web.context.ContextLoader; // 导入Spring上下文加载器
import javax.servlet.ServletContext; // 导入Servlet上下文接口
import com.service.TokenService; // 导入自定义的Token服务类
import com.utils.*; // 导入自定义工具类
import java.lang.reflect.InvocationTargetException; // 导入反射异常类
import com.service.DictionaryService; // 导入自定义的字典服务类
import org.apache.commons.lang3.StringUtils; // 导入Apache字符串工具类
import com.annotation.IgnoreAuth; // 导入自定义的忽略认证注解
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解
import org.springframework.stereotype.Controller; // 导入Spring控制器注解
import org.springframework.web.bind.annotation.*; // 导入Spring Web注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus查询条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus包装器接口
import com.entity.*; // 导入实体类
import com.entity.view.*; // 导入视图实体类
import com.service.*; // 导入服务类
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入统一返回结果类
import com.alibaba.fastjson.*; // 导入FastJSON相关类
//课程留言
//后端接口
//@author
//@email
@RestController // 标识为RESTful控制器，用于处理HTTP请求
@Controller // 标识为Spring控制器
@RequestMapping("/jianshenkechengLiuyan") // 定义请求映射路径
public class JianshenkechengLiuyanController {
private static final Logger logger = LoggerFactory.getLogger(JianshenkechengLiuyanController.class); // 日志记录器，用于记录日志信息
private static final String TABLE_NAME = "jianshenkechengLiuyan"; // 数据库表名常量
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 自动注入课程留言服务
@Autowired
private TokenService tokenService; // 自动注入Token服务
@Autowired
private DictionaryService dictionaryService; // 自动注入字典服务
@Autowired
private ForumService forumService; // 自动注入健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 自动注入健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 自动注入课程收藏服务
@Autowired
private JiaolianService jiaolianService; // 自动注入教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 自动注入教练预约申请服务
@Autowired
private NewsService newsService; // 自动注入健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 自动注入单页数据服务
@Autowired
private YonghuService yonghuService; // 自动注入用户服务
@Autowired
private UsersService usersService; // 自动注入管理员服务
//后端列表
//处理分页查询请求
@RequestMapping("/page") // 映射分页查询请求
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录请求日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 从session中获取用户角色
if(false) // 永远不会执行的代码块
return R.error(511,"永不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
params.put("yonghuId",request.getSession().getAttribute("userId")); // 将用户ID添加到查询参数
else if("教练".equals(role)) // 如果是教练角色
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 将教练ID添加到查询参数
CommonUtil.checkMap(params); // 检查参数有效性
PageUtils page = jianshenkechengLiuyanService.queryPage(params); // 调用服务层查询分页数据
// 字典表数据转换
List<JianshenkechengLiuyanView> list =(List<JianshenkechengLiuyanView>)page.getList(); // 获取分页数据列表
for(JianshenkechengLiuyanView c:list){ // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
}
return R.ok().put("data", page); // 返回分页数据
}
//后端详情
//根据ID查询单条留言详情
@RequestMapping("/info/{id}") // 映射详情查询请求
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录请求日志
JianshenkechengLiuyanEntity jianshenkechengLiuyan = jianshenkechengLiuyanService.selectById(id); // 根据ID查询留言
if(jianshenkechengLiuyan !=null){ // 如果查询到数据
JianshenkechengLiuyanView view = new JianshenkechengLiuyanView(); // 创建视图对象
BeanUtils.copyProperties(jianshenkechengLiuyan, view); // 复制属性到视图对象
// 查询关联的健身课程信息
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(jianshenkechengLiuyan.getJianshenkechengId());
if(jianshenkecheng != null){
BeanUtils.copyProperties(jianshenkecheng, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setJianshenkechengId(jianshenkecheng.getId());
}
// 查询关联的用户信息
YonghuEntity yonghu = yonghuService.selectById(jianshenkechengLiuyan.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties(yonghu, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setYonghuId(yonghu.getId());
}
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//后端保存
//处理新增留言请求
@RequestMapping("/save") // 映射保存请求
public R save(@RequestBody JianshenkechengLiuyanEntity jianshenkechengLiuyan, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,jianshenkechengLiuyan:{}",this.getClass().getName(),jianshenkechengLiuyan.toString()); // 记录请求日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 永远不会执行的代码块
return R.error(511,"永远不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
jianshenkechengLiuyan.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 设置用户ID
jianshenkechengLiuyan.setCreateTime(new Date()); // 设置创建时间
jianshenkechengLiuyan.setInsertTime(new Date()); // 设置插入时间
jianshenkechengLiuyanService.insert(jianshenkechengLiuyan); // 调用服务层保存数据
return R.ok(); // 返回成功信息
}
//后端修改
//处理更新留言请
@RequestMapping("/update") // 映射更新请求
public R update(@RequestBody JianshenkechengLiuyanEntity jianshenkechengLiuyan, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,jianshenkechengLiuyan:{}",this.getClass().getName(),jianshenkechengLiuyan.toString()); // 记录请求日志
JianshenkechengLiuyanEntity oldJianshenkechengLiuyanEntity = jianshenkechengLiuyanService.selectById(jianshenkechengLiuyan.getId()); // 查询原有数据
// 处理空值情况
if("".equals(jianshenkechengLiuyan.getJianshenkechengLiuyanText()) || "null".equals(jianshenkechengLiuyan.getJianshenkechengLiuyanText())){
jianshenkechengLiuyan.setJianshenkechengLiuyanText(null);
}
if("".equals(jianshenkechengLiuyan.getReplyText()) || "null".equals(jianshenkechengLiuyan.getReplyText())){
jianshenkechengLiuyan.setReplyText(null);
}
jianshenkechengLiuyan.setUpdateTime(new Date()); // 设置更新时间
jianshenkechengLiuyanService.updateById(jianshenkechengLiuyan); // 调用服务层更新数据
return R.ok(); // 返回成功信息
}
//删除
//处理删除留言请求
@RequestMapping("/delete") // 映射删除请求
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录请求日志
List<JianshenkechengLiuyanEntity> oldJianshenkechengLiuyanList = jianshenkechengLiuyanService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
jianshenkechengLiuyanService.deleteBatchIds(Arrays.asList(ids)); // 调用服务层批量删除
return R.ok(); // 返回成功信息
}
//批量上传
//处理批量导入数据请求
@RequestMapping("/batchInsert") // 映射批量导入请求
public R save(String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录请求日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<JianshenkechengLiuyanEntity> jianshenkechengLiuyanList = new ArrayList<>(); // 创建数据列表
Map<String, List<String>> seachFields = new HashMap<>(); // 创建查询字段映射
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){ // 如果没有后缀
return R.error(511,"该文件没有后缀"); // 返回错误信息
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){ // 如果不是xls文件
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误信息
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){ // 如果文件不存在
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误信息
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取Excel文件
dataList.remove(0); // 删除标题行
for(List<String> data:dataList){ // 遍历数据行
JianshenkechengLiuyanEntity jianshenkechengLiuyanEntity = new JianshenkechengLiuyanEntity(); // 创建实体对象
jianshenkechengLiuyanList.add(jianshenkechengLiuyanEntity); // 添加到列表
}
jianshenkechengLiuyanService.insertBatch(jianshenkechengLiuyanList); // 批量插入数据
return R.ok(); // 返回成功信息
}
}
}
}catch (Exception e){
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误信息
}
}
//前端列表
//处理前端分页查询请求
@IgnoreAuth // 忽略认证
@RequestMapping("/list") // 映射列表查询请求
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录请求日志
CommonUtil.checkMap(params); // 检查参数有效性
PageUtils page = jianshenkechengLiuyanService.queryPage(params); // 调用服务层查询分页数据
// 字典表数据转换
List<JianshenkechengLiuyanView> list =(List<JianshenkechengLiuyanView>)page.getList(); // 获取分页数据列表
for(JianshenkechengLiuyanView c:list){ // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
}
return R.ok().put("data", page); // 返回分页数据
}
//前端详情
//处理前端详情查询请求
@RequestMapping("/detail/{id}") // 映射详情查询请求
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录请求日志
JianshenkechengLiuyanEntity jianshenkechengLiuyan = jianshenkechengLiuyanService.selectById(id); // 根据ID查询留言
if(jianshenkechengLiuyan !=null){ // 如果查询到数据
JianshenkechengLiuyanView view = new JianshenkechengLiuyanView(); // 创建视图对象
BeanUtils.copyProperties(jianshenkechengLiuyan, view); // 复制属性到视图对象
// 查询关联的健身课程信息
JianshenkechengEntity jianshenkecheng = jianshenkechengService.selectById(jianshenkechengLiuyan.getJianshenkechengId());
if(jianshenkecheng != null){
BeanUtils.copyProperties(jianshenkecheng, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setJianshenkechengId(jianshenkecheng.getId());
}
// 查询关联的用户信息
YonghuEntity yonghu = yonghuService.selectById(jianshenkechengLiuyan.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties(yonghu, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setYonghuId(yonghu.getId());
}
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//前端保存
//处理前端新增留言请求
@RequestMapping("/add") // 映射新增请求
public R add(@RequestBody JianshenkechengLiuyanEntity jianshenkechengLiuyan, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,jianshenkechengLiuyan:{}",this.getClass().getName(),jianshenkechengLiuyan.toString()); // 记录请求日志
jianshenkechengLiuyan.setCreateTime(new Date()); // 设置创建时间
jianshenkechengLiuyan.setInsertTime(new Date()); // 设置插入时间
jianshenkechengLiuyanService.insert(jianshenkechengLiuyan); // 调用服务层保存数据
return R.ok(); // 返回成功信息
}
}

506
src/main/java/com/controller/JiaolianController.java
Unescape View File

@ -0,0 +1,506 @@
// 声明当前 Java 文件所属的包，此包一般用于存放控制器相关的类，负责处理 HTTP 请求和响应
package com.controller;
// 导入 Java 标准库中的 File 类，用于操作文件和目录
import java.io.File;
// 导入 Java 标准库中的 BigDecimal 类，用于进行高精度的十进制数运算
import java.math.BigDecimal;
// 导入 Java 标准库中的 URL 类，用于表示统一资源定位符，可用于处理网络资源
import java.net.URL;
// 导入 Java 标准库中的 SimpleDateFormat 类，用于格式化和解析日期时间
import java.text.SimpleDateFormat;
// 导入阿里巴巴的 FastJSON 库中的 JSONObject 类，用于处理 JSON 对象，方便进行 JSON 数据的操作
import com.alibaba.fastjson.JSONObject;
// 导入 Java 标准库中的 java.util 包下的所有类，该包包含了集合框架、日期和时间、随机数生成等常用工具类
import java.util.*;
// 导入 Spring 框架中的 BeanUtils 类，用于对象属性的复制，方便在不同对象之间传递数据
import org.springframework.beans.BeanUtils;
// 导入 Java Servlet API 中的 HttpServletRequest 类，用于封装 HTTP 请求信息，在控制器中可获取请求参数等
import javax.servlet.http.HttpServletRequest;
// 导入 Spring 框架中的 ContextLoader 类，用于获取 Spring 的应用上下文
import org.springframework.web.context.ContextLoader;
// 导入 Java Servlet API 中的 ServletContext 类，用于表示 Servlet 上下文，可获取应用的全局信息
import javax.servlet.ServletContext;
// 导入自定义的 TokenService 类，该类可能用于处理令牌相关的业务逻辑
import com.service.TokenService;
// 导入自定义的 utils 包下的所有类，这些类通常包含一些通用的工具方法
import com.utils.*;
// 导入 Java 反射机制中的 InvocationTargetException 类，当使用反射调用方法时，如果被调用的方法抛出异常，会被封装成该异常抛出
import java.lang.reflect.InvocationTargetException;
// 导入自定义的 DictionaryService 类，该类可能用于处理字典数据的业务逻辑
import com.service.DictionaryService;
// 导入 Apache Commons Lang3 库中的 StringUtils 类，提供了许多方便的字符串操作方法
import org.apache.commons.lang3.StringUtils;
// 导入自定义的 IgnoreAuth 注解，该注解可能用于标记不需要进行身份验证的接口
import com.annotation.IgnoreAuth;
// 导入 SLF4J 日志框架中的 Logger 接口，用于记录日志信息
import org.slf4j.Logger;
// 导入 SLF4J 日志框架中的 LoggerFactory 类，用于创建 Logger 实例
import org.slf4j.LoggerFactory;
// 导入 Spring 框架中的 Autowired 注解，用于自动注入依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中的 Controller 注解，用于标记该类为控制器类，处理 HTTP 请求
import org.springframework.stereotype.Controller;
// 导入 Spring 框架中的 RestController 和 RequestMapping 等注解，用于构建 RESTful 风格的接口
import org.springframework.web.bind.annotation.*;
// 导入 MyBatis-Plus 框架中的 EntityWrapper 类，用于构建实体对象的查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入 MyBatis-Plus 框架中的 Wrapper 接口，EntityWrapper 实现了该接口，用于灵活构建查询条件
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义的 entity 包下的所有类，这些类通常是实体类，对应数据库表结构
import com.entity.*;
// 导入自定义的 view 包下的所有类，这些类可能是用于视图展示的实体类
import com.entity.view.*;
// 导入自定义的 service 包下的所有类，这些类通常包含业务逻辑处理方法
import com.service.*;
// 导入自定义的 PageUtils 类，用于处理分页相关的逻辑
import com.utils.PageUtils;
// 导入自定义的 R 类，通常用于封装统一的响应结果
import com.utils.R;
// 导入阿里巴巴的 FastJSON 库中的所有类，进一步方便进行 JSON 数据的操作
import com.alibaba.fastjson.*;
//教练
//后端接口
//@author
//@email
@RestController
@Controller
@RequestMapping("/jiaolian")
public class JiaolianController {
private static final Logger logger = LoggerFactory.getLogger(JiaolianController.class);
private static final String TABLE_NAME = "jiaolian";
@Autowired
private JiaolianService jiaolianService;
@Autowired
private TokenService tokenService;
@Autowired
private DictionaryService dictionaryService;//字典
@Autowired
private ForumService forumService;//健身论坛
@Autowired
private JianshenkechengService jianshenkechengService;//健身课程
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService;//课程收藏
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService;//课程留言
@Autowired
private JiaolianYuyueService jiaolianYuyueService;//教练预约申请
@Autowired
private NewsService newsService;//健身资讯
@Autowired
private SingleSeachService singleSeachService;//单页数据
@Autowired
private YonghuService yonghuService;//用户
@Autowired
private UsersService usersService;//管理员
//后端列表
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId"));
else if("教练".equals(role))
params.put("jiaolianId",request.getSession().getAttribute("userId"));
params.put("dataDeleteStart",1);params.put("dataDeleteEnd",1);
CommonUtil.checkMap(params);
PageUtils page = jiaolianService.queryPage(params);
//字典表数据转换
List<JiaolianView> list =(List<JiaolianView>)page.getList();
for(JiaolianView c:list){
//修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page);
}
//后端详情
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){
//entity转view
JiaolianView view = new JiaolianView();
BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
//后端保存
@RequestMapping("/save")
public R save(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername())
.or()
.eq("jiaolian_phone", jiaolian.getJiaolianPhone())
.eq("data_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity==null){
jiaolian.setDataDelete(1);
jiaolian.setInsertTime(new Date());
jiaolian.setCreateTime(new Date());
jiaolian.setPassword("123456");
jiaolianService.insert(jiaolian);
return R.ok();
}else {
return R.error(511,"账户或者教练手机号已经被使用");
}
}
//后端修改
@RequestMapping("/update")
public R update(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
JiaolianEntity oldJiaolianEntity = jiaolianService.selectById(jiaolian.getId());//查询原先数据
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
if("".equals(jiaolian.getJiaolianPhoto()) || "null".equals(jiaolian.getJiaolianPhoto())){
jiaolian.setJiaolianPhoto(null);
}
if("".equals(jiaolian.getJiaolianContent()) || "null".equals(jiaolian.getJiaolianContent())){
jiaolian.setJiaolianContent(null);
}
jiaolianService.updateById(jiaolian);//根据id更新
return R.ok();
}
//删除
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<JiaolianEntity> oldJiaolianList =jiaolianService.selectBatchIds(Arrays.asList(ids));//要删除的数据
ArrayList<JiaolianEntity> list = new ArrayList<>();
for(Integer id:ids){
JiaolianEntity jiaolianEntity = new JiaolianEntity();
jiaolianEntity.setId(id);
jiaolianEntity.setDataDelete(2);
list.add(jiaolianEntity);
}
if(list != null && list.size() >0){
jiaolianService.updateBatchById(list);
}
return R.ok();
}
//批量上传
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//.eq("time", new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
try {
List<JiaolianEntity> jiaolianList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
Date date = new Date();
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
JiaolianEntity jiaolianEntity = new JiaolianEntity();
// jiaolianEntity.setUsername(data.get(0)); //账户 要改的
// jiaolianEntity.setPassword("123456");//密码
// jiaolianEntity.setJiaolianName(data.get(0)); //教练名称 要改的
// jiaolianEntity.setJiaolianPhone(data.get(0)); //教练手机号 要改的
// jiaolianEntity.setJiaolianPhoto("");//详情和图片
// jiaolianEntity.setSexTypes(Integer.valueOf(data.get(0))); //性别 要改的
// jiaolianEntity.setJiaolianEmail(data.get(0)); //教练邮箱 要改的
// jiaolianEntity.setJiaolianContent("");//详情和图片
// jiaolianEntity.setDataDelete(1);//逻辑删除字段
// jiaolianEntity.setInsertTime(date);//时间
// jiaolianEntity.setCreateTime(date);//时间
jiaolianList.add(jiaolianEntity);
//把要查询是否重复的字段放入map中
//账户
if(seachFields.containsKey("username")){
List<String> username = seachFields.get("username");
username.add(data.get(0));//要改的
}else{
List<String> username = new ArrayList<>();
username.add(data.get(0));//要改的
seachFields.put("username",username);
}
//教练手机号
if(seachFields.containsKey("jiaolianPhone")){
List<String> jiaolianPhone = seachFields.get("jiaolianPhone");
jiaolianPhone.add(data.get(0));//要改的
}else{
List<String> jiaolianPhone = new ArrayList<>();
jiaolianPhone.add(data.get(0));//要改的
seachFields.put("jiaolianPhone",jiaolianPhone);
}
}
//查询是否重复
//账户
List<JiaolianEntity> jiaolianEntities_username = jiaolianService.selectList(new EntityWrapper<JiaolianEntity>().in("username", seachFields.get("username")).eq("data_delete", 1));
if(jiaolianEntities_username.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(JiaolianEntity s:jiaolianEntities_username){
repeatFields.add(s.getUsername());
}
return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString());
}
//教练手机号
List<JiaolianEntity> jiaolianEntities_jiaolianPhone = jiaolianService.selectList(new EntityWrapper<JiaolianEntity>().in("jiaolian_phone", seachFields.get("jiaolianPhone")).eq("data_delete", 1));
if(jiaolianEntities_jiaolianPhone.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(JiaolianEntity s:jiaolianEntities_jiaolianPhone){
repeatFields.add(s.getJiaolianPhone());
}
return R.error(511,"数据库的该表中的 [教练手机号] 字段已经存在 存在数据为:"+repeatFields.toString());
}
jiaolianService.insertBatch(jiaolianList);
return R.ok();
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
//登录
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username));
if(jiaolian==null || !jiaolian.getPassword().equals(password))
return R.error("账号或密码不正确");
else if(jiaolian.getDataDelete() != 1)
return R.error("账户已被删除");
String token = tokenService.generateToken(jiaolian.getId(),username, "jiaolian", "教练");
R r = R.ok();
r.put("token", token);
r.put("role","教练");
r.put("username",jiaolian.getJiaolianName());
r.put("tableName","jiaolian");
r.put("userId",jiaolian.getId());
return r;
}
//注册
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) {
// ValidatorUtils.validateEntity(user);
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername())
.or()
.eq("jiaolian_phone", jiaolian.getJiaolianPhone())
.andNew()
.eq("data_delete", 1)
;
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity != null)
return R.error("账户或者教练手机号已经被使用");
jiaolian.setDataDelete(1);
jiaolian.setInsertTime(new Date());
jiaolian.setCreateTime(new Date());
jiaolianService.insert(jiaolian);
return R.ok();
}
//重置密码
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id, HttpServletRequest request) {
JiaolianEntity jiaolian = jiaolianService.selectById(id);
jiaolian.setPassword("123456");
jiaolianService.updateById(jiaolian);
return R.ok();
}
//修改密码
@GetMapping(value = "/updatePassword")
public R updatePassword(String oldPassword, String newPassword, HttpServletRequest request) {
JiaolianEntity jiaolian = jiaolianService.selectById((Integer)request.getSession().getAttribute("userId"));
if(newPassword == null){
return R.error("新密码不能为空") ;
}
if(!oldPassword.equals(jiaolian.getPassword())){
return R.error("原密码输入错误");
}
if(newPassword.equals(jiaolian.getPassword())){
return R.error("新密码不能和原密码一致") ;
}
jiaolian.setPassword(newPassword);
jiaolianService.updateById(jiaolian);
return R.ok();
}
//忘记密码
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username));
if(jiaolian!=null){
jiaolian.setPassword("123456");
jiaolianService.updateById(jiaolian);
return R.ok();
}else{
return R.error("账号不存在");
}
}
//获取用户的session用户信息
@RequestMapping("/session")
public R getCurrJiaolian(HttpServletRequest request){
Integer id = (Integer)request.getSession().getAttribute("userId");
JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){
//entity转view
JiaolianView view = new JiaolianView();
BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
//退出
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate();
return R.ok("退出成功");
}
//前端列表
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params);
PageUtils page = jiaolianService.queryPage(params);
//字典表数据转换
List<JiaolianView> list =(List<JiaolianView>)page.getList();
for(JiaolianView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
//前端详情
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){
//entity转view
JiaolianView view = new JiaolianView();
BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
//前端保存
@RequestMapping("/add")
public R add(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername())
.or()
.eq("jiaolian_phone", jiaolian.getJiaolianPhone())
.andNew()
.eq("data_delete", 1)
// .notIn("jiaolian_types", new Integer[]{102})
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity==null){
jiaolian.setDataDelete(1);
jiaolian.setInsertTime(new Date());
jiaolian.setCreateTime(new Date());
jiaolian.setPassword("123456");
jiaolianService.insert(jiaolian);
return R.ok();
}else {
return R.error(511,"账户或者教练手机号已经被使用");
}
}
}

340
src/main/java/com/controller/JiaolianYuyueController.java
Unescape View File

@ -0,0 +1,340 @@
package com.controller; // 声明包路径，表示该文件位于com.controller包下
import java.io.File; // 导入文件操作类，用于处理文件上传
import java.math.BigDecimal; // 导入高精度数学计算类，用于处理金额计算
import java.net.URL; // 导入网络URL处理类，用于获取资源路径
import java.text.SimpleDateFormat; // 导入日期格式化类，用于日期格式转换
import com.alibaba.fastjson.JSONObject; // 导入FastJSON的JSON对象类，用于JSON处理
import java.util.*; // 导入Java常用工具类（集合、日期等）
import org.springframework.beans.BeanUtils; // 导入Spring Bean属性复制工具类
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求处理类
import org.springframework.web.context.ContextLoader; // 导入Spring上下文加载器
import javax.servlet.ServletContext; // 导入Servlet上下文接口
import com.service.TokenService; // 导入自定义的Token服务类
import com.utils.*; // 导入自定义工具类
import java.lang.reflect.InvocationTargetException; // 导入反射异常类
import com.service.DictionaryService; // 导入自定义的字典服务类
import org.apache.commons.lang3.StringUtils; // 导入Apache字符串工具类
import com.annotation.IgnoreAuth; // 导入自定义的忽略认证注解
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // 导入Spring自动注入注解
import org.springframework.stereotype.Controller; // 导入Spring控制器注解
import org.springframework.web.bind.annotation.*; // 导入Spring Web注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 导入MyBatis Plus查询条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 导入MyBatis Plus包装器接口
import com.entity.*; // 导入实体类
import com.entity.view.*; // 导入视图实体类
import com.service.*; // 导入服务类
import com.utils.PageUtils; // 导入分页工具类
import com.utils.R; // 导入统一返回结果类
import com.alibaba.fastjson.*; // 导入FastJSON相关类
//教练预约申请
//后端接口
//@author
// @email
@RestController // 标识为RESTful控制器，用于处理HTTP请求
@Controller // 标识为Spring控制器
@RequestMapping("/jiaolianYuyue") // 定义请求映射路径
public class JiaolianYuyueController {
private static final Logger logger = LoggerFactory.getLogger(JiaolianYuyueController.class); // 日志记录器，用于记录日志信息
private static final String TABLE_NAME = "jiaolianYuyue"; // 数据库表名常量
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 自动注入教练预约服务
@Autowired
private TokenService tokenService; // 自动注入Token服务
@Autowired
private DictionaryService dictionaryService; // 自动注入字典服务
@Autowired
private ForumService forumService; // 自动注入健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 自动注入健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 自动注入课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 自动注入课程留言服务
@Autowired
private JiaolianService jiaolianService; // 自动注入教练服务
@Autowired
private NewsService newsService; // 自动注入健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 自动注入单页数据服务
@Autowired
private YonghuService yonghuService; // 自动注入用户服务
@Autowired
private UsersService usersService; // 自动注入管理员服务
//后端列表
//处理分页查询请求
@RequestMapping("/page") // 映射分页查询请求
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录请求日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 从session中获取用户角色
if(false) // 永远不会执行的代码块
return R.error(511,"永不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
params.put("yonghuId",request.getSession().getAttribute("userId")); // 将用户ID添加到查询参数
else if("教练".equals(role)) // 如果是教练角色
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 将教练ID添加到查询参数
CommonUtil.checkMap(params); // 检查参数有效性
PageUtils page = jiaolianYuyueService.queryPage(params); // 调用服务层查询分页数据
// 字典表数据转换
List<JiaolianYuyueView> list =(List<JiaolianYuyueView>)page.getList(); // 获取分页数据列表
for(JiaolianYuyueView c:list){ // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
}
return R.ok().put("data", page); // 返回分页数据
}
//后端详情
//根据ID查询单条预约详情
@RequestMapping("/info/{id}") // 映射详情查询请求
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录请求日志
JiaolianYuyueEntity jiaolianYuyue = jiaolianYuyueService.selectById(id); // 根据ID查询预约
if(jiaolianYuyue !=null){ // 如果查询到数据
JiaolianYuyueView view = new JiaolianYuyueView(); // 创建视图对象
BeanUtils.copyProperties(jiaolianYuyue, view); // 复制属性到视图对象
// 查询关联的用户信息
YonghuEntity yonghu = yonghuService.selectById(jiaolianYuyue.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties(yonghu, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setYonghuId(yonghu.getId());
}
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//后端保存
//处理新增预约请求
@RequestMapping("/save") // 映射保存请求
public R save(@RequestBody JiaolianYuyueEntity jiaolianYuyue, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,jiaolianYuyue:{}",this.getClass().getName(),jiaolianYuyue.toString()); // 记录请求日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 永远不会执行的代码块
return R.error(511,"永远不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
jiaolianYuyue.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")))); // 设置用户ID
// 构建查询条件，检查是否存在相同用户的待审核或已通过的预约
Wrapper<JiaolianYuyueEntity> queryWrapper = new EntityWrapper<JiaolianYuyueEntity>()
.eq("yonghu_id", jiaolianYuyue.getYonghuId())
.in("jiaolian_yuyue_yesno_types", new Integer[]{1,2});
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JiaolianYuyueEntity jiaolianYuyueEntity = jiaolianYuyueService.selectOne(queryWrapper); // 查询是否存在重复数据
if(jiaolianYuyueEntity==null){ // 如果没有重复数据
jiaolianYuyue.setJiaolianYuyueYesnoTypes(1); // 设置状态为待审核
jiaolianYuyue.setInsertTime(new Date()); // 设置插入时间
jiaolianYuyue.setCreateTime(new Date()); // 设置创建时间
jiaolianYuyueService.insert(jiaolianYuyue); // 调用服务层保存数据
return R.ok(); // 返回成功信息
}else { // 如果存在重复数据
if(jiaolianYuyueEntity.getJiaolianYuyueYesnoTypes()==1) // 如果是待审核状态
return R.error(511,"有相同的待审核的数据"); // 返回错误信息
else if(jiaolianYuyueEntity.getJiaolianYuyueYesnoTypes()==2) // 如果是已通过状态
return R.error(511,"有相同的审核通过的数据"); // 返回错误信息
else
return R.error(511,"表中有相同数据"); // 返回错误信息
}
}
//后端修改
//处理更新预约请求
@RequestMapping("/update") // 映射更新请求
public R update(@RequestBody JiaolianYuyueEntity jiaolianYuyue, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,jiaolianYuyue:{}",this.getClass().getName(),jiaolianYuyue.toString()); // 记录请求日志
JiaolianYuyueEntity oldJiaolianYuyueEntity = jiaolianYuyueService.selectById(jiaolianYuyue.getId()); // 查询原有数据
// 处理空值情况
if("".equals(jiaolianYuyue.getJiaolianYuyueText()) || "null".equals(jiaolianYuyue.getJiaolianYuyueText())){
jiaolianYuyue.setJiaolianYuyueText(null);
}
if("".equals(jiaolianYuyue.getJiaolianYuyueYesnoText()) || "null".equals(jiaolianYuyue.getJiaolianYuyueYesnoText())){
jiaolianYuyue.setJiaolianYuyueYesnoText(null);
}
jiaolianYuyueService.updateById(jiaolianYuyue); // 调用服务层更新数据
return R.ok(); // 返回成功信息
}
//审核
//处理预约审核请求
@RequestMapping("/shenhe") // 映射审核请求
public R shenhe(@RequestBody JiaolianYuyueEntity jiaolianYuyueEntity, HttpServletRequest request){
logger.debug("shenhe方法:,,Controller:{},,jiaolianYuyueEntity:{}",this.getClass().getName(),jiaolianYuyueEntity.toString()); // 记录请求日志
JiaolianYuyueEntity oldJiaolianYuyue = jiaolianYuyueService.selectById(jiaolianYuyueEntity.getId()); // 查询原有数据
jiaolianYuyueService.updateById(jiaolianYuyueEntity); // 调用服务层更新审核状态
return R.ok(); // 返回成功信息
}
//删除
//处理删除预约请求
@RequestMapping("/delete") // 映射删除请求
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录请求日志
List<JiaolianYuyueEntity> oldJiaolianYuyueList = jiaolianYuyueService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
jiaolianYuyueService.deleteBatchIds(Arrays.asList(ids)); // 调用服务层批量删除
return R.ok(); // 返回成功信息
}
//批量上传
//处理批量导入数据请求
@RequestMapping("/batchInsert") // 映射批量导入请求
public R save(String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录请求日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<JiaolianYuyueEntity> jiaolianYuyueList = new ArrayList<>(); // 创建数据列表
Map<String, List<String>> seachFields = new HashMap<>(); // 创建查询字段映射
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){ // 如果没有后缀
return R.error(511,"该文件没有后缀"); // 返回错误信息
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){ // 如果不是xls文件
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误信息
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){ // 如果文件不存在
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误信息
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取Excel文件
dataList.remove(0); // 删除标题行
for(List<String> data:dataList){ // 遍历数据行
JiaolianYuyueEntity jiaolianYuyueEntity = new JiaolianYuyueEntity(); // 创建实体对象
jiaolianYuyueList.add(jiaolianYuyueEntity); // 添加到列表
// 检查预约编号是否重复
if(seachFields.containsKey("jiaolianYuyueUuidNumber")){
List<String> jiaolianYuyueUuidNumber = seachFields.get("jiaolianYuyueUuidNumber");
jiaolianYuyueUuidNumber.add(data.get(0));
}else{
List<String> jiaolianYuyueUuidNumber = new ArrayList<>();
jiaolianYuyueUuidNumber.add(data.get(0));
seachFields.put("jiaolianYuyueUuidNumber",jiaolianYuyueUuidNumber);
}
}
// 检查预约编号是否已存在
List<JiaolianYuyueEntity> jiaolianYuyueEntities_jiaolianYuyueUuidNumber = jiaolianYuyueService.selectList(new EntityWrapper<JiaolianYuyueEntity>().in("jiaolian_yuyue_uuid_number", seachFields.get("jiaolianYuyueUuidNumber")));
if(jiaolianYuyueEntities_jiaolianYuyueUuidNumber.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(JiaolianYuyueEntity s:jiaolianYuyueEntities_jiaolianYuyueUuidNumber){
repeatFields.add(s.getJiaolianYuyueUuidNumber());
}
return R.error(511,"数据库的该表中的 [预约编号] 字段已经存在 存在数据为:"+repeatFields.toString());
}
jiaolianYuyueService.insertBatch(jiaolianYuyueList); // 批量插入数据
return R.ok(); // 返回成功信息
}
}
}
}catch (Exception e){
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误信息
}
}
//前端列表
//处理前端分页查询请求
@IgnoreAuth // 忽略认证
@RequestMapping("/list") // 映射列表查询请求
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录请求日志
CommonUtil.checkMap(params); // 检查参数有效性
PageUtils page = jiaolianYuyueService.queryPage(params); // 调用服务层查询分页数据
// 字典表数据转换
List<JiaolianYuyueView> list =(List<JiaolianYuyueView>)page.getList(); // 获取分页数据列表
for(JiaolianYuyueView c:list){ // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
}
return R.ok().put("data", page); // 返回分页数据
}
//前端详情
//处理前端详情查询请求
@RequestMapping("/detail/{id}") // 映射详情查询请求
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录请求日志
JiaolianYuyueEntity jiaolianYuyue = jiaolianYuyueService.selectById(id); // 根据ID查询预约
if(jiaolianYuyue !=null){ // 如果查询到数据
JiaolianYuyueView view = new JiaolianYuyueView(); // 创建视图对象
BeanUtils.copyProperties(jiaolianYuyue, view); // 复制属性到视图对象
// 查询关联的用户信息
YonghuEntity yonghu = yonghuService.selectById(jiaolianYuyue.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties(yonghu, view, new String[]{ "id", "createTime", "insertTime", "updateTime", "username", "password", "newMoney", "yonghuId"});
view.setYonghuId(yonghu.getId());
}
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回详情数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//前端保存
//处理前端新增预约请求
@RequestMapping("/add") // 映射新增请求
public R add(@RequestBody JiaolianYuyueEntity jiaolianYuyue, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,jiaolianYuyue:{}",this.getClass().getName(),jiaolianYuyue.toString()); // 记录请求日志
// 构建查询条件，检查是否存在相同用户的待审核或已通过的预约
Wrapper<JiaolianYuyueEntity> queryWrapper = new EntityWrapper<JiaolianYuyueEntity>()
.eq("jiaolian_yuyue_uuid_number", jiaolianYuyue.getJiaolianYuyueUuidNumber())
.eq("yonghu_id", jiaolianYuyue.getYonghuId())
.eq("jiaolian_yuyue_text", jiaolianYuyue.getJiaolianYuyueText())
.in("jiaolian_yuyue_yesno_types", new Integer[]{1,2})
.eq("jiaolian_yuyue_yesno_text", jiaolianYuyue.getJiaolianYuyueYesnoText());
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
JiaolianYuyueEntity jiaolianYuyueEntity = jiaolianYuyueService.selectOne(queryWrapper); // 查询是否存在重复数据
if(jiaolianYuyueEntity==null){ // 如果没有重复数据
jiaolianYuyue.setJiaolianYuyueYesnoTypes(1); // 设置状态为待审核
jiaolianYuyue.setInsertTime(new Date()); // 设置插入时间
jiaolianYuyue.setCreateTime(new Date()); // 设置创建时间
jiaolianYuyueService.insert(jiaolianYuyue); // 调用服务层保存数据
return R.ok(); // 返回成功信息
}else { // 如果存在重复数据
if(jiaolianYuyueEntity.getJiaolianYuyueYesnoTypes()==1) // 如果是待审核状态
return R.error(511,"有相同的待审核的数据"); // 返回错误信息
else if(jiaolianYuyueEntity.getJiaolianYuyueYesnoTypes()==2) // 如果是已通过状态
return R.error(511,"有相同的审核通过的数据"); // 返回错误信息
else
return R.error(511,"表中有相同数据"); // 返回错误信息
}
}
}

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

@ -0,0 +1,324 @@
package com.controller; // 定义包名为com.controller
import java.io.File; // 文件操作类
import java.math.BigDecimal; // 大数字处理类
import java.net.URL; // 统一资源定位符类
import java.text.SimpleDateFormat; // 日期格式化类
import com.alibaba.fastjson.JSONObject; // 阿里巴巴FastJSON库的JSON对象类
import java.util.*; // 通用工具类集合
import org.springframework.beans.BeanUtils; // Spring Bean工具类
import javax.servlet.http.HttpServletRequest; // HTTP请求处理类
import org.springframework.web.context.ContextLoader; // Spring上下文加载器
import javax.servlet.ServletContext; // Servlet上下文接口
import com.service.TokenService; // 自定义Token服务类
import com.utils.*; // 自定义工具类包
import java.lang.reflect.InvocationTargetException; // 反射异常类
import com.service.DictionaryService; // 自定义字典服务类
import org.apache.commons.lang3.StringUtils; // Apache字符串工具类
import com.annotation.IgnoreAuth; // 自定义忽略认证注解
import org.slf4j.Logger; // 日志接口
import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // Spring自动注入注解
import org.springframework.stereotype.Controller; // Spring控制器注解
import org.springframework.web.bind.annotation.*; // Spring Web注解集合
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis Plus实体包装器
import com.baomidou.mybatisplus.mapper.Wrapper; // MyBatis Plus包装器接口
import com.entity.*; // 自定义实体类包
import com.entity.view.*; // 自定义视图类包
import com.service.*; // 自定义服务类包
import com.utils.PageUtils; // 自定义分页工具类
import com.utils.R; // 自定义返回结果类
import com.alibaba.fastjson.*; // 阿里巴巴FastJSON库
//健身资讯
//后端接口
//@author
// @email
@RestController
@Controller
@RequestMapping("/news")
public class NewsController {
private static final Logger logger = LoggerFactory.getLogger(NewsController.class);
private static final String TABLE_NAME = "news"; // 数据库表名
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private TokenService tokenService; // token服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private ForumService forumService; // 健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约申请服务
@Autowired
private SingleSeachService singleSeachService; // 单页数据服务
@Autowired
private YonghuService yonghuService; // 用户服务
@Autowired
private UsersService usersService; // 管理员服务
//后端列表
//分页查询健身资讯数据
//@param params 请求参数，包含分页和查询条件
//@param request HTTP请求对象
//@return 返回分页数据和状态信息
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); // 如果是用户角色，添加用户ID查询条件
else if("教练".equals(role))
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 如果是教练角色，添加教练ID查询条件
CommonUtil.checkMap(params); // 检查参数
PageUtils page = newsService.queryPage(params); // 分页查询
// 字典表数据转换
List<NewsView> list =(List<NewsView>)page.getList();
for(NewsView c:list){
// 修改对应字典表字段
dictionaryService.dictionaryConvert(c, request);
}
return R.ok().put("data", page); // 返回成功和数据
}
//后端详情
//根据ID查询单条健身资讯详情
//@param id 资讯ID
//@param request HTTP请求对象
//@return 返回资讯详情和状态信息
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
NewsEntity news = newsService.selectById(id); // 根据ID查询资讯
if(news !=null){
// entity转view
NewsView view = new NewsView();
BeanUtils.copyProperties( news , view ); // 把实体数据重构到view中
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回成功和数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//后端保存
//新增健身资讯
//@param news 资讯实体
//@param request HTTP请求对象
//@return 返回操作结果状态
@RequestMapping("/save")
public R save(@RequestBody NewsEntity news, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false)
return R.error(511,"永远不会进入");
// 构建查询条件
Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
.eq("news_name", news.getNewsName()) // 资讯标题相等
.eq("news_types", news.getNewsTypes()) // 资讯类型相等
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
NewsEntity newsEntity = newsService.selectOne(queryWrapper); // 查询是否已存在
if(newsEntity==null){
news.setInsertTime(new Date()); // 设置插入时间
news.setCreateTime(new Date()); // 设置创建时间
newsService.insert(news); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"表中有相同数据"); // 返回错误信息
}
}
//后端修改
//更新健身资讯
//@param news 资讯实体
//@param request HTTP请求对象
//@return 返回操作结果状态
@RequestMapping("/update")
public R update(@RequestBody NewsEntity news, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
NewsEntity oldNewsEntity = newsService.selectById(news.getId()); // 查询原先数据
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
// if(false)
// return R.error(511,"永远不会进入");
if("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())){
news.setNewsPhoto(null); // 如果图片为空，设置为null
}
if("".equals(news.getNewsContent()) || "null".equals(news.getNewsContent())){
news.setNewsContent(null); // 如果内容为空，设置为null
}
newsService.updateById(news); // 根据id更新
return R.ok(); // 返回成功
}
//删除
//批量删除健身资讯
//@param ids 要删除的资讯ID数组
//@param request HTTP请求对象
//@return 返回操作结果状态
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<NewsEntity> oldNewsList =newsService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
newsService.deleteBatchIds(Arrays.asList(ids)); // 批量删除
return R.ok(); // 返回成功
}
//批量上传
//通过Excel文件批量导入健身资讯数据
//@param fileName Excel文件名
//@param request HTTP请求对象
//@return 返回操作结果状态
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 日期格式化
try {
List<NewsEntity> newsList = new ArrayList<>(); // 存储上传的数据
Map<String, List<String>> seachFields= new HashMap<>(); // 要查询的字段
Date date = new Date();
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); // 返回错误信息
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误信息
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误信息
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取xls文件
dataList.remove(0); // 删除第一行，因为第一行是提示
for(List<String> data:dataList){
// 循环处理每行数据
NewsEntity newsEntity = new NewsEntity();
// newsEntity.setNewsName(data.get(0)); // 资讯标题 要改的
// newsEntity.setNewsTypes(Integer.valueOf(data.get(0))); // 资讯类型 要改的
// newsEntity.setNewsPhoto("");//详情和图片
// newsEntity.setInsertTime(date);//时间
// newsEntity.setNewsContent("");//详情和图片
// newsEntity.setCreateTime(date);//时间
newsList.add(newsEntity); // 添加到列表
// 把要查询是否重复的字段放入map中
}
// 查询是否重复
newsService.insertBatch(newsList); // 批量插入
return R.ok(); // 返回成功
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误信息
}
}
//前端列表
//分页查询健身资讯数据（无需认证）
//@param params 请求参数，包含分页和查询条件
//@param request HTTP请求对象
//@return 返回分页数据和状态信息
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params); // 检查参数
PageUtils page = newsService.queryPage(params); // 分页查询
// 字典表数据转换
List<NewsView> list =(List<NewsView>)page.getList();
for(NewsView c:list)
dictionaryService.dictionaryConvert(c, request); // 修改对应字典表字段
return R.ok().put("data", page); // 返回成功和数据
}
//前端详情
//根据ID查询单条健身资讯详情
//@param id 资讯ID
//@param request HTTP请求对象
//@return 返回资讯详情和状态信息
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
NewsEntity news = newsService.selectById(id); // 根据ID查询资讯
if(news !=null){
// entity转view
NewsView view = new NewsView();
BeanUtils.copyProperties( news , view ); // 把实体数据重构到view中
// 修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); // 返回成功和数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//前端保存
//新增健身资讯
//@param news 资讯实体
//@param request HTTP请求对象
//@return 返回操作结果状态
@RequestMapping("/add")
public R add(@RequestBody NewsEntity news, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
.eq("news_name", news.getNewsName()) // 资讯标题相等
.eq("news_types", news.getNewsTypes()) // 资讯类型相等
// .notIn("news_types", new Integer[]{102})
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
NewsEntity newsEntity = newsService.selectOne(queryWrapper); // 查询是否已存在
if(newsEntity==null){
news.setInsertTime(new Date()); // 设置插入时间
news.setCreateTime(new Date()); // 设置创建时间
newsService.insert(news); // 插入新数据
return R.ok(); // 返回成功
}else {
return R.error(511,"表中有相同数据"); // 返回错误信息
}
}
}

297
src/main/java/com/controller/SingleSeachController.java
Unescape View File

@ -0,0 +1,297 @@
// 声明当前文件所在的包路径
package com.controller;
// 导入所需的Java类库
import java.io.File; // 文件操作类
import java.math.BigDecimal; // 高精度数字计算类
import java.net.URL; // 统一资源定位符类
import java.text.SimpleDateFormat; // 日期格式化类
import com.alibaba.fastjson.JSONObject; // FastJSON的JSON对象类
import java.util.*; // 通用工具类集合
import org.springframework.beans.BeanUtils; // Spring Bean工具类
import javax.servlet.http.HttpServletRequest; // HTTP请求类
import org.springframework.web.context.ContextLoader; // Spring上下文加载器
import javax.servlet.ServletContext; // Servlet上下文接口
import com.service.TokenService; // 自定义Token服务类
import com.utils.*; // 自定义工具类包
import java.lang.reflect.InvocationTargetException; // 反射异常类
// 导入自定义服务类
import com.service.DictionaryService; // 字典服务类
import org.apache.commons.lang3.StringUtils; // Apache字符串工具类
import com.annotation.IgnoreAuth; // 自定义忽略认证注解
import org.slf4j.Logger; // 日志接口
import org.slf4j.LoggerFactory; // 日志工厂类
import org.springframework.beans.factory.annotation.Autowired; // Spring自动注入注解
import org.springframework.stereotype.Controller; // Spring控制器注解
import org.springframework.web.bind.annotation.*; // Spring Web注解集合
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis Plus实体包装类
import com.baomidou.mybatisplus.mapper.Wrapper; // MyBatis Plus包装接口
import com.entity.*; // 实体类包
import com.entity.view.*; // 实体视图类包
import com.service.*; // 服务接口包
import com.utils.PageUtils; // 分页工具类
import com.utils.R; // 通用返回结果类
import com.alibaba.fastjson.*; // FastJSON工具包
//单页数据
//后端接口控制器
//@author
//@email
@RestController // 标识这是一个RESTful风格的控制器
@Controller // 标识这是一个Spring MVC控制器
@RequestMapping("/singleSeach") // 定义基础请求路径
public class SingleSeachController {
private static final Logger logger = LoggerFactory.getLogger(SingleSeachController.class); // 日志记录器
private static final String TABLE_NAME = "singleSeach"; // 数据库表名常量
@Autowired
private SingleSeachService singleSeachService; // 注入单页数据服务
@Autowired
private TokenService tokenService; // 注入token服务
// 注入其他相关服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private ForumService forumService; // 健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约申请服务
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private YonghuService yonghuService; // 用户服务
@Autowired
private UsersService usersService; // 管理员服务
//后端列表
//分页查询单页数据
//@param params 请求参数Map
//@param request HTTP请求对象
//@return 返回分页数据结果
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 条件判断
return R.error(511,"永不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
params.put("yonghuId",request.getSession().getAttribute("userId")); // 添加用户ID参数
else if("教练".equals(role)) // 如果是教练角色
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 添加教练ID参数
CommonUtil.checkMap(params); // 检查参数
PageUtils page = singleSeachService.queryPage(params); // 调用服务层分页查询
// 字典表数据转换
List<SingleSeachView> list =(List<SingleSeachView>)page.getList(); // 获取分页数据列表
for(SingleSeachView c:list){ // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典表字段
}
return R.ok().put("data", page); // 返回成功结果和数据
}
//后端详情
//根据ID查询单条单页数据详情
//@param id 数据ID
//@param request HTTP请求对象
//@return 返回查询结果
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
SingleSeachEntity singleSeach = singleSeachService.selectById(id); // 根据ID查询数据
if(singleSeach !=null){ // 如果查询到数据
SingleSeachView view = new SingleSeachView(); // 创建视图对象
BeanUtils.copyProperties(singleSeach, view); // 复制属性到视图对象
dictionaryService.dictionaryConvert(view, request); // 转换字典表字段
return R.ok().put("data", view); // 返回成功结果和数据
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//后端保存
//新增单页数据
//@param singleSeach 单页数据实体
//@param request HTTP请求对象
//@return 返回操作结果
//@RequestMapping("/save")
public R save(@RequestBody SingleSeachEntity singleSeach, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,singleSeach:{}",this.getClass().getName(),singleSeach.toString()); // 记录日志
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 条件判断
return R.error(511,"永远不会进入"); // 返回错误信息
// 构建查询条件
Wrapper<SingleSeachEntity> queryWrapper = new EntityWrapper<SingleSeachEntity>()
.eq("single_seach_types",singleSeach.getSingleSeachTypes()); // 按类型查询
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
SingleSeachEntity singleSeachEntity = singleSeachService.selectOne(queryWrapper); // 查询是否存在
if(singleSeachEntity==null){ // 如果不存在
singleSeach.setCreateTime(new Date()); // 设置创建时间
singleSeachService.insert(singleSeach); // 插入新数据
return R.ok(); // 返回成功结果
}else {
return R.error(511,"该类型已经有存在的,请删除后重新新增"); // 返回错误信息
}
}
//后端修改
//更新单页数据
//@param singleSeach 单页数据实体
//@param request HTTP请求对象
//@return 返回操作结果
@RequestMapping("/update")
public R update(@RequestBody SingleSeachEntity singleSeach, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,singleSeach:{}",this.getClass().getName(),singleSeach.toString()); // 记录日志
SingleSeachEntity oldSingleSeachEntity = singleSeachService.selectById(singleSeach.getId()); // 查询原数据
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if("".equals(singleSeach.getSingleSeachPhoto()) || "null".equals(singleSeach.getSingleSeachPhoto())){ // 如果图片为空
singleSeach.setSingleSeachPhoto(null); // 设置为null
}
if("".equals(singleSeach.getSingleSeachContent()) || "null".equals(singleSeach.getSingleSeachContent())){ // 如果内容为空
singleSeach.setSingleSeachContent(null); // 设置为null
}
singleSeachService.updateById(singleSeach); // 更新数据
return R.ok(); // 返回成功结果
}
//删除
//批量删除单页数据
//@param ids 要删除的ID数组
//@param request HTTP请求对象
//@return 返回操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString()); // 记录日志
List<SingleSeachEntity> oldSingleSeachList = singleSeachService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
singleSeachService.deleteBatchIds(Arrays.asList(ids)); // 批量删除
return R.ok(); // 返回成功结果
}
//批量上传/
//通过Excel批量导入数据
//@param fileName Excel文件名
//@param request HTTP请求对象
//@return 返回操作结果
@RequestMapping("/batchInsert")
public R save(String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName); // 记录日志
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<SingleSeachEntity> singleSeachList = new ArrayList<>(); // 创建数据列表
Map<String, List<String>> seachFields = new HashMap<>(); // 创建查询字段Map
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){ // 如果没有后缀
return R.error(511,"该文件没有后缀"); // 返回错误信息
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){ // 如果不是xls文件
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误信息
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){ // 如果文件不存在
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误信息
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取Excel文件
dataList.remove(0); // 删除标题行
for(List<String> data:dataList){ // 遍历数据行
SingleSeachEntity singleSeachEntity = new SingleSeachEntity(); // 创建实体对象
// 可以在此处设置实体属性，示例中被注释掉了
singleSeachList.add(singleSeachEntity); // 添加到列表
}
singleSeachService.insertBatch(singleSeachList); // 批量插入
return R.ok(); // 返回成功结果
}
}
}
}catch (Exception e){ // 捕获异常
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误信息
}
}
//前端列表
//无需认证的分页查询
//@param params 请求参数Map
//@param request HTTP请求对象
//@return 返回分页数据结果
@IgnoreAuth // 忽略认证
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 记录日志
CommonUtil.checkMap(params); // 检查参数
PageUtils page = singleSeachService.queryPage(params); // 分页查询
List<SingleSeachView> list = (List<SingleSeachView>)page.getList(); // 获取数据列表
for(SingleSeachView c:list) // 遍历列表
dictionaryService.dictionaryConvert(c, request); // 转换字典表字段
return R.ok().put("data", page); // 返回成功结果和数据
}
//前端详情
//根据类型查询单条数据
//@param id 数据类型ID
//@param request HTTP请求对象
//@return 返回查询结果
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 记录日志
// 根据类型查询单条数据
SingleSeachEntity singleSeach = singleSeachService.selectOne(new EntityWrapper<SingleSeachEntity>().eq("single_seach_types", id));
if(singleSeach != null) // 如果查询到数据
return R.ok().put("data", singleSeach); // 返回成功结果和数据
else
return R.error(511,"查不到数据"); // 返回错误信息
}
//前端保存
//新增单页数据
//@param singleSeach 单页数据实体
//@param request HTTP请求对象
//@return 返回操作结果
@RequestMapping("/add")
public R add(@RequestBody SingleSeachEntity singleSeach, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,singleSeach:{}",this.getClass().getName(),singleSeach.toString()); // 记录日志
// 构建查询条件
Wrapper<SingleSeachEntity> queryWrapper = new EntityWrapper<SingleSeachEntity>()
.eq("single_seach_types",singleSeach.getSingleSeachTypes()); // 按类型查询
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
SingleSeachEntity singleSeachEntity = singleSeachService.selectOne(queryWrapper); // 查询是否已存在
if(singleSeachEntity==null){ // 如果不存在
singleSeach.setCreateTime(new Date()); // 设置创建时间
singleSeachService.insert(singleSeach); // 插入新数据
return R.ok(); // 返回成功结果
}else {
return R.error(511,"该类型已经有存在的,请删除后重新新增"); // 返回错误信息
}
}
}

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

@ -0,0 +1,236 @@
package com.controller; // 声明当前类所在的包路径
// 导入Java集合类
import java.util.List; // 列表接口
import java.util.Arrays; // 数组工具类
import java.util.Map; // 映射接口
// 导入Servlet相关类
import javax.servlet.http.HttpServletRequest; // HTTP请求对象
// 导入服务类
import com.service.UsersService; // 用户服务接口
// 导入Spring框架注解
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.web.bind.annotation.GetMapping; // GET请求映射注解
import org.springframework.web.bind.annotation.PathVariable; // 路径变量注解
import org.springframework.web.bind.annotation.PostMapping; // POST请求映射注解
import org.springframework.web.bind.annotation.RequestBody; // 请求体注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解
import org.springframework.web.bind.annotation.RequestParam; // 请求参数注解
import org.springframework.web.bind.annotation.RestController; // REST控制器注解
// 导入自定义注解和工具类
import com.annotation.IgnoreAuth; // 忽略认证注解
import com.baomidou.mybatisplus.mapper.EntityWrapper; // MyBatis Plus条件构造器
import com.entity.UsersEntity; // 用户实体类
import com.service.TokenService; // Token服务接口
import com.utils.MPUtil; // MyBatis Plus工具类
import com.utils.PageUtils; // 分页工具类
import com.utils.R; // 统一返回结果类
//用户登录相关功能控制器
//处理用户认证、注册、密码管理等操作
@RequestMapping("users") // 定义基础请求路径为/users
@RestController // 标识这是一个RESTful风格的控制器
public class UsersController {
@Autowired // 自动注入用户服务
private UsersService usersService;
@Autowired // 自动注入Token服务
private TokenService tokenService;
//用户登录接口
//@param username 用户名
//@param password 密码
//@param captcha 验证码(未使用)
//@param request HTTP请求对象
//@return 返回登录结果和Token信息
@IgnoreAuth // 忽略认证检查
@PostMapping(value = "/login") // 处理POST /users/login请求
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户
UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
// 验证用户是否存在和密码是否正确
if(user==null || !user.getPassword().equals(password)) {
return R.error("账号或密码不正确"); // 返回错误信息
}
// 生成Token
String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
// 构建返回结果
R r = R.ok();
r.put("token", token); // 返回Token
r.put("role",user.getRole()); // 返回用户角色
r.put("userId",user.getId()); // 返回用户ID
return r;
}
//用户注册接口
//@param user 用户实体对象(通过请求体传入)
//@return 返回注册结果
@IgnoreAuth // 忽略认证检查
@PostMapping(value = "/register") // 处理POST /users/register请求
public R register(@RequestBody UsersEntity user){
// 检查用户名是否已存在
if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
return R.error("用户已存在"); // 返回错误信息
}
usersService.insert(user); // 插入新用户
return R.ok(); // 返回成功结果
}
//用户退出接口
//@param request HTTP请求对象
//@return 返回退出结果
@GetMapping(value = "logout") // 处理GET /users/logout请求
public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使会话失效
return R.ok("退出成功"); // 返回成功信息
}
//修改密码接口
//@param oldPassword 旧密码
//@param newPassword 新密码
//@param request HTTP请求对象
//@return 返回修改结果
@GetMapping(value = "/updatePassword") // 处理GET /users/updatePassword请求
public R updatePassword(String oldPassword, String newPassword, HttpServletRequest request) {
// 获取当前用户
UsersEntity users = usersService.selectById((Integer)request.getSession().getAttribute("userId"));
// 验证新密码是否为空
if(newPassword == null){
return R.error("新密码不能为空") ;
}
// 验证旧密码是否正确
if(!oldPassword.equals(users.getPassword())){
return R.error("原密码输入错误");
}
// 验证新密码是否与旧密码相同
if(newPassword.equals(users.getPassword())){
return R.error("新密码不能和原密码一致") ;
}
// 更新密码
users.setPassword(newPassword);
usersService.updateById(users);
return R.ok(); // 返回成功结果
}
//密码重置接口
//@param username 用户名
//@param request HTTP请求对象
//@return 返回重置结果
@IgnoreAuth // 忽略认证检查
@RequestMapping(value = "/resetPass") // 处理/users/resetPass请求
public R resetPass(String username, HttpServletRequest request){
// 根据用户名查询用户
UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
if(user==null) {
return R.error("账号不存在"); // 返回错误信息
}
// 重置密码为默认值
user.setPassword("123456");
usersService.update(user,null); // 更新用户信息
return R.ok("密码已重置为：123456"); // 返回成功信息
}
//分页查询用户列表
//@param params 请求参数Map
//@param user 用户实体(用于条件查询)
//@return 返回分页结果
@RequestMapping("/page") // 处理/users/page请求
public R page(@RequestParam Map<String, Object> params,UsersEntity user){
// 创建条件构造器
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
// 构建分页查询
PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
return R.ok().put("data", page); // 返回分页数据
}
//查询用户列表
//@param user 用户实体(用于条件查询)
//@return 返回用户列表
@RequestMapping("/list") // 处理/users/list请求
public R list(UsersEntity user){
// 创建条件构造器
EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
// 构建查询条件
ew.allEq(MPUtil.allEQMapPre(user, "user"));
return R.ok().put("data", usersService.selectListView(ew)); // 返回查询结果
}
//获取用户详细信息
//@param id 用户ID
//@return 返回用户信息
@RequestMapping("/info/{id}") // 处理/users/info/{id}请求
public R info(@PathVariable("id") String id){
UsersEntity user = usersService.selectById(id); // 根据ID查询用户
return R.ok().put("data", user); // 返回用户信息
}
// 获取当前会话用户信息
//@param request HTTP请求对象
// @return 返回当前用户信息
@RequestMapping("/session") // 处理/users/session请求
public R getCurrUser(HttpServletRequest request){
// 从会话中获取用户ID
Integer id = (Integer)request.getSession().getAttribute("userId");
UsersEntity user = usersService.selectById(id); // 查询用户信息
return R.ok().put("data", user); // 返回用户信息
}
//保存用户信息
//@param user 用户实体对象(通过请求体传入)
// @return 返回保存结果
@PostMapping("/save") // 处理POST /users/save请求
public R save(@RequestBody UsersEntity user){
// 检查用户名是否已存在
if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
return R.error("用户已存在"); // 返回错误信息
}
usersService.insert(user); // 插入新用户
return R.ok(); // 返回成功结果
}
// 更新用户信息
//@param user 用户实体对象(通过请求体传入)
//@return 返回更新结果
@RequestMapping("/update") // 处理/users/update请求
public R update(@RequestBody UsersEntity user){
usersService.updateById(user); // 更新用户信息
return R.ok(); // 返回成功结果
}
//删除用户
//@param ids 用户ID数组(通过请求体传入)
// @return 返回删除结果
@RequestMapping("/delete") // 处理/users/delete请求
public R delete(@RequestBody Long[] ids){
// 查询所有用户
List<UsersEntity> user = usersService.selectList(null);
// 确保至少保留一个管理员
if(user.size() > 1){
usersService.deleteBatchIds(Arrays.asList(ids)); // 批量删除用户
}else{
return R.error("管理员最少保留一个"); // 返回错误信息
}
return R.ok(); // 返回成功结果
}
}

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

@ -0,0 +1,532 @@
package com.controller; // 声明当前类所在的包路径
// 导入Java IO类
import java.io.File; // 文件操作类
// 导入数学类
import java.math.BigDecimal; // 高精度数字计算类
// 导入网络类
import java.net.URL; // 统一资源定位符类
// 导入文本处理类
import java.text.SimpleDateFormat; // 日期格式化类
// 导入JSON处理类
import com.alibaba.fastjson.JSONObject; // FastJSON对象类
// 导入集合类
import java.util.*; // 通用集合工具类
// 导入Spring Bean工具类
import org.springframework.beans.BeanUtils; // Bean属性复制工具类
// 导入Servlet类
import javax.servlet.http.HttpServletRequest; // HTTP请求对象
// 导入Spring上下文类
import org.springframework.web.context.ContextLoader; // Web应用上下文加载器
// 导入Servlet上下文类
import javax.servlet.ServletContext; // Servlet上下文对象
// 导入自定义服务类
import com.service.TokenService; // Token服务接口
// 导入自定义工具类
import com.utils.*; // 自定义工具类集合
// 导入反射异常类
import java.lang.reflect.InvocationTargetException; // 反射调用异常类
// 导入字典服务类
import com.service.DictionaryService; // 字典数据服务接口
// 导入Apache Commons工具类
import org.apache.commons.lang3.StringUtils; // 字符串处理工具类
// 导入自定义注解
import com.annotation.IgnoreAuth; // 忽略认证注解
// 导入日志类
import org.slf4j.Logger; // 日志接口
import org.slf4j.LoggerFactory; // 日志工厂类
// 导入Spring注解
import org.springframework.beans.factory.annotation.Autowired; // 自动注入注解
import org.springframework.stereotype.Controller; // 控制器注解
import org.springframework.web.bind.annotation.*; // Web请求相关注解
// 导入MyBatis Plus类
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 条件构造器
import com.baomidou.mybatisplus.mapper.Wrapper; // 条件构造器接口
// 导入实体类
import com.entity.*; // 实体类集合
import com.entity.view.*; // 视图实体类集合
// 导入服务接口
import com.service.*; // 服务接口集合
// 导入分页工具类
import com.utils.PageUtils; // 分页工具类
// 导入返回结果类
import com.utils.R; // 统一返回结果类
// 导入FastJSON类
import com.alibaba.fastjson.*; // FastJSON工具类
//用户控制器
// 处理用户相关操作的RESTful接口
@RestController // 标识为RESTful控制器
@Controller // 标识为Spring MVC控制器
@RequestMapping("/yonghu") // 基础请求路径
public class YonghuController {
private static final Logger logger = LoggerFactory.getLogger(YonghuController.class); // 日志记录器
private static final String TABLE_NAME = "yonghu"; // 数据库表名常量
@Autowired // 自动注入用户服务
private YonghuService yonghuService;
@Autowired // 自动注入Token服务
private TokenService tokenService;
// 注入其他相关服务
@Autowired
private DictionaryService dictionaryService; // 字典服务
@Autowired
private ForumService forumService; // 健身论坛服务
@Autowired
private JianshenkechengService jianshenkechengService; // 健身课程服务
@Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; // 课程收藏服务
@Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; // 课程留言服务
@Autowired
private JiaolianService jiaolianService; // 教练服务
@Autowired
private JiaolianYuyueService jiaolianYuyueService; // 教练预约服务
@Autowired
private NewsService newsService; // 健身资讯服务
@Autowired
private SingleSeachService singleSeachService; // 单页数据服务
@Autowired
private UsersService usersService; // 管理员服务
//后端分页列表
//@param params 请求参数Map
//@param request HTTP请求对象
//@return 分页结果
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 条件判断
return R.error(511,"永不会进入"); // 返回错误信息
else if("用户".equals(role)) // 如果是用户角色
params.put("yonghuId",request.getSession().getAttribute("userId")); // 添加用户ID参数
else if("教练".equals(role)) // 如果是教练角色
params.put("jiaolianId",request.getSession().getAttribute("userId")); // 添加教练ID参数
params.put("dataDeleteStart",1);params.put("dataDeleteEnd",1); // 设置逻辑删除条件
CommonUtil.checkMap(params); // 检查参数
PageUtils page = yonghuService.queryPage(params); // 分页查询
// 字典表数据转换
List<YonghuView> list =(List<YonghuView>)page.getList(); // 获取分页数据
for(YonghuView c:list){ // 遍历数据
dictionaryService.dictionaryConvert(c, request); // 转换字典表字段
}
return R.ok().put("data", page); // 返回分页结果
}
//后端详情
//@param id 用户ID
//@param request HTTP请求对象
//@return 用户详情
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
YonghuEntity yonghu = yonghuService.selectById(id); // 根据ID查询用户
if(yonghu !=null){ // 如果查询到数据
YonghuView view = new YonghuView(); // 创建视图对象
BeanUtils.copyProperties(yonghu, view); // 复制属性到视图对象
dictionaryService.dictionaryConvert(view, request); // 转换字典表字段
return R.ok().put("data", view); // 返回成功结果
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//后端保存用户
//@param yonghu 用户实体
//@param request HTTP请求对象
//@return 操作结果
@RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if(false) // 条件判断
return R.error(511,"永远不会进入"); // 返回错误信息
// 构建查询条件：检查用户名、手机号、身份证号是否已存在
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername()) // 用户名条件
.or() // 或条件
.eq("yonghu_phone", yonghu.getYonghuPhone()) // 手机号条件
.or() // 或条件
.eq("yonghu_id_number", yonghu.getYonghuIdNumber()) // 身份证号条件
.eq("data_delete", 1) // 未删除条件
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); // 查询是否存在
if(yonghuEntity==null){ // 如果不存在
yonghu.setDataDelete(1); // 设置未删除状态
yonghu.setInsertTime(new Date()); // 设置插入时间
yonghu.setCreateTime(new Date()); // 设置创建时间
yonghu.setPassword("123456"); // 设置默认密码
yonghuService.insert(yonghu); // 插入新用户
return R.ok(); // 返回成功结果
}else {
return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用"); // 返回错误信息
}
}
//后端修改用户
//@param yonghu 用户实体
//@param request HTTP请求对象
//@return 操作结果
@RequestMapping("/update")
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
YonghuEntity oldYonghuEntity = yonghuService.selectById(yonghu.getId()); // 查询原数据
String role = String.valueOf(request.getSession().getAttribute("role")); // 获取用户角色
if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){ // 如果图片为空
yonghu.setYonghuPhoto(null); // 设置为null
}
yonghuService.updateById(yonghu); // 更新用户信息
return R.ok(); // 返回成功结果
}
//删除用户（逻辑删除）
//@param ids 用户ID数组
//@param request HTTP请求对象
//@return 操作结果
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<YonghuEntity> oldYonghuList = yonghuService.selectBatchIds(Arrays.asList(ids)); // 查询要删除的数据
ArrayList<YonghuEntity> list = new ArrayList<>(); // 创建更新列表
for(Integer id:ids){ // 遍历ID数组
YonghuEntity yonghuEntity = new YonghuEntity(); // 创建用户实体
yonghuEntity.setId(id); // 设置ID
yonghuEntity.setDataDelete(2); // 设置删除状态
list.add(yonghuEntity); // 添加到列表
}
if(list != null && list.size() >0){ // 如果有数据需要更新
yonghuService.updateBatchById(list); // 批量更新
}
return R.ok(); // 返回成功结果
}
//批量导入用户数据
//@param fileName Excel文件名
//@param request HTTP请求对象
//@return 导入结果
@RequestMapping("/batchInsert")
public R save(String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); // 获取当前用户ID
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 创建日期格式化对象
try {
List<YonghuEntity> yonghuList = new ArrayList<>(); // 创建用户列表
Map<String, List<String>> seachFields = new HashMap<>(); // 创建查重字段Map
Date date = new Date(); // 当前时间
int lastIndexOf = fileName.lastIndexOf("."); // 获取文件后缀位置
if(lastIndexOf == -1){ // 如果没有后缀
return R.error(511,"该文件没有后缀"); // 返回错误信息
}else{
String suffix = fileName.substring(lastIndexOf); // 获取文件后缀
if(!".xls".equals(suffix)){ // 如果不是xls文件
return R.error(511,"只支持后缀为xls的excel文件"); // 返回错误信息
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName); // 获取文件路径
File file = new File(resource.getFile()); // 创建文件对象
if(!file.exists()){ // 如果文件不存在
return R.error(511,"找不到上传文件，请联系管理员"); // 返回错误信息
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); // 读取Excel文件
dataList.remove(0); // 删除标题行
for(List<String> data:dataList){ // 遍历数据行
YonghuEntity yonghuEntity = new YonghuEntity(); // 创建用户实体
// 可以在此处设置实体属性，示例中被注释掉了
yonghuList.add(yonghuEntity); // 添加到列表
// 构建查重字段Map
// 账户查重
if(seachFields.containsKey("username")){
List<String> username = seachFields.get("username");
username.add(data.get(0)); // 添加用户名
}else{
List<String> username = new ArrayList<>();
username.add(data.get(0)); // 添加用户名
seachFields.put("username",username); // 放入Map
}
// 手机号查重
if(seachFields.containsKey("yonghuPhone")){
List<String> yonghuPhone = seachFields.get("yonghuPhone");
yonghuPhone.add(data.get(0)); // 添加手机号
}else{
List<String> yonghuPhone = new ArrayList<>();
yonghuPhone.add(data.get(0)); // 添加手机号
seachFields.put("yonghuPhone",yonghuPhone); // 放入Map
}
// 身份证号查重
if(seachFields.containsKey("yonghuIdNumber")){
List<String> yonghuIdNumber = seachFields.get("yonghuIdNumber");
yonghuIdNumber.add(data.get(0)); // 添加身份证号
}else{
List<String> yonghuIdNumber = new ArrayList<>();
yonghuIdNumber.add(data.get(0)); // 添加身份证号
seachFields.put("yonghuIdNumber",yonghuIdNumber); // 放入Map
}
}
// 查重验证
// 验证用户名是否重复
List<YonghuEntity> yonghuEntities_username = yonghuService.selectList(
new EntityWrapper<YonghuEntity>().in("username", seachFields.get("username")).eq("data_delete", 1));
if(yonghuEntities_username.size() >0 ){ // 如果有重复
ArrayList<String> repeatFields = new ArrayList<>(); // 创建重复字段列表
for(YonghuEntity s:yonghuEntities_username){ // 遍历重复数据
repeatFields.add(s.getUsername()); // 添加重复用户名
}
return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString()); // 返回错误信息
}
// 验证手机号是否重复
List<YonghuEntity> yonghuEntities_yonghuPhone = yonghuService.selectList(
new EntityWrapper<YonghuEntity>().in("yonghu_phone", seachFields.get("yonghuPhone")).eq("data_delete", 1));
if(yonghuEntities_yonghuPhone.size() >0 ){ // 如果有重复
ArrayList<String> repeatFields = new ArrayList<>(); // 创建重复字段列表
for(YonghuEntity s:yonghuEntities_yonghuPhone){ // 遍历重复数据
repeatFields.add(s.getYonghuPhone()); // 添加重复手机号
}
return R.error(511,"数据库的该表中的 [用户手机号] 字段已经存在 存在数据为:"+repeatFields.toString()); // 返回错误信息
}
// 验证身份证号是否重复
List<YonghuEntity> yonghuEntities_yonghuIdNumber = yonghuService.selectList(
new EntityWrapper<YonghuEntity>().in("yonghu_id_number", seachFields.get("yonghuIdNumber")).eq("data_delete", 1));
if(yonghuEntities_yonghuIdNumber.size() >0 ){ // 如果有重复
ArrayList<String> repeatFields = new ArrayList<>(); // 创建重复字段列表
for(YonghuEntity s:yonghuEntities_yonghuIdNumber){ // 遍历重复数据
repeatFields.add(s.getYonghuIdNumber()); // 添加重复身份证号
}
return R.error(511,"数据库的该表中的 [用户身份证号] 字段已经存在 存在数据为:"+repeatFields.toString()); // 返回错误信息
}
yonghuService.insertBatch(yonghuList); // 批量插入数据
return R.ok(); // 返回成功结果
}
}
}
}catch (Exception e){ // 捕获异常
e.printStackTrace(); // 打印异常堆栈
return R.error(511,"批量插入数据异常，请联系管理员"); // 返回错误信息
}
}
//用户登录
//@param username 用户名
//@param password 密码
//@param captcha 验证码
//@param request HTTP请求对象
//@return 登录结果
@IgnoreAuth // 忽略认证
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username)); // 根据用户名查询用户
if(yonghu==null || !yonghu.getPassword().equals(password)) // 验证用户名和密码
return R.error("账号或密码不正确"); // 返回错误信息
else if(yonghu.getDataDelete() != 1) // 检查是否被删除
return R.error("账户已被删除"); // 返回错误信息
String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户"); // 生成Token
R r = R.ok(); // 创建返回结果
r.put("token", token); // 添加Token
r.put("role","用户"); // 添加角色
r.put("username",yonghu.getYonghuName()); // 添加用户名
r.put("tableName","yonghu"); // 添加表名
r.put("userId",yonghu.getId()); // 添加用户ID
return r; // 返回结果
}
//用户注册
//@param yonghu 用户实体
// @param request HTTP请求对象
//@return 注册结果
@IgnoreAuth // 忽略认证
@PostMapping(value = "/register")
public R register(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
// 构建查询条件：检查用户名、手机号、身份证号是否已存在
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername()) // 用户名条件
.or() // 或条件
.eq("yonghu_phone", yonghu.getYonghuPhone()) // 手机号条件
.or() // 或条件
.eq("yonghu_id_number", yonghu.getYonghuIdNumber()) // 身份证号条件
.andNew() // 新条件组
.eq("data_delete", 1) // 未删除条件
;
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); // 查询是否存在
if(yonghuEntity != null) // 如果已存在
return R.error("账户或者用户手机号或者用户身份证号已经被使用"); // 返回错误信息
yonghu.setNewMoney(0.0); // 设置初始余额
yonghu.setDataDelete(1); // 设置未删除状态
yonghu.setInsertTime(new Date()); // 设置插入时间
yonghu.setCreateTime(new Date()); // 设置创建时间
yonghuService.insert(yonghu); // 插入新用户
return R.ok(); // 返回成功结果
}
//重置密码为默认值
//@param id 用户ID
//@param request HTTP请求对象
// @return 操作结果
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id, HttpServletRequest request) {
YonghuEntity yonghu = yonghuService.selectById(id); // 根据ID查询用户
yonghu.setPassword("123456"); // 重置密码
yonghuService.updateById(yonghu); // 更新用户
return R.ok(); // 返回成功结果
}
//修改密码
//@param oldPassword 旧密码
//@param newPassword 新密码
//@param request HTTP请求对象
// @return 操作结果
@GetMapping(value = "/updatePassword")
public R updatePassword(String oldPassword, String newPassword, HttpServletRequest request) {
YonghuEntity yonghu = yonghuService.selectById((Integer)request.getSession().getAttribute("userId")); // 获取当前用户
if(newPassword == null){ // 检查新密码是否为空
return R.error("新密码不能为空") ; // 返回错误信息
}
if(!oldPassword.equals(yonghu.getPassword())){ // 检查旧密码是否正确
return R.error("原密码输入错误"); // 返回错误信息
}
if(newPassword.equals(yonghu.getPassword())){ // 检查新旧密码是否相同
return R.error("新密码不能和原密码一致") ; // 返回错误信息
}
yonghu.setPassword(newPassword); // 设置新密码
yonghuService.updateById(yonghu); // 更新用户
return R.ok(); // 返回成功结果
}
//忘记密码（重置为默认密码）
//@param username 用户名
//@param request HTTP请求对象
//@return 操作结果
@IgnoreAuth // 忽略认证
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username)); // 根据用户名查询用户
if(yonghu!=null){ // 如果用户存在
yonghu.setPassword("123456"); // 重置密码
yonghuService.updateById(yonghu); // 更新用户
return R.ok(); // 返回成功结果
}else{ // 如果用户不存在
return R.error("账号不存在"); // 返回错误信息
}
}
//获取当前会话用户信息
//@param request HTTP请求对象
//@return 用户信息
@RequestMapping("/session")
public R getCurrYonghu(HttpServletRequest request){
Integer id = (Integer)request.getSession().getAttribute("userId"); // 获取当前用户ID
YonghuEntity yonghu = yonghuService.selectById(id); // 查询用户信息
if(yonghu !=null){ // 如果用户存在
YonghuView view = new YonghuView(); // 创建视图对象
BeanUtils.copyProperties(yonghu, view); // 复制属性
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回用户信息
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//用户退出
//@param request HTTP请求对象
//@return 操作结果
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate(); // 使会话失效
return R.ok("退出成功"); // 返回成功信息
}
//前端分页列表
//@param params 请求参数
//@param request HTTP请求对象
//@return 分页结果
@IgnoreAuth // 忽略认证
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params); // 检查参数
PageUtils page = yonghuService.queryPage(params); // 分页查询
// 字典表数据转换
List<YonghuView> list =(List<YonghuView>)page.getList(); // 获取分页数据
for(YonghuView c:list) // 遍历数据
dictionaryService.dictionaryConvert(c, request); // 转换字典字段
return R.ok().put("data", page); // 返回分页结果
}
//前端详情
//@param id 用户ID
//@param request HTTP请求对象
//@return 用户详情
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
YonghuEntity yonghu = yonghuService.selectById(id); // 根据ID查询用户
if(yonghu !=null){ // 如果用户存在
YonghuView view = new YonghuView(); // 创建视图对象
BeanUtils.copyProperties(yonghu, view); // 复制属性
dictionaryService.dictionaryConvert(view, request); // 转换字典字段
return R.ok().put("data", view); // 返回用户信息
}else {
return R.error(511,"查不到数据"); // 返回错误信息
}
}
//前端保存用户
//@param yonghu 用户实体
//@param request HTTP请求对象
//@return 操作结果
@RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
// 构建查询条件：检查用户名、手机号、身份证号是否已存在
Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
.eq("username", yonghu.getUsername()) // 用户名条件
.or() // 或条件
.eq("yonghu_phone", yonghu.getYonghuPhone()) // 手机号条件
.or() // 或条件
.eq("yonghu_id_number", yonghu.getYonghuIdNumber()) // 身份证号条件
.andNew() // 新条件组
.eq("data_delete", 1) // 未删除条件
;
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 记录SQL语句
YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper); // 查询是否存在
if(yonghuEntity==null){ // 如果不存在
yonghu.setDataDelete(1); // 设置未删除状态
yonghu.setInsertTime(new Date()); // 设置插入时间
yonghu.setCreateTime(new Date()); // 设置创建时间
yonghu.setPassword("123456"); // 设置默认密码
yonghuService.insert(yonghu); // 插入新用户
return R.ok(); // 返回成功结果
}else {
return R.error(511,"账户或者用户手机号或者用户身份证号已经被使用"); // 返回错误信息
}
}
}

89
src/main/java/com/dao/CommonDao.java
Unescape View File

@ -0,0 +1,89 @@
// 声明当前文件所在的包路径为com.dao，表示这是一个数据访问层(Dao)的类
package com.dao;
// 导入java.util.List类，用于处理有序集合数据
import java.util.List;
// 导入java.util.Map类，用于处理键值对映射数据
import java.util.Map;
//通用接口
//提供各种数据查询和统计方法的接口定义，包括饼图、柱状图等的数据求和与计数。
public interface CommonDao{
//获取饼图数据的求和结果
//@param params 查询参数
// @return 包含求和结果的列表
List<Map<String, Object>> pieSum(Map<String, Object> params);
//获取饼图数据的计数结果
// @param params 查询参数
// @return 包含计数结果的列表
List<Map<String, Object>> pieCount(Map<String, Object> params);
//获取单组柱状图数据的求和结果
//@param params 查询参数
// @return 包含求和结果的列表
List<Map<String, Object>> barSumOne(Map<String, Object> params);
//获取单组柱状图数据的计数结果
//@param params 查询参数
// @return 包含计数结果的列表
List<Map<String, Object> >barCountOne(Map<String, Object> params);
//获取双组柱状图数据的求和结果
//@param params 查询参数
// @return 包含求和结果的列表
List<Map<String, Object>> barSumTwo(Map<String, Object> params);
//获取双组柱状图数据的计数结果
//@param params 查询参数
// @return 包含计数结果的列表
List<Map<String, Object>> barCountTwo(Map<String, Object> params);
//查询评分信息
// @param params 查询参数
// @return 包含评分信息的Map
Map<String, Object> queryScore(Map<String, Object> params);
// 新的级联字典表的分组求和方法
//@param params 查询参数
// @return 包含分组求和结果的列表
List<Map<String, Object>> newSelectGroupSum(Map<String, Object> params);
// 新的级联字典表的分组条数统计方法
//@param params 查询参数
// @return 包含分组条数统计结果的列表
List<Map<String, Object>> newSelectGroupCount(Map<String, Object> params);
//获取柱状图数据的求和结果
//@param params 查询参数
// @return 包含求和结果的列表
List<Map<String, Object>> barSum(Map<String, Object> params);
//获取柱状图数据的计数结果
//@param params 查询参数
// @return 包含计数结果的列表
List<Map<String, Object>> barCount(Map<String, Object> params);
}

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

@ -0,0 +1,16 @@
// 声明当前文件所在的包路径，表示该文件位于com.dao包下
package com.dao;
// 导入MyBatis Plus框架中的BaseMapper接口
// BaseMapper是MyBatis Plus提供的核心接口，包含基本的CRUD操作方法
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入自定义的ConfigEntity实体类
// ConfigEntity通常对应数据库中的配置表，用于存储配置信息
import com.entity.ConfigEntity;
//配置数据访问对象接口，用于对配置相关的数据库操作
public interface ConfigDao extends BaseMapper<ConfigEntity> {
// 继承自MyBatis-Plus的BaseMapper，无需额外编写基本的CRUD方法
}

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

@ -0,0 +1,36 @@
// 声明当前文件所在的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入字典实体类，用于操作数据库中的字典表
import com.entity.DictionaryEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类，用于返回多个结果的集合
import java.util.List;
// 导入Java的Map集合类，用于传递键值对参数
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询功能
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给Mapper接口的参数命名
import org.apache.ibatis.annotations.Param;
// 导入字典视图类，用于返回自定义的视图对象
import com.entity.view.DictionaryView;
//字典 Dao 接口
//该接口继承自MyBatis Plus的BaseMapper，提供对字典表的基本操作
//并定义了自定义的查询方法
// @author
public interface DictionaryDao extends BaseMapper<DictionaryEntity> {
//分页查询字典数据
// @param page 分页参数对象，包含当前页、每页数量等信息
//@param params 查询条件参数Map，可以包含各种查询条件
// @return 返回字典视图对象的列表，包含查询结果数据
List<DictionaryView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

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

@ -0,0 +1,35 @@
// 声明当前文件所在的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入ForumEntity实体类，用于数据库表映射
import com.entity.ForumEntity;
// 导入MyBatis Plus的BaseMapper接口，提供基础的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类
import java.util.List;
// 导入Java的Map集合类，用于存储键值对参数
import java.util.Map;
// 导入MyBatis Plus的分页插件类
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给参数命名
import org.apache.ibatis.annotations.Param;
// 导入论坛视图实体类，用于展示论坛数据
import com.entity.view.ForumView;
//健身论坛 Dao 接口
// 该接口继承MyBatis Plus的BaseMapper，提供对ForumEntity的基本数据库操作
// @author 作者信息（未填写具体作者）
public interface ForumDao extends BaseMapper<ForumEntity> {
//分页查询论坛列表视图
// @param page 分页对象，包含当前页、每页显示条数等信息
//@param params 查询参数Map，可以包含各种查询条件
// @return 返回论坛视图对象的列表，用于前端展示
List<ForumView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

35
src/main/java/com/dao/JianshenkechengCollectionDao.java
Unescape View File

@ -0,0 +1,35 @@
// 声明当前文件所在的包路径，表示这是com.dao包下的类
package com.dao;
// 导入课程收藏实体类，用于数据库操作
import com.entity.JianshenkechengCollectionEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类，用于返回多条数据
import java.util.List;
// 导入Java的Map集合类，用于传递参数键值对
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给Mapper方法参数命名
import org.apache.ibatis.annotations.Param;
// 导入课程收藏的视图实体类，用于返回视图数据
import com.entity.view.JianshenkechengCollectionView;
//课程收藏 Dao 接口
//继承MyBatis Plus的BaseMapper，提供对课程收藏表的基本数据库操作
//@author 作者信息（未填写）
public interface JianshenkechengCollectionDao extends BaseMapper<JianshenkechengCollectionEntity> {
// 分页查询课程收藏列表视图
//@param page 分页对象，包含当前页、每页条数等信息
//@param params 查询参数Map，可以包含各种查询条件
//@return 返回课程收藏视图对象的列表
List<JianshenkechengCollectionView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

35
src/main/java/com/dao/JianshenkechengDao.java
Unescape View File

@ -0,0 +1,35 @@
// 声明当前文件所在的包路径，表示该文件位于com.dao包下
package com.dao;
// 导入健身课程实体类，用于数据库表映射
import com.entity.JianshenkechengEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入List集合类，用于返回多条数据
import java.util.List;
// 导入Map集合类，用于传递参数键值对
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给Mapper方法参数命名
import org.apache.ibatis.annotations.Param;
// 导入健身课程的视图类，用于展示数据
import com.entity.view.JianshenkechengView;
//健身课程 Dao 接口
//继承MyBatis Plus的BaseMapper接口，提供对JianshenkechengEntity的基本数据库操作
// @author 作者信息（未填写）
public interface JianshenkechengDao extends BaseMapper<JianshenkechengEntity> {
// 分页查询健身课程列表
// @param page 分页对象，包含当前页、每页显示条数等信息
// @param params 查询参数Map集合，可包含各种筛选条件
//@return 返回健身课程视图对象的列表，用于前端展示
List<JianshenkechengView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

35
src/main/java/com/dao/JianshenkechengLiuyanDao.java
Unescape View File

@ -0,0 +1,35 @@
// 声明当前文件所在的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入课程留言实体类，用于数据库操作
import com.entity.JianshenkechengLiuyanEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入List集合类，用于返回多条数据
import java.util.List;
// 导入Map集合类，用于传递参数或返回键值对数据
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给参数命名
import org.apache.ibatis.annotations.Param;
// 导入课程留言的视图实体类，可能用于返回特定视图数据
import com.entity.view.JianshenkechengLiuyanView;
//课程留言 Dao 接口
//该接口继承自MyBatis Plus的BaseMapper，提供对JianshenkechengLiuyanEntity的基本数据库操作
// 并扩展了分页查询方法
// @author 作者信息（未填写具体作者）
public interface JianshenkechengLiuyanDao extends BaseMapper<JianshenkechengLiuyanEntity> {
// 分页查询课程留言列表
// @param page 分页对象，包含当前页、每页显示条数等信息
// @param params 查询参数Map，可以包含各种查询条件
// @return 返回课程留言视图对象列表，包含分页后的数据
List<JianshenkechengLiuyanView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

35
src/main/java/com/dao/JiaolianDao.java
Unescape View File

@ -0,0 +1,35 @@
// 声明当前文件所在的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入教练实体类，用于数据库操作
import com.entity.JiaolianEntity;
// 导入MyBatis Plus的BaseMapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入List集合类，用于返回多条数据
import java.util.List;
// 导入Map集合类，用于传递参数键值对
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页功能
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的Param注解，用于给参数命名
import org.apache.ibatis.annotations.Param;
// 导入教练视图类，用于返回视图数据
import com.entity.view.JiaolianView;
//教练 Dao 接口
//定义与教练表相关的数据库操作方法
// @author
public interface JiaolianDao extends BaseMapper<JiaolianEntity> {
// 分页查询教练信息列表
//@param page 分页对象，包含当前页、每页显示条数等信息
//@param params 查询参数Map集合，可包含各种查询条件
//@return 返回教练视图对象列表，用于前端展示
List<JiaolianView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

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

@ -0,0 +1,36 @@
// 声明当前类所在的包路径，表示该类位于com.dao包下
package com.dao;
// 导入教练预约申请实体类，用于数据库操作
import com.entity.JiaolianYuyueEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本的CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入List集合类，用于返回多条数据
import java.util.List;
// 导入Map集合类，用于存储键值对参数
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入Param注解，用于给Mapper接口的参数命名
import org.apache.ibatis.annotations.Param;
// 导入教练预约申请的视图实体类，用于展示数据
import com.entity.view.JiaolianYuyueView;
// 教练预约申请 Dao 接口
//该接口继承自MyBatis Plus的BaseMapper，提供了基本的数据库操作方法
//同时定义了自定义的查询方法用于处理教练预约申请相关的业务逻辑
// @author 作者信息（未填写具体作者）
public interface JiaolianYuyueDao extends BaseMapper<JiaolianYuyueEntity> {
//分页查询教练预约申请列表
//@param page 分页对象，包含当前页码、每页显示条数等信息
//@param params 查询参数Map集合，可以包含各种查询条件
// @return 返回教练预约申请的视图对象列表，用于前端展示
List<JiaolianYuyueView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

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

@ -0,0 +1,35 @@
// 声明当前文件所属的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入新闻实体类，用于数据库表映射
import com.entity.NewsEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类
import java.util.List;
// 导入Java的Map集合类，用于键值对存储
import java.util.Map;
// 导入MyBatis Plus的分页插件类
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的参数注解，用于标识方法参数
import org.apache.ibatis.annotations.Param;
// 导入新闻视图实体类，用于展示层数据
import com.entity.view.NewsView;
// 健身资讯 Dao 接口
//定义数据库访问层操作方法
// @author // 作者信息（未填写）
public interface NewsDao extends BaseMapper<NewsEntity> {
//分页查询新闻资讯列表视图
//@param page 分页参数对象，包含当前页、每页数量等信息
// @param params 查询条件参数Map集合
// @return 返回新闻视图对象列表
List<NewsView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

34
src/main/java/com/dao/SingleSeachDao.java
Unescape View File

@ -0,0 +1,34 @@
// 声明当前文件所属的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入单页数据实体类，用于数据库表映射
import com.entity.SingleSeachEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类，用于存储查询结果列表
import java.util.List;
// 导入Java的Map集合类，用于存储键值对形式的查询参数
import java.util.Map;
// 导入MyBatis Plus的分页插件类，用于实现分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的参数注解，用于标识方法参数
import org.apache.ibatis.annotations.Param;
// 导入单页数据视图实体类，用于展示层数据
import com.entity.view.SingleSeachView;
//单页数据 Dao 接口
//定义数据库访问层操作方法
//@author // 作者信息（未填写）
public interface SingleSeachDao extends BaseMapper<SingleSeachEntity> {
//分页查询单页数据列表视图
// @param page 分页参数对象，包含当前页、每页数量等信息
//@param params 查询条件参数Map集合
//@return 返回单页数据视图对象列表
List<SingleSeachView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

39
src/main/java/com/dao/TokenDao.java
Unescape View File

@ -0,0 +1,39 @@
// 声明当前文件所属的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入Java的List集合类，用于存储查询结果列表
import java.util.List;
// 导入MyBatis的参数注解，用于标识方法参数
import org.apache.ibatis.annotations.Param;
// 导入MyBatis Plus的基础Mapper接口，提供基本CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入MyBatis Plus的条件构造器Wrapper，用于动态SQL条件拼接
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入MyBatis Plus的分页插件类，用于分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入Token实体类，用于数据库表映射
import com.entity.TokenEntity;
// Token数据访问层接口
//定义Token相关的数据库操作方法
public interface TokenDao extends BaseMapper<TokenEntity> {
//查询Token列表（不带分页）
//@param wrapper 条件构造器，用于动态SQL条件拼接
//@return 返回Token实体对象列表
List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
//查询Token列表（带分页）
//@param page 分页参数对象，包含当前页、每页数量等信息
//@param wrapper 条件构造器，用于动态SQL条件拼接
// @return 返回Token实体对象列表
List<TokenEntity> selectListView(Pagination page, @Param("ew") Wrapper<TokenEntity> wrapper);
}

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

@ -0,0 +1,40 @@
// 声明当前文件所属的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入Java的List集合类，用于存储查询结果列表
import java.util.List;
// 导入MyBatis的参数注解，用于标识方法参数
import org.apache.ibatis.annotations.Param;
// 导入MyBatis Plus的基础Mapper接口，提供基本CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入MyBatis Plus的条件构造器Wrapper，用于动态SQL条件拼接
import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入MyBatis Plus的分页插件类，用于分页查询
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入用户实体类，用于数据库表映射
import com.entity.UsersEntity;
// 用户数据访问层接口
// 定义用户相关的数据库操作方法
public interface UsersDao extends BaseMapper<UsersEntity> {
// 查询用户列表（不带分页）
//@param wrapper 条件构造器，用于动态SQL条件拼接
//@return 返回用户实体对象列表
List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
// 分页查询用户列表
// @param page 分页参数对象，包含当前页、每页数量等信息
//@param wrapper 条件构造器，用于动态SQL条件拼接
//@return 返回用户实体对象列表
List<UsersEntity> selectListView(Pagination page, @Param("ew") Wrapper<UsersEntity> wrapper);
}

35
src/main/java/com/dao/YonghuDao.java
Unescape View File

@ -0,0 +1,35 @@
// 声明当前文件所属的包路径，表示该接口位于com.dao包下
package com.dao;
// 导入用户实体类，用于数据库表映射
import com.entity.YonghuEntity;
// 导入MyBatis Plus的基础Mapper接口，提供基本CRUD操作
import com.baomidou.mybatisplus.mapper.BaseMapper;
// 导入Java的List集合类
import java.util.List;
// 导入Java的Map集合类，用于键值对存储
import java.util.Map;
// 导入MyBatis Plus的分页插件类
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
// 导入MyBatis的参数注解，用于标识方法参数
import org.apache.ibatis.annotations.Param;
// 导入用户视图实体类，用于展示层数据
import com.entity.view.YonghuView;
//用户 Dao 接口
//定义用户数据访问层操作方法
// @author // 作者信息（未填写）
public interface YonghuDao extends BaseMapper<YonghuEntity> {
//分页查询用户列表视图
//@param page 分页参数对象，包含当前页、每页数量等信息
// @param params 查询条件参数Map集合
//@return 返回用户视图对象列表
List<YonghuView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
}

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

@ -0,0 +1,61 @@
package com.entity;
import java.io.Serializable; // Java序列化支持
import com.baomidou.mybatisplus.annotations.TableId; // 主键注解
import com.baomidou.mybatisplus.annotations.TableName; // 表名注解
import com.baomidou.mybatisplus.enums.IdType; // ID类型枚举
@TableName("config")
public class ConfigEntity implements Serializable {
// 序列化版本UID，保证序列化兼容性
private static final long serialVersionUID = 1L;
// 主键ID（自增）
// 使用MyBatis-Plus的数据库ID自增策略
@TableId(type = IdType.AUTO)
private Long id;
// 配置项名称（唯一标识）
// 存储配置的键名称，具有唯一性约束
private String name;
// 配置项值
// 存储与配置名称对应的具体配置值
private String value;
// 获取主键ID
// @return 主键ID
public Long getId() {
return id;
}
// 设置主键ID
// @param id 主键ID
public void setId(Long id) {
this.id = id;
}
// 获取配置项名称
// @return 配置项名称
public String getName() {
return name;
}
// 设置配置项名称
// @param name 配置项名称
public void setName(String name) {
this.name = name;
}
// 获取配置项值
// @return 配置项值
public String getValue() {
return value;
}
// 设置配置项值
// @param value 配置项值
public void setValue(String value) {
this.value = value;
}
}

224
src/main/java/com/entity/DictionaryEntity.java
Unescape View File

@ -0,0 +1,224 @@
// 包声明
package com.entity;
// 自定义注解
import com.annotation.ColumnInfo;
// 数据校验相关
import javax.validation.constraints.*;
// Jackson序列化配置
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 反射相关
import java.lang.reflect.InvocationTargetException;
// 基础包
import java.io.Serializable;
import java.util.*;
// 日期工具
import org.apache.tools.ant.util.DateUtils;
import org.springframework.format.annotation.DateTimeFormat;
// 日期格式处理
import com.fasterxml.jackson.annotation.JsonFormat;
// Bean工具类
import org.apache.commons.beanutils.BeanUtils;
// MyBatis-Plus注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import com.baomidou.mybatisplus.enums.FieldFill;
// 自定义日期工具
import com.utils.DateUtil;
// 字典实体类
// 对应数据库dictionary表，用于存储字典数据
// @author [作者名]
// @email [邮箱地址]
@TableName("dictionary")
public class DictionaryEntity<T> implements Serializable {
// 序列化版本ID
private static final long serialVersionUID = 1L;
// 无参构造器
public DictionaryEntity() {
}
// 泛型构造器（对象拷贝）
// 使用BeanUtils进行属性拷贝
// @param t 源对象
public DictionaryEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理（建议记录日志而不是直接打印）
e.printStackTrace();
}
}
// 主键ID
// MyBatis-Plus自增主键策略
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="bigint(20)")
@TableField(value = "id")
private Long id;
// 字典编码字段
// 存储字典类型标识代码
@ColumnInfo(comment="字段",type="varchar(200)")
@TableField(value = "dic_code")
private String dicCode;
// 字典名称字段
// 存储字典类型显示名称
@ColumnInfo(comment="字段名",type="varchar(200)")
@TableField(value = "dic_name")
private String dicName;
// 编码索引值
// 字典项的数值型编码
@ColumnInfo(comment="编码",type="int(11)")
@TableField(value = "code_index")
private Integer codeIndex;
// 编码显示名称
// 字典项的可读显示名称
@ColumnInfo(comment="编码名字",type="varchar(200)")
@TableField(value = "index_name")
private String indexName;
// 父级字典ID
// 用于构建多级字典结构（0表示无父级）
@ColumnInfo(comment="父字段id",type="int(11)")
@TableField(value = "super_id")
private Integer superId;
// 备注信息
// 存储字典项的附加说明
@ColumnInfo(comment="备注",type="varchar(200)")
@TableField(value = "beizhu")
private String beizhu;
// 创建时间
// 自动填充创建时间（插入时自动填充）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 返回格式
@DateTimeFormat // 接收格式
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// 获取主键ID
// @return 主键ID
public Long getId() {
return id;
}
// 设置主键ID
// @param id 主键ID
public void setId(Long id) {
this.id = id;
}
// 获取字典编码
// @return 字典编码
public String getDicCode() {
return dicCode;
}
// 设置字典编码
// @param dicCode 字典编码
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
// 获取字典名称
// @return 字典名称
public String getDicName() {
return dicName;
}
// 设置字典名称
// @param dicName 字典名称
public void setDicName(String dicName) {
this.dicName = dicName;
}
// 获取编码索引
// @return 编码索引值
public Integer getCodeIndex() {
return codeIndex;
}
// 设置编码索引
// @param codeIndex 编码索引值
public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex;
}
// 获取编码名称
// @return 编码显示名称
public String getIndexName() {
return indexName;
}
// 设置编码名称
// @param indexName 编码显示名称
public void setIndexName(String indexName) {
this.indexName = indexName;
}
// 获取父级ID
// @return 父字典项ID
public Integer getSuperId() {
return superId;
}
// 设置父级ID
// @param superId 父字典项ID
public void setSuperId(Integer superId) {
this.superId = superId;
}
// 获取备注信息
// @return 备注内容
public String getBeizhu() {
return beizhu;
}
// 设置备注信息
// @param beizhu 备注内容
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
// 获取创建时间
// @return 创建时间对象
public Date getCreateTime() {
return createTime;
}
// 设置创建时间
// @param createTime 创建时间对象
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 对象字符串表示
// @return 格式化后的对象信息
@Override
public String toString() {
return "Dictionary{" +
", id=" + id +
", dicCode=" + dicCode +
", dicName=" + dicName +
", codeIndex=" + codeIndex +
", indexName=" + indexName +
", superId=" + superId +
", beizhu=" + beizhu +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

70
src/main/java/com/entity/EIException.java
Unescape View File

@ -0,0 +1,70 @@
// 包路径声明，定义该类的存放位置
package com.entity;
// 自定义异常类，继承自RuntimeException
// 用于在业务逻辑中抛出特定错误，包含错误信息和状态码
public class EIException extends RuntimeException {
// 序列化版本ID，用于反序列化时保持版本兼容性
private static final long serialVersionUID = 1L;
// 异常信息字段，存储具体的错误描述
private String msg;
// 状态码字段，默认500表示服务器内部错误
private int code = 500;
// 构造器1：通过错误信息创建异常对象
// 参数msg - 需要传递的异常描述信息
public EIException(String msg) {
super(msg); // 调用父类构造器初始化异常信息
this.msg = msg; // 设置当前对象的msg字段
}
// 构造器2：通过错误信息和原因异常创建对象
// 参数msg - 异常描述信息
// 参数e - 触发当前异常的底层异常对象
public EIException(String msg, Throwable e) {
super(msg, e); // 调用父类构造器初始化信息和原因
this.msg = msg; // 设置当前对象的msg字段
}
// 构造器3：通过错误信息和状态码创建异常对象
// 参数msg - 异常描述信息
// 参数code - 自定义状态码（如400表示客户端错误）
public EIException(String msg, int code) {
super(msg); // 调用父类构造器初始化信息
this.msg = msg; // 设置msg字段
this.code = code; // 设置状态码字段
}
// 构造器4：通过错误信息、状态码和原因异常创建对象
// 参数msg - 异常描述信息
// 参数code - 自定义状态码
// 参数e - 触发当前异常的底层异常对象
public EIException(String msg, int code, Throwable e) {
super(msg, e); // 调用父类构造器初始化信息和原因
this.msg = msg; // 设置msg字段
this.code = code; // 设置状态码字段
}
// 以下为字段的getter和setter方法
// 获取异常信息
public String getMsg() {
return msg;
}
// 设置异常信息
public void setMsg(String msg) {
this.msg = msg;
}
// 获取状态码
public int getCode() {
return code;
}
// 设置状态码
public void setCode(int code) {
this.code = code;
}
}

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

@ -0,0 +1,252 @@
// 包声明，表示该文件所在的包路径
package com.entity;
// 导入列信息注解
import com.annotation.ColumnInfo;
// 导入验证相关的注解
import javax.validation.constraints.*;
// 导入JSON忽略属性注解
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入集合工具类
import java.util.*;
// 导入Ant日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入JSON格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Bean工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入MyBatis Plus主键类型枚举
import com.baomidou.mybatisplus.enums.IdType;
// 导入MyBatis Plus字段填充枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入日期工具类
import com.utils.DateUtil;
//健身论坛实体类
//@author
// @email
// 指定数据库表名
@TableName("forum")
public class ForumEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造方法
public ForumEntity() {
}
// 带参构造方法，使用BeanUtils复制属性
public ForumEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键字段
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="int(11)")
@TableField(value = "id")
private Integer id;
// 帖子标题字段
@ColumnInfo(comment="帖子标题",type="varchar(200)")
@TableField(value = "forum_name")
private String forumName;
// 用户ID字段
@ColumnInfo(comment="用户",type="int(11)")
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 教练ID字段
@ColumnInfo(comment="教练",type="int(11)")
@TableField(value = "jiaolian_id")
private Integer jiaolianId;
// 管理员ID字段
@ColumnInfo(comment="管理员",type="int(11)")
@TableField(value = "users_id")
private Integer usersId;
// 发布内容字段
@ColumnInfo(comment="发布内容",type="longtext")
@TableField(value = "forum_content")
private String forumContent;
// 父ID字段
@ColumnInfo(comment="父id",type="int(11)")
@TableField(value = "super_ids")
private Integer superIds;
// 帖子状态字段
@ColumnInfo(comment="帖子状态",type="int(11)")
@TableField(value = "forum_state_types")
private Integer forumStateTypes;
// 发帖时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="发帖时间",type="timestamp")
@TableField(value = "insert_time",fill = FieldFill.INSERT)
private Date insertTime;
// 修改时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="修改时间",type="timestamp")
@TableField(value = "update_time",fill = FieldFill.UPDATE)
private Date updateTime;
// 创建时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// 获取主键方法
public Integer getId() {
return id;
}
// 设置主键方法
public void setId(Integer id) {
this.id = id;
}
// 获取帖子标题方法
public String getForumName() {
return forumName;
}
// 设置帖子标题方法
public void setForumName(String forumName) {
this.forumName = forumName;
}
// 获取用户ID方法
public Integer getYonghuId() {
return yonghuId;
}
// 设置用户ID方法
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 获取教练ID方法
public Integer getJiaolianId() {
return jiaolianId;
}
// 设置教练ID方法
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
// 获取管理员ID方法
public Integer getUsersId() {
return usersId;
}
// 设置管理员ID方法
public void setUsersId(Integer usersId) {
this.usersId = usersId;
}
// 获取发布内容方法
public String getForumContent() {
return forumContent;
}
// 设置发布内容方法
public void setForumContent(String forumContent) {
this.forumContent = forumContent;
}
// 获取父ID方法
public Integer getSuperIds() {
return superIds;
}
// 设置父ID方法
public void setSuperIds(Integer superIds) {
this.superIds = superIds;
}
// 获取帖子状态方法
public Integer getForumStateTypes() {
return forumStateTypes;
}
// 设置帖子状态方法
public void setForumStateTypes(Integer forumStateTypes) {
this.forumStateTypes = forumStateTypes;
}
// 获取发帖时间方法
public Date getInsertTime() {
return insertTime;
}
// 设置发帖时间方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取修改时间方法
public Date getUpdateTime() {
return updateTime;
}
// 设置修改时间方法
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
// 获取创建时间方法
public Date getCreateTime() {
return createTime;
}
// 设置创建时间方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// toString方法，用于对象字符串表示
@Override
public String toString() {
return "Forum{" +
", id=" + id +
", forumName=" + forumName +
", yonghuId=" + yonghuId +
", jiaolianId=" + jiaolianId +
", usersId=" + usersId +
", forumContent=" + forumContent +
", superIds=" + superIds +
", forumStateTypes=" + forumStateTypes +
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
", updateTime=" + DateUtil.convertString(updateTime,"yyyy-MM-dd") +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

176
src/main/java/com/entity/JianshenkechengCollectionEntity.java
Unescape View File

@ -0,0 +1,176 @@
// 包声明：实体类包，存放所有与数据库表映射的JavaBean对象
package com.entity;
// 字段注解：自定义数据库字段描述信息
import com.annotation.ColumnInfo;
// 数据校验注解：非空、范围等验证规则
import javax.validation.constraints.*;
// JSON序列化注解：忽略未定义字段
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 反射异常类：用于处理属性拷贝时的异常
import java.lang.reflect.InvocationTargetException;
// 序列化接口标识
import java.io.Serializable;
// 集合工具类
import java.util.*;
// Apache Ant日期工具（代码中未实际使用，建议检查是否冗余）
import org.apache.tools.ant.util.DateUtils;
// Spring日期格式注解：请求参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// Jackson日期格式注解：响应数据格式化
import com.fasterxml.jackson.annotation.JsonFormat;
// Bean工具类：对象属性拷贝
import org.apache.commons.beanutils.BeanUtils;
// MyBatis Plus字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// MyBatis Plus主键策略枚举
import com.baomidou.mybatisplus.enums.IdType;
// MyBatis Plus字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 自定义日期工具类
import com.utils.DateUtil;
/**
* 课程收藏实体
* 映射数据库表 jianshenkecheng_collection
* 记录用户对健身课程的收藏/点赞等关系数据
* @author
* @email
*/
@TableName("jianshenkecheng_collection") // 指定关联数据库表名
public class JianshenkechengCollectionEntity<T> implements Serializable {
// 序列化版本UID（类版本控制）
private static final long serialVersionUID = 1L;
// 空参构造器（JPA/MyBatis等框架需要）
public JianshenkechengCollectionEntity() {
}
// 泛型构造器：通过反射将泛型对象属性拷贝到当前实体
public JianshenkechengCollectionEntity(T t) {
try {
// 使用Apache BeanUtils进行属性拷贝
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理（建议生产环境改为日志记录）
e.printStackTrace();
}
}
// 主键字段
@TableId(type = IdType.AUTO) // 主键自增策略
@ColumnInfo(comment="主键",type="int(11)") // 字段注释：主键，数据库类型int(11)
@TableField(value = "id") // 映射数据库字段名（可省略，默认驼峰转下划线）
private Integer id;
// 关联健身课程ID（外键）
@ColumnInfo(comment="健身课程",type="int(11)") // 字段注释：关联健身课程表
@TableField(value = "jianshenkecheng_id") // 数据库字段名
private Integer jianshenkechengId;
// 关联用户ID（外键）
@ColumnInfo(comment="用户",type="int(11)") // 字段注释：关联用户表
@TableField(value = "yonghu_id") // 数据库字段名
private Integer yonghuId;
// 收藏类型（需配合字典表或枚举类使用）
@ColumnInfo(comment="类型",type="int(11)") // 字段注释：1-收藏 2-点赞等类型
@TableField(value = "jianshenkecheng_collection_types")
private Integer jianshenkechengCollectionTypes;
// 收藏时间（插入时自动填充）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 响应JSON格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 请求参数格式
@ColumnInfo(comment="收藏时间",type="timestamp") // 数据库类型timestamp
@TableField(value = "insert_time",fill = FieldFill.INSERT) // 插入时自动填充
private Date insertTime;
// 创建时间（与insert_time可能存在冗余）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT) // 与insert_time同样使用插入填充，需确认业务需求
private Date createTime;
// Getter/Setter方法
// ----------------------------
// 主键访问器
public Integer getId() {
return id;
}
// 主键修改器
public void setId(Integer id) {
this.id = id;
}
// 健身课程ID访问器
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
// 健身课程ID修改器
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
// 用户ID访问器
public Integer getYonghuId() {
return yonghuId;
}
// 用户ID修改器
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 收藏类型访问器
public Integer getJianshenkechengCollectionTypes() {
return jianshenkechengCollectionTypes;
}
// 收藏类型修改器（建议使用枚举限定值）
public void setJianshenkechengCollectionTypes(Integer jianshenkechengCollectionTypes) {
this.jianshenkechengCollectionTypes = jianshenkechengCollectionTypes;
}
// 收藏时间访问器
public Date getInsertTime() {
return insertTime;
}
// 收藏时间修改器（通常自动填充，无需手动设置）
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 创建时间访问器
public Date getCreateTime() {
return createTime;
}
// 创建时间修改器（通常自动填充，需确认与insert_time的区别）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 对象字符串表示（调试用）
@Override
public String toString() {
return "JianshenkechengCollection{" +
", id=" + id +
", jianshenkechengId=" + jianshenkechengId +
", yonghuId=" + yonghuId +
", jianshenkechengCollectionTypes=" + jianshenkechengCollectionTypes +
// 使用自定义工具类格式化日期（注意：格式化为yyyy-MM-dd会丢失时间精度）
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

282
src/main/java/com/entity/JianshenkechengEntity.java
Unescape View File

@ -0,0 +1,282 @@
// 包声明：实体类包，存放所有与数据库表映射的JavaBean对象
package com.entity;
// 字段描述注解：自定义数据库字段元数据
import com.annotation.ColumnInfo;
// 数据校验注解：提供非空、范围等验证规则
import javax.validation.constraints.*;
// JSON序列化配置：忽略未定义属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 反射异常类：处理属性拷贝时的异常
import java.lang.reflect.InvocationTargetException;
// 序列化接口标识
import java.io.Serializable;
// 集合工具类
import java.util.*;
// Apache Ant日期工具（代码中未使用，建议移除）
import org.apache.tools.ant.util.DateUtils;
// Spring日期参数绑定注解
import org.springframework.format.annotation.DateTimeFormat;
// Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// Bean属性拷贝工具
import org.apache.commons.beanutils.BeanUtils;
// MyBatis Plus字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// MyBatis Plus主键策略枚举
import com.baomidou.mybatisplus.enums.IdType;
// MyBatis Plus字段填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 自定义日期格式化工具
import com.utils.DateUtil;
// 健身课程实体
//映射数据库表 jianshenkecheng
//存储健身课程基本信息、统计数据和关联信息
@TableName("jianshenkecheng") // 指定关联数据库表名
public class JianshenkechengEntity<T> implements Serializable {
// 序列化版本标识（类版本控制）
private static final long serialVersionUID = 1L;
// 空构造器（持久层框架需要）
public JianshenkechengEntity() {
}
// 泛型构造器：通过反射进行属性拷贝
public JianshenkechengEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用Apache工具类拷贝属性
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace(); // 生产环境建议改为日志记录
}
}
// 主键字段（自增策略）
@TableId(type = IdType.AUTO) // 主键生成策略：数据库自增
@ColumnInfo(comment="主键",type="int(11)") // 字段注释：主键，数据库类型int(11)
@TableField("id") // 映射数据库字段名（可省略）
private Integer id;
// 关联教练ID（外键）
@ColumnInfo(comment="教练",type="int(11)") // 关联jiaolian表主键
@TableField("jiaolian_id")
private Integer jiaolianId;
// 课程名称（需考虑唯一性约束）
@ColumnInfo(comment="健身课程名称",type="varchar(200)") // 数据库类型varchar(200)
@TableField("jianshenkecheng_name")
private String jianshenkechengName;
// 课程封面图URL（建议添加OSS存储注释）
@ColumnInfo(comment="健身课程照片",type="varchar(200)") // 存储图片路径
@TableField("jianshenkecheng_photo")
private String jianshenkechengPhoto;
// 课程视频地址（建议标注支持的格式）
@ColumnInfo(comment="课程视频",type="varchar(200)") // 存储视频文件路径或URL
@TableField("jianshenkecheng_video")
private String jianshenkechengVideo;
// 点赞计数器（建议添加并发控制）
@ColumnInfo(comment="赞",type="int(11)") // 默认值建议设置为0
@TableField("zan_number")
private Integer zanNumber;
// 点踩计数器（考虑是否需要负值限制）
@ColumnInfo(comment="踩",type="int(11)")
@TableField("cai_number")
private Integer caiNumber;
// 课程分类（应关联字典表或使用枚举类）
@ColumnInfo(comment="健身课程类型",type="int(11)") // 例：1-有氧 2-力量 3-柔韧
@TableField("jianshenkecheng_types")
private Integer jianshenkechengTypes;
// 点击量统计（可考虑每日统计优化）
@ColumnInfo(comment="健身课程热度",type="int(11)") // 记录课程查看次数
@TableField("jianshenkecheng_clicknum")
private Integer jianshenkechengClicknum;
// 富文本课程介绍（需考虑XSS防护）
@ColumnInfo(comment="健身课程介绍",type="longtext") // 存储HTML格式内容
@TableField("jianshenkecheng_content")
private String jianshenkechengContent;
// 逻辑删除标志（0-未删除 1-已删除）
@ColumnInfo(comment="逻辑删除",type="int(11)") // 替代物理删除
@TableField("data_delete")
private Integer dataDelete;
// 数据录入时间（管理后台操作时间）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 响应格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 请求参数格式
@ColumnInfo(comment="录入时间",type="timestamp") // 数据库类型timestamp
@TableField(value = "insert_time", fill = FieldFill.INSERT) // 新增时自动填充
private Date insertTime;
// 课程创建时间（业务时间，可能与insert_time重复）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ColumnInfo(comment="创建时间",type="timestamp") // 建议确认与insert_time的区别
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
// ----------------------------- Getter/Setter方法 -----------------------------
// 主键访问器
public Integer getId() {
return id;
}
// 主键修改器
public void setId(Integer id) {
this.id = id;
}
// 教练ID访问器
public Integer getJiaolianId() {
return jiaolianId;
}
// 教练ID修改器（应校验教练存在性）
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
// 课程名称访问器
public String getJianshenkechengName() {
return jianshenkechengName;
}
// 课程名称修改器（建议添加唯一性校验）
public void setJianshenkechengName(String jianshenkechengName) {
this.jianshenkechengName = jianshenkechengName;
}
// 课程图片访问器
public String getJianshenkechengPhoto() {
return jianshenkechengPhoto;
}
// 课程图片修改器（建议添加格式校验）
public void setJianshenkechengPhoto(String jianshenkechengPhoto) {
this.jianshenkechengPhoto = jianshenkechengPhoto;
}
// 课程视频访问器
public String getJianshenkechengVideo() {
return jianshenkechengVideo;
}
// 课程视频修改器（建议添加视频格式校验）
public void setJianshenkechengVideo(String jianshenkechengVideo) {
this.jianshenkechengVideo = jianshenkechengVideo;
}
// 点赞数访问器
public Integer getZanNumber() {
return zanNumber;
}
// 点赞数修改器（建议添加非负校验）
public void setZanNumber(Integer zanNumber) {
this.zanNumber = zanNumber;
}
// 点踩数访问器
public Integer getCaiNumber() {
return caiNumber;
}
// 点踩数修改器（建议添加非负校验）
public void setCaiNumber(Integer caiNumber) {
this.caiNumber = caiNumber;
}
// 课程类型访问器
public Integer getJianshenkechengTypes() {
return jianshenkechengTypes;
}
// 课程类型修改器（应限制有效值范围）
public void setJianshenkechengTypes(Integer jianshenkechengTypes) {
this.jianshenkechengTypes = jianshenkechengTypes;
}
// 点击量访问器
public Integer getJianshenkechengClicknum() {
return jianshenkechengClicknum;
}
// 点击量修改器（建议只允许递增）
public void setJianshenkechengClicknum(Integer jianshenkechengClicknum) {
this.jianshenkechengClicknum = jianshenkechengClicknum;
}
// 课程详情访问器
public String getJianshenkechengContent() {
return jianshenkechengContent;
}
// 课程详情修改器（建议添加HTML过滤）
public void setJianshenkechengContent(String jianshenkechengContent) {
this.jianshenkechengContent = jianshenkechengContent;
}
// 逻辑删除标志访问器
public Integer getDataDelete() {
return dataDelete;
}
// 逻辑删除标志修改器（应限制0/1取值）
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 录入时间访问器（通常自动生成）
public Date getInsertTime() {
return insertTime;
}
// 录入时间修改器（通常无需手动设置）
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 创建时间访问器（注意与insert_time区别）
public Date getCreateTime() {
return createTime;
}
// 创建时间修改器（需确认业务场景）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 对象字符串表示（调试用）
@Override
public String toString() {
return "Jianshenkecheng{" +
", id=" + id +
", jiaolianId=" + jiaolianId +
", jianshenkechengName=" + jianshenkechengName +
", jianshenkechengPhoto=" + jianshenkechengPhoto +
", jianshenkechengVideo=" + jianshenkechengVideo +
", zanNumber=" + zanNumber +
", caiNumber=" + caiNumber +
", jianshenkechengTypes=" + jianshenkechengTypes +
", jianshenkechengClicknum=" + jianshenkechengClicknum +
", jianshenkechengContent=" + jianshenkechengContent +
", dataDelete=" + dataDelete +
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") + // 格式化丢失时间精度
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

212
src/main/java/com/entity/JianshenkechengLiuyanEntity.java
Unescape View File

@ -0,0 +1,212 @@
// 包声明：实体类包，存放所有与数据库表映射的JavaBean对象
package com.entity;
// 字段描述注解：自定义数据库字段元数据
import com.annotation.ColumnInfo;
// 数据校验注解：提供非空、长度等验证规则
import javax.validation.constraints.*;
// JSON序列化配置：忽略未定义属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 反射异常类：处理属性拷贝时的异常
import java.lang.reflect.InvocationTargetException;
// 序列化接口标识
import java.io.Serializable;
// 集合工具类
import java.util.*;
// Apache Ant日期工具（代码中未使用，建议移除）
import org.apache.tools.ant.util.DateUtils;
// Spring日期参数绑定注解
import org.springframework.format.annotation.DateTimeFormat;
// Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// Bean属性拷贝工具
import org.apache.commons.beanutils.BeanUtils;
// MyBatis Plus字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// MyBatis Plus主键策略枚举
import com.baomidou.mybatisplus.enums.IdType;
// MyBatis Plus字段填充策略
import com.baomidou.mybatisplus.enums.FieldFill;
// 自定义日期格式化工具
import com.utils.DateUtil;
// 课程留言实体
// 映射数据库表 jianshenkecheng_liuyan
// 存储用户对健身课程的留言及管理员回复信息
@TableName("jianshenkecheng_liuyan") // 指定关联数据库表名
public class JianshenkechengLiuyanEntity<T> implements Serializable {
// 序列化版本标识（类版本控制）
private static final long serialVersionUID = 1L;
// 空构造器（持久层框架需要）
public JianshenkechengLiuyanEntity() {
}
// 泛型构造器：通过反射进行属性拷贝
public JianshenkechengLiuyanEntity(T t) {
try {
BeanUtils.copyProperties(this, t); // 使用Apache工具类拷贝属性
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace(); // 生产环境建议改为日志记录
}
}
// 主键字段（自增策略）
@TableId(type = IdType.AUTO) // 主键生成策略：数据库自增
@ColumnInfo(comment="主键",type="int(11)") // 字段注释：主键，数据库类型int(11)
@TableField("id") // 映射数据库字段名
private Integer id; // 唯一标识符
// 关联健身课程ID（外键）
@ColumnInfo(comment="健身课程",type="int(11)") // 关联jianshenkecheng表主键
@TableField("jianshenkecheng_id")
private Integer jianshenkechengId; // 被评论的课程ID
// 关联用户ID（外键）
@ColumnInfo(comment="用户",type="int(11)") // 关联yonghu表主键
@TableField("yonghu_id")
private Integer yonghuId; // 留言用户ID
// 留言内容（需考虑敏感词过滤）
@ColumnInfo(comment="留言内容",type="longtext") // 数据库类型longtext
@TableField("jianshenkecheng_liuyan_text")
private String jianshenkechengLiuyanText; // 用户留言正文
// 留言时间（自动填充）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 响应JSON格式
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 请求参数格式
@ColumnInfo(comment="留言时间",type="timestamp") // 数据库类型timestamp
@TableField(value = "insert_time", fill = FieldFill.INSERT) // 插入时自动填充
private Date insertTime; // 用户提交留言时间
// 管理员回复内容（null表示未回复）
@ColumnInfo(comment="回复内容",type="longtext")
@TableField("reply_text")
private String replyText; // 管理员回复正文
// 回复时间（更新时自动填充）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ColumnInfo(comment="回复时间",type="timestamp")
@TableField(value = "update_time", fill = FieldFill.UPDATE) // 更新时自动填充
private Date updateTime; // 最后回复/更新时间
// 创建时间（与insert_time可能存在冗余）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime; // 记录创建时间（建议确认业务需求）
// ----------------------------- Getter/Setter方法 -----------------------------
// 主键访问器
public Integer getId() {
return id;
}
// 主键修改器
public void setId(Integer id) {
this.id = id;
}
// 课程ID访问器
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
// 课程ID修改器（应校验课程存在性）
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
// 用户ID访问器
public Integer getYonghuId() {
return yonghuId;
}
// 用户ID修改器（应校验用户存在性）
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 留言内容访问器
public String getJianshenkechengLiuyanText() {
return jianshenkechengLiuyanText;
}
// 留言内容修改器（建议添加敏感词过滤）
public void setJianshenkechengLiuyanText(String jianshenkechengLiuyanText) {
this.jianshenkechengLiuyanText = jianshenkechengLiuyanText;
}
// 留言时间访问器（通常自动生成）
public Date getInsertTime() {
return insertTime;
}
// 留言时间修改器（通常无需手动设置）
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 回复内容访问器
public String getReplyText() {
return replyText;
}
// 回复内容修改器（需权限控制）
public void setReplyText(String replyText) {
this.replyText = replyText;
}
// 回复时间访问器
public Date getUpdateTime() {
return updateTime;
}
// 回复时间修改器（通常自动更新）
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
// 创建时间访问器（注意与insert_time区别）
public Date getCreateTime() {
return createTime;
}
// 创建时间修改器（需确认业务场景）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 对象字符串表示（调试用）
@Override
public String toString() {
return "JianshenkechengLiuyan{" +
// 主键ID
", id=" + id +
// 关联课程ID
", jianshenkechengId=" + jianshenkechengId +
// 用户ID
", yonghuId=" + yonghuId +
// 留言内容（建议截断显示）
", jianshenkechengLiuyanText=" + jianshenkechengLiuyanText +
// 留言时间（格式化为日期）
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
// 回复内容（建议截断显示）
", replyText=" + replyText +
// 最后更新时间（格式化为日期）
", updateTime=" + DateUtil.convertString(updateTime,"yyyy-MM-dd") +
// 记录创建时间
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

265
src/main/java/com/entity/JiaolianEntity.java
Unescape View File

@ -0,0 +1,265 @@
// 包声明，表示该文件所在的包路径
package com.entity;
// 导入列信息注解
import com.annotation.ColumnInfo;
// 导入验证相关的注解
import javax.validation.constraints.*;
// 导入JSON忽略属性注解
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入集合工具类
import java.util.*;
// 导入Ant日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入JSON格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Bean工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入MyBatis Plus主键类型枚举
import com.baomidou.mybatisplus.enums.IdType;
// 导入MyBatis Plus字段填充枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入日期工具类
import com.utils.DateUtil;
//教练实体类
//@author
//@email
// 指定数据库表名
@TableName("jiaolian")
public class JiaolianEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造方法
public JiaolianEntity() {
}
// 带参构造方法，使用BeanUtils复制属性
public JiaolianEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键字段
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="int(11)")
@TableField(value = "id")
private Integer id;
// 账户字段
@ColumnInfo(comment="账户",type="varchar(200)")
@TableField(value = "username")
private String username;
// 密码字段
@ColumnInfo(comment="密码",type="varchar(200)")
@TableField(value = "password")
private String password;
// 教练名称字段
@ColumnInfo(comment="教练名称",type="varchar(200)")
@TableField(value = "jiaolian_name")
private String jiaolianName;
// 教练手机号字段
@ColumnInfo(comment="教练手机号",type="varchar(200)")
@TableField(value = "jiaolian_phone")
private String jiaolianPhone;
// 教练头像字段
@ColumnInfo(comment="教练头像",type="varchar(200)")
@TableField(value = "jiaolian_photo")
private String jiaolianPhoto;
// 性别字段
@ColumnInfo(comment="性别",type="int(11)")
@TableField(value = "sex_types")
private Integer sexTypes;
// 教练邮箱字段
@ColumnInfo(comment="教练邮箱",type="varchar(200)")
@TableField(value = "jiaolian_email")
private String jiaolianEmail;
// 教练简介字段
@ColumnInfo(comment="教练简介",type="longtext")
@TableField(value = "jiaolian_content")
private String jiaolianContent;
// 逻辑删除字段
@ColumnInfo(comment="逻辑删除",type="int(11)")
@TableField(value = "data_delete")
private Integer dataDelete;
// 添加时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="添加时间",type="timestamp")
@TableField(value = "insert_time",fill = FieldFill.INSERT)
private Date insertTime;
// 创建时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// 获取主键方法
public Integer getId() {
return id;
}
// 设置主键方法
public void setId(Integer id) {
this.id = id;
}
// 获取账户方法
public String getUsername() {
return username;
}
// 设置账户方法
public void setUsername(String username) {
this.username = username;
}
// 获取密码方法
public String getPassword() {
return password;
}
// 设置密码方法
public void setPassword(String password) {
this.password = password;
}
// 获取教练名称方法
public String getJiaolianName() {
return jiaolianName;
}
// 设置教练名称方法
public void setJiaolianName(String jiaolianName) {
this.jiaolianName = jiaolianName;
}
// 获取教练手机号方法
public String getJiaolianPhone() {
return jiaolianPhone;
}
// 设置教练手机号方法
public void setJiaolianPhone(String jiaolianPhone) {
this.jiaolianPhone = jiaolianPhone;
}
// 获取教练头像方法
public String getJiaolianPhoto() {
return jiaolianPhoto;
}
// 设置教练头像方法
public void setJiaolianPhoto(String jiaolianPhoto) {
this.jiaolianPhoto = jiaolianPhoto;
}
// 获取性别方法
public Integer getSexTypes() {
return sexTypes;
}
// 设置性别方法
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取教练邮箱方法
public String getJiaolianEmail() {
return jiaolianEmail;
}
// 设置教练邮箱方法
public void setJiaolianEmail(String jiaolianEmail) {
this.jiaolianEmail = jiaolianEmail;
}
// 获取教练简介方法
public String getJiaolianContent() {
return jiaolianContent;
}
// 设置教练简介方法
public void setJiaolianContent(String jiaolianContent) {
this.jiaolianContent = jiaolianContent;
}
// 获取逻辑删除方法
public Integer getDataDelete() {
return dataDelete;
}
// 设置逻辑删除方法
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 获取添加时间方法
public Date getInsertTime() {
return insertTime;
}
// 设置添加时间方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取创建时间方法
public Date getCreateTime() {
return createTime;
}
// 设置创建时间方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// toString方法，用于对象字符串表示
@Override
public String toString() {
return "Jiaolian{" +
", id=" + id +
", username=" + username +
", password=" + password +
", jiaolianName=" + jiaolianName +
", jiaolianPhone=" + jiaolianPhone +
", jiaolianPhoto=" + jiaolianPhoto +
", sexTypes=" + sexTypes +
", jiaolianEmail=" + jiaolianEmail +
", jiaolianContent=" + jiaolianContent +
", dataDelete=" + dataDelete +
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

242
src/main/java/com/entity/JiaolianYuyueEntity.java
Unescape View File

@ -0,0 +1,242 @@
// 包声明：定义当前类所在的包路径
package com.entity;
// 引入自定义注解-用于字段信息描述
import com.annotation.ColumnInfo;
// 引入Java校验注解-用于参数校验
import javax.validation.constraints.*;
// 引入JSON序列化忽略注解-用于过滤特定字段
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 引入反射相关异常类
import java.lang.reflect.InvocationTargetException;
// 引入序列化接口
import java.io.Serializable;
// 引入集合工具类
import java.util.*;
// 引入Ant日期工具类（注：实际建议使用Java8日期API）
import org.apache.tools.ant.util.DateUtils;
// 引入日期格式注解-用于请求参数格式化
import org.springframework.format.annotation.DateTimeFormat;
// 引入JSON格式注解-用于响应数据格式化
import com.fasterxml.jackson.annotation.JsonFormat;
// 引入Bean操作工具类-用于对象属性拷贝
import org.apache.commons.beanutils.BeanUtils;
// 引入MyBatis Plus字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 引入MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// 引入MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 引入MyBatis Plus主键类型枚举
import com.baomidou.mybatisplus.enums.IdType;
// 引入MyBatis Plus字段填充策略枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 引入自定义日期工具类
import com.utils.DateUtil;
// 教练预约申请实体类
// @author
// @email
@TableName("jiaolian_yuyue")
public class JiaolianYuyueEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造
public JiaolianYuyueEntity() {
}
// 带参构造（通过反射拷贝属性）
public JiaolianYuyueEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
}
// 主键
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="int(11)")
@TableField(value = "id")
private Integer id;
// 预约编号
@ColumnInfo(comment="预约编号",type="varchar(200)")
@TableField(value = "jiaolian_yuyue_uuid_number")
private String jiaolianYuyueUuidNumber;
// 关联用户ID
@ColumnInfo(comment="用户",type="int(11)")
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 预约备注
@ColumnInfo(comment="预约备注",type="longtext")
@TableField(value = "jiaolian_yuyue_text")
private String jiaolianYuyueText;
// 预约时间（带格式转换）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="预约时间",type="timestamp")
@TableField(value = "jiaolian_yuyue_time")
private Date jiaolianYuyueTime;
// 预约状态（0待审核 1已同意 2已拒绝）
@ColumnInfo(comment="预约状态",type="int(11)")
@TableField(value = "jiaolian_yuyue_yesno_types")
private Integer jiaolianYuyueYesnoTypes;
// 审核回复内容
@ColumnInfo(comment="审核回复",type="longtext")
@TableField(value = "jiaolian_yuyue_yesno_text")
private String jiaolianYuyueYesnoText;
// 申请时间（自动填充）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="申请时间",type="timestamp")
@TableField(value = "insert_time",fill = FieldFill.INSERT)
private Date insertTime;
// 创建时间（列表展示用）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// id的get方法
// 获取：主键
public Integer getId() {
return id;
}
// id的set方法
// 设置：主键
public void setId(Integer id) {
this.id = id;
}
// 预约编号的get方法
// 获取：预约编号
public String getJiaolianYuyueUuidNumber() {
return jiaolianYuyueUuidNumber;
}
// 预约编号的set方法
// 设置：预约编号
public void setJiaolianYuyueUuidNumber(String jiaolianYuyueUuidNumber) {
this.jiaolianYuyueUuidNumber = jiaolianYuyueUuidNumber;
}
// 用户ID的get方法
// 获取：用户
public Integer getYonghuId() {
return yonghuId;
}
// 用户ID的set方法
// 设置：用户
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 预约备注的get方法
// 获取：预约备注
public String getJiaolianYuyueText() {
return jiaolianYuyueText;
}
// 预约备注的set方法
// 设置：预约备注
public void setJiaolianYuyueText(String jiaolianYuyueText) {
this.jiaolianYuyueText = jiaolianYuyueText;
}
// 预约时间的get方法
// 获取：预约时间
public Date getJiaolianYuyueTime() {
return jiaolianYuyueTime;
}
// 预约时间的set方法
// 设置：预约时间
public void setJiaolianYuyueTime(Date jiaolianYuyueTime) {
this.jiaolianYuyueTime = jiaolianYuyueTime;
}
// 预约状态的get方法
// 获取：预约状态
public Integer getJiaolianYuyueYesnoTypes() {
return jiaolianYuyueYesnoTypes;
}
// 预约状态的set方法
// 设置：预约状态
public void setJiaolianYuyueYesnoTypes(Integer jiaolianYuyueYesnoTypes) {
this.jiaolianYuyueYesnoTypes = jiaolianYuyueYesnoTypes;
}
// 审核回复的get方法
// 获取：审核回复
public String getJiaolianYuyueYesnoText() {
return jiaolianYuyueYesnoText;
}
// 审核回复的set方法
// 设置：审核回复
public void setJiaolianYuyueYesnoText(String jiaolianYuyueYesnoText) {
this.jiaolianYuyueYesnoText = jiaolianYuyueYesnoText;
}
// 申请时间的get方法
// 获取：申请时间
public Date getInsertTime() {
return insertTime;
}
// 申请时间的set方法
// 设置：申请时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 创建时间的get方法
// 获取：创建时间 listShow
public Date getCreateTime() {
return createTime;
}
// 创建时间的set方法
// 设置：创建时间 listShow
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// toString方法（实体对象字符串表示）
@Override
public String toString() {
return "JiaolianYuyue{" +
// 主键字段
", id=" + id +
// 预约编号字段
", jiaolianYuyueUuidNumber=" + jiaolianYuyueUuidNumber +
// 用户ID字段
", yonghuId=" + yonghuId +
// 预约备注字段
", jiaolianYuyueText=" + jiaolianYuyueText +
// 预约时间字段（格式化）
", jiaolianYuyueTime=" + DateUtil.convertString(jiaolianYuyueTime,"yyyy-MM-dd") +
// 预约状态字段
", jiaolianYuyueYesnoTypes=" + jiaolianYuyueYesnoTypes +
// 审核回复字段
", jiaolianYuyueYesnoText=" + jiaolianYuyueYesnoText +
// 申请时间字段（格式化）
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
// 创建时间字段（格式化）
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

184
src/main/java/com/entity/NewsEntity.java
Unescape View File

@ -0,0 +1,184 @@
// 包声明：定义当前类所在包路径
package com.entity;
// 导入列信息注解
import com.annotation.ColumnInfo;
// 导入验证相关的注解
import javax.validation.constraints.*;
// 导入JSON忽略属性注解
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入集合工具类
import java.util.*;
// 导入Ant日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入JSON格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Bean工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入MyBatis Plus主键类型枚举
import com.baomidou.mybatisplus.enums.IdType;
// 导入MyBatis Plus字段填充枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入日期工具类
import com.utils.DateUtil;
/**
* 资讯实体类
*/
// 指定数据库表名
@TableName("news")
public class NewsEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造方法
public NewsEntity() {
}
// 带参构造方法，使用BeanUtils复制属性
public NewsEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键字段
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="int(11)")
@TableField(value = "id")
private Integer id;
// 资讯标题字段
@ColumnInfo(comment="资讯标题",type="varchar(200)")
@TableField(value = "news_name")
private String newsName;
// 资讯类型字段
@ColumnInfo(comment="资讯类型",type="int(11)")
@TableField(value = "news_types")
private Integer newsTypes;
// 资讯图片字段
@ColumnInfo(comment="资讯图片",type="varchar(200)")
@TableField(value = "news_photo")
private String newsPhoto;
// 添加时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="添加时间",type="timestamp")
@TableField(value = "insert_time",fill = FieldFill.INSERT)
private Date insertTime;
// 资讯详情字段
@ColumnInfo(comment="资讯详情",type="longtext")
@TableField(value = "news_content")
private String newsContent;
// 创建时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// 获取主键方法
public Integer getId() {
return id;
}
// 设置主键方法
public void setId(Integer id) {
this.id = id;
}
// 获取资讯标题方法
public String getNewsName() {
return newsName;
}
// 设置资讯标题方法
public void setNewsName(String newsName) {
this.newsName = newsName;
}
// 获取资讯类型方法
public Integer getNewsTypes() {
return newsTypes;
}
// 设置资讯类型方法
public void setNewsTypes(Integer newsTypes) {
this.newsTypes = newsTypes;
}
// 获取资讯图片方法
public String getNewsPhoto() {
return newsPhoto;
}
// 设置资讯图片方法
public void setNewsPhoto(String newsPhoto) {
this.newsPhoto = newsPhoto;
}
// 获取添加时间方法
public Date getInsertTime() {
return insertTime;
}
// 设置添加时间方法
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取资讯详情方法
public String getNewsContent() {
return newsContent;
}
// 设置资讯详情方法
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
// 获取创建时间方法
public Date getCreateTime() {
return createTime;
}
// 设置创建时间方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// toString方法，用于对象字符串表示
@Override
public String toString() {
return "News{" +
", id=" + id +
", newsName=" + newsName +
", newsTypes=" + newsTypes +
", newsPhoto=" + newsPhoto +
", insertTime=" + DateUtil.convertString(insertTime,"yyyy-MM-dd") +
", newsContent=" + newsContent +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

157
src/main/java/com/entity/SingleSeachEntity.java
Unescape View File

@ -0,0 +1,157 @@
// 声明实体类所在的包
package com.entity;
// 导入列信息注解
import com.annotation.ColumnInfo;
// 导入验证相关注解
import javax.validation.constraints.*;
// 导入JSON忽略属性注解
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入反射相关异常类
import java.lang.reflect.InvocationTargetException;
// 导入序列化接口
import java.io.Serializable;
// 导入集合类
import java.util.*;
// 导入Ant日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入JSON格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Bean工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus主键注解
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入MyBatis Plus主键类型枚举
import com.baomidou.mybatisplus.enums.IdType;
// 导入MyBatis Plus字段填充枚举
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入日期工具类
import com.utils.DateUtil;
//单页数据
//@author
//@email
// 指定表名
@TableName("single_seach")
public class SingleSeachEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造方法
public SingleSeachEntity() {
}
// 带参构造方法，使用泛型对象初始化
public SingleSeachEntity(T t) {
try {
// 复制属性值
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 主键字段
@TableId(type = IdType.AUTO)
@ColumnInfo(comment="主键",type="int(11)")
@TableField(value = "id")
private Integer id;
// 名字字段
@ColumnInfo(comment="名字",type="varchar(200)")
@TableField(value = "single_seach_name")
private String singleSeachName;
// 数据类型字段
@ColumnInfo(comment="数据类型",type="int(11)")
@TableField(value = "single_seach_types")
private Integer singleSeachTypes;
// 图片字段
@ColumnInfo(comment="图片",type="varchar(200)")
@TableField(value = "single_seach_photo")
private String singleSeachPhoto;
// 内容字段
@ColumnInfo(comment="内容",type="longtext")
@TableField(value = "single_seach_content")
private String singleSeachContent;
// 创建时间字段
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment="创建时间",type="timestamp")
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
// 获取主键方法
public Integer getId() {
return id;
}
// 设置主键方法
public void setId(Integer id) {
this.id = id;
}
// 获取名字方法
public String getSingleSeachName() {
return singleSeachName;
}
// 设置名字方法
public void setSingleSeachName(String singleSeachName) {
this.singleSeachName = singleSeachName;
}
// 获取数据类型方法
public Integer getSingleSeachTypes() {
return singleSeachTypes;
}
// 设置数据类型方法
public void setSingleSeachTypes(Integer singleSeachTypes) {
this.singleSeachTypes = singleSeachTypes;
}
// 获取图片方法
public String getSingleSeachPhoto() {
return singleSeachPhoto;
}
// 设置图片方法
public void setSingleSeachPhoto(String singleSeachPhoto) {
this.singleSeachPhoto = singleSeachPhoto;
}
// 获取内容方法
public String getSingleSeachContent() {
return singleSeachContent;
}
// 设置内容方法
public void setSingleSeachContent(String singleSeachContent) {
this.singleSeachContent = singleSeachContent;
}
// 获取创建时间方法
public Date getCreateTime() {
return createTime;
}
// 设置创建时间方法
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// toString方法
@Override
public String toString() {
return "SingleSeach{" +
", id=" + id +
", singleSeachName=" + singleSeachName +
", singleSeachTypes=" + singleSeachTypes +
", singleSeachPhoto=" + singleSeachPhoto +
", singleSeachContent=" + singleSeachContent +
", createTime=" + DateUtil.convertString(createTime,"yyyy-MM-dd") +
"}";
}
}

136
src/main/java/com/entity/TokenEntity.java
Unescape View File

@ -0,0 +1,136 @@
// 包声明
package com.entity;
// 导入相关类
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
// token表实体类
@TableName("token")
public class TokenEntity implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键ID（自增）
@TableId(type = IdType.AUTO)
private Integer id;
// 用户id
private Integer userid;
// 用户名
private String username;
// 表名
private String tablename;
// 角色
private String role;
// token值
private String token;
// 过期时间
private Date expiratedtime;
// 新增时间
private Date addtime;
// 获取ID
public Integer getId() {
return id;
}
// 设置ID
public void setId(Integer id) {
this.id = id;
}
// 获取用户ID
public Integer getUserid() {
return userid;
}
// 设置用户ID
public void setUserid(Integer userid) {
this.userid = userid;
}
// 获取角色
public String getRole() {
return role;
}
// 设置角色
public void setRole(String role) {
this.role = role;
}
// 获取token
public String getToken() {
return token;
}
// 获取表名
public String getTablename() {
return tablename;
}
// 设置表名
public void setTablename(String tablename) {
this.tablename = tablename;
}
// 设置token
public void setToken(String token) {
this.token = token;
}
// 获取过期时间
public Date getExpiratedtime() {
return expiratedtime;
}
// 设置过期时间
public void setExpiratedtime(Date expiratedtime) {
this.expiratedtime = expiratedtime;
}
// 获取新增时间
public Date getAddtime() {
return addtime;
}
// 设置新增时间
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取用户名
public String getUsername() {
return username;
}
// 设置用户名
public void setUsername(String username) {
this.username = username;
}
// 全参数构造方法（用户ID、用户名、表名、角色、token、过期时间）
public TokenEntity(Integer userid, String username, String tablename,String role, String token, Date expiratedtime) {
super();
this.userid = userid;
this.username = username;
this.tablename = tablename;
this.role = role;
this.token = token;
this.expiratedtime = expiratedtime;
}
// 无参构造方法
public TokenEntity() {
}
}

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

@ -0,0 +1,82 @@
// 包声明
package com.entity;
// 导入相关类
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
// 用户实体类
@TableName("users")
public class UsersEntity implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键ID（自增）
@TableId(type = IdType.AUTO)
private Integer id;
// 用户账号
private String username;
// 密码
private String password;
// 用户类型
private String role;
// 新增时间
private Date addtime;
// 获取用户账号
public String getUsername() {
return username;
}
// 设置用户账号
public void setUsername(String username) {
this.username = username;
}
// 获取密码
public String getPassword() {
return password;
}
// 设置密码
public void setPassword(String password) {
this.password = password;
}
// 获取用户类型
public String getRole() {
return role;
}
// 设置用户类型
public void setRole(String role) {
this.role = role;
}
// 获取新增时间
public Date getAddtime() {
return addtime;
}
// 设置新增时间
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
// 获取ID
public Integer getId() {
return id;
}
// 设置ID
public void setId(Integer id) {
this.id = id;
}
}

273
src/main/java/com/entity/YonghuEntity.java
Unescape View File

@ -0,0 +1,273 @@
// 包声明
package com.entity;
// 导入Java核心库
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.Date;
// 导入校验相关注解
import javax.validation.constraints.*;
// 导入Jackson注解
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Apache工具类
import org.apache.tools.ant.util.DateUtils;
import org.apache.commons.beanutils.BeanUtils;
// 导入Spring框架注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入MyBatis Plus注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入自定义注解和工具类
import com.annotation.ColumnInfo;
import com.utils.DateUtil;
// 用户实体类（对应数据库表yonghu）
@TableName("yonghu")
public class YonghuEntity<T> implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 无参构造方法
public YonghuEntity() {
}
// 带泛型参数的构造方法（通过BeanUtils进行属性拷贝）
public YonghuEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 异常处理（打印堆栈跟踪）
e.printStackTrace();
}
}
// 主键（自增）
@TableId(type = IdType.AUTO)
@ColumnInfo(comment = "主键", type = "int(11)")
@TableField(value = "id")
private Integer id;
// 用户账户
@ColumnInfo(comment = "账户", type = "varchar(200)")
@TableField(value = "username")
private String username;
// 登录密码
@ColumnInfo(comment = "密码", type = "varchar(200)")
@TableField(value = "password")
private String password;
// 用户真实姓名
@ColumnInfo(comment = "用户名称", type = "varchar(200)")
@TableField(value = "yonghu_name")
private String yonghuName;
// 用户手机号码
@ColumnInfo(comment = "用户手机号", type = "varchar(200)")
@TableField(value = "yonghu_phone")
private String yonghuPhone;
// 用户身份证号码
@ColumnInfo(comment = "用户身份证号", type = "varchar(200)")
@TableField(value = "yonghu_id_number")
private String yonghuIdNumber;
// 用户头像存储路径
@ColumnInfo(comment = "用户头像", type = "varchar(200)")
@TableField(value = "yonghu_photo")
private String yonghuPhoto;
// 性别（0=未知,1=男,2=女）
@ColumnInfo(comment = "性别", type = "int(11)")
@TableField(value = "sex_types")
private Integer sexTypes;
// 用户电子邮箱
@ColumnInfo(comment = "用户邮箱", type = "varchar(200)")
@TableField(value = "yonghu_email")
private String yonghuEmail;
// 账户余额（十进制类型）
@ColumnInfo(comment = "现有余额", type = "decimal(10,2)")
@TableField(value = "new_money")
private Double newMoney;
// 逻辑删除标记（0=正常,1=删除）
@ColumnInfo(comment = "逻辑删除", type = "int(11)")
@TableField(value = "data_delete")
private Integer dataDelete;
// 数据插入时间（自动填充）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment = "添加时间", type = "timestamp")
@TableField(value = "insert_time", fill = FieldFill.INSERT)
private Date insertTime;
// 记录创建时间（自动填充）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@ColumnInfo(comment = "创建时间", type = "timestamp")
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取用户账户
public String getUsername() {
return username;
}
// 设置用户账户
public void setUsername(String username) {
this.username = username;
}
// 获取登录密码
public String getPassword() {
return password;
}
// 设置登录密码
public void setPassword(String password) {
this.password = password;
}
// 获取用户真实姓名
public String getYonghuName() {
return yonghuName;
}
// 设置用户真实姓名
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
// 获取用户手机号
public String getYonghuPhone() {
return yonghuPhone;
}
// 设置用户手机号
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
// 获取身份证号码
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
// 设置身份证号码
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
// 获取头像路径
public String getYonghuPhoto() {
return yonghuPhoto;
}
// 设置头像路径
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
// 获取性别类型
public Integer getSexTypes() {
return sexTypes;
}
// 设置性别类型
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取用户邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
// 设置用户邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
// 获取账户余额
public Double getNewMoney() {
return newMoney;
}
// 设置账户余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 获取逻辑删除状态
public Integer getDataDelete() {
return dataDelete;
}
// 设置逻辑删除状态
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 获取数据插入时间
public Date getInsertTime() {
return insertTime;
}
// 设置数据插入时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取记录创建时间
public Date getCreateTime() {
return createTime;
}
// 设置记录创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写toString方法（返回对象字符串表示）
@Override
public String toString() {
return "Yonghu{" +
", id=" + id +
", username=" + username +
", password=" + password +
", yonghuName=" + yonghuName +
", yonghuPhone=" + yonghuPhone +
", yonghuIdNumber=" + yonghuIdNumber +
", yonghuPhoto=" + yonghuPhoto +
", sexTypes=" + sexTypes +
", yonghuEmail=" + yonghuEmail +
", newMoney=" + newMoney +
", dataDelete=" + dataDelete +
", insertTime=" + DateUtil.convertString(insertTime, "yyyy-MM-dd") +
", createTime=" + DateUtil.convertString(createTime, "yyyy-MM-dd") +
"}";
}
}

155
src/main/java/com/entity/model/DictionaryModel.java
Unescape View File

@ -0,0 +1,155 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入字典实体类，用于数据表映射
import com.entity.DictionaryEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 字典模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//该类名称取自ModelAndView中的model名称
public class DictionaryModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Long id;
//字典编码
private String dicCode;
//字典名称
private String dicName;
// 编码索引
private Integer codeIndex;
//索引名称
private String indexName;
// 父级字典ID
private Integer superId;
// 备注信息
private String beizhu;
//创建时间
//使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Long getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Long id) {
this.id = id;
}
//获取字典编码
// @return 字典编码
public String getDicCode() {
return dicCode;
}
//设置字典编码
// @param dicCode 字典编码
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
//获取字典名称
// @return 字典名称
public String getDicName() {
return dicName;
}
//设置字典名称
// @param dicName 字典名称
public void setDicName(String dicName) {
this.dicName = dicName;
}
//获取编码索引
//@return 编码索引
public Integer getCodeIndex() {
return codeIndex;
}
//设置编码索引
//@param codeIndex 编码索引
public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex;
}
//获取索引名称
//@return 索引名称
public String getIndexName() {
return indexName;
}
//设置索引名称
//@param indexName 索引名称
public void setIndexName(String indexName) {
this.indexName = indexName;
}
//获取父级字典ID
//@return 父级字典ID
public Integer getSuperId() {
return superId;
}
//设置父级字典ID
//@param superId 父级字典ID
public void setSuperId(Integer superId) {
this.superId = superId;
}
//获取备注信息
//@return 备注信息
public String getBeizhu() {
return beizhu;
}
// 设置备注信息
// @param beizhu 备注信息
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取创建时间
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

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

@ -0,0 +1,268 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入论坛实体类，用于数据表映射
import com.entity.ForumEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 健身论坛模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//该类名称取自ModelAndView中的model名称
public class ForumModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 帖子标题
private String forumName;
// 关联用户ID
private Integer yonghuId;
// 关联教练ID
private Integer jiaolianId;
// 关联管理员ID
private Integer usersId;
//帖子内容
private String forumContent;
// 父级帖子ID（用于回复关系）
private Integer superIds;
//帖子状态（如：0-正常 1-置顶 2-精华等）
private Integer forumStateTypes;
// 发帖时间
//使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
//最后修改时间
//使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date updateTime;
//创建时间（展示用）
// 使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取帖子标题
// @return 帖子标题
public String getForumName() {
return forumName;
}
//设置帖子标题
// @param forumName 帖子标题
public void setForumName(String forumName) {
this.forumName = forumName;
}
//获取关联用户ID
// @return 用户ID
public Integer getYonghuId() {
return yonghuId;
}
//设置关联用户ID
//@param yonghuId 用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
//获取关联教练ID
// @return 教练ID
public Integer getJiaolianId() {
return jiaolianId;
}
//设置关联教练ID
// @param jiaolianId 教练ID
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
//获取关联管理员ID
//@return 管理员ID
public Integer getUsersId() {
return usersId;
}
//设置关联管理员ID
// @param usersId 管理员ID
public void setUsersId(Integer usersId) {
this.usersId = usersId;
}
//获取帖子内容
// @return 帖子内容
public String getForumContent() {
return forumContent;
}
//设置帖子内容
// @param forumContent 帖子内容
public void setForumContent(String forumContent) {
this.forumContent = forumContent;
}
//获取父级帖子ID
// @return 父级帖子ID
public Integer getSuperIds() {
return superIds;
}
//设置父级帖子ID
// @param superIds 父级帖子ID
public void setSuperIds(Integer superIds) {
this.superIds = superIds;
}
//获取帖子状态
// @return 帖子状态
public Integer getForumStateTypes() {
return forumStateTypes;
}
//设置帖子状态
// @param forumStateTypes 帖子状态
public void setForumStateTypes(Integer forumStateTypes) {
this.forumStateTypes = forumStateTypes;
}
//获取发帖时间
// @return 发帖时间
public Date getInsertTime() {
return insertTime;
}
//设置发帖时间
// @param insertTime 发帖时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取最后修改时间
// @return 修改时间
public Date getUpdateTime() {
return updateTime;
}
//设置最后修改时间
// @param updateTime 修改时间
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
//获取创建时间（展示用）
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间（展示用）
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

161
src/main/java/com/entity/model/JianshenkechengCollectionModel.java
Unescape View File

@ -0,0 +1,161 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入健身课程收藏实体类，用于数据表映射
import com.entity.JianshenkechengCollectionEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 健身课程收藏模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//该类名称取自ModelAndView中的model名称
public class JianshenkechengCollectionModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 关联的健身课程ID
private Integer jianshenkechengId;
// 关联的用户ID
private Integer yonghuId;
// 收藏类型（如：1-收藏 2-点赞等）
private Integer jianshenkechengCollectionTypes;
// 收藏时间
//使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
// 创建时间（用于展示）
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
// * 设置主键ID
//* @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
// * 获取关联的健身课程ID
//* @return 健身课程ID
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
// * 设置关联的健身课程ID
//* @param jianshenkechengId 健身课程ID
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
// * 获取关联的用户ID
//* @return 用户ID
public Integer getYonghuId() {
return yonghuId;
}
//* 设置关联的用户ID
//* @param yonghuId 用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
//* 获取收藏类型
//* @return 收藏类型
public Integer getJianshenkechengCollectionTypes() {
return jianshenkechengCollectionTypes;
}
//* 设置收藏类型
//* @param jianshenkechengCollectionTypes 收藏类型
public void setJianshenkechengCollectionTypes(Integer jianshenkechengCollectionTypes) {
this.jianshenkechengCollectionTypes = jianshenkechengCollectionTypes;
}
//* 获取收藏时间
//* @return 收藏时间
public Date getInsertTime() {
return insertTime;
}
//* 设置收藏时间
//* @param insertTime 收藏时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//* 获取创建时间（用于展示）
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//* 设置创建时间（用于展示）
//* @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

203
src/main/java/com/entity/model/JianshenkechengLiuyanModel.java
Unescape View File

@ -0,0 +1,203 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入健身课程留言实体类，用于数据表映射
import com.entity.JianshenkechengLiuyanEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
//* 健身课程留言模型类
//* 用于接收前端传参的实体类
//* （实际开发中可根据移动端需求手动移除无用字段，
//* 后端一般直接使用entity实体类即可）
//* 该类名称取自ModelAndView中的model名称
public class JianshenkechengLiuyanModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//* 主键ID
private Integer id;
//* 关联的健身课程ID
private Integer jianshenkechengId;
//* 关联的用户ID
private Integer yonghuId;
// * 留言内容
private String jianshenkechengLiuyanText;
//* 留言时间
//* 使用Jackson注解指定JSON格式
//* 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
//* 回复内容
private String replyText;
//* 回复时间
//* 使用Jackson注解指定JSON格式
//* 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date updateTime;
//* 创建时间（用于展示）
//* 使用Jackson注解指定JSON格式
//* 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//* 获取主键ID
//* @return 主键ID
public Integer getId() {
return id;
}
//* 设置主键ID
//* @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//* 获取关联的健身课程ID
//* @return 健身课程ID
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
//* 设置关联的健身课程ID
// * @param jianshenkechengId 健身课程ID
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
//* 获取关联的用户ID
//* @return 用户ID
public Integer getYonghuId() {
return yonghuId;
}
//* 设置关联的用户ID
//* @param yonghuId 用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// * 获取留言内容
//* @return 留言内容
public String getJianshenkechengLiuyanText() {
return jianshenkechengLiuyanText;
}
//* 设置留言内容
// * @param jianshenkechengLiuyanText 留言内容
public void setJianshenkechengLiuyanText(String jianshenkechengLiuyanText) {
this.jianshenkechengLiuyanText = jianshenkechengLiuyanText;
}
//* 获取留言时间
// * @return 留言时间
public Date getInsertTime() {
return insertTime;
}
//* 设置留言时间
//* @param insertTime 留言时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//* 获取回复内容
//* @return 回复内容
public String getReplyText() {
return replyText;
}
//* 设置回复内容
// * @param replyText 回复内容
public void setReplyText(String replyText) {
this.replyText = replyText;
}
//* 获取回复时间
//* @return 回复时间
public Date getUpdateTime() {
return updateTime;
}
//* 设置回复时间
//* @param updateTime 回复时间
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
//* 获取创建时间（用于展示）
// * @return 创建时间
public Date getCreateTime() {
return createTime;
}
//* 设置创建时间（用于展示）
//* @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

284
src/main/java/com/entity/model/JianshenkechengModel.java
Unescape View File

@ -0,0 +1,284 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入健身课程实体类，用于数据表映射
import com.entity.JianshenkechengEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 健身课程模型类
// 用于接收前端传参的实体类
// （实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
// 该类名称取自ModelAndView中的model名称
public class JianshenkechengModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
/**主键ID*/
private Integer id;
/**关联教练ID*/
private Integer jiaolianId;
/**健身课程名称*/
private String jianshenkechengName;
/**健身课程封面图片*/
private String jianshenkechengPhoto;
/**课程视频地址*/
private String jianshenkechengVideo;
/**点赞数量*/
private Integer zanNumber;
/**点踩数量*/
private Integer caiNumber;
/**课程类型（如：1-有氧 2-力量 3-瑜伽等）*/
private Integer jianshenkechengTypes;
/**课程点击量/热度*/
private Integer jianshenkechengClicknum;
/**课程详细介绍*/
private String jianshenkechengContent;
/**逻辑删除标志（0-未删除 1-已删除）*/
private Integer dataDelete;
//课程录入时间
// 使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
// 创建时间（用于多种展示场景）
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
// 获取主键ID
//@return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取关联教练ID
// @return 教练ID
public Integer getJiaolianId() {
return jiaolianId;
}
//设置关联教练ID
// @param jiaolianId 教练ID
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
//获取健身课程名称
// @return 课程名称
public String getJianshenkechengName() {
return jianshenkechengName;
}
//设置健身课程名称
// @param jianshenkechengName 课程名称
public void setJianshenkechengName(String jianshenkechengName) {
this.jianshenkechengName = jianshenkechengName;
}
//获取健身课程封面图片
// @return 封面图片路径
public String getJianshenkechengPhoto() {
return jianshenkechengPhoto;
}
//设置健身课程封面图片
// @param jianshenkechengPhoto 封面图片路径
public void setJianshenkechengPhoto(String jianshenkechengPhoto) {
this.jianshenkechengPhoto = jianshenkechengPhoto;
}
//获取课程视频地址
// @return 视频地址
public String getJianshenkechengVideo() {
return jianshenkechengVideo;
}
//设置课程视频地址
// @param jianshenkechengVideo 视频地址
public void setJianshenkechengVideo(String jianshenkechengVideo) {
this.jianshenkechengVideo = jianshenkechengVideo;
}
//获取点赞数量
// @return 点赞数
public Integer getZanNumber() {
return zanNumber;
}
//设置点赞数量
// @param zanNumber 点赞数
public void setZanNumber(Integer zanNumber) {
this.zanNumber = zanNumber;
}
//获取点踩数量
//@return 点踩数
public Integer getCaiNumber() {
return caiNumber;
}
//设置点踩数量
// @param caiNumber 点踩数
public void setCaiNumber(Integer caiNumber) {
this.caiNumber = caiNumber;
}
//获取课程类型
// @return 课程类型编号
public Integer getJianshenkechengTypes() {
return jianshenkechengTypes;
}
//设置课程类型*
//@param jianshenkechengTypes 课程类型编号
public void setJianshenkechengTypes(Integer jianshenkechengTypes) {
this.jianshenkechengTypes = jianshenkechengTypes;
}
//获取课程点击量
// @return 点击量
public Integer getJianshenkechengClicknum() {
return jianshenkechengClicknum;
}
//设置课程点击量
// @param jianshenkechengClicknum 点击量
public void setJianshenkechengClicknum(Integer jianshenkechengClicknum) {
this.jianshenkechengClicknum = jianshenkechengClicknum;
}
//获取课程详细介绍
// @return 课程介绍内容
public String getJianshenkechengContent() {
return jianshenkechengContent;
}
//设置课程详细介绍
// @param jianshenkechengContent 课程介绍内容
public void setJianshenkechengContent(String jianshenkechengContent) {
this.jianshenkechengContent = jianshenkechengContent;
}
//获取逻辑删除标志
// @return 删除状态（0未删除/1已删除）
public Integer getDataDelete() {
return dataDelete;
}
//设置逻辑删除标志
// @param dataDelete 删除状态（0未删除/1已删除）
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
//获取课程录入时间
// @return 录入时间
public Date getInsertTime() {
return insertTime;
}
//设置课程录入时间
// @param insertTime 录入时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取创建时间（用于多种展示场景）
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（用于多种展示场景）
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

279
src/main/java/com/entity/model/JiaolianModel.java
Unescape View File

@ -0,0 +1,279 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入教练实体类，用于数据表映射
import com.entity.JiaolianEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
//教练模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
// 该类名称取自ModelAndView中的model名称
public class JiaolianModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
//登录账号
private String username;
// 登录密码（通常需要加密存储）
private String password;
// 教练姓名
private String jiaolianName;
// 教练联系电话
private String jiaolianPhone;
// 教练头像URL
private String jiaolianPhoto;
// 性别（1-男 2-女等）
private Integer sexTypes;
// 教练电子邮箱
private String jiaolianEmail;
// 教练详细介绍
private String jiaolianContent;
// 逻辑删除标志（0-未删除 1-已删除）
private Integer dataDelete;
//记录添加时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
//创建时间（用于多种展示场景）
//使Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取登录账号
// @return 登录账号
public String getUsername() {
return username;
}
//设置登录账号
// @param username 登录账号
public void setUsername(String username) {
this.username = username;
}
//获取登录密码
// @return 登录密码
public String getPassword() {
return password;
}
//设置登录密码
// @param password 登录密码
public void setPassword(String password) {
this.password = password;
}
//获取教练姓名
// @return 教练姓名
public String getJiaolianName() {
return jiaolianName;
}
//设置教练姓名
// @param jiaolianName 教练姓名
public void setJiaolianName(String jiaolianName) {
this.jiaolianName = jiaolianName;
}
//获取教练联系电话
// @return 联系电话
public String getJiaolianPhone() {
return jiaolianPhone;
}
//设置教练联系电话
// @param jiaolianPhone 联系电话
public void setJiaolianPhone(String jiaolianPhone) {
this.jiaolianPhone = jiaolianPhone;
}
//获取教练头像URL
// @return 头像URL
public String getJiaolianPhoto() {
return jiaolianPhoto;
}
//设置教练头像URL
// @param jiaolianPhoto 头像URL
public void setJiaolianPhoto(String jiaolianPhoto) {
this.jiaolianPhoto = jiaolianPhoto;
}
//获取性别类型
// @return 性别类型编号
public Integer getSexTypes() {
return sexTypes;
}
// 设置性别类型
// @param sexTypes 性别类型编号
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取教练电子邮箱
// @return 电子邮箱
public String getJiaolianEmail() {
return jiaolianEmail;
}
//设置教练电子邮箱
// @param jiaolianEmail 电子邮箱
public void setJiaolianEmail(String jiaolianEmail) {
this.jiaolianEmail = jiaolianEmail;
}
//获取教练详细介绍
// @return 详细介绍内容
public String getJiaolianContent() {
return jiaolianContent;
}
//设置教练详细介绍
// @param jiaolianContent 详细介绍内容
public void setJiaolianContent(String jiaolianContent) {
this.jiaolianContent = jiaolianContent;
}
//获取逻辑删除标志
// @return 删除状态（0未删除/1已删除）
public Integer getDataDelete() {
return dataDelete;
}
//设置逻辑删除标志
// @param dataDelete 删除状态（0未删除/1已删除）
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
//获取记录添加时间
// @return 添加时间
public Date getInsertTime() {
return insertTime;
}
//设置记录添加时间
// @param insertTime 添加时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取创建时间（用于多种展示场景）
// @return 创建时间*/
public Date getCreateTime() {
return createTime;
}
//设置创建时间（用于多种展示场景）
// @param createTime 创建时间*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

228
src/main/java/com/entity/model/JiaolianYuyueModel.java
Unescape View File

@ -0,0 +1,228 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入教练预约实体类，用于数据表映射
import com.entity.JiaolianYuyueEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 教练预约申请模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
// 该类名称取自ModelAndView中的model名称
public class JiaolianYuyueModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 预约唯一编号（用于业务标识）
private String jiaolianYuyueUuidNumber;
// 关联用户ID
private Integer yonghuId;
// 预约备注信息
private String jiaolianYuyueText;
//预约的具体时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date jiaolianYuyueTime;
// 预约状态（如：0-待审核 1-已通过 2-已拒绝）
private Integer jiaolianYuyueYesnoTypes;
// 审核回复内容
private String jiaolianYuyueYesnoText;
//申请创建时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
//创建时间（用于展示）
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取预约唯一编号
// @return 预约编号
public String getJiaolianYuyueUuidNumber() {
return jiaolianYuyueUuidNumber;
}
//设置预约唯一编号
//@param jiaolianYuyueUuidNumber 预约编号
public void setJiaolianYuyueUuidNumber(String jiaolianYuyueUuidNumber) {
this.jiaolianYuyueUuidNumber = jiaolianYuyueUuidNumber;
}
//获取关联用户ID
// @return 用户ID
public Integer getYonghuId() {
return yonghuId;
}
//设置关联用户ID
// @param yonghuId 用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
//获取预约备注信息
// @return 备注内容
public String getJiaolianYuyueText() {
return jiaolianYuyueText;
}
//设置预约备注信息
// @param jiaolianYuyueText 备注内容
public void setJiaolianYuyueText(String jiaolianYuyueText) {
this.jiaolianYuyueText = jiaolianYuyueText;
}
//获取预约的具体时间
// @return 预约时间
public Date getJiaolianYuyueTime() {
return jiaolianYuyueTime;
}
//设置预约的具体时间
// @param jiaolianYuyueTime 预约时间
public void setJiaolianYuyueTime(Date jiaolianYuyueTime) {
this.jiaolianYuyueTime = jiaolianYuyueTime;
}
//获取预约状态
// @return 状态值
public Integer getJiaolianYuyueYesnoTypes() {
return jiaolianYuyueYesnoTypes;
}
//设置预约状态
//@param jiaolianYuyueYesnoTypes 状态值
public void setJiaolianYuyueYesnoTypes(Integer jiaolianYuyueYesnoTypes) {
this.jiaolianYuyueYesnoTypes = jiaolianYuyueYesnoTypes;
}
//获取审核回复内容
//@return 回复内容
public String getJiaolianYuyueYesnoText() {
return jiaolianYuyueYesnoText;
}
//设置审核回复内容
// @param jiaolianYuyueYesnoText 回复内容
public void setJiaolianYuyueYesnoText(String jiaolianYuyueYesnoText) {
this.jiaolianYuyueYesnoText = jiaolianYuyueYesnoText;
}
//获取申请创建时间
// @return 创建时间
public Date getInsertTime() {
return insertTime;
}
//设置申请创建时间
//@param insertTime 创建时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取创建时间（用于展示）
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间（用于展示）
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

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

@ -0,0 +1,179 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入资讯实体类，用于数据表映射
import com.entity.NewsEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
//健身资讯模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//该类名称取自ModelAndView中的model名称
public class NewsModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 资讯标题
private String newsName;
//资讯类型（如：1-健身知识 2-饮食建议 3-训练计划等）
private Integer newsTypes;
// 资讯封面图片URL
private String newsPhoto;
//资讯添加时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
// 资讯详细内容（HTML格式）
private String newsContent;
//创建时间（用于多种展示场景）
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取资讯标题
// @return 资讯标题
public String getNewsName() {
return newsName;
}
//设置资讯标题
// @param newsName 资讯标题
public void setNewsName(String newsName) {
this.newsName = newsName;
}
//获取资讯类型
// @return 资讯类型编号
public Integer getNewsTypes() {
return newsTypes;
}
//设置资讯类型
// @param newsTypes 资讯类型编号
public void setNewsTypes(Integer newsTypes) {
this.newsTypes = newsTypes;
}
//获取资讯封面图片URL
// @return 图片URL
public String getNewsPhoto() {
return newsPhoto;
}
//设置资讯封面图片URL
// @param newsPhoto 图片URL
public void setNewsPhoto(String newsPhoto) {
this.newsPhoto = newsPhoto;
}
//获取资讯添加时间
// @return 添加时间
public Date getInsertTime() {
return insertTime;
}
//设置资讯添加时间
// @param insertTime 添加时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取资讯详细内容
// @return 资讯内容
public String getNewsContent() {
return newsContent;
}
//设置资讯详细内容
//@param newsContent 资讯内容
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
//获取创建时间（用于多种展示场景）
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间（用于多种展示场景）
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

156
src/main/java/com/entity/model/SingleSeachModel.java
Unescape View File

@ -0,0 +1,156 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入单页数据实体类，用于数据表映射
import com.entity.SingleSeachEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
// 单页数据模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//该类名称取自ModelAndView中的model名称
public class SingleSeachModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 单页数据名称
private String singleSeachName;
// 数据类型（如：1-关于我们 2-服务条款 3-隐私政策等）
private Integer singleSeachTypes;
// 关联图片URL
private String singleSeachPhoto;
// 单页内容（HTML格式）
private String singleSeachContent;
// 创建时间（用于展示）
//使用Jackson注解指定JSON格式
//使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
// 获取主键ID
//@return 主键ID
public Integer getId() {
return id;
}
// 设置主键ID
//@param id 主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取单页数据名称
//@return 名称
public String getSingleSeachName() {
return singleSeachName;
}
// 设置单页数据名称
//@param singleSeachName 名称
public void setSingleSeachName(String singleSeachName) {
this.singleSeachName = singleSeachName;
}
// 获取数据类型
//@return 数据类型编号
public Integer getSingleSeachTypes() {
return singleSeachTypes;
}
// 设置数据类型
// @param singleSeachTypes 数据类型编号
public void setSingleSeachTypes(Integer singleSeachTypes) {
this.singleSeachTypes = singleSeachTypes;
}
// 获取关联图片URL
//@return 图片URL
public String getSingleSeachPhoto() {
return singleSeachPhoto;
}
// 设置关联图片URL
// @param singleSeachPhoto 图片URL
public void setSingleSeachPhoto(String singleSeachPhoto) {
this.singleSeachPhoto = singleSeachPhoto;
}
// 获取单页内容
//@return 内容
public String getSingleSeachContent() {
return singleSeachContent;
}
// 设置单页内容
//@param singleSeachContent 内容
public void setSingleSeachContent(String singleSeachContent) {
this.singleSeachContent = singleSeachContent;
}
// 获取创建时间（用于展示）
//@return 创建时间
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（用于展示）
//@param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

307
src/main/java/com/entity/model/YonghuModel.java
Unescape View File

@ -0,0 +1,307 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.model包下
package com.entity.model;
// 导入用户实体类，用于数据表映射
import com.entity.YonghuEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解，用于JSON序列化/反序列化
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的Date类，用于处理日期时间
import java.util.Date;
// 导入Spring的日期格式化注解，用于前端参数绑定
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口
import java.io.Serializable;
//用户模型类
//用于接收前端传参的实体类
//（实际开发中可根据移动端需求手动移除无用字段，
// 后端一般直接使用entity实体类即可）
//类名称取自ModelAndView中的model名称
public class YonghuModel implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
private Integer id;
// 登录账号
private String username;
// 登录密码（通常需要加密存储）
private String password;
// 用户真实姓名
private String yonghuName;
// 用户手机号码
private String yonghuPhone;
// 用户身份证号码
private String yonghuIdNumber;
// 用户头像URL
private String yonghuPhoto;
// 性别（1-男 2-女等）
private Integer sexTypes;
//用户电子邮箱
private String yonghuEmail;
// 用户账户余额
private Double newMoney;
// 逻辑删除标志（0-未删除 1-已删除）
private Integer dataDelete;
//记录添加时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date insertTime;
//创建时间
//使用Jackson注解指定JSON格式
// 使用Spring注解指定前端参数格式
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime;
//获取主键ID
// @return 主键ID
public Integer getId() {
return id;
}
//设置主键ID
// @param id 主键ID
public void setId(Integer id) {
this.id = id;
}
//获取登录账号
// @return 登录账号
public String getUsername() {
return username;
}
//设置登录账号
// @param username 登录账号
public void setUsername(String username) {
this.username = username;
}
//获取登录密码
// @return 登录密码
public String getPassword() {
return password;
}
//设置登录密码
// @param password 登录密码
public void setPassword(String password) {
this.password = password;
}
//获取用户真实姓名
// @return 用户姓名
public String getYonghuName() {
return yonghuName;
}
//设置用户真实姓名
//@param yonghuName 用户姓名
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
//获取用户手机号码
// @return 手机号码
public String getYonghuPhone() {
return yonghuPhone;
}
//设置用户手机号码
// @param yonghuPhone 手机号码
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
//获取用户身份证号码
// @return 身份证号码
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
//设置用户身份证号码
// @param yonghuIdNumber 身份证号码
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
//获取用户头像URL
// @return 头像URL
public String getYonghuPhoto() {
return yonghuPhoto;
}
//设置用户头像URL
// @param yonghuPhoto 头像URL
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
//获取性别类型
//@return 性别类型编号
public Integer getSexTypes() {
return sexTypes;
}
//设置性别类型
// @param sexTypes 性别类型编号
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
//获取用户电子邮箱
// @return 电子邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
//设置用户电子邮箱
//@param yonghuEmail 电子邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
//获取用户账户余额
// @return 账户余额
public Double getNewMoney() {
return newMoney;
}
//设置用户账户余额
// @param newMoney 账户余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
//获取逻辑删除标志
// @return 删除状态（0未删除/1已删除）
public Integer getDataDelete() {
return dataDelete;
}
//设置逻辑删除标志
// @param dataDelete 删除状态（0未删除/1已删除）
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
//获取记录添加时间
// @return 添加时间
public Date getInsertTime() {
return insertTime;
}
//设置记录添加时间
// @param insertTime 添加时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
//获取创建时间
// @return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间
// @param createTime 创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

69
src/main/java/com/entity/view/DictionaryView.java
Unescape View File

@ -0,0 +1,69 @@
// 声明当前文件所属的包路径，表示该类位于com.entity.view包下
package com.entity.view;
// 导入Apache Ant的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入字典实体类
import com.entity.DictionaryEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入Java反射异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的JSON格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java序列化接口
import java.io.Serializable;
// 导入Java日期类
import java.util.Date;
// 导入自定义日期工具类
import com.utils.DateUtil;
//字典视图类
//后端返回视图实体辅助类
//（通常用于返回后端关联的表或自定义字段）
//继承自DictionaryEntity并实现Serializable接口
@TableName("dictionary") // 指定关联的数据库表名
public class DictionaryView extends DictionaryEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 当前表没有额外字段，所以这里为空
// 无参构造函数
public DictionaryView() {
}
//带参构造函数
//通过BeanUtils将DictionaryEntity属性复制到当前视图对象
// @param dictionaryEntity 字典实体对象
public DictionaryView(DictionaryEntity dictionaryEntity) {
try {
// 使用BeanUtils复制属性
BeanUtils.copyProperties(this, dictionaryEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印复制属性时的异常堆栈
e.printStackTrace();
}
}
//重写toString方法
// @return 返回对象的字符串表示
@Override
public String toString() {
return "DictionaryView{" +
"} " + super.toString();
}
}

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

@ -0,0 +1,370 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant的DateUtils工具类，用于日期处理
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的ColumnInfo注解，用于数据库字段映射
import com.annotation.ColumnInfo;
// 导入ForumEntity实体类，表示论坛帖子
import com.entity.ForumEntity;
// 导入MyBatis Plus的TableName注解，用于表名映射
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，用于对象属性拷贝
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//健身论坛
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定表名
@TableName("forum")
// 继承ForumEntity并实现Serializable接口
public class ForumView extends ForumEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//帖子状态的值
// 使用ColumnInfo注解标注字段信息，包括注释和数据库类型
@ColumnInfo(comment="帖子状态的字典表值",type="varchar(200)")
private String forumStateValue;
//级联表 教练
//教练名称
// 教练名称字段
@ColumnInfo(comment="教练名称",type="varchar(200)")
private String jiaolianName;
//教练手机号
// 教练手机号字段
@ColumnInfo(comment="教练手机号",type="varchar(200)")
private String jiaolianPhone;
//教练头像
// 教练头像字段
@ColumnInfo(comment="教练头像",type="varchar(200)")
private String jiaolianPhoto;
//教练邮箱
// 教练邮箱字段
@ColumnInfo(comment="教练邮箱",type="varchar(200)")
private String jiaolianEmail;
//教练简介
// 教练简介字段，使用长文本类型
@ColumnInfo(comment="教练简介",type="longtext")
private String jiaolianContent;
//级联表 用户
//用户名称
// 用户名称字段
@ColumnInfo(comment="用户名称",type="varchar(200)")
private String yonghuName;
//用户手机号
// 用户手机号字段
@ColumnInfo(comment="用户手机号",type="varchar(200)")
private String yonghuPhone;
//用户身份证号
// 用户身份证号字段
@ColumnInfo(comment="用户身份证号",type="varchar(200)")
private String yonghuIdNumber;
//用户头像
// 用户头像字段
@ColumnInfo(comment="用户头像",type="varchar(200)")
private String yonghuPhoto;
//用户邮箱
// 用户邮箱字段
@ColumnInfo(comment="用户邮箱",type="varchar(200)")
private String yonghuEmail;
//现有余额
// 用户余额字段，使用十进制类型
@ColumnInfo(comment="现有余额",type="decimal(10,2)")
private Double newMoney;
//级联表 管理员
//医院名
// 管理员用户名字段
@ColumnInfo(comment="医院名",type="varchar(100)")
private String uusername;
// 密码
// 管理员密码字段
@ColumnInfo(comment="密码",type="varchar(100)")
private String upassword;
// 角色
// 管理员角色字段
@ColumnInfo(comment="角色",type="varchar(100)")
private String urole;
//新增时间
// 管理员新增时间字段
@ColumnInfo(comment="新增时间",type="timestamp")
private Date uaddtime;
//重复字段
//重复字段 的types
// 性别类型字段
@ColumnInfo(comment="重复字段 的types",type="Integer")
private Integer sexTypes;
// 性别值字段
@ColumnInfo(comment="重复字段 的值",type="varchar(200)")
private String sexValue;
// 无参构造方法
public ForumView() {
}
// 带参数的构造方法，通过BeanUtils.copyProperties进行属性拷贝
public ForumView(ForumEntity forumEntity) {
try {
BeanUtils.copyProperties(this, forumEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈
e.printStackTrace();
}
}
//当前表的get和set方法
//获取： 帖子状态的值
public String getForumStateValue() {
return forumStateValue;
}
//设置： 帖子状态的值
public void setForumStateValue(String forumStateValue) {
this.forumStateValue = forumStateValue;
}
//级联表的get和set 教练
//获取： 教练名称
public String getJiaolianName() {
return jiaolianName;
}
//设置： 教练名称
public void setJiaolianName(String jiaolianName) {
this.jiaolianName = jiaolianName;
}
// 获取： 教练手机号
public String getJiaolianPhone() {
return jiaolianPhone;
}
//设置： 教练手机号
public void setJiaolianPhone(String jiaolianPhone) {
this.jiaolianPhone = jiaolianPhone;
}
//获取： 教练头像
public String getJiaolianPhoto() {
return jiaolianPhoto;
}
//设置： 教练头像
public void setJiaolianPhoto(String jiaolianPhoto) {
this.jiaolianPhoto = jiaolianPhoto;
}
//获取： 教练邮箱
public String getJiaolianEmail() {
return jiaolianEmail;
}
//设置： 教练邮箱
public void setJiaolianEmail(String jiaolianEmail) {
this.jiaolianEmail = jiaolianEmail;
}
//获取： 教练简介
public String getJiaolianContent() {
return jiaolianContent;
}
//设置： 教练简介
public void setJiaolianContent(String jiaolianContent) {
this.jiaolianContent = jiaolianContent;
}
//级联表的get和set 用户
//获取： 用户名称
public String getYonghuName() {
return yonghuName;
}
//设置： 用户名称
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
//获取： 用户手机号
public String getYonghuPhone() {
return yonghuPhone;
}
//设置： 用户手机号
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
//获取： 用户身份证号
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
//设置： 用户身份证号
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
//获取： 用户头像
public String getYonghuPhoto() {
return yonghuPhoto;
}
//设置： 用户头像
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
//获取： 用户邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
//设置： 用户邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
//获取： 现有余额
public Double getNewMoney() {
return newMoney;
}
//设置： 现有余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
//级联表的get和set 管理员
//获取： 医院名
public String getUusername() {
return uusername;
}
//设置： 医院名
public void setUusername(String uusername) {
this.uusername = uusername;
}
//获取： 密码
public String getUpassword() {
return upassword;
}
//设置： 密码
public void setUpassword(String upassword) {
this.upassword = upassword;
}
//获取： 角色
public String getUrole() {
return urole;
}
//设置： 角色
public void setUrole(String urole) {
this.urole = urole;
}
// 获取： 新增时间
public Date getUaddtime() {
return uaddtime;
}
//设置： 新增时间
public void setUaddtime(Date uaddtime) {
this.uaddtime = uaddtime;
}
//重复字段的get和set方法
// 获取： 重复字段 的types
public Integer getSexTypes() {
return sexTypes;
}
// 设置： 重复字段 的types
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取： 重复字段 的值
public String getSexValue() {
return sexValue;
}
// 设置： 重复字段 的值
public void setSexValue(String sexValue) {
this.sexValue = sexValue;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "ForumView{" +
", forumStateValue=" + forumStateValue +
", yonghuName=" + yonghuName +
", yonghuPhone=" + yonghuPhone +
", yonghuIdNumber=" + yonghuIdNumber +
", yonghuPhoto=" + yonghuPhoto +
", yonghuEmail=" + yonghuEmail +
", newMoney=" + newMoney +
", jiaolianName=" + jiaolianName +
", jiaolianPhone=" + jiaolianPhone +
", jiaolianPhoto=" + jiaolianPhoto +
", jiaolianEmail=" + jiaolianEmail +
", jiaolianContent=" + jiaolianContent +
"} " + super.toString();
}
}

337
src/main/java/com/entity/view/JianshenkechengCollectionView.java
Unescape View File

@ -0,0 +1,337 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入课程收藏实体类
import com.entity.JianshenkechengCollectionEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//课程收藏
// 后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng_collection")
// 继承课程收藏实体类并实现序列化接口
public class JianshenkechengCollectionView extends JianshenkechengCollectionEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//类型的值
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="类型的字典表值",type="varchar(200)")
private String jianshenkechengCollectionValue;
//级联表 健身课程
//健身课程 的 教练
@ColumnInfo(comment="教练",type="int(11)")
private Integer jianshenkechengJiaolianId;
//健身课程名称
@ColumnInfo(comment="健身课程名称",type="varchar(200)")
private String jianshenkechengName;
//健身课程照片
@ColumnInfo(comment="健身课程照片",type="varchar(200)")
private String jianshenkechengPhoto;
//课程视频
@ColumnInfo(comment="课程视频",type="varchar(200)")
private String jianshenkechengVideo;
//赞
@ColumnInfo(comment="赞",type="int(11)")
private Integer zanNumber;
//踩
@ColumnInfo(comment="踩",type="int(11)")
private Integer caiNumber;
//健身课程类型
@ColumnInfo(comment="健身课程类型",type="int(11)")
private Integer jianshenkechengTypes;
//健身课程类型的值
@ColumnInfo(comment="健身课程类型的字典表值",type="varchar(200)")
private String jianshenkechengValue;
//健身课程热度
@ColumnInfo(comment="健身课程热度",type="int(11)")
private Integer jianshenkechengClicknum;
//健身课程介绍
@ColumnInfo(comment="健身课程介绍",type="longtext")
private String jianshenkechengContent;
//级联表 用户
//用户名称
@ColumnInfo(comment="用户名称",type="varchar(200)")
private String yonghuName;
//用户手机号
@ColumnInfo(comment="用户手机号",type="varchar(200)")
private String yonghuPhone;
//用户身份证号
@ColumnInfo(comment="用户身份证号",type="varchar(200)")
private String yonghuIdNumber;
//用户头像
@ColumnInfo(comment="用户头像",type="varchar(200)")
private String yonghuPhoto;
//用户邮箱
@ColumnInfo(comment="用户邮箱",type="varchar(200)")
private String yonghuEmail;
//现有余额
@ColumnInfo(comment="现有余额",type="decimal(10,2)")
private Double newMoney;
// 无参构造方法
public JianshenkechengCollectionView() {
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public JianshenkechengCollectionView(JianshenkechengCollectionEntity jianshenkechengCollectionEntity) {
try {
BeanUtils.copyProperties(this, jianshenkechengCollectionEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的get和set方法
//获取： 类型的值
public String getJianshenkechengCollectionValue() {
return jianshenkechengCollectionValue;
}
//设置： 类型的值
public void setJianshenkechengCollectionValue(String jianshenkechengCollectionValue) {
this.jianshenkechengCollectionValue = jianshenkechengCollectionValue;
}
//级联表的get和set 健身课程
//获取：健身课程 的 教练
public Integer getJianshenkechengJiaolianId() {
return jianshenkechengJiaolianId;
}
//设置：健身课程 的 教练
public void setJianshenkechengJiaolianId(Integer jianshenkechengJiaolianId) {
this.jianshenkechengJiaolianId = jianshenkechengJiaolianId;
}
//获取： 健身课程名称
public String getJianshenkechengName() {
return jianshenkechengName;
}
//设置： 健身课程名称
public void setJianshenkechengName(String jianshenkechengName) {
this.jianshenkechengName = jianshenkechengName;
}
//获取： 健身课程照片
public String getJianshenkechengPhoto() {
return jianshenkechengPhoto;
}
//设置： 健身课程照片
public void setJianshenkechengPhoto(String jianshenkechengPhoto) {
this.jianshenkechengPhoto = jianshenkechengPhoto;
}
//获取： 课程视频
public String getJianshenkechengVideo() {
return jianshenkechengVideo;
}
//设置： 课程视频
public void setJianshenkechengVideo(String jianshenkechengVideo) {
this.jianshenkechengVideo = jianshenkechengVideo;
}
//获取： 赞
public Integer getZanNumber() {
return zanNumber;
}
//设置： 赞
public void setZanNumber(Integer zanNumber) {
this.zanNumber = zanNumber;
}
//获取： 踩
public Integer getCaiNumber() {
return caiNumber;
}
//设置： 踩
public void setCaiNumber(Integer caiNumber) {
this.caiNumber = caiNumber;
}
//获取： 健身课程类型
public Integer getJianshenkechengTypes() {
return jianshenkechengTypes;
}
//设置： 健身课程类型
public void setJianshenkechengTypes(Integer jianshenkechengTypes) {
this.jianshenkechengTypes = jianshenkechengTypes;
}
//获取： 健身课程类型的值
public String getJianshenkechengValue() {
return jianshenkechengValue;
}
//设置： 健身课程类型的值
public void setJianshenkechengValue(String jianshenkechengValue) {
this.jianshenkechengValue = jianshenkechengValue;
}
//获取： 健身课程热度
public Integer getJianshenkechengClicknum() {
return jianshenkechengClicknum;
}
//设置： 健身课程热度
public void setJianshenkechengClicknum(Integer jianshenkechengClicknum) {
this.jianshenkechengClicknum = jianshenkechengClicknum;
}
//获取： 健身课程介绍
public String getJianshenkechengContent() {
return jianshenkechengContent;
}
//设置： 健身课程介绍
public void setJianshenkechengContent(String jianshenkechengContent) {
this.jianshenkechengContent = jianshenkechengContent;
}
//级联表的get和set 用户
//获取： 用户名称
public String getYonghuName() {
return yonghuName;
}
//设置： 用户名称
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
//获取： 用户手机号
public String getYonghuPhone() {
return yonghuPhone;
}
//设置： 用户手机号
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
//获取： 用户身份证号
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
//设置： 用户身份证号
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
//获取： 用户头像
public String getYonghuPhoto() {
return yonghuPhoto;
}
//设置： 用户头像
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
//获取： 用户邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
//设置： 用户邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
//获取： 现有余额
public Double getNewMoney() {
return newMoney;
}
//设置： 现有余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "JianshenkechengCollectionView{" +
", jianshenkechengCollectionValue=" + jianshenkechengCollectionValue +
", jianshenkechengName=" + jianshenkechengName +
", jianshenkechengPhoto=" + jianshenkechengPhoto +
", jianshenkechengVideo=" + jianshenkechengVideo +
", zanNumber=" + zanNumber +
", caiNumber=" + caiNumber +
", jianshenkechengClicknum=" + jianshenkechengClicknum +
", jianshenkechengContent=" + jianshenkechengContent +
", yonghuName=" + yonghuName +
", yonghuPhone=" + yonghuPhone +
", yonghuIdNumber=" + yonghuIdNumber +
", yonghuPhoto=" + yonghuPhoto +
", yonghuEmail=" + yonghuEmail +
", newMoney=" + newMoney +
"} " + super.toString();
}
}

313
src/main/java/com/entity/view/JianshenkechengLiuyanView.java
Unescape View File

@ -0,0 +1,313 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入课程留言实体类
import com.entity.JianshenkechengLiuyanEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//课程留言
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng_liuyan")
// 继承课程留言实体类并实现序列化接口
public class JianshenkechengLiuyanView extends JianshenkechengLiuyanEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//级联表 健身课程
//健身课程 的 教练
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="教练",type="int(11)")
private Integer jianshenkechengJiaolianId;
//健身课程名称
@ColumnInfo(comment="健身课程名称",type="varchar(200)")
private String jianshenkechengName;
//健身课程照片
@ColumnInfo(comment="健身课程照片",type="varchar(200)")
private String jianshenkechengPhoto;
//课程视频
@ColumnInfo(comment="课程视频",type="varchar(200)")
private String jianshenkechengVideo;
//赞
@ColumnInfo(comment="赞",type="int(11)")
private Integer zanNumber;
//踩
@ColumnInfo(comment="踩",type="int(11)")
private Integer caiNumber;
//健身课程类型
@ColumnInfo(comment="健身课程类型",type="int(11)")
private Integer jianshenkechengTypes;
//健身课程类型的值
@ColumnInfo(comment="健身课程类型的字典表值",type="varchar(200)")
private String jianshenkechengValue;
//健身课程热度
@ColumnInfo(comment="健身课程热度",type="int(11)")
private Integer jianshenkechengClicknum;
//健身课程介绍
@ColumnInfo(comment="健身课程介绍",type="longtext")
private String jianshenkechengContent;
//级联表 用户
//用户名称
@ColumnInfo(comment="用户名称",type="varchar(200)")
private String yonghuName;
//用户手机号
@ColumnInfo(comment="用户手机号",type="varchar(200)")
private String yonghuPhone;
//用户身份证号
@ColumnInfo(comment="用户身份证号",type="varchar(200)")
private String yonghuIdNumber;
//用户头像
@ColumnInfo(comment="用户头像",type="varchar(200)")
private String yonghuPhoto;
//用户邮箱
@ColumnInfo(comment="用户邮箱",type="varchar(200)")
private String yonghuEmail;
//现有余额
@ColumnInfo(comment="现有余额",type="decimal(10,2)")
private Double newMoney;
// 无参构造方法
public JianshenkechengLiuyanView() {
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public JianshenkechengLiuyanView(JianshenkechengLiuyanEntity jianshenkechengLiuyanEntity) {
try {
BeanUtils.copyProperties(this, jianshenkechengLiuyanEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//级联表的get和set 健身课程
//获取：健身课程 的 教练
public Integer getJianshenkechengJiaolianId() {
return jianshenkechengJiaolianId;
}
//设置：健身课程 的 教练
public void setJianshenkechengJiaolianId(Integer jianshenkechengJiaolianId) {
this.jianshenkechengJiaolianId = jianshenkechengJiaolianId;
}
//获取： 健身课程名称
public String getJianshenkechengName() {
return jianshenkechengName;
}
//设置： 健身课程名称
public void setJianshenkechengName(String jianshenkechengName) {
this.jianshenkechengName = jianshenkechengName;
}
//获取： 健身课程照片
public String getJianshenkechengPhoto() {
return jianshenkechengPhoto;
}
//设置： 健身课程照片
public void setJianshenkechengPhoto(String jianshenkechengPhoto) {
this.jianshenkechengPhoto = jianshenkechengPhoto;
}
//获取： 课程视频
public String getJianshenkechengVideo() {
return jianshenkechengVideo;
}
//设置： 课程视频
public void setJianshenkechengVideo(String jianshenkechengVideo) {
this.jianshenkechengVideo = jianshenkechengVideo;
}
//获取： 赞
public Integer getZanNumber() {
return zanNumber;
}
//设置： 赞
public void setZanNumber(Integer zanNumber) {
this.zanNumber = zanNumber;
}
//获取： 踩
public Integer getCaiNumber() {
return caiNumber;
}
//设置： 踩
public void setCaiNumber(Integer caiNumber) {
this.caiNumber = caiNumber;
}
//获取： 健身课程类型
public Integer getJianshenkechengTypes() {
return jianshenkechengTypes;
}
//设置： 健身课程类型
public void setJianshenkechengTypes(Integer jianshenkechengTypes) {
this.jianshenkechengTypes = jianshenkechengTypes;
}
//获取： 健身课程类型的值
public String getJianshenkechengValue() {
return jianshenkechengValue;
}
// 设置： 健身课程类型的值
public void setJianshenkechengValue(String jianshenkechengValue) {
this.jianshenkechengValue = jianshenkechengValue;
}
//获取： 健身课程热度
public Integer getJianshenkechengClicknum() {
return jianshenkechengClicknum;
}
//设置： 健身课程热度
public void setJianshenkechengClicknum(Integer jianshenkechengClicknum) {
this.jianshenkechengClicknum = jianshenkechengClicknum;
}
//获取： 健身课程介绍
public String getJianshenkechengContent() {
return jianshenkechengContent;
}
//设置： 健身课程介绍
public void setJianshenkechengContent(String jianshenkechengContent) {
this.jianshenkechengContent = jianshenkechengContent;
}
//级联表的get和set 用户
//获取： 用户名称
public String getYonghuName() {
return yonghuName;
}
//设置： 用户名称
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
//获取： 用户手机号
public String getYonghuPhone() {
return yonghuPhone;
}
//设置： 用户手机号
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
//获取： 用户身份证号
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
//设置： 用户身份证号
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
//获取： 用户头像
public String getYonghuPhoto() {
return yonghuPhoto;
}
//设置： 用户头像
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
//获取： 用户邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
//设置： 用户邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
//获取： 现有余额
public Double getNewMoney() {
return newMoney;
}
//设置： 现有余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "JianshenkechengLiuyanView{" +
", jianshenkechengName=" + jianshenkechengName +
", jianshenkechengPhoto=" + jianshenkechengPhoto +
", jianshenkechengVideo=" + jianshenkechengVideo +
", zanNumber=" + zanNumber +
", caiNumber=" + caiNumber +
", jianshenkechengClicknum=" + jianshenkechengClicknum +
", jianshenkechengContent=" + jianshenkechengContent +
", yonghuName=" + yonghuName +
", yonghuPhone=" + yonghuPhone +
", yonghuIdNumber=" + yonghuIdNumber +
", yonghuPhoto=" + yonghuPhoto +
", yonghuEmail=" + yonghuEmail +
", newMoney=" + newMoney +
"} " + super.toString();
}
}

163
src/main/java/com/entity/view/JianshenkechengView.java
Unescape View File

@ -0,0 +1,163 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入健身课程实体类
import com.entity.JianshenkechengEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
// 健身课程
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng")
// 继承健身课程实体类并实现序列化接口
public class JianshenkechengView extends JianshenkechengEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
// 健身课程类型的值
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="健身课程类型的字典表值",type="varchar(200)")
private String jianshenkechengValue;
//级联表 教练
//教练名称
@ColumnInfo(comment="教练名称",type="varchar(200)")
private String jiaolianName;
//教练手机号
@ColumnInfo(comment="教练手机号",type="varchar(200)")
private String jiaolianPhone;
//教练头像
@ColumnInfo(comment="教练头像",type="varchar(200)")
private String jiaolianPhoto;
//教练邮箱
@ColumnInfo(comment="教练邮箱",type="varchar(200)")
private String jiaolianEmail;
//教练简介
@ColumnInfo(comment="教练简介",type="longtext")
private String jiaolianContent;
// 无参构造方法
public JianshenkechengView() {
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public JianshenkechengView(JianshenkechengEntity jianshenkechengEntity) {
try {
BeanUtils.copyProperties(this, jianshenkechengEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的get和set方法
//获取： 健身课程类型的
public String getJianshenkechengValue() {
return jianshenkechengValue;
}
//设置： 健身课程类型的值
public void setJianshenkechengValue(String jianshenkechengValue) {
this.jianshenkechengValue = jianshenkechengValue;
}
//级联表的get和set 教练
//获取： 教练名称
public String getJiaolianName() {
return jiaolianName;
}
//设置： 教练名称
public void setJiaolianName(String jiaolianName) {
this.jiaolianName = jiaolianName;
}
//获取： 教练手机号
public String getJiaolianPhone() {
return jiaolianPhone;
}
//设置： 教练手机号
public void setJiaolianPhone(String jiaolianPhone) {
this.jiaolianPhone = jiaolianPhone;
}
//获取： 教练头像
public String getJiaolianPhoto() {
return jiaolianPhoto;
}
//设置： 教练头像
public void setJiaolianPhoto(String jiaolianPhoto) {
this.jiaolianPhoto = jiaolianPhoto;
}
//获取： 教练邮
public String getJiaolianEmail() {
return jiaolianEmail;
}
//设置： 教练邮箱
public void setJiaolianEmail(String jiaolianEmail) {
this.jiaolianEmail = jiaolianEmail;
}
//获取： 教练简介
public String getJiaolianContent() {
return jiaolianContent;
}
//设置： 教练简介
public void setJiaolianContent(String jiaolianContent) {
this.jiaolianContent = jiaolianContent;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "JianshenkechengView{" +
", jianshenkechengValue=" + jianshenkechengValue +
", jiaolianName=" + jiaolianName +
", jiaolianPhone=" + jiaolianPhone +
", jiaolianPhoto=" + jiaolianPhoto +
", jiaolianEmail=" + jiaolianEmail +
", jiaolianContent=" + jiaolianContent +
"} " + super.toString();
}
}

84
src/main/java/com/entity/view/JiaolianView.java
Unescape View File

@ -0,0 +1,84 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant的日期工具类，用于日期处理
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解，用于数据库字段的元数据描述
import com.annotation.ColumnInfo;
// 导入教练实体类，表示数据库中的教练表
import com.entity.JiaolianEntity;
// 导入MyBatis Plus的注解，用于指定数据库表名
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，用于JavaBean的属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring的日期格式化注解，用于定义日期格式
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson的日期格式化注解，用于JSON序列化时的日期格式
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//教练视图类
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的注解指定数据库表名
@TableName("jiaolian")
// 继承教练实体类并实现序列化接口
public class JiaolianView extends JiaolianEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//性别的值
// 使用自定义注解描述字段信息，包括备注和数据库类型
@ColumnInfo(comment="性别的字典表值",type="varchar(200)")
// 性别值字段，存储性别的字典表值
private String sexValue;
// 无参构造方法
public JiaolianView() {
}
// 带参构造方法，通过教练实体对象初始化视图对象
public JiaolianView(JiaolianEntity jiaolianEntity) {
try {
// 使用BeanUtils复制属性值
BeanUtils.copyProperties(this, jiaolianEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的
//获取： 性别的值
// 获取性别值的方法
public String getSexValue() {
return sexValue;
}
//设置： 性别的值
// 设置性别值的方法
public void setSexValue(String sexValue) {
this.sexValue = sexValue;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "JiaolianView{" +
", sexValue=" + sexValue +
"} " + super.toString();
}
}

179
src/main/java/com/entity/view/JiaolianYuyueView.java
Unescape View File

@ -0,0 +1,179 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant工具包中的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入教练预约实体类
import com.entity.JiaolianYuyueEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson库的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//教练预约申请
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jiaolian_yuyue")
// 继承教练预约实体类并实现序列化接口
public class JiaolianYuyueView extends JiaolianYuyueEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//预约状态的值
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="预约状态的字典表值",type="varchar(200)")
private String jiaolianYuyueYesnoValue;
//级联表 用户
//用户名称
@ColumnInfo(comment="用户名称",type="varchar(200)")
private String yonghuName;
//用户手机号
@ColumnInfo(comment="用户手机号",type="varchar(200)")
private String yonghuPhone;
//用户身份证号
@ColumnInfo(comment="用户身份证号",type="varchar(200)")
private String yonghuIdNumber;
//用户头像
@ColumnInfo(comment="用户头像",type="varchar(200)")
private String yonghuPhoto;
//用户邮箱
@ColumnInfo(comment="用户邮箱",type="varchar(200)")
private String yonghuEmail;
//现有余额
@ColumnInfo(comment="现有余额",type="decimal(10,2)")
private Double newMoney;
// 无参构造方法
public JiaolianYuyueView() {
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public JiaolianYuyueView(JiaolianYuyueEntity jiaolianYuyueEntity) {
try {
// 使用BeanUtils复制属性值
BeanUtils.copyProperties(this, jiaolianYuyueEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的get和set方法
//获取： 预约状态的值
public String getJiaolianYuyueYesnoValue() {
return jiaolianYuyueYesnoValue;
}
//设置： 预约状态的值
public void setJiaolianYuyueYesnoValue(String jiaolianYuyueYesnoValue) {
this.jiaolianYuyueYesnoValue = jiaolianYuyueYesnoValue;
}
//级联表的get和set 用户
//获取： 用户名称
public String getYonghuName() {
return yonghuName;
}
//设置： 用户名称
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
//获取： 用户手机号
public String getYonghuPhone() {
return yonghuPhone;
}
//设置： 用户手机号
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
//获取： 用户身份证号
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
//设置： 用户身份证号
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
//获取： 用户头像
public String getYonghuPhoto() {
return yonghuPhoto;
}
//设置： 用户头像
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
//获取： 用户邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
//设置： 用户邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
//获取： 现有余额
public Double getNewMoney() {
return newMoney;
}
//设置： 现有余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "JiaolianYuyueView{" +
", jiaolianYuyueYesnoValue=" + jiaolianYuyueYesnoValue +
", yonghuName=" + yonghuName +
", yonghuPhone=" + yonghuPhone +
", yonghuIdNumber=" + yonghuIdNumber +
", yonghuPhoto=" + yonghuPhoto +
", yonghuEmail=" + yonghuEmail +
", newMoney=" + newMoney +
"} " + super.toString();
}
}

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

@ -0,0 +1,80 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant工具包中的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入资讯实体类
import com.entity.NewsEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson库的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//健身资讯
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("news")
// 继承资讯实体类并实现序列化接口
public class NewsView extends NewsEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//资讯类型的值
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="资讯类型的字典表值",type="varchar(200)")
private String newsValue;
// 无参构造方法
public NewsView() {
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public NewsView(NewsEntity newsEntity) {
try {
// 使用BeanUtils复制属性值
BeanUtils.copyProperties(this, newsEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的get和set方法
//获取： 资讯类型的值
public String getNewsValue() {
return newsValue;
}
//设置： 资讯类型的值
public void setNewsValue(String newsValue) {
this.newsValue = newsValue;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "NewsView{" +
", newsValue=" + newsValue +
"} " + super.toString();
}
}

83
src/main/java/com/entity/view/SingleSeachView.java
Unescape View File

@ -0,0 +1,83 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant工具包中的日期工具类
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解
import com.annotation.ColumnInfo;
// 导入单页数据实体类
import com.entity.SingleSeachEntity;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson库的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//单页数据
//后端返回视图实体辅助类
//（通常后端关联的表或者自定义的字段需要返回使用）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("single_seach")
// 继承单页数据实体类并实现序列化接口
public class SingleSeachView extends SingleSeachEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//当前表
//数据类型的值
// 使用ColumnInfo注解标注字段的注释和类型
@ColumnInfo(comment="数据类型的字典表值",type="varchar(200)")
private String singleSeachValue;
// 无参构造方法
public SingleSeachView() {
// 空构造方法
}
// 带参构造方法，通过BeanUtils.copyProperties复制属性
public SingleSeachView(SingleSeachEntity singleSeachEntity) {
try {
// 使用BeanUtils复制属性值
BeanUtils.copyProperties(this, singleSeachEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
//当前表的get和set方法
//获取：数据类型的值
//@return 数据类型的值
public String getSingleSeachValue() {
return singleSeachValue;
}
//设置：数据类型的值
//@param singleSeachValue 要设置的数据类型的值
public void setSingleSeachValue(String singleSeachValue) {
this.singleSeachValue = singleSeachValue;
}
// 重写toString方法，返回对象的字符串表示
@Override
public String toString() {
return "SingleSeachView{" +
", singleSeachValue=" + singleSeachValue +
"} " + super.toString();
}
}

88
src/main/java/com/entity/view/YonghuView.java
Unescape View File

@ -0,0 +1,88 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.view;
// 导入Apache Ant工具包中的日期工具类，用于日期处理
import org.apache.tools.ant.util.DateUtils;
// 导入自定义的列信息注解，用于数据库字段映射
import com.annotation.ColumnInfo;
// 导入用户实体类，作为基类继承
import com.entity.YonghuEntity;
// 导入MyBatis Plus的表名注解，用于指定数据库表
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，用于对象属性复制
import org.apache.commons.beanutils.BeanUtils;
// 导入反射相关的异常类
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson库的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入序列化接口
import java.io.Serializable;
// 导入日期类
import java.util.Date;
// 导入自定义的日期工具类
import com.utils.DateUtil;
//用户视图类
//后端返回视图实体辅助类
//（通常用于后端关联表或自定义字段的返回）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("yonghu")
// 继承用户实体类并实现序列化接口
public class YonghuView extends YonghuEntity implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 当前表字段
//性别的字典值
//用于存储性别类型的字典表对应值
// 使用ColumnInfo注解标注字段的注释和数据库类型
@ColumnInfo(comment="性别的字典表值",type="varchar(200)")
private String sexValue;
// 无参构造方法
public YonghuView() {
// 空构造方法
}
// 带参构造方法
//通过用户实体对象构造视图对象
//@param yonghuEntity 用户实体对象
public YonghuView(YonghuEntity yonghuEntity) {
try {
// 使用BeanUtils复制属性值
BeanUtils.copyProperties(this, yonghuEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// 打印异常堆栈信息
e.printStackTrace();
}
}
// getter和setter方法
//获取性别字典值
//@return 性别字典值
public String getSexValue() {
return sexValue;
}
//设置性别字典值
//@param sexValue 要设置的性别字典值
public void setSexValue(String sexValue) {
this.sexValue = sexValue;
}
// 重写toString方法
//返回对象的字符串表示
//@return 对象的字符串表示
@Override
public String toString() {
return "YonghuView{" +
", sexValue=" + sexValue +
"} " + super.toString();
}
}

190
src/main/java/com/entity/vo/DictionaryVO.java
Unescape View File

@ -0,0 +1,190 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.vo;
// 导入字典实体类
import com.entity.DictionaryEntity;
// 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入日期类
import java.util.Date;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入序列化接口
import java.io.Serializable;
//字典VO类
//手机端接口返回实体辅助类
//（主要作用去除一些不必要的字段，简化返回数据）
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("dictionary")
// 实现序列化接口
public class DictionaryVO implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
//主键ID
// 使用TableField注解映射数据库字段
@TableField(value = "id")
private Long id;
//字典编码
//表示字典类型的唯一标识
@TableField(value = "dic_code")
private String dicCode;
//字典名称
//表示字典类型的显示名称
@TableField(value = "dic_name")
private String dicName;
//编码索引
//表示字典项的数字编码
@TableField(value = "code_index")
private Integer codeIndex;
//编码名称
//表示字典项的显示名称
@TableField(value = "index_name")
private String indexName;
//父级ID
//表示父级字典项的ID
@TableField(value = "super_id")
private Integer superId;
//备注信息
//存储额外的描述信息
@TableField(value = "beizhu")
private String beizhu;
//创建时间
//记录数据创建时间
// 使用Jackson和Spring的日期格式化注解
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
//获取主键ID
//@return 主键ID
public Long getId() {
return id;
}
//设置主键ID
//@param id 要设置的主键ID
public void setId(Long id) {
this.id = id;
}
//获取字典编码
//@return 字典编码
public String getDicCode() {
return dicCode;
}
//设置字典编码
//@param dicCode 要设置的字典编码
public void setDicCode(String dicCode) {
this.dicCode = dicCode;
}
//获取字典名称
//@return 字典名称
public String getDicName() {
return dicName;
}
//设置字典名称
//@param dicName 要设置的字典名称
public void setDicName(String dicName) {
this.dicName = dicName;
}
//获取编码索引
//@return 编码索引
public Integer getCodeIndex() {
return codeIndex;
}
//设置编码索引
//@param codeIndex 要设置的编码索引
public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex;
}
//获取编码名称
//@return 编码名称
public String getIndexName() {
return indexName;
}
//设置编码名称
//@param indexName 要设置的编码名称
public void setIndexName(String indexName) {
this.indexName = indexName;
}
//获取父级ID
//@return 父级ID
public Integer getSuperId() {
return superId;
}
//设置父级ID
//@param superId 要设置的父级ID
public void setSuperId(Integer superId) {
this.superId = superId;
}
//获取备注信息
//@return 备注信息
public String getBeizhu() {
return beizhu;
}
//设置备注信息
//@param beizhu 要设置的备注信息
public void setBeizhu(String beizhu) {
this.beizhu = beizhu;
}
//获取创建时间
//@return 创建时间
public Date getCreateTime() {
return createTime;
}
//设置创建时间
//@param createTime 要设置的创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

189
src/main/java/com/entity/vo/ForumVO.java
Unescape View File

@ -0,0 +1,189 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.vo;
// 导入健身论坛实体类
import com.entity.ForumEntity;
// 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入日期类
import java.util.Date;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入序列化接口
import java.io.Serializable;
//健身论坛VO类
//手机端接口返回实体辅助类
//主要用于去除一些不必要的字段，简化返回数据
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("forum")
// 实现序列化接口
public class ForumVO implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
@TableField(value = "id")
private Integer id;
// 帖子标题
@TableField(value = "forum_name")
private String forumName;
// 关联用户ID
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 关联教练ID
@TableField(value = "jiaolian_id")
private Integer jiaolianId;
// 关联管理员ID
@TableField(value = "users_id")
private Integer usersId;
// 帖子内容
@TableField(value = "forum_content")
private String forumContent;
// 父级帖子ID
@TableField(value = "super_ids")
private Integer superIds;
// 帖子状态
@TableField(value = "forum_state_types")
private Integer forumStateTypes;
// 发帖时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 修改时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "update_time")
private Date updateTime;
// 创建时间（show2）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取帖子标题
public String getForumName() {
return forumName;
}
// 设置帖子标题
public void setForumName(String forumName) {
this.forumName = forumName;
}
// 获取关联用户ID
public Integer getYonghuId() {
return yonghuId;
}
// 设置关联用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 获取关联教练ID
public Integer getJiaolianId() {
return jiaolianId;
}
// 设置关联教练ID
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
// 获取关联管理员ID
public Integer getUsersId() {
return usersId;
}
// 设置关联管理员ID
public void setUsersId(Integer usersId) {
this.usersId = usersId;
}
// 获取帖子内容
public String getForumContent() {
return forumContent;
}
// 设置帖子内容
public void setForumContent(String forumContent) {
this.forumContent = forumContent;
}
// 获取父级帖子ID
public Integer getSuperIds() {
return superIds;
}
// 设置父级帖子ID
public void setSuperIds(Integer superIds) {
this.superIds = superIds;
}
// 获取帖子状态
public Integer getForumStateTypes() {
return forumStateTypes;
}
// 设置帖子状态
public void setForumStateTypes(Integer forumStateTypes) {
this.forumStateTypes = forumStateTypes;
}
// 获取发帖时间
public Date getInsertTime() {
return insertTime;
}
// 设置发帖时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取修改时间
public Date getUpdateTime() {
return updateTime;
}
// 设置修改时间
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
// 获取创建时间（show2）
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（show2）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

116
src/main/java/com/entity/vo/JianshenkechengCollectionVO.java
Unescape View File

@ -0,0 +1,116 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.vo;
// 导入课程收藏实体类
import com.entity.JianshenkechengCollectionEntity;
// 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入日期类
import java.util.Date;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入序列化接口
import java.io.Serializable;
// 课程收藏VO类
// 手机端接口返回实体辅助类
// 主要用于去除一些不必要的字段，简化返回数据
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng_collection")
// 实现序列化接口
public class JianshenkechengCollectionVO implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
@TableField(value = "id")
private Integer id;
// 关联的健身课程ID
@TableField(value = "jianshenkecheng_id")
private Integer jianshenkechengId;
// 关联的用户ID
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 收藏类型
@TableField(value = "jianshenkecheng_collection_types")
private Integer jianshenkechengCollectionTypes;
// 收藏时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 创建时间（show3 photoShow）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取关联的健身课程ID
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
// 设置关联的健身课程ID
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
// 获取关联的用户ID
public Integer getYonghuId() {
return yonghuId;
}
// 设置关联的用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 获取收藏类型
public Integer getJianshenkechengCollectionTypes() {
return jianshenkechengCollectionTypes;
}
// 设置收藏类型
public void setJianshenkechengCollectionTypes(Integer jianshenkechengCollectionTypes) {
this.jianshenkechengCollectionTypes = jianshenkechengCollectionTypes;
}
// 获取收藏时间
public Date getInsertTime() {
return insertTime;
}
// 设置收藏时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取创建时间（show3 photoShow）
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（show3 photoShow）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

146
src/main/java/com/entity/vo/JianshenkechengLiuyanVO.java
Unescape View File

@ -0,0 +1,146 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.vo;
// 导入课程留言实体类
import com.entity.JianshenkechengLiuyanEntity;
// 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入日期类
import java.util.Date;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入序列化接口
import java.io.Serializable;
// 课程留言VO类
// 手机端接口返回实体辅助类
// 主要用于去除一些不必要的字段，简化返回数据
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng_liuyan")
// 实现序列化接口
public class JianshenkechengLiuyanVO implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
@TableField(value = "id")
private Integer id;
// 关联的健身课程ID
@TableField(value = "jianshenkecheng_id")
private Integer jianshenkechengId;
// 关联的用户ID
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 留言内容
@TableField(value = "jianshenkecheng_liuyan_text")
private String jianshenkechengLiuyanText;
// 留言时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 回复内容
@TableField(value = "reply_text")
private String replyText;
// 回复时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "update_time")
private Date updateTime;
// 创建时间（show3 listShow）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取关联的健身课程ID
public Integer getJianshenkechengId() {
return jianshenkechengId;
}
// 设置关联的健身课程ID
public void setJianshenkechengId(Integer jianshenkechengId) {
this.jianshenkechengId = jianshenkechengId;
}
// 获取关联的用户ID
public Integer getYonghuId() {
return yonghuId;
}
// 设置关联的用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 获取留言内容
public String getJianshenkechengLiuyanText() {
return jianshenkechengLiuyanText;
}
// 设置留言内容
public void setJianshenkechengLiuyanText(String jianshenkechengLiuyanText) {
this.jianshenkechengLiuyanText = jianshenkechengLiuyanText;
}
// 获取留言时间
public Date getInsertTime() {
return insertTime;
}
// 设置留言时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取回复内容
public String getReplyText() {
return replyText;
}
// 设置回复内容
public void setReplyText(String replyText) {
this.replyText = replyText;
}
// 获取回复时间
public Date getUpdateTime() {
return updateTime;
}
// 设置回复时间
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
// 获取创建时间（show3 listShow）
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（show3 listShow）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

214
src/main/java/com/entity/vo/JianshenkechengVO.java
Unescape View File

@ -0,0 +1,214 @@
// 定义包路径，表示该文件所在的目录结构
package com.entity.vo;
// 导入健身课程实体类
import com.entity.JianshenkechengEntity;
// 导入MyBatis Plus的表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus的表名注解
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson的日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入日期类
import java.util.Date;
// 导入Spring框架的日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 导入序列化接口
import java.io.Serializable;
// 健身课程VO类
// 手机端接口返回实体辅助类
// 主要用于去除一些不必要的字段，简化返回数据
// 使用MyBatis Plus的TableName注解指定数据库表名
@TableName("jianshenkecheng")
// 实现序列化接口
public class JianshenkechengVO implements Serializable {
// 序列化版本UID，用于版本控制
private static final long serialVersionUID = 1L;
// 主键ID
@TableField(value = "id")
private Integer id;
// 关联的教练ID
@TableField(value = "jiaolian_id")
private Integer jiaolianId;
// 健身课程名称
@TableField(value = "jianshenkecheng_name")
private String jianshenkechengName;
// 健身课程封面照片URL
@TableField(value = "jianshenkecheng_photo")
private String jianshenkechengPhoto;
// 课程视频URL
@TableField(value = "jianshenkecheng_video")
private String jianshenkechengVideo;
// 点赞数量
@TableField(value = "zan_number")
private Integer zanNumber;
// 踩数量
@TableField(value = "cai_number")
private Integer caiNumber;
// 健身课程类型（关联字典表）
@TableField(value = "jianshenkecheng_types")
private Integer jianshenkechengTypes;
// 课程点击量/热度
@TableField(value = "jianshenkecheng_clicknum")
private Integer jianshenkechengClicknum;
// 课程详细介绍内容
@TableField(value = "jianshenkecheng_content")
private String jianshenkechengContent;
// 逻辑删除标志（1表示已删除）
@TableField(value = "data_delete")
private Integer dataDelete;
// 课程录入时间
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 创建时间（用于show1 show2 photoShow homeMain等多个展示场景）
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取关联的教练ID
public Integer getJiaolianId() {
return jiaolianId;
}
// 设置关联的教练ID
public void setJiaolianId(Integer jiaolianId) {
this.jiaolianId = jiaolianId;
}
// 获取健身课程名称
public String getJianshenkechengName() {
return jianshenkechengName;
}
// 设置健身课程名称
public void setJianshenkechengName(String jianshenkechengName) {
this.jianshenkechengName = jianshenkechengName;
}
// 获取健身课程封面照片URL
public String getJianshenkechengPhoto() {
return jianshenkechengPhoto;
}
// 设置健身课程封面照片URL
public void setJianshenkechengPhoto(String jianshenkechengPhoto) {
this.jianshenkechengPhoto = jianshenkechengPhoto;
}
// 获取课程视频URL
public String getJianshenkechengVideo() {
return jianshenkechengVideo;
}
// 设置课程视频URL
public void setJianshenkechengVideo(String jianshenkechengVideo) {
this.jianshenkechengVideo = jianshenkechengVideo;
}
// 获取点赞数量
public Integer getZanNumber() {
return zanNumber;
}
// 设置点赞数量
public void setZanNumber(Integer zanNumber) {
this.zanNumber = zanNumber;
}
// 获取踩数量
public Integer getCaiNumber() {
return caiNumber;
}
// 设置踩数量
public void setCaiNumber(Integer caiNumber) {
this.caiNumber = caiNumber;
}
// 获取健身课程类型
public Integer getJianshenkechengTypes() {
return jianshenkechengTypes;
}
// 设置健身课程类型
public void setJianshenkechengTypes(Integer jianshenkechengTypes) {
this.jianshenkechengTypes = jianshenkechengTypes;
}
// 获取课程点击量/热度
public Integer getJianshenkechengClicknum() {
return jianshenkechengClicknum;
}
// 设置课程点击量/热度
public void setJianshenkechengClicknum(Integer jianshenkechengClicknum) {
this.jianshenkechengClicknum = jianshenkechengClicknum;
}
// 获取课程详细介绍内容
public String getJianshenkechengContent() {
return jianshenkechengContent;
}
// 设置课程详细介绍内容
public void setJianshenkechengContent(String jianshenkechengContent) {
this.jianshenkechengContent = jianshenkechengContent;
}
// 获取逻辑删除标志
public Integer getDataDelete() {
return dataDelete;
}
// 设置逻辑删除标志
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 获取课程录入时间
public Date getInsertTime() {
return insertTime;
}
// 设置课程录入时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取创建时间（用于多个展示场景）
public Date getCreateTime() {
return createTime;
}
// 设置创建时间（用于多个展示场景）
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

198
src/main/java/com/entity/vo/JiaolianVO.java
Unescape View File

@ -0,0 +1,198 @@
// 包声明
package com.entity.vo;
// 导入原教练实体类
import com.entity.JiaolianEntity;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java核心库
import java.io.Serializable;
import java.util.Date;
// 导入Spring日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 教练手机端接口返回实体辅助类（精简字段）
@TableName("jiaolian")
public class JiaolianVO implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键字段（自增）
@TableField(value = "id")
private Integer id;
// 登录账户（唯一标识）
@TableField(value = "username")
private String username;
// 登录密码（加密存储）
@TableField(value = "password")
private String password;
// 教练真实姓名
@TableField(value = "jiaolian_name")
private String jiaolianName;
// 教练联系电话
@TableField(value = "jiaolian_phone")
private String jiaolianPhone;
// 教练头像存储路径
@TableField(value = "jiaolian_photo")
private String jiaolianPhoto;
// 性别类型（0=未知,1=男,2=女）
@TableField(value = "sex_types")
private Integer sexTypes;
// 教练联系邮箱
@TableField(value = "jiaolian_email")
private String jiaolianEmail;
// 教练详细介绍（支持富文本）
@TableField(value = "jiaolian_content")
private String jiaolianContent;
// 逻辑删除标记（0=正常,1=删除）
@TableField(value = "data_delete")
private Integer dataDelete;
// 数据入库时间（带中文时区格式化）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 记录创建时间（支持多种展示模式）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取登录账户
public String getUsername() {
return username;
}
// 设置登录账户
public void setUsername(String username) {
this.username = username;
}
// 获取登录密码
public String getPassword() {
return password;
}
// 设置登录密码
public void setPassword(String password) {
this.password = password;
}
// 获取教练姓名
public String getJiaolianName() {
return jiaolianName;
}
// 设置教练姓名
public void setJiaolianName(String jiaolianName) {
this.jiaolianName = jiaolianName;
}
// 获取联系电话
public String getJiaolianPhone() {
return jiaolianPhone;
}
// 设置联系电话
public void setJiaolianPhone(String jiaolianPhone) {
this.jiaolianPhone = jiaolianPhone;
}
// 获取头像路径
public String getJiaolianPhoto() {
return jiaolianPhoto;
}
// 设置头像路径
public void setJiaolianPhoto(String jiaolianPhoto) {
this.jiaolianPhoto = jiaolianPhoto;
}
// 获取性别类型
public Integer getSexTypes() {
return sexTypes;
}
// 设置性别类型
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取联系邮箱
public String getJiaolianEmail() {
return jiaolianEmail;
}
// 设置联系邮箱
public void setJiaolianEmail(String jiaolianEmail) {
this.jiaolianEmail = jiaolianEmail;
}
// 获取详细介绍
public String getJiaolianContent() {
return jiaolianContent;
}
// 设置详细介绍
public void setJiaolianContent(String jiaolianContent) {
this.jiaolianContent = jiaolianContent;
}
// 获取逻辑删除状态
public Integer getDataDelete() {
return dataDelete;
}
// 设置逻辑删除状态
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 获取数据入库时间
public Date getInsertTime() {
return insertTime;
}
// 设置数据入库时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取记录创建时间（支持列表/详情/头像展示模式）
public Date getCreateTime() {
return createTime;
}
// 设置记录创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

158
src/main/java/com/entity/vo/JiaolianYuyueVO.java
Unescape View File

@ -0,0 +1,158 @@
// 包声明
package com.entity.vo;
// 导入原教练预约实体类
import com.entity.JiaolianYuyueEntity;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java核心库
import java.io.Serializable;
import java.util.Date;
// 导入Spring日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 教练预约申请手机端接口返回实体辅助类（精简字段）
@TableName("jiaolian_yuyue")
public class JiaolianYuyueVO implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键字段
@TableField(value = "id")
private Integer id;
// 预约唯一标识编号（UUID生成）
@TableField(value = "jiaolian_yuyue_uuid_number")
private String jiaolianYuyueUuidNumber;
// 关联用户表主键（外键）
@TableField(value = "yonghu_id")
private Integer yonghuId;
// 用户填写的预约备注信息
@TableField(value = "jiaolian_yuyue_text")
private String jiaolianYuyueText;
// 预约的具体时间（带中文时区格式化）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "jiaolian_yuyue_time")
private Date jiaolianYuyueTime;
// 预约审核状态（0=待处理,1=通过,2=拒绝）
@TableField(value = "jiaolian_yuyue_yesno_types")
private Integer jiaolianYuyueYesnoTypes;
// 管理员审核后的回复内容
@TableField(value = "jiaolian_yuyue_yesno_text")
private String jiaolianYuyueYesnoText;
// 用户提交申请的时间
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 记录创建时间（带格式化注解，支持多种显示模式）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取预约唯一编号
public String getJiaolianYuyueUuidNumber() {
return jiaolianYuyueUuidNumber;
}
// 设置预约唯一编号
public void setJiaolianYuyueUuidNumber(String jiaolianYuyueUuidNumber) {
this.jiaolianYuyueUuidNumber = jiaolianYuyueUuidNumber;
}
// 获取关联用户ID
public Integer getYonghuId() {
return yonghuId;
}
// 设置关联用户ID
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
// 获取预约备注内容
public String getJiaolianYuyueText() {
return jiaolianYuyueText;
}
// 设置预约备注内容
public void setJiaolianYuyueText(String jiaolianYuyueText) {
this.jiaolianYuyueText = jiaolianYuyueText;
}
// 获取预约具体时间
public Date getJiaolianYuyueTime() {
return jiaolianYuyueTime;
}
// 设置预约具体时间
public void setJiaolianYuyueTime(Date jiaolianYuyueTime) {
this.jiaolianYuyueTime = jiaolianYuyueTime;
}
// 获取审核状态标识
public Integer getJiaolianYuyueYesnoTypes() {
return jiaolianYuyueYesnoTypes;
}
// 设置审核状态标识
public void setJiaolianYuyueYesnoTypes(Integer jiaolianYuyueYesnoTypes) {
this.jiaolianYuyueYesnoTypes = jiaolianYuyueYesnoTypes;
}
// 获取审核回复内容
public String getJiaolianYuyueYesnoText() {
return jiaolianYuyueYesnoText;
}
// 设置审核回复内容
public void setJiaolianYuyueYesnoText(String jiaolianYuyueYesnoText) {
this.jiaolianYuyueYesnoText = jiaolianYuyueYesnoText;
}
// 获取申请提交时间
public Date getInsertTime() {
return insertTime;
}
// 设置申请提交时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取记录创建时间（支持列表和详情展示格式）
public Date getCreateTime() {
return createTime;
}
// 设置记录创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

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

@ -0,0 +1,128 @@
// 包声明
package com.entity.vo;
// 导入原资讯实体类
import com.entity.NewsEntity;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java核心库
import java.io.Serializable;
import java.util.Date;
// 导入Spring日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 健身资讯手机端接口返回实体辅助类（精简字段）
@TableName("news")
public class NewsVO implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键字段
@TableField(value = "id")
private Integer id;
// 资讯标题（最大长度200）
@TableField(value = "news_name")
private String newsName;
// 资讯类型标识（通过数字表示不同类型）
@TableField(value = "news_types")
private Integer newsTypes;
// 资讯封面图存储路径
@TableField(value = "news_photo")
private String newsPhoto;
// 数据添加时间（带中文时区格式化）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 资讯详细内容（HTML格式文本）
@TableField(value = "news_content")
private String newsContent;
// 记录创建时间（带格式化注解）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取资讯标题
public String getNewsName() {
return newsName;
}
// 设置资讯标题
public void setNewsName(String newsName) {
this.newsName = newsName;
}
// 获取资讯类型标识
public Integer getNewsTypes() {
return newsTypes;
}
// 设置资讯类型标识
public void setNewsTypes(Integer newsTypes) {
this.newsTypes = newsTypes;
}
// 获取封面图路径
public String getNewsPhoto() {
return newsPhoto;
}
// 设置封面图路径
public void setNewsPhoto(String newsPhoto) {
this.newsPhoto = newsPhoto;
}
// 获取数据添加时间
public Date getInsertTime() {
return insertTime;
}
// 设置数据添加时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取资讯详细内容
public String getNewsContent() {
return newsContent;
}
// 设置资讯详细内容
public void setNewsContent(String newsContent) {
this.newsContent = newsContent;
}
// 获取记录创建时间（支持多种显示格式）
public Date getCreateTime() {
return createTime;
}
// 设置记录创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

112
src/main/java/com/entity/vo/SingleSeachVO.java
Unescape View File

@ -0,0 +1,112 @@
// 包声明
package com.entity.vo;
// 导入原实体类
import com.entity.SingleSeachEntity;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java核心库
import java.io.Serializable;
import java.util.Date;
// 导入Spring日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 单页数据手机端接口返回实体辅助类（精简字段）
@TableName("single_seach")
public class SingleSeachVO implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键字段
@TableField(value = "id")
private Integer id;
// 数据项名称
@TableField(value = "single_seach_name")
private String singleSeachName;
// 数据类型标识（通过数字表示不同类型）
@TableField(value = "single_seach_types")
private Integer singleSeachTypes;
// 关联图片存储路径
@TableField(value = "single_seach_photo")
private String singleSeachPhoto;
// 数据内容（长文本）
@TableField(value = "single_seach_content")
private String singleSeachContent;
// 记录创建时间（带格式化注解）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取数据项名称
public String getSingleSeachName() {
return singleSeachName;
}
// 设置数据项名称
public void setSingleSeachName(String singleSeachName) {
this.singleSeachName = singleSeachName;
}
// 获取数据类型标识
public Integer getSingleSeachTypes() {
return singleSeachTypes;
}
// 设置数据类型标识
public void setSingleSeachTypes(Integer singleSeachTypes) {
this.singleSeachTypes = singleSeachTypes;
}
// 获取图片路径
public String getSingleSeachPhoto() {
return singleSeachPhoto;
}
// 设置图片路径
public void setSingleSeachPhoto(String singleSeachPhoto) {
this.singleSeachPhoto = singleSeachPhoto;
}
// 获取数据内容
public String getSingleSeachContent() {
return singleSeachContent;
}
// 设置数据内容
public void setSingleSeachContent(String singleSeachContent) {
this.singleSeachContent = singleSeachContent;
}
// 获取创建时间（带中文时区格式化）
public Date getCreateTime() {
return createTime;
}
// 设置创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

212
src/main/java/com/entity/vo/YonghuVO.java
Unescape View File

@ -0,0 +1,212 @@
// 包声明
package com.entity.vo;
// 导入原用户实体类
import com.entity.YonghuEntity;
// 导入MyBatis Plus表字段注解
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson日期格式化注解
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java核心库
import java.io.Serializable;
import java.util.Date;
// 导入Spring日期格式化注解
import org.springframework.format.annotation.DateTimeFormat;
// 用户手机端接口返回实体辅助类（精简字段）
@TableName("yonghu")
public class YonghuVO implements Serializable {
// 序列化版本UID
private static final long serialVersionUID = 1L;
// 主键字段
@TableField(value = "id")
private Integer id;
// 用户登录账户
@TableField(value = "username")
private String username;
// 用户登录密码
@TableField(value = "password")
private String password;
// 用户真实姓名
@TableField(value = "yonghu_name")
private String yonghuName;
// 用户手机号码
@TableField(value = "yonghu_phone")
private String yonghuPhone;
// 用户身份证号码
@TableField(value = "yonghu_id_number")
private String yonghuIdNumber;
// 用户头像存储路径
@TableField(value = "yonghu_photo")
private String yonghuPhoto;
// 性别类型（0=未知,1=男,2=女）
@TableField(value = "sex_types")
private Integer sexTypes;
// 用户电子邮箱
@TableField(value = "yonghu_email")
private String yonghuEmail;
// 用户账户余额
@TableField(value = "new_money")
private Double newMoney;
// 逻辑删除标记（0=正常,1=删除）
@TableField(value = "data_delete")
private Integer dataDelete;
// 数据插入时间（带格式化注解）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time")
private Date insertTime;
// 记录创建时间（带格式化注解）
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time")
private Date createTime;
// 获取主键ID
public Integer getId() {
return id;
}
// 设置主键ID
public void setId(Integer id) {
this.id = id;
}
// 获取登录账户
public String getUsername() {
return username;
}
// 设置登录账户
public void setUsername(String username) {
this.username = username;
}
// 获取登录密码
public String getPassword() {
return password;
}
// 设置登录密码
public void setPassword(String password) {
this.password = password;
}
// 获取用户真实姓名
public String getYonghuName() {
return yonghuName;
}
// 设置用户真实姓名
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
// 获取手机号码
public String getYonghuPhone() {
return yonghuPhone;
}
// 设置手机号码
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
// 获取身份证号码
public String getYonghuIdNumber() {
return yonghuIdNumber;
}
// 设置身份证号码
public void setYonghuIdNumber(String yonghuIdNumber) {
this.yonghuIdNumber = yonghuIdNumber;
}
// 获取头像路径
public String getYonghuPhoto() {
return yonghuPhoto;
}
// 设置头像路径
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
// 获取性别类型
public Integer getSexTypes() {
return sexTypes;
}
// 设置性别类型
public void setSexTypes(Integer sexTypes) {
this.sexTypes = sexTypes;
}
// 获取电子邮箱
public String getYonghuEmail() {
return yonghuEmail;
}
// 设置电子邮箱
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
// 获取账户余额
public Double getNewMoney() {
return newMoney;
}
// 设置账户余额
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 获取逻辑删除状态
public Integer getDataDelete() {
return dataDelete;
}
// 设置逻辑删除状态
public void setDataDelete(Integer dataDelete) {
this.dataDelete = dataDelete;
}
// 获取数据插入时间
public Date getInsertTime() {
return insertTime;
}
// 设置数据插入时间
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
// 获取记录创建时间
public Date getCreateTime() {
return createTime;
}
// 设置记录创建时间
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}

126
src/main/java/com/interceptor/AuthorizationInterceptor.java
Unescape View File

@ -0,0 +1,126 @@
// 包声明，定义当前类所在的包路径
package com.interceptor;
// 导入Java IO包中的IOException类，用于处理输入输出异常
import java.io.IOException;
// 导入Java IO包中的PrintWriter类，用于向客户端输出数据
import java.io.PrintWriter;
// 导入Java util包中的HashMap类，用于存储键值对数据
import java.util.HashMap;
// 导入Java util包中的Map接口，用于定义键值对集合
import java.util.Map;
// 导入FastJSON的JSONObject类，用于处理JSON数据
import com.alibaba.fastjson.JSONObject;
// 导入Servlet包中的HttpServletRequest类，用于处理HTTP请求
import javax.servlet.http.HttpServletRequest;
// 导入Servlet包中的HttpServletResponse类，用于处理HTTP响应
import javax.servlet.http.HttpServletResponse;
// 导入Apache Commons Lang库中的StringUtils类，用于字符串处理
import org.apache.commons.lang3.StringUtils;
// 导入Spring框架的Autowired注解，用于自动装配依赖
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架的Component注解，标识该类为Spring组件
import org.springframework.stereotype.Component;
// 导入Spring Web包中的HandlerMethod类，用于处理方法级别的处理器
import org.springframework.web.method.HandlerMethod;
// 导入Spring Web MVC包中的HandlerInterceptor接口，用于定义拦截器
import org.springframework.web.servlet.HandlerInterceptor;
// 导入自定义的IgnoreAuth注解，用于标记不需要认证的方法
import com.annotation.IgnoreAuth;
// 导入自定义的EIException异常类，用于处理业务异常
import com.entity.EIException;
// 导入自定义的TokenEntity实体类，用于表示令牌信息
import com.entity.TokenEntity;
// 导入自定义的TokenService服务类，用于处理令牌相关逻辑
import com.service.TokenService;
// 导入自定义的R工具类，用于封装统一响应格式
import com.utils.R;
// 权限(Token)验证拦截器
@Component
public class AuthorizationInterceptor implements HandlerInterceptor {
// 登录Token的键名
public static final String LOGIN_TOKEN_KEY = "Token";
@Autowired
private TokenService tokenService; // 自动注入Token服务
@Override
//在请求处理之前进行拦截
// @param request HTTP请求对象
// @param response HTTP响应对象
//@param handler 处理器对象
// @return 如果返回true，则继续处理请求；如果返回false，则中断请求处理
// @throws Exception 处理过程中可能抛出的异常
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 获取请求路径
String servletPath = request.getServletPath();
// 如果是字典表或文件上传或用户注册接口，直接放行
if("/dictionary/page".equals(request.getServletPath()) || "/file/upload".equals(request.getServletPath()) || "/yonghu/register".equals(request.getServletPath()) ){
return true;
}
// 支持跨域请求
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
response.setHeader("Access-Control-Max-Age", "3600");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
IgnoreAuth annotation;
// 如果handler是方法处理器，则尝试获取IgnoreAuth注解
if (handler instanceof HandlerMethod) {
annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class);
} else {
return true; // 如果不是方法处理器，直接放行
}
//从header中获取token
String token = request.getHeader(LOGIN_TOKEN_KEY);
/**
* 不需要验证权限的方法直接放过
*/
if(annotation!=null) {
return true; // 如果存在IgnoreAuth注解，直接放行
}
TokenEntity tokenEntity = null;
// 如果token不为空，验证token
if(StringUtils.isNotBlank(token)) {
tokenEntity = tokenService.getTokenEntity(token);
}
// 如果token有效，设置session属性并放行
if(tokenEntity != null) {
request.getSession().setAttribute("userId", tokenEntity.getUserid());
request.getSession().setAttribute("role", tokenEntity.getRole());
request.getSession().setAttribute("tableName", tokenEntity.getTablename());
request.getSession().setAttribute("username", tokenEntity.getUsername());
return true;
}
PrintWriter writer = null;
response.setCharacterEncoding("UTF-8"); // 设置响应字符编码为UTF-8
response.setContentType("application/json; charset=utf-8"); // 设置响应内容类型为JSON
try {
writer = response.getWriter(); // 获取响应输出流
writer.print(JSONObject.toJSONString(R.error(401, "请先登录"))); // 返回错误信息
} finally {
if(writer != null){
writer.close(); // 关闭响应输出流
}
}
// throw new EIException("请先登录", 401); // 抛出未登录异常，已注释掉
return false; // 返回false，中断请求处理
}
}

26
src/main/java/com/jianshenfangglApplication.java
Unescape View File

@ -0,0 +1,26 @@
package com; // 定义包名为com，表示该文件位于com包下
// 导入Spring Boot和MyBatis相关的注解和类
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication // 标识这是一个Spring Boot应用程序的主类，包含自动配置、组件扫描等功能
@ServletComponentScan(value = "com.ServletContextListener") // 指定扫描Servlet组件的包路径，用于注册Servlet、Filter等
@MapperScan(basePackages = {"com.dao"}) // 指定MyBatis的Mapper接口所在的包路径，Spring会自动扫描并注册这些接口
public class jianshenfangglApplication extends SpringBootServletInitializer { // 主类继承SpringBootServletInitializer，支持以WAR包形式部署
public static void main(String[] args) {
// 主方法，启动Spring Boot应用程序
SpringApplication.run(jianshenfangglApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder applicationBuilder) {
// 重写configure方法，用于配置Spring Boot应用程序的启动源，支持外部容器（如Tomcat）部署
return applicationBuilder.sources(jianshenfangglApplication.class);
}
}

51
src/main/java/com/model/enums/TypeEnum.java
Unescape View File

@ -0,0 +1,51 @@
// 包声明，定义当前文件所在的包路径
package com.model.enums;
// 导入Java的序列化接口，用于标记类的实例可以被序列化
import java.io.Serializable;
// 导入MyBatis-Plus的枚举接口，用于支持枚举类型的数据库映射
import com.baomidou.mybatisplus.enums.IEnum;
//类型枚举类，继承自MyBatis-Plus的IEnum接口，用于定义不同的状态类型。
// 必须在IEnum中配置该包扫描自动注入，查看文件spring-mybatis.xml中的参数typeEnumsPackage。
public enum TypeEnum implements IEnum {
// 定义枚举值DISABLED，表示禁用状态，值为0，描述为"禁用"
DISABLED(0, "禁用"),
// 定义枚举值NORMAL，表示正常状态，值为1，描述为"正常"
NORMAL(1, "正常");
// 枚举值对应的整数值
private final int value;
// 枚举值对应的描述信息
private final String desc;
//构造方法，初始化枚举值的整数和描述信息
//@param value 枚举值对应的整数
// @param desc 枚举值对应的描述信息
TypeEnum(final int value, final String desc) {
this.value = value;
this.desc = desc;
}
//获取枚举值对应的整数值
// @return 枚举值对应的整数值
@Override
public Serializable getValue() {
return this.value;
}
//获取枚举值对应的描述信息
//@return 枚举值对应的描述信息
public String getDesc() {
return this.desc;
}
}

110
src/main/java/com/service/CommonService.java
Unescape View File

@ -0,0 +1,110 @@
package com.service; // 定义包路径为com.service，表示该接口属于服务层
import java.util.List; // 导入List接口，用于返回数据集合
import java.util.Map; // 导入Map接口，用于参数传递和返回数据
// 通用统计服务接口
//提供各类数据统计和分析方法
public interface CommonService {
// 饼图求和统计
//@param params 查询参数Map，包含统计条件和分组字段
//@return 饼图数据列表，每个元素包含name和value字段
List<Map<String, Object>> pieSum(Map<String, Object> params);
//饼图计数统计
// @param params 查询参数Map，包含统计条件和分组字段
//@return 饼图数据列表，每个元素包含name和value字段
List<Map<String, Object>> pieCount(Map<String, Object> params);
// 单维度柱状图求和统计
//@param params 查询参数Map，包含：
// - xAxis：X轴字段
// - yAxis：Y轴计算字段
// - 其他查询条件
//@return 柱状图数据列表，每个元素包含x轴值和y轴求和值
List<Map<String, Object>> barSumOne(Map<String, Object> params);
//单维度柱状图计数统计
//@param params 查询参数Map，包含：
// - xAxis：X轴字段
// - 其他查询条件
//@return 柱状图数据列表，每个元素包含x轴值和计数结果
List<Map<String, Object>> barCountOne(Map<String, Object> params);
// 双维度柱状图求和统计
//@param params 查询参数Map，包含：
// - xAxis：X轴字段
// - series：系列字段
// - yAxis：Y轴计算字段
// - 其他查询条件
//@return 柱状图数据列表，包含多系列数据
List<Map<String, Object>> barSumTwo(Map<String, Object> params);
//双维度柱状图计数统计
//@param params 查询参数Map，包含：
// - xAxis：X轴字段
// - series：系列字段
// - 其他查询条件
//@return 柱状图数据列表，包含多系列数据
List<Map<String, Object>> barCountTwo(Map<String, Object> params);
// 查询评分数据
//@param params 查询参数Map，包含：
// - tableName：查询表名
// - condition1：条件字段
// - condition1Value：条件值
// - average：是否计算平均评分
//@return 包含评分统计结果的Map，如：
// - total：总评分
// - count：评分次数
// - average：平均分
Map<String, Object> queryScore(Map<String, Object> params);
// 新的级联字典表分组求和统计
//@param params 查询参数Map，包含：
// - groupField：分组字段
// - sumField：求和字段
// - 其他查询条件
//@return 分组求和结果列表
//
List<Map<String, Object>> newSelectGroupSum(Map<String, Object> params);
// 新的级联字典表分组计数统计
//@param params 查询参数Map，包含：
// - groupField：分组字段
// - 其他查询条件
// @return 分组计数结果列表
List<Map<String, Object>> newSelectGroupCount(Map<String, Object> params);
// 通用柱状图求和统计
//@param params 查询参数Map，包含：0
// - xAxis：X轴字段
// - yAxis：Y轴计算字段
// - 其他查询条件
//@return 柱状图数据列表
List<Map<String, Object>> barSum(Map<String, Object> params);
// 通用柱状图计数统计
//@param params 查询参数Map，包含：
// - xAxis：X轴字段
// - 其他查询条件
//0@return 柱状图数据列表
List<Map<String, Object>> barCount(Map<String, Object> params);
}

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

@ -0,0 +1,40 @@
package com.service; // 定义包路径为com.service，表示该接口属于服务层
import java.util.Map; // 导入Map接口，用于参数传递
import com.baomidou.mybatisplus.service.IService; // 导入MyBatis-Plus服务接口
import com.entity.ConfigEntity; // 导入系统配置实体类
import com.utils.PageUtils; // 导入分页工具类
// 系统配置服务接口
//继承MyBatis-Plus的IService接口，提供系统配置相关业务方法
// @author yangliyuan
//@date 2019年10月10日 上午9:18:20
public interface ConfigService extends IService<ConfigEntity> {
// 分页查询系统配置信息
//@param params 查询参数Map，包含以下常用键值：
// - page：当前页码（从1开始）
// - limit：每页记录数
// - paramKey：配置键（模糊查询）
// - paramValue：配置值（模糊查询）
// - configType：配置类型
// - status：状态（1-启用，0-禁用）
//@return PageUtils分页对象，包含：
// - list：当前页配置数据列表
// - totalCount：总记录数
// - pageSize：每页条数
// - totalPage：总页数
// - currPage：当前页码
PageUtils queryPage(Map<String, Object> params);
// 可扩展的业务方法示例：
// String getConfigValueByKey(String paramKey); // 根据配置键获取配置值
// boolean updateConfigByKey(String paramKey, String paramValue); // 根据配置键更新配置值
// Map<String, String> getAllEnabledConfigs(); // 获取所有启用的配置项
// boolean refreshConfigCache(); // 刷新配置缓存
}

45
src/main/java/com/service/DictionaryService.java
Unescape View File

@ -0,0 +1,45 @@
package com.service; // 定义包路径为com.service，表示该接口属于服务层
import com.baomidou.mybatisplus.service.IService; // 导入MyBatis-Plus服务接口
import com.utils.PageUtils; // 导入分页工具类
import com.entity.DictionaryEntity; // 导入字典实体类
import java.util.Map; // 导入Map接口，用于参数传递
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类
import org.springframework.lang.Nullable; // 导入Spring的Nullable注解
import java.util.List; // 导入List接口
// 字典服务接口
//继承MyBatis-Plus的IService接口，提供字典相关业务方法
public interface DictionaryService extends IService<DictionaryEntity> {
// 分页查询字典数据
//@param params 查询参数Map，包含以下常用键值：
// - page：当前页码（从1开始）
// - limit：每页记录数
// - dicCode：字典编码（模糊查询）
// - dicName：字典名称（模糊查询）
// - codeIndex：字典项编码（精确查询）
// - indexName：字典项名称（模糊查询）
//@return PageUtils分页对象，包含：
// - list：当前页字典数据列表
// - totalCount：总记录数
// - pageSize：每页条数
// - totalPage：总页数
// - currPage：当前页码
PageUtils queryPage(Map<String, Object> params);
// 字典数据转换方法
//将对象中的字典编码转换为对应的字典值
//@param obj 需要转换的对象（可以是实体对象或Map）
//@param request HTTP请求对象（可用于获取上下文信息）
void dictionaryConvert(Object obj, HttpServletRequest request);
// 可扩展的业务方法示例：
// Map<String, String> getDictionaryByCode(String dicCode); // 根据字典编码获取字典项
// String getDictionaryName(String dicCode, Integer codeIndex); // 获取指定字典项名称
// boolean refreshCache(); // 刷新字典缓存
}

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

@ -0,0 +1,43 @@
package com.service; // 定义包路径为com.service，表示该接口属于服务层
import com.baomidou.mybatisplus.service.IService; // 导入MyBatis-Plus服务接口
import com.utils.PageUtils; // 导入分页工具类
import com.entity.ForumEntity; // 导入论坛实体类
import java.util.Map; // 导入Map接口，用于参数传递
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类（保留参数）
import org.springframework.lang.Nullable; // 导入Spring的Nullable注解（保留参数）
import java.util.List; // 导入List接口（保留参数）
// 健身论坛服务接口
//继承MyBatis-Plus的IService接口，提供健身论坛相关业务方法
public interface ForumService extends IService<ForumEntity> {
// 分页查询论坛帖子
//@param params 查询参数Map，包含以下常用键值：
// - page：当前页码（从1开始）
// - limit：每页记录数
// - title：帖子标题（模糊查询）
// - authorId：作者ID（精确查询）
// - postType：帖子类型（如：1-经验分享，2-问题求助）
// - status：帖子状态（如：0-正常，1-置顶，2-精华）
// - startTime：发帖开始时间（时间范围查询）
// - endTime：发帖结束时间（时间范围查询）
//@return PageUtils分页对象，包含：
// - list：当前页帖子列表
// - totalCount：总记录数
// - pageSize：每页条数
// - totalPage：总页数
// - currPage：当前页码
PageUtils queryPage(Map<String, Object> params);
// 可扩展的业务方法示例：
// boolean addPost(ForumEntity post); // 发布新帖
// boolean updatePostStatus(Long postId, Integer status); // 更新帖子状态
// List<ForumEntity> getHotPosts(int limit); // 获取热门帖子
// boolean addComment(Long postId, Long userId, String content); // 添加评论
// List<ForumEntity> searchPosts(String keyword); // 搜索帖子
}

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

@ -0,0 +1,39 @@
package com.service; // 定义包路径为com.service，表示该接口属于服务层
import com.baomidou.mybatisplus.service.IService; // 导入MyBatis-Plus服务接口
import com.utils.PageUtils; // 导入分页工具类
import com.entity.JianshenkechengCollectionEntity; // 导入课程收藏实体类
import java.util.Map; // 导入Map接口，用于参数传递
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类（保留参数）
import org.springframework.lang.Nullable; // 导入Spring的Nullable注解（保留参数）
import java.util.List; // 导入List接口（保留参数）
// 健身课程收藏服务接口
//继承MyBatis-Plus的IService接口，提供课程收藏相关业务方法
public interface JianshenkechengCollectionService extends IService<JianshenkechengCollectionEntity> {
// 分页查询课程收藏记录
//@param params 查询参数Map，包含以下常用键值：
// - page：当前页码（从1开始）
// - limit：每页记录数
// - userId：用户ID（筛选特定用户的收藏）
// - courseId：课程ID（筛选特定课程的收藏）
// - collectionTime：收藏时间（时间范围查询）
//@return PageUtils分页对象，包含：
// - list：当前页收藏记录列表
// - totalCount：总记录数
// - pageSize：每页条数
// - totalPage：总页数
// - currPage：当前页码
PageUtils queryPage(Map<String, Object> params);
// 可扩展的业务方法示例：
// boolean addCollection(Long userId, Long courseId); // 添加收藏
// boolean cancelCollection(Long collectionId); // 取消收藏
// boolean checkCollected(Long userId, Long courseId); // 检查是否已收藏
// List<Long> getUserCollectionIds(Long userId); // 获取用户收藏课程ID列表
}

41
src/main/java/com/service/JianshenkechengLiuyanService.java
Unescape View File

@ -0,0 +1,41 @@
package com.service; // 定义包路径为com.service，表示该接口位于服务层
import com.baomidou.mybatisplus.service.IService; // 导入MyBatis-Plus服务接口
import com.utils.PageUtils; // 导入分页工具类
import com.entity.JianshenkechengLiuyanEntity; // 导入课程留言实体类
import java.util.Map; // 导入Map接口，用于传递查询参数
import javax.servlet.http.HttpServletRequest; // 导入HTTP请求类（保留参数）
import org.springframework.lang.Nullable; // 导入Spring的Nullable注解（保留参数）
import java.util.List; // 导入List接口（保留参数）
// 健身课程留言服务接口
//继承MyBatis-Plus的IService接口，提供课程留言相关业务方法
public interface JianshenkechengLiuyanService extends IService<JianshenkechengLiuyanEntity> {
// 分页查询课程留言信息
//@param params 查询参数Map，包含以下常用键值：
// - page：当前页码（从1开始）
// - limit：每页记录数
// - courseId：课程ID（筛选特定课程的留言）
// - userId：用户ID（筛选特定用户的留言）
// - startTime：留言开始时间（时间范围查询）
// - endTime：留言结束时间（时间范围查询）
// - status：留言状态（如：0-未读，1-已读）
//@return PageUtils分页对象，包含：
// - list：当前页留言数据列表
// - totalCount：总记录数
// - pageSize：每页条数
// - totalPage：总页数
// - currPage：当前页码
PageUtils queryPage(Map<String, Object> params);
// 可扩展的业务方法示例：
// boolean addComment(Long courseId, Long userId, String content); // 添加留言
// boolean replyComment(Long commentId, String replyContent); // 回复留言
// boolean updateCommentStatus(Long commentId, Integer status); // 更新留言状态
// List<JianshenkechengLiuyanEntity> getLatestComments(Long courseId, int limit); // 获取最新留言
}

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save