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

Compare commits

base: phfsut2ie:main
Branches Tags
phfsut2ie:刘洋注释
phfsut2ie:main
phfsut2ie:feature/dw
phfsut2ie:develop
..
compare: phfsut2ie:8c8cf7a8681e2f96b698a83a3a3b9eb8f37dc88b
Branches Tags
phfsut2ie:刘洋注释
phfsut2ie:main
phfsut2ie:feature/dw
phfsut2ie:develop

No commits in common. 'main' and '8c8cf7a8681e2f96b698a83a3a3b9eb8f37dc88b' have entirely different histories.
main ... 8c8cf7a868

33 changed files with 3609 additions and 5622 deletions
Show Stats

4
.idea/.gitignore vendored
Unescape View File

@ -2,11 +2,7 @@
/shelf/ /shelf/
/workspace.xml /workspace.xml
# 数据源本地存储已忽略文件 # 数据源本地存储已忽略文件
<<<<<<< HEAD
/../../../../../../:\Users\33424\Desktop\jianshenfanggl没有注释\.idea/dataSources/ /../../../../../../:\Users\33424\Desktop\jianshenfanggl没有注释\.idea/dataSources/
=======
/../../../../../../../:\Users\33424\Desktop\gym\jianshenfanggl\.idea/dataSources/
>>>>>>> develop
/dataSources.local.xml /dataSources.local.xml
# 基于编辑器的 HTTP 客户端请求 # 基于编辑器的 HTTP 客户端请求
/httpRequests/ /httpRequests/

1
.idea/compiler.xml
Unescape View File

@ -6,6 +6,7 @@
<sourceOutputDir name="target/generated-sources/annotations" /> <sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" /> <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" /> <outputRelativeToContentRoot value="true" />
<module name="jianshenfanggl" />
</profile> </profile>
</annotationProcessing> </annotationProcessing>
</component> </component>

6
.idea/inspectionProfiles/Project_Default.xml
Unescape View File

@ -1,6 +0,0 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
</profile>
</component>

9
.idea/jianshenfanggl.iml
Unescape View File

@ -1,9 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

4
.idea/modules.xml
Unescape View File

@ -2,11 +2,7 @@
<project version="4"> <project version="4">
<component name="ProjectModuleManager"> <component name="ProjectModuleManager">
<modules> <modules>
<<<<<<< HEAD
<module fileurl="file://$PROJECT_DIR$/jianshenfanggl.iml" filepath="$PROJECT_DIR$/jianshenfanggl.iml" /> <module fileurl="file://$PROJECT_DIR$/jianshenfanggl.iml" filepath="$PROJECT_DIR$/jianshenfanggl.iml" />
=======
<module fileurl="file://$PROJECT_DIR$/.idea/jianshenfanggl.iml" filepath="$PROJECT_DIR$/.idea/jianshenfanggl.iml" />
>>>>>>> develop
</modules> </modules>
</component> </component>
</project> </project>

3
.idea/vcs.xml
Unescape View File

@ -2,9 +2,6 @@
<project version="4"> <project version="4">
<component name="VcsDirectoryMappings"> <component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" /> <mapping directory="$PROJECT_DIR$" vcs="Git" />
<<<<<<< HEAD
<mapping directory="$PROJECT_DIR$/gym" vcs="Git" /> <mapping directory="$PROJECT_DIR$/gym" vcs="Git" />
=======
>>>>>>> develop
</component> </component>
</project> </project>

2464
.idea/vue1.js
View File

File diff suppressed because it is too large Load Diff

0
C:\Users\Administrator\Desktop\软件工程项目\springboot542健身房管理系统--论文pf\健身房管理系统代码\jianshenfanggl\src\main\java\com\entity\vo
Unescape View File

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,142 +1,94 @@
// 声明当前文件所在的包路径
package com.controller; package com.controller;
// 导入输入输出相关类
import java.io.*; import java.io.*;
// 导入SQL相关类
import java.sql.Connection; import java.sql.Connection;
import java.sql.DriverManager; import java.sql.DriverManager;
import java.sql.SQLException; import java.sql.SQLException;
// 导入日期格式化类
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
// 导入集合类
import java.util.*; import java.util.*;
// 导入Servlet请求类
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
// 导入FastJSON相关类
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
// 导入字符串工具类
import com.utils.StringUtil; import com.utils.StringUtil;
// 导入Apache Commons字符串工具
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
// 导入JSON对象类
import org.json.JSONObject; import org.json.JSONObject;
// 导入SLF4J日志框架相关类（用于日志记录）
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架核心注解和工具类 import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.annotation.Autowired; // 自动依赖注入注解 import org.springframework.util.ResourceUtils;
import org.springframework.beans.factory.annotation.Value; // 配置文件值注入注解 import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.util.ResourceUtils; // Spring资源工具类 import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
// 导入Spring MVC控制器相关注解 import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.PathVariable; // 路径变量注解 import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestBody; // 请求体注解
import org.springframework.web.bind.annotation.RequestMapping; // 请求映射注解 import com.annotation.IgnoreAuth;
import org.springframework.web.bind.annotation.RequestParam; // 请求参数注解 import com.baidu.aip.face.AipFace;
import org.springframework.web.bind.annotation.RestController; // REST控制器注解 import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util;
// 导入项目自定义注解 import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.annotation.IgnoreAuth; // 忽略认证的自定义注解 import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.ConfigEntity;
// 导入百度AI人脸识别SDK相关类 import com.service.CommonService;
import com.baidu.aip.face.AipFace; // 百度人脸识别客户端主类 import com.service.ConfigService;
import com.baidu.aip.face.MatchRequest; // 人脸比对请求类 import com.utils.BaiduUtil;
import com.baidu.aip.util.Base64Util; // 百度Base64编码工具类 import com.utils.FileUtil;
import com.utils.R;
// 导入MyBatis-Plus ORM框架相关类
import com.baomidou.mybatisplus.mapper.EntityWrapper; // 实体条件构造器 /**
import com.baomidou.mybatisplus.mapper.Wrapper; // 条件构造器接口 * 通用接口
*/
// 导入项目实体类 @RestController
import com.entity.ConfigEntity; // 系统配置实体类
// 导入项目服务层接口
import com.service.CommonService; // 通用服务接口
import com.service.ConfigService; // 配置服务接口
// 导入项目工具类
import com.utils.BaiduUtil; // 百度AI工具类
import com.utils.FileUtil; // 文件操作工具类
import com.utils.R; // 统一响应结果封装类
//通用接口控制器
//提供系统通用的各种功能接口
@RestController // 标识这是一个RESTful风格的控制器
public class CommonController { public class CommonController {
// 日志记录器，使用slf4j的LoggerFactory创建
private static final Logger logger = LoggerFactory.getLogger(CommonController.class); private static final Logger logger = LoggerFactory.getLogger(CommonController.class);
// 自动注入通用服务
@Autowired @Autowired
private CommonService commonService; private CommonService commonService;
// * MySQL数据库备份接口 /**
// * @param mysqlUrl MySQL安装路径 * Java代码实现MySQL数据库导出
// * @param hostIP 数据库服务器IP *
// * @param userName 数据库用户名 * @param mysqlUrl MySQL安装路径
// * @param hostPort 数据库端口 * @param hostIP MySQL数据库所在服务器地址IP
//* @param password 数据库密码 * @param userName 进入数据库所需要的用户名
//* @param savePath 备份文件保存路径 * @param hostPort 数据库端口
//* @param fileName 备份文件名 * @param password 进入数据库所需要的密码
//* @param databaseName 要备份的数据库名 * @param savePath 数据库文件保存路径
//* @return 操作结果 * @param fileName 数据库导出文件文件名
* @param databaseName 要导出的数据库名
@IgnoreAuth // 忽略权限验证 * @return 返回true表示导出成功，否则返回false。
@RequestMapping("/beifen") // 映射请求路径 */
public R beifen(String mysqlUrl, String hostIP, String userName, String hostPort, @IgnoreAuth
String password, String savePath, String fileName, String databaseName) { @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); File saveFile = new File(savePath);
// 检查目录是否存在 if (!saveFile.exists()) {// 如果目录不存在 
if (!saveFile.exists()) { saveFile.mkdirs();// 创建文件夹 
// 不存在则创建多级目录
saveFile.mkdirs();
} }
// 确保路径以分隔符结尾
if (!savePath.endsWith(File.separator)) { if (!savePath.endsWith(File.separator)) {
savePath = savePath + File.separator; savePath = savePath + File.separator;
} }
// 声明打印写入器和缓冲读取器
PrintWriter printWriter = null; PrintWriter printWriter = null;
BufferedReader bufferedReader = null; BufferedReader bufferedReader = null;
try { try {
// 获取运行时对象
Runtime runtime = Runtime.getRuntime(); Runtime runtime = Runtime.getRuntime();
// 构建mysqldump命令字符串 String cmd = mysqlUrl + "mysqldump -h" + hostIP + " -u" + userName + " -P" + hostPort + " -p" + password + " " + databaseName;
String cmd = mysqlUrl + "mysqldump -h" + hostIP + " -u" + userName +
" -P" + hostPort + " -p" + password + " " + databaseName;
// 执行命令
runtime.exec(cmd); runtime.exec(cmd);
Process process = runtime.exec(cmd); Process process = runtime.exec(cmd);
// 创建输入流读取器，指定UTF-8编码
InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream(), "utf8"); InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream(), "utf8");
// 创建缓冲读取器
bufferedReader = new BufferedReader(inputStreamReader); bufferedReader = new BufferedReader(inputStreamReader);
// 创建打印写入器，指定UTF-8编码
printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(savePath + fileName), "utf8")); printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(savePath + fileName), "utf8"));
// 逐行读取备份数据
String line; String line;
while ((line = bufferedReader.readLine()) != null) { while ((line = bufferedReader.readLine()) != null) {
// 写入备份文件
printWriter.println(line); printWriter.println(line);
} }
// 刷新缓冲区
printWriter.flush(); printWriter.flush();
} catch (Exception e) { } catch (Exception e) {
// 打印异常堆栈
e.printStackTrace(); e.printStackTrace();
// 返回错误信息
return R.error("备份数据出错"); return R.error("备份数据出错");
} finally { } finally {
// 在finally块中确保资源关闭
try { try {
if (bufferedReader != null) { if (bufferedReader != null) {
bufferedReader.close(); bufferedReader.close();
@ -148,150 +100,586 @@ public class CommonController {
e.printStackTrace(); e.printStackTrace();
} }
} }
// 返回成功结果
return R.ok(); return R.ok();
} }
/**
//* MySQL数据库还原接口 * Java实现MySQL数据库导入
// * @param mysqlUrl MySQL安装路径 *
// * @param hostIP 数据库服务器IP * @param mysqlUrl MySQL安装路径
//* @param userName 数据库用户名 * @param hostIP MySQL数据库所在服务器地址IP
// * @param hostPort 数据库端口 * @param userName 进入数据库所需要的用户名
// * @param password 数据库密码 * @param hostPort 数据库端口
// * @param savePath 备份文件路径 * @param password 进入数据库所需要的密码
// * @param fileName 备份文件名 * @param savePath 数据库文件保存路径
// * @param databaseName 要还原的数据库名 * @param fileName 数据库导出文件文件名
//* @return 操作结果 * @param databaseName 要导出的数据库名
*/
@IgnoreAuth // 忽略权限验证 @IgnoreAuth
@RequestMapping("/huanyuan") // 映射请求路径 @RequestMapping("/huanyuan")
public R huanyuan(String mysqlUrl, String hostIP, String userName, String hostPort, public R huanyuan(String mysqlUrl, String hostIP, String userName, String hostPort, String password, String savePath, String fileName, String databaseName) {
String password, String savePath, String fileName, String databaseName) {
try { try {
// 获取运行时对象
Runtime rt = Runtime.getRuntime(); Runtime rt = Runtime.getRuntime();
// 执行mysql命令 Process child1 = rt.exec(mysqlUrl+"mysql.exe -h" + hostIP + " -u" + userName + " -P" + hostPort + " -p" + password + " " + databaseName);
Process child1 = rt.exec(mysqlUrl+"mysql.exe -h" + hostIP + " -u" + userName + OutputStream out = child1.getOutputStream();//控制台的输入信息作为输出流
" -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; String inStr;
StringBuffer sb = new StringBuffer("");
String outStr;
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(savePath+"/"+fileName), "utf-8"));
while ((inStr = br.readLine()) != null) { while ((inStr = br.readLine()) != null) {
// 将每行内容添加到缓冲区，并添加换行符
sb.append(inStr + "\r\n"); sb.append(inStr + "\r\n");
} }
outStr = sb.toString();
// 创建输出流写入器
OutputStreamWriter writer = new OutputStreamWriter(out, "utf8"); OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");
// 写入备份数据 writer.write(outStr);
writer.write(sb.toString()); // 注：这里如果用缓冲方式写入文件的话，会导致中文乱码，用flush()方法则可以避免
// 刷新缓冲区
writer.flush(); writer.flush();
// 关闭资源
out.close(); out.close();
br.close(); br.close();
writer.close(); writer.close();
} catch (Exception e) { } catch (Exception e) {
// 打印异常堆栈
e.printStackTrace(); e.printStackTrace();
// 返回错误信息
return R.error("数据导入出错"); return R.error("数据导入出错");
} }
// 返回成功结果
return R.ok(); return R.ok();
} }
// * 饼状图求和接口 /**
//* @param params 请求参数Map * 饼状图求和
// * @return 包含求和结果的响应 * @return
*/
@RequestMapping("/pieSum") // 映射请求路径 @RequestMapping("/pieSum")
public R pieSum(@RequestParam Map<String,Object> params) { public R pieSum(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("饼状图求和:,,Controller:{},,params:{}",this.getClass().getName(),params); logger.debug("饼状图求和:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取求和结果
List<Map<String, Object>> result = commonService.pieSum(params); List<Map<String, Object>> result = commonService.pieSum(params);
// 返回成功结果和数据
return R.ok().put("data", result); return R.ok().put("data", result);
} }
/**
// * 饼状图统计接口 * 饼状图统计
// * @param params 请求参数Map * @return
//* @return 包含统计结果的响应 */
@RequestMapping("/pieCount")
@RequestMapping("/pieCount") // 映射请求路径
public R pieCount(@RequestParam Map<String,Object> params) { public R pieCount(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("饼状图统计:,,Controller:{},,params:{}",this.getClass().getName(),params); logger.debug("饼状图统计:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取统计结果
List<Map<String, Object>> result = commonService.pieCount(params); List<Map<String, Object>> result = commonService.pieCount(params);
// 返回成功结果和数据
return R.ok().put("data", result); return R.ok().put("data", result);
} }
// * 单列柱状图求和接口 /**
// * @param params 请求参数Map * 柱状图求和单列
//* @return 包含图表数据的响应 * @return
*/
@RequestMapping("/barSumOne") // 映射请求路径 @RequestMapping("/barSumOne")
public R barSumOne(@RequestParam Map<String,Object> params) { public R barSumOne(@RequestParam Map<String,Object> params) {
// 记录调试日志
logger.debug("柱状图求和单列:,,Controller:{},,params:{}",this.getClass().getName(),params); logger.debug("柱状图求和单列:,,Controller:{},,params:{}",this.getClass().getName(),params);
// 调用服务层获取数据
List<Map<String, Object>> result = commonService.barSumOne(params); List<Map<String, Object>> result = commonService.barSumOne(params);
// 准备图表数据 List<String> xAxis = new ArrayList<>();//报表x轴
List<String> xAxis = new ArrayList<>(); // x轴数据 List<List<String>> yAxis = new ArrayList<>();//y轴
List<List<String>> yAxis = new ArrayList<>(); // y轴数据 List<String> legend = new ArrayList<>();//标题
List<String> legend = new ArrayList<>(); // 图例 List<String> yAxis0 = new ArrayList<>();
List<String> yAxis0 = new ArrayList<>(); // 第一个y轴数据系列 yAxis.add(yAxis0);
yAxis.add(yAxis0); // 添加到y轴集合 legend.add("");
legend.add(""); // 添加空图例 for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get("name"));
// 遍历结果集 String value = String.valueOf(map.get("value"));
for(Map<String, Object> map : result){ xAxis.add(oneValue);
// 获取名称和值 yAxis0.add(value);
}
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
return R.ok().put("data", resultMap);
}
/**
* 柱状图统计单列
* @return
*/
@RequestMapping("/barCountOne")
public R barCountOne(@RequestParam Map<String,Object> params) {
logger.debug("柱状图统计单列:,,Controller:{},,params:{}",this.getClass().getName(),params);
List<Map<String, Object>> result = commonService.barCountOne(params);
List<String> xAxis = new ArrayList<>();//报表x轴
List<List<String>> yAxis = new ArrayList<>();//y轴
List<String> legend = new ArrayList<>();//标题
List<String> yAxis0 = new ArrayList<>();
yAxis.add(yAxis0);
legend.add("");
for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get("name")); String oneValue = String.valueOf(map.get("name"));
String value = String.valueOf(map.get("value")); String value = String.valueOf(map.get("value"));
// 添加到对应集合
xAxis.add(oneValue); xAxis.add(oneValue);
yAxis0.add(value); yAxis0.add(value);
} }
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
return R.ok().put("data", resultMap);
}
/**
* 柱状图统计双列
* @return
*/
@RequestMapping("/barSumTwo")
public R barSumTwo(@RequestParam Map<String,Object> params) {
logger.debug("柱状图统计双列:,,Controller:{},,params:{}",this.getClass().getName(),params);
List<Map<String, Object>> result = commonService.barSumTwo(params);
List<String> xAxis = new ArrayList<>();//报表x轴
List<List<String>> yAxis = new ArrayList<>();//y轴
List<String> legend = new ArrayList<>();//标题
Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
for(Map<String, Object> map :result){
String name1Value = String.valueOf(map.get("name1"));
String name2Value = String.valueOf(map.get("name2"));
String value = String.valueOf(map.get("value"));
if(!legend.contains(name2Value)){
legend.add(name2Value);//添加完成后 就是最全的第二列的类型
}
if(dataMap.containsKey(name1Value)){
dataMap.get(name1Value).put(name2Value,value);
}else{
HashMap<String, String> name1Data = new HashMap<>();
name1Data.put(name2Value,value);
dataMap.put(name1Value,name1Data);
}
}
for(int i =0; i<legend.size(); i++){
yAxis.add(new ArrayList<String>());
}
Set<String> keys = dataMap.keySet();
for(String key:keys){
xAxis.add(key);
HashMap<String, String> map = dataMap.get(key);
for(int i =0; i<legend.size(); i++){
List<String> data = yAxis.get(i);
if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
data.add(map.get(legend.get(i)));
}else{
data.add("0");
}
}
}
System.out.println();
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
return R.ok().put("data", resultMap);
}
/**
* 柱状图统计双列
* @return
*/
@RequestMapping("/barCountTwo")
public R barCountTwo(@RequestParam Map<String,Object> params) {
logger.debug("柱状图统计双列:,,Controller:{},,params:{}",this.getClass().getName(),params);
List<Map<String, Object>> result = commonService.barCountTwo(params);
List<String> xAxis = new ArrayList<>();//报表x轴
List<List<String>> yAxis = new ArrayList<>();//y轴
List<String> legend = new ArrayList<>();//标题
Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
for(Map<String, Object> map :result){
String name1Value = String.valueOf(map.get("name1"));
String name2Value = String.valueOf(map.get("name2"));
String value = String.valueOf(map.get("value"));
if(!legend.contains(name2Value)){
legend.add(name2Value);//添加完成后 就是最全的第二列的类型
}
if(dataMap.containsKey(name1Value)){
dataMap.get(name1Value).put(name2Value,value);
}else{
HashMap<String, String> name1Data = new HashMap<>();
name1Data.put(name2Value,value);
dataMap.put(name1Value,name1Data);
}
}
for(int i =0; i<legend.size(); i++){
yAxis.add(new ArrayList<String>());
}
Set<String> keys = dataMap.keySet();
for(String key:keys){
xAxis.add(key);
HashMap<String, String> map = dataMap.get(key);
for(int i =0; i<legend.size(); i++){
List<String> data = yAxis.get(i);
if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
data.add(map.get(legend.get(i)));
}else{
data.add("0");
}
}
}
System.out.println();
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
return R.ok().put("data", resultMap);
}
/**
tableName 查询表
condition1 条件1
condition1Value 条件1值
average 计算平均评分
取值
有值 Number(res.data.value.toFixed(1))
无值 if(res.data){}
* */
@IgnoreAuth
@RequestMapping("/queryScore")
public R queryScore(@RequestParam Map<String, Object> params) {
logger.debug("queryScore:,,Controller:{},,params:{}",this.getClass().getName(),params);
Map<String, Object> queryScore = commonService.queryScore(params);
return R.ok().put("data", queryScore);
}
/**
* 查询字典表的分组统计总条数
* tableName 表名
* groupColumn 分组字段
* @return
*/
@RequestMapping("/newSelectGroupCount")
public R newSelectGroupCount(@RequestParam Map<String,Object> params) {
logger.debug("newSelectGroupCount:,,Controller:{},,params:{}",this.getClass().getName(),params);
List<Map<String, Object>> result = commonService.newSelectGroupCount(params);
return R.ok().put("data", result);
}
/**
* 查询字典表的分组求和
* tableName 表名
* groupColumn 分组字段
* sumCloum 统计字段
* @return
*/
@RequestMapping("/newSelectGroupSum")
public R newSelectGroupSum(@RequestParam Map<String,Object> params) {
logger.debug("newSelectGroupSum:,,Controller:{},,params:{}",this.getClass().getName(),params);
List<Map<String, Object>> result = commonService.newSelectGroupSum(params);
return R.ok().put("data", result);
}
/**
* 柱状图求和 老的
*/
@RequestMapping("/barSum")
public R barSum(@RequestParam Map<String,Object> params) {
logger.debug("barSum方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
Boolean isJoinTableFlag = false;//是否有级联表相关
String one = "";//第一优先
String two = "";//第二优先
//处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
//当前表
Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
params.put("thisTable",thisTable);
//级联表
String joinTableString = String.valueOf(params.get("joinTable"));
if(StringUtil.isNotEmpty(joinTableString)) {
Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);
params.put("joinTable", joinTable);
isJoinTableFlag = true;
}
if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期
thisTable.put("date",String.valueOf(thisTable.get("date")).split(","));
one = "thisDate0";
}
if(isJoinTableFlag){//级联表日期
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){
joinTable.put("date",String.valueOf(joinTable.get("date")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinDate0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinDate0";
}
}
}
}
if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串
thisTable.put("string",String.valueOf(thisTable.get("string")).split(","));
if(StringUtil.isEmpty(one)){
one ="thisString0";
}else{
if(StringUtil.isEmpty(two)){
two ="thisString0";
}
}
}
if(isJoinTableFlag){//级联表字符串
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){
joinTable.put("string",String.valueOf(joinTable.get("string")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinString0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinString0";
}
}
}
}
if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型
thisTable.put("types",String.valueOf(thisTable.get("types")).split(","));
if(StringUtil.isEmpty(one)){
one ="thisTypes0";
}else{
if(StringUtil.isEmpty(two)){
two ="thisTypes0";
}
}
}
if(isJoinTableFlag){//级联表类型
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){
joinTable.put("types",String.valueOf(joinTable.get("types")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinTypes0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinTypes0";
}
}
}
}
List<Map<String, Object>> result = commonService.barSum(params);
List<String> xAxis = new ArrayList<>();//报表x轴
List<List<String>> yAxis = new ArrayList<>();//y轴
List<String> legend = new ArrayList<>();//标题
if(StringUtil.isEmpty(two)){//不包含第二列
List<String> yAxis0 = new ArrayList<>();
yAxis.add(yAxis0);
legend.add("");
for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get(one));
String value = String.valueOf(map.get("value"));
xAxis.add(oneValue);
yAxis0.add(value);
}
}else{//包含第二列
Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
if(StringUtil.isNotEmpty(two)){
for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get(one));
String twoValue = String.valueOf(map.get(two));
String value = String.valueOf(map.get("value"));
if(!legend.contains(twoValue)){
legend.add(twoValue);//添加完成后 就是最全的第二列的类型
}
if(dataMap.containsKey(oneValue)){
dataMap.get(oneValue).put(twoValue,value);
}else{
HashMap<String, String> oneData = new HashMap<>();
oneData.put(twoValue,value);
dataMap.put(oneValue,oneData);
}
}
}
for(int i =0; i<legend.size(); i++){
yAxis.add(new ArrayList<String>());
}
Set<String> keys = dataMap.keySet();
for(String key:keys){
xAxis.add(key);
HashMap<String, String> map = dataMap.get(key);
for(int i =0; i<legend.size(); i++){
List<String> data = yAxis.get(i);
if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
data.add(map.get(legend.get(i)));
}else{
data.add("0");
}
}
}
System.out.println();
}
// 构建结果Map
Map<String, Object> resultMap = new HashMap<>(); Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis); resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis); resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend); resultMap.put("legend",legend);
// 返回成功结果和数据
return R.ok().put("data", resultMap); return R.ok().put("data", resultMap);
} }
// 其他方法的行注释类似，遵循相同的模式... /**
// 每个方法都包含： * 柱状图统计 老的
// 1. 方法功能说明 */
// 2. 参数说明 @RequestMapping("/barCount")
// 3. 返回值说明 public R barCount(@RequestParam Map<String,Object> params) {
// 4. 关键代码行的详细注释 logger.debug("barCount方法:,,Controller:{},,params:{}",this.getClass().getName(), com.alibaba.fastjson.JSONObject.toJSONString(params));
Boolean isJoinTableFlag = false;//是否有级联表相关
String one = "";//第一优先
String two = "";//第二优先
//处理thisTable和joinTable 处理内容是把json字符串转为Map并把带有,的切割为数组
//当前表
Map<String,Object> thisTable = JSON.parseObject(String.valueOf(params.get("thisTable")),Map.class);
params.put("thisTable",thisTable);
//级联表
String joinTableString = String.valueOf(params.get("joinTable"));
if(StringUtil.isNotEmpty(joinTableString)) {
Map<String, Object> joinTable = JSON.parseObject(joinTableString, Map.class);
params.put("joinTable", joinTable);
isJoinTableFlag = true;
}
// 由于篇幅限制，这里省略了部分方法的详细行注释 if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("date")))){//当前表日期
// 但每个方法都应按照上述模式进行注释 thisTable.put("date",String.valueOf(thisTable.get("date")).split(","));
one = "thisDate0";
}
if(isJoinTableFlag){//级联表日期
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("date")))){
joinTable.put("date",String.valueOf(joinTable.get("date")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinDate0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinDate0";
}
}
}
}
if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("string")))){//当前表字符串
thisTable.put("string",String.valueOf(thisTable.get("string")).split(","));
if(StringUtil.isEmpty(one)){
one ="thisString0";
}else{
if(StringUtil.isEmpty(two)){
two ="thisString0";
}
}
}
if(isJoinTableFlag){//级联表字符串
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("string")))){
joinTable.put("string",String.valueOf(joinTable.get("string")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinString0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinString0";
}
}
}
}
if(StringUtil.isNotEmpty(String.valueOf(thisTable.get("types")))){//当前表类型
thisTable.put("types",String.valueOf(thisTable.get("types")).split(","));
if(StringUtil.isEmpty(one)){
one ="thisTypes0";
}else{
if(StringUtil.isEmpty(two)){
two ="thisTypes0";
}
}
}
if(isJoinTableFlag){//级联表类型
Map<String, Object> joinTable = (Map<String, Object>) params.get("joinTable");
if(StringUtil.isNotEmpty(String.valueOf(joinTable.get("types")))){
joinTable.put("types",String.valueOf(joinTable.get("types")).split(","));
if(StringUtil.isEmpty(one)){
one ="joinTypes0";
}else{
if(StringUtil.isEmpty(two)){
two ="joinTypes0";
}
}
}
}
List<Map<String, Object>> result = commonService.barCount(params);
List<String> xAxis = new ArrayList<>();//报表x轴
List<List<String>> yAxis = new ArrayList<>();//y轴
List<String> legend = new ArrayList<>();//标题
if(StringUtil.isEmpty(two)){//不包含第二列
List<String> yAxis0 = new ArrayList<>();
yAxis.add(yAxis0);
legend.add("");
for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get(one));
String value = String.valueOf(map.get("value"));
xAxis.add(oneValue);
yAxis0.add(value);
}
}else{//包含第二列
Map<String, HashMap<String, String>> dataMap = new LinkedHashMap<>();
if(StringUtil.isNotEmpty(two)){
for(Map<String, Object> map :result){
String oneValue = String.valueOf(map.get(one));
String twoValue = String.valueOf(map.get(two));
String value = String.valueOf(map.get("value"));
if(!legend.contains(twoValue)){
legend.add(twoValue);//添加完成后 就是最全的第二列的类型
}
if(dataMap.containsKey(oneValue)){
dataMap.get(oneValue).put(twoValue,value);
}else{
HashMap<String, String> oneData = new HashMap<>();
oneData.put(twoValue,value);
dataMap.put(oneValue,oneData);
}
}
}
for(int i =0; i<legend.size(); i++){
yAxis.add(new ArrayList<String>());
}
// 所有方法的注释都应包括： Set<String> keys = dataMap.keySet();
// - 方法用途 for(String key:keys){
// - 参数说明 xAxis.add(key);
// - 返回值说明 HashMap<String, String> map = dataMap.get(key);
// - 关键处理逻辑说明 for(int i =0; i<legend.size(); i++){
// - 异常处理说明 List<String> data = yAxis.get(i);
if(StringUtil.isNotEmpty(map.get(legend.get(i)))){
data.add(map.get(legend.get(i)));
}else{
data.add("0");
}
}
}
System.out.println();
}
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("xAxis",xAxis);
resultMap.put("yAxis",yAxis);
resultMap.put("legend",legend);
return R.ok().put("data", resultMap);
}
} }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,186 +1,137 @@
// 声明当前 Java 文件所属的包，此包用于存放控制器类，处理与教练相关的HTTP请求
package com.controller; package com.controller;
// 导入Java IO包中的File类，用于文件操作
import java.io.File; import java.io.File;
// 导入Java数学包中的BigDecimal类，用于高精度计算
import java.math.BigDecimal; import java.math.BigDecimal;
// 导入Java网络包中的URL类，用于处理统一资源定位符
import java.net.URL; import java.net.URL;
// 导入Java文本包中的SimpleDateFormat类，用于日期格式化
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
// 导入FastJSON库中的JSONObject类，用于JSON数据处理
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
// 导入Java工具包中的所有类，包括集合、日期等工具
import java.util.*; import java.util.*;
// 导入Spring框架的BeanUtils类，用于对象属性复制
import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanUtils;
// 导入Servlet的HttpServletRequest类，用于处理HTTP请求
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
// 导入Spring框架的ContextLoader类，用于获取应用上下文
import org.springframework.web.context.ContextLoader; import org.springframework.web.context.ContextLoader;
// 导入Servlet的ServletContext类，表示Servlet上下文
import javax.servlet.ServletContext; import javax.servlet.ServletContext;
// 导入自定义的TokenService类，用于令牌管理
import com.service.TokenService; import com.service.TokenService;
// 导入自定义工具类包中的所有工具类
import com.utils.*; import com.utils.*;
// 导入反射相关的InvocationTargetException类
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
// 导入自定义的DictionaryService类，用于字典数据管理
import com.service.DictionaryService; import com.service.DictionaryService;
// 导入Apache Commons Lang3库的StringUtils类，用于字符串处理
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
// 导入自定义的IgnoreAuth注解，用于标记不需要认证的接口
import com.annotation.IgnoreAuth; import com.annotation.IgnoreAuth;
// 导入SLF4J日志框架的Logger接口
import org.slf4j.Logger; import org.slf4j.Logger;
// 导入SLF4J日志框架的LoggerFactory类
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
// 导入Spring框架的Autowired注解，用于依赖注入
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架的Controller注解，标记该类为控制器
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller;
// 导入Spring框架的RestController和RequestMapping等注解
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
// 导入MyBatis Plus的EntityWrapper类，用于构建查询条件
import com.baomidou.mybatisplus.mapper.EntityWrapper; import com.baomidou.mybatisplus.mapper.EntityWrapper;
// 导入MyBatis Plus的Wrapper接口
import com.baomidou.mybatisplus.mapper.Wrapper; import com.baomidou.mybatisplus.mapper.Wrapper;
// 导入自定义实体类包中的所有类
import com.entity.*; import com.entity.*;
// 导入自定义视图实体类包中的所有类
import com.entity.view.*; import com.entity.view.*;
// 导入自定义服务类包中的所有类
import com.service.*; import com.service.*;
// 导入自定义分页工具类
import com.utils.PageUtils; import com.utils.PageUtils;
// 导入自定义统一返回结果类
import com.utils.R; import com.utils.R;
// 导入FastJSON库中的所有类
import com.alibaba.fastjson.*; import com.alibaba.fastjson.*;
/** /**
* 教练控制器 * 教练
* 后端接口 * 后端接口
*/ * @author
@RestController // 标记为RESTful控制器 * @email
@Controller // 标记为Spring控制器 */
@RequestMapping("/jiaolian") // 定义基础请求路径 @RestController
@Controller
@RequestMapping("/jiaolian")
public class JiaolianController { public class JiaolianController {
// 创建日志记录器
private static final Logger logger = LoggerFactory.getLogger(JiaolianController.class); private static final Logger logger = LoggerFactory.getLogger(JiaolianController.class);
// 定义常量表名
private static final String TABLE_NAME = "jiaolian"; private static final String TABLE_NAME = "jiaolian";
// 自动注入教练服务
@Autowired @Autowired
private JiaolianService jiaolianService; private JiaolianService jiaolianService;
// 自动注入令牌服务
@Autowired @Autowired
private TokenService tokenService; private TokenService tokenService;
// 自动注入字典服务
@Autowired @Autowired
private DictionaryService dictionaryService; private DictionaryService dictionaryService;//字典
// 自动注入论坛服务
@Autowired @Autowired
private ForumService forumService; private ForumService forumService;//健身论坛
// 自动注入健身课程服务
@Autowired @Autowired
private JianshenkechengService jianshenkechengService; private JianshenkechengService jianshenkechengService;//健身课程
// 自动注入课程收藏服务
@Autowired @Autowired
private JianshenkechengCollectionService jianshenkechengCollectionService; private JianshenkechengCollectionService jianshenkechengCollectionService;//课程收藏
// 自动注入课程留言服务
@Autowired @Autowired
private JianshenkechengLiuyanService jianshenkechengLiuyanService; private JianshenkechengLiuyanService jianshenkechengLiuyanService;//课程留言
// 自动注入教练预约服务
@Autowired @Autowired
private JiaolianYuyueService jiaolianYuyueService; private JiaolianYuyueService jiaolianYuyueService;//教练预约申请
// 自动注入健身资讯服务
@Autowired @Autowired
private NewsService newsService; private NewsService newsService;//健身资讯
// 自动注入单页数据服务
@Autowired @Autowired
private SingleSeachService singleSeachService; private SingleSeachService singleSeachService;//单页数据
// 自动注入用户服务
@Autowired @Autowired
private YonghuService yonghuService; private YonghuService yonghuService;//用户
// 自动注入管理员服务
@Autowired @Autowired
private UsersService usersService; private UsersService usersService;//管理员
/** /**
* 后端列表查询 * 后端列表
*/ */
@RequestMapping("/page") @RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){ public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("分页查询方法:,,控制器:{},,参数:{}",this.getClass().getName(),JSONObject.toJSONString(params)); logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 获取当前用户角色
String role = String.valueOf(request.getSession().getAttribute("role")); String role = String.valueOf(request.getSession().getAttribute("role"));
// 根据角色设置查询条件
if(false) if(false)
return R.error(511,"永不会进入"); return R.error(511,"永不会进入");
else if("用户".equals(role)) else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId")); params.put("yonghuId",request.getSession().getAttribute("userId"));
else if("教练".equals(role)) else if("教练".equals(role))
params.put("jiaolianId",request.getSession().getAttribute("userId")); params.put("jiaolianId",request.getSession().getAttribute("userId"));
// 设置数据删除状态条件 params.put("dataDeleteStart",1);params.put("dataDeleteEnd",1);
params.put("dataDeleteStart",1);
params.put("dataDeleteEnd",1);
// 检查参数有效性
CommonUtil.checkMap(params); CommonUtil.checkMap(params);
// 调用服务层查询分页数据
PageUtils page = jiaolianService.queryPage(params); PageUtils page = jiaolianService.queryPage(params);
// 字典数据转换 //字典表数据转换
List<JiaolianView> list =(List<JiaolianView>)page.getList(); List<JiaolianView> list =(List<JiaolianView>)page.getList();
for(JiaolianView c:list){ for(JiaolianView c:list){
// 转换字典表字段 //修改对应字典表字段
dictionaryService.dictionaryConvert(c, request); dictionaryService.dictionaryConvert(c, request);
} }
// 返回分页数据
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 后端详情查询 * 后端详情
*/ */
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){ public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("详情查询方法:,,控制器:{},,ID:{}",this.getClass().getName(),id); logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
// 根据ID查询教练信息
JiaolianEntity jiaolian = jiaolianService.selectById(id); JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){ if(jiaolian !=null){
// 实体转视图 //entity转view
JiaolianView view = new JiaolianView(); JiaolianView view = new JiaolianView();
// 复制属性 BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
BeanUtils.copyProperties( jiaolian , view ); //修改对应字典表字段
// 转换字典表字段
dictionaryService.dictionaryConvert(view, request); dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); return R.ok().put("data", view);
}else { }else {
return R.error(511,"查不到数据"); return R.error(511,"查不到数据");
} }
} }
/** /**
* 后端保存教练信息 * 后端保存
*/ */
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){ public R save(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){
logger.debug("保存方法:,,控制器:{},,教练信息:{}",this.getClass().getName(),jiaolian.toString()); logger.debug("save方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
// 获取当前用户角色
String role = String.valueOf(request.getSession().getAttribute("role")); String role = String.valueOf(request.getSession().getAttribute("role"));
if(false) if(false)
return R.error(511,"永远不会进入"); return R.error(511,"永远不会进入");
// 构建查询条件，检查用户名和手机号是否已存在
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>() Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername()) .eq("username", jiaolian.getUsername())
.or() .or()
@ -188,16 +139,13 @@ public class JiaolianController {
.eq("data_delete", 1) .eq("data_delete", 1)
; ;
logger.info("SQL语句:"+queryWrapper.getSqlSegment()); logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 执行查询
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper); JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity==null){ if(jiaolianEntity==null){
// 设置默认值 jiaolian.setDataDelete(1);
jiaolian.setDataDelete(1); // 数据删除状态 jiaolian.setInsertTime(new Date());
jiaolian.setInsertTime(new Date()); // 插入时间 jiaolian.setCreateTime(new Date());
jiaolian.setCreateTime(new Date()); // 创建时间 jiaolian.setPassword("123456");
jiaolian.setPassword("123456"); // 默认密码
// 保存教练信息
jiaolianService.insert(jiaolian); jiaolianService.insert(jiaolian);
return R.ok(); return R.ok();
}else { }else {
@ -206,17 +154,16 @@ public class JiaolianController {
} }
/** /**
* 后端修改教练信息 * 后端修改
*/ */
@RequestMapping("/update") @RequestMapping("/update")
public R update(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException { public R update(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("修改方法:,,控制器:{},,教练信息:{}",this.getClass().getName(),jiaolian.toString()); logger.debug("update方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
// 查询原有数据 JiaolianEntity oldJiaolianEntity = jiaolianService.selectById(jiaolian.getId());//查询原先数据
JiaolianEntity oldJiaolianEntity = jiaolianService.selectById(jiaolian.getId());
// 获取当前用户角色
String role = String.valueOf(request.getSession().getAttribute("role")); String role = String.valueOf(request.getSession().getAttribute("role"));
// 处理空字段 // if(false)
// return R.error(511,"永远不会进入");
if("".equals(jiaolian.getJiaolianPhoto()) || "null".equals(jiaolian.getJiaolianPhoto())){ if("".equals(jiaolian.getJiaolianPhoto()) || "null".equals(jiaolian.getJiaolianPhoto())){
jiaolian.setJiaolianPhoto(null); jiaolian.setJiaolianPhoto(null);
} }
@ -224,28 +171,26 @@ public class JiaolianController {
jiaolian.setJiaolianContent(null); jiaolian.setJiaolianContent(null);
} }
// 更新数据 jiaolianService.updateById(jiaolian);//根据id更新
jiaolianService.updateById(jiaolian);
return R.ok(); return R.ok();
} }
/** /**
* 删除教练信息（逻辑删除） * 删除
*/ */
@RequestMapping("/delete") @RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){ public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("删除方法:,,控制器:{},,IDs:{}",this.getClass().getName(),ids.toString()); logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
// 查询要删除的数据 List<JiaolianEntity> oldJiaolianList =jiaolianService.selectBatchIds(Arrays.asList(ids));//要删除的数据
List<JiaolianEntity> oldJiaolianList =jiaolianService.selectBatchIds(Arrays.asList(ids));
// 准备更新列表
ArrayList<JiaolianEntity> list = new ArrayList<>(); ArrayList<JiaolianEntity> list = new ArrayList<>();
for(Integer id:ids){ for(Integer id:ids){
JiaolianEntity jiaolianEntity = new JiaolianEntity(); JiaolianEntity jiaolianEntity = new JiaolianEntity();
jiaolianEntity.setId(id); jiaolianEntity.setId(id);
jiaolianEntity.setDataDelete(2); // 标记为删除 jiaolianEntity.setDataDelete(2);
list.add(jiaolianEntity); list.add(jiaolianEntity);
} }
// 批量更新删除状态
if(list != null && list.size() >0){ if(list != null && list.size() >0){
jiaolianService.updateBatchById(list); jiaolianService.updateBatchById(list);
} }
@ -253,24 +198,20 @@ public class JiaolianController {
return R.ok(); return R.ok();
} }
/** /**
* 批量导入教练数据 * 批量上传
*/ */
@RequestMapping("/batchInsert") @RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){ public R save( String fileName, HttpServletRequest request){
logger.debug("批量导入方法:,,控制器:{},,文件名:{}",this.getClass().getName(),fileName); logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
// 获取当前用户ID
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))); Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//.eq("time", new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
try { try {
// 准备导入的数据列表 List<JiaolianEntity> jiaolianList = new ArrayList<>();//上传的东西
List<JiaolianEntity> jiaolianList = new ArrayList<>(); Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 需要检查重复的字段映射
Map<String, List<String>> seachFields= new HashMap<>();
// 当前日期
Date date = new Date(); Date date = new Date();
// 检查文件后缀
int lastIndexOf = fileName.lastIndexOf("."); int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){ if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀"); return R.error(511,"该文件没有后缀");
@ -279,54 +220,53 @@ public class JiaolianController {
if(!".xls".equals(suffix)){ if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件"); return R.error(511,"只支持后缀为xls的excel文件");
}else{ }else{
// 获取文件路径 URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
File file = new File(resource.getFile()); File file = new File(resource.getFile());
if(!file.exists()){ if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员"); return R.error(511,"找不到上传文件，请联系管理员");
}else{ }else{
// 读取Excel文件 List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
List<List<String>> dataList = PoiUtil.poiImport(file.getPath()); dataList.remove(0);//删除第一行，因为第一行是提示
dataList.remove(0);// 删除标题行
for(List<String> data:dataList){ for(List<String> data:dataList){
// 创建教练实体 //循环
JiaolianEntity jiaolianEntity = new JiaolianEntity(); JiaolianEntity jiaolianEntity = new JiaolianEntity();
// 设置各字段值（示例代码，实际应根据Excel列设置） // jiaolianEntity.setUsername(data.get(0)); //账户 要改的
// jiaolianEntity.setUsername(data.get(0)); // 账户 // jiaolianEntity.setPassword("123456");//密码
// jiaolianEntity.setPassword("123456"); // 密码 // jiaolianEntity.setJiaolianName(data.get(0)); //教练名称 要改的
// jiaolianEntity.setJiaolianName(data.get(0)); // 教练名称 // jiaolianEntity.setJiaolianPhone(data.get(0)); //教练手机号 要改的
// jiaolianEntity.setJiaolianPhone(data.get(0)); // 教练手机号 // jiaolianEntity.setJiaolianPhoto("");//详情和图片
// jiaolianEntity.setJiaolianPhoto(""); // 照片 // jiaolianEntity.setSexTypes(Integer.valueOf(data.get(0))); //性别 要改的
// jiaolianEntity.setSexTypes(Integer.valueOf(data.get(0))); // 性别 // jiaolianEntity.setJiaolianEmail(data.get(0)); //教练邮箱 要改的
// jiaolianEntity.setJiaolianEmail(data.get(0)); // 邮箱 // jiaolianEntity.setJiaolianContent("");//详情和图片
// jiaolianEntity.setJiaolianContent(""); // 内容 // jiaolianEntity.setDataDelete(1);//逻辑删除字段
// jiaolianEntity.setDataDelete(1); // 删除状态 // jiaolianEntity.setInsertTime(date);//时间
// jiaolianEntity.setInsertTime(date); // 插入时间 // jiaolianEntity.setCreateTime(date);//时间
// jiaolianEntity.setCreateTime(date); // 创建时间
jiaolianList.add(jiaolianEntity); jiaolianList.add(jiaolianEntity);
// 收集需要检查重复的字段
// 账户字段检查 //把要查询是否重复的字段放入map中
//账户
if(seachFields.containsKey("username")){ if(seachFields.containsKey("username")){
List<String> username = seachFields.get("username"); List<String> username = seachFields.get("username");
username.add(data.get(0)); username.add(data.get(0));//要改的
}else{ }else{
List<String> username = new ArrayList<>(); List<String> username = new ArrayList<>();
username.add(data.get(0)); username.add(data.get(0));//要改的
seachFields.put("username",username); seachFields.put("username",username);
} }
// 手机号字段检查 //教练手机号
if(seachFields.containsKey("jiaolianPhone")){ if(seachFields.containsKey("jiaolianPhone")){
List<String> jiaolianPhone = seachFields.get("jiaolianPhone"); List<String> jiaolianPhone = seachFields.get("jiaolianPhone");
jiaolianPhone.add(data.get(0)); jiaolianPhone.add(data.get(0));//要改的
}else{ }else{
List<String> jiaolianPhone = new ArrayList<>(); List<String> jiaolianPhone = new ArrayList<>();
jiaolianPhone.add(data.get(0)); jiaolianPhone.add(data.get(0));//要改的
seachFields.put("jiaolianPhone",jiaolianPhone); seachFields.put("jiaolianPhone",jiaolianPhone);
} }
} }
// 检查账户是否重复 //查询是否重复
//账户
List<JiaolianEntity> jiaolianEntities_username = jiaolianService.selectList(new EntityWrapper<JiaolianEntity>().in("username", seachFields.get("username")).eq("data_delete", 1)); List<JiaolianEntity> jiaolianEntities_username = jiaolianService.selectList(new EntityWrapper<JiaolianEntity>().in("username", seachFields.get("username")).eq("data_delete", 1));
if(jiaolianEntities_username.size() >0 ){ if(jiaolianEntities_username.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>(); ArrayList<String> repeatFields = new ArrayList<>();
@ -335,7 +275,7 @@ public class JiaolianController {
} }
return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString()); 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)); List<JiaolianEntity> jiaolianEntities_jiaolianPhone = jiaolianService.selectList(new EntityWrapper<JiaolianEntity>().in("jiaolian_phone", seachFields.get("jiaolianPhone")).eq("data_delete", 1));
if(jiaolianEntities_jiaolianPhone.size() >0 ){ if(jiaolianEntities_jiaolianPhone.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>(); ArrayList<String> repeatFields = new ArrayList<>();
@ -344,7 +284,6 @@ public class JiaolianController {
} }
return R.error(511,"数据库的该表中的 [教练手机号] 字段已经存在 存在数据为:"+repeatFields.toString()); return R.error(511,"数据库的该表中的 [教练手机号] 字段已经存在 存在数据为:"+repeatFields.toString());
} }
// 批量插入数据
jiaolianService.insertBatch(jiaolianList); jiaolianService.insertBatch(jiaolianList);
return R.ok(); return R.ok();
} }
@ -357,22 +296,17 @@ public class JiaolianController {
} }
/** /**
* 教练登录 * 登录
*/ */
@IgnoreAuth // 忽略认证 @IgnoreAuth
@RequestMapping(value = "/login") @RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) { public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询教练
JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username)); JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username));
// 验证账号密码
if(jiaolian==null || !jiaolian.getPassword().equals(password)) if(jiaolian==null || !jiaolian.getPassword().equals(password))
return R.error("账号或密码不正确"); return R.error("账号或密码不正确");
// 检查账号状态
else if(jiaolian.getDataDelete() != 1) else if(jiaolian.getDataDelete() != 1)
return R.error("账户已被删除"); return R.error("账户已被删除");
// 生成令牌
String token = tokenService.generateToken(jiaolian.getId(),username, "jiaolian", "教练"); String token = tokenService.generateToken(jiaolian.getId(),username, "jiaolian", "教练");
// 构建返回结果
R r = R.ok(); R r = R.ok();
r.put("token", token); r.put("token", token);
r.put("role","教练"); r.put("role","教练");
@ -383,12 +317,12 @@ public class JiaolianController {
} }
/** /**
* 教练注册 * 注册
*/ */
@IgnoreAuth // 忽略认证 @IgnoreAuth
@PostMapping(value = "/register") @PostMapping(value = "/register")
public R register(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) { public R register(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request) {
// 构建查询条件，检查用户名和手机号是否已存在 // ValidatorUtils.validateEntity(user);
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>() Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername()) .eq("username", jiaolian.getUsername())
.or() .or()
@ -396,15 +330,12 @@ public class JiaolianController {
.andNew() .andNew()
.eq("data_delete", 1) .eq("data_delete", 1)
; ;
// 执行查询
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper); JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity != null) if(jiaolianEntity != null)
return R.error("账户或者教练手机号已经被使用"); return R.error("账户或者教练手机号已经被使用");
// 设置默认值 jiaolian.setDataDelete(1);
jiaolian.setDataDelete(1); // 数据状态 jiaolian.setInsertTime(new Date());
jiaolian.setInsertTime(new Date()); // 插入时间 jiaolian.setCreateTime(new Date());
jiaolian.setCreateTime(new Date()); // 创建时间
// 保存教练信息
jiaolianService.insert(jiaolian); jiaolianService.insert(jiaolian);
return R.ok(); return R.ok();
@ -415,11 +346,8 @@ public class JiaolianController {
*/ */
@GetMapping(value = "/resetPassword") @GetMapping(value = "/resetPassword")
public R resetPassword(Integer id, HttpServletRequest request) { public R resetPassword(Integer id, HttpServletRequest request) {
// 根据ID查询教练
JiaolianEntity jiaolian = jiaolianService.selectById(id); JiaolianEntity jiaolian = jiaolianService.selectById(id);
// 重置密码为默认值
jiaolian.setPassword("123456"); jiaolian.setPassword("123456");
// 更新密码
jiaolianService.updateById(jiaolian); jiaolianService.updateById(jiaolian);
return R.ok(); return R.ok();
} }
@ -429,60 +357,53 @@ public class JiaolianController {
*/ */
@GetMapping(value = "/updatePassword") @GetMapping(value = "/updatePassword")
public R updatePassword(String oldPassword, String newPassword, HttpServletRequest request) { public R updatePassword(String oldPassword, String newPassword, HttpServletRequest request) {
// 获取当前登录教练
JiaolianEntity jiaolian = jiaolianService.selectById((Integer)request.getSession().getAttribute("userId")); JiaolianEntity jiaolian = jiaolianService.selectById((Integer)request.getSession().getAttribute("userId"));
// 验证新密码
if(newPassword == null){ if(newPassword == null){
return R.error("新密码不能为空") ; return R.error("新密码不能为空") ;
} }
// 验证旧密码
if(!oldPassword.equals(jiaolian.getPassword())){ if(!oldPassword.equals(jiaolian.getPassword())){
return R.error("原密码输入错误"); return R.error("原密码输入错误");
} }
// 检查新旧密码是否相同
if(newPassword.equals(jiaolian.getPassword())){ if(newPassword.equals(jiaolian.getPassword())){
return R.error("新密码不能和原密码一致") ; return R.error("新密码不能和原密码一致") ;
} }
// 更新密码
jiaolian.setPassword(newPassword); jiaolian.setPassword(newPassword);
jiaolianService.updateById(jiaolian); jiaolianService.updateById(jiaolian);
return R.ok(); return R.ok();
} }
/** /**
* 忘记密码（重置密码） * 忘记密码
*/ */
@IgnoreAuth // 忽略认证 @IgnoreAuth
@RequestMapping(value = "/resetPass") @RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) { public R resetPass(String username, HttpServletRequest request) {
// 根据用户名查询教练
JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username)); JiaolianEntity jiaolian = jiaolianService.selectOne(new EntityWrapper<JiaolianEntity>().eq("username", username));
if(jiaolian!=null){ if(jiaolian!=null){
// 重置密码为默认值
jiaolian.setPassword("123456"); jiaolian.setPassword("123456");
// 更新密码
jiaolianService.updateById(jiaolian); jiaolianService.updateById(jiaolian);
return R.ok(); return R.ok();
}else { }else{
return R.error("账号不存在"); return R.error("账号不存在");
} }
} }
/** /**
* 获取当前登录教练的会话信息 * 获取用户的session用户信息
*/ */
@RequestMapping("/session") @RequestMapping("/session")
public R getCurrJiaolian(HttpServletRequest request){ public R getCurrJiaolian(HttpServletRequest request){
// 从会话中获取用户ID
Integer id = (Integer)request.getSession().getAttribute("userId"); Integer id = (Integer)request.getSession().getAttribute("userId");
// 查询教练信息
JiaolianEntity jiaolian = jiaolianService.selectById(id); JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){ if(jiaolian !=null){
// 实体转视图 //entity转view
JiaolianView view = new JiaolianView(); JiaolianView view = new JiaolianView();
// 复制属性 BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
BeanUtils.copyProperties( jiaolian , view );
// 转换字典字段 //修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); return R.ok().put("data", view);
}else { }else {
@ -490,51 +411,52 @@ public class JiaolianController {
} }
} }
/** /**
* 退出登录 * 退出
*/ */
@GetMapping(value = "logout") @GetMapping(value = "logout")
public R logout(HttpServletRequest request) { public R logout(HttpServletRequest request) {
// 使会话失效
request.getSession().invalidate(); request.getSession().invalidate();
return R.ok("退出成功"); return R.ok("退出成功");
} }
/** /**
* 前端列表查询 * 前端列表
*/ */
@IgnoreAuth // 忽略认证 @IgnoreAuth
@RequestMapping("/list") @RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){ public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("前端列表查询方法:,,控制器:{},,参数:{}",this.getClass().getName(),JSONObject.toJSONString(params)); logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 检查参数有效性
CommonUtil.checkMap(params); CommonUtil.checkMap(params);
// 查询分页数据
PageUtils page = jiaolianService.queryPage(params); PageUtils page = jiaolianService.queryPage(params);
// 字典数据转换 //字典表数据转换
List<JiaolianView> list =(List<JiaolianView>)page.getList(); List<JiaolianView> list =(List<JiaolianView>)page.getList();
for(JiaolianView c:list) for(JiaolianView c:list)
dictionaryService.dictionaryConvert(c, request); // 转换字典字段 dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 前端详情查询 * 前端详情
*/ */
@RequestMapping("/detail/{id}") @RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Integer id, HttpServletRequest request){ public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
logger.debug("前端详情查询方法:,,控制器:{},,ID:{}",this.getClass().getName(),id); logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
// 根据ID查询教练
JiaolianEntity jiaolian = jiaolianService.selectById(id); JiaolianEntity jiaolian = jiaolianService.selectById(id);
if(jiaolian !=null){ if(jiaolian !=null){
// 实体转视图
//entity转view
JiaolianView view = new JiaolianView(); JiaolianView view = new JiaolianView();
// 复制属性 BeanUtils.copyProperties( jiaolian , view );//把实体数据重构到view中
BeanUtils.copyProperties( jiaolian , view );
// 转换字典字段 //修改对应字典表字段
dictionaryService.dictionaryConvert(view, request); dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view); return R.ok().put("data", view);
}else { }else {
@ -542,34 +464,35 @@ public class JiaolianController {
} }
} }
/** /**
* 前端保存教练信息 * 前端保存
*/ */
@RequestMapping("/add") @RequestMapping("/add")
public R add(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){ public R add(@RequestBody JiaolianEntity jiaolian, HttpServletRequest request){
logger.debug("前端保存方法:,,控制器:{},,教练信息:{}",this.getClass().getName(),jiaolian.toString()); logger.debug("add方法:,,Controller:{},,jiaolian:{}",this.getClass().getName(),jiaolian.toString());
// 构建查询条件，检查用户名和手机号是否已存在
Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>() Wrapper<JiaolianEntity> queryWrapper = new EntityWrapper<JiaolianEntity>()
.eq("username", jiaolian.getUsername()) .eq("username", jiaolian.getUsername())
.or() .or()
.eq("jiaolian_phone", jiaolian.getJiaolianPhone()) .eq("jiaolian_phone", jiaolian.getJiaolianPhone())
.andNew() .andNew()
.eq("data_delete", 1) .eq("data_delete", 1)
// .notIn("jiaolian_types", new Integer[]{102})
; ;
logger.info("SQL语句:"+queryWrapper.getSqlSegment()); logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 执行查询
JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper); JiaolianEntity jiaolianEntity = jiaolianService.selectOne(queryWrapper);
if(jiaolianEntity==null){ if(jiaolianEntity==null){
// 设置默认值 jiaolian.setDataDelete(1);
jiaolian.setDataDelete(1); // 数据状态 jiaolian.setInsertTime(new Date());
jiaolian.setInsertTime(new Date()); // 插入时间 jiaolian.setCreateTime(new Date());
jiaolian.setCreateTime(new Date()); // 创建时间 jiaolian.setPassword("123456");
jiaolian.setPassword("123456"); // 默认密码
// 保存教练信息
jiaolianService.insert(jiaolian); jiaolianService.insert(jiaolian);
return R.ok(); return R.ok();
}else { }else {
return R.error(511,"账户或者教练手机号已经被使用"); return R.error(511,"账户或者教练手机号已经被使用");
} }
} }
} }

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

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

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

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

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

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

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

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

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

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

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

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

76
src/main/java/com/utils/R.java
Unescape View File

@ -1,93 +1,51 @@
package com.utils;
package com.utils; // 定义包名为com.utils，表示该类位于com.utils包下 import java.util.HashMap;
import java.util.Map;
import java.util.HashMap; // 导入HashMap类，用于实现键值对存储
import java.util.Map; // 导入Map接口，用于处理键值对集合
// 返回数据工具类
//继承HashMap，提供统一的API响应格式封装
/**
* 返回数据
*/
public class R extends HashMap<String, Object> { public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L; // 序列化版本ID，保证序列化兼容性 private static final long serialVersionUID = 1L;
// 默认构造函数
//初始化时默认设置code为0（表示成功）
public R() { public R() {
put("code", 0); // 默认成功状态码 put("code", 0);
} }
// 创建错误响应（使用默认错误码和消息）
//@return 包含默认错误信息的R对象
public static R error() { public static R error() {
return error(500, "未知异常，请联系管理员"); // 默认服务器错误 return error(500, "未知异常，请联系管理员");
} }
// 创建带自定义消息的错误响应（使用默认错误码500）
//@param msg 错误消息
//@return 包含自定义错误消息的R对象
public static R error(String msg) { public static R error(String msg) {
return error(500, msg); // 使用默认错误码500 return error(500, msg);
} }
// 创建带自定义错误码和消息的错误响应
//@param code 错误码
//@param msg 错误消息
//@return 包含自定义错误信息的R对象
public static R error(int code, String msg) { public static R error(int code, String msg) {
R r = new R(); R r = new R();
r.put("code", code); // 设置错误码 r.put("code", code);
r.put("msg", msg); // 设置错误消息 r.put("msg", msg);
return r; return r;
} }
// 创建成功响应（带自定义消息）
//@param msg 成功消息
//@return 包含成功消息的R对象
public static R ok(String msg) { public static R ok(String msg) {
R r = new R(); R r = new R();
r.put("msg", msg); // 设置成功消息 r.put("msg", msg);
return r; return r;
} }
// 创建成功响应（带多个数据）
//@param map 包含多个键值对的数据集合
//@return 包含所有数据的R对象
public static R ok(Map<String, Object> map) { public static R ok(Map<String, Object> map) {
R r = new R(); R r = new R();
r.putAll(map); // 添加所有数据到响应中 r.putAll(map);
return r; return r;
} }
// 创建默认成功响应
//@return 只包含默认成功码的R对象
public static R ok() { public static R ok() {
return new R(); // 使用默认构造函数 return new R();
} }
// 添加键值对到响应中（链式调用支持）
//@param key 键名
//@param value 键值
//@return 当前R对象（支持链式调用）
@Override
public R put(String key, Object value) { public R put(String key, Object value) {
super.put(key, value); // 调用父类HashMap的put方法 super.put(key, value);
return this; // 返回当前对象以实现链式调用 return this;
} }
} }

Write Preview
Loading…
Cancel
Save