spring:
  # 修改数据库连接
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库地址
    url: "jdbc:mysql://localhost:3306/playedu?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&allowPublicKeyRetrieval=true&useSSL=false"
    # 数据库账号
    username: "root"
    # 数据库密码
    password: "123456"
 # 修改redis连接
  data:
    redis:
      # redis地址
      host: "127.0.0.1"
      # redis端口
      port: 6379
      # redis密码
      password:
  # Kafka
   kafka: 
    bootstrap-servers: "kafka的连接地址"

spring:
  # 修改数据库连接
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库地址
    url: "jdbc:mysql://localhost:3306/playedu?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&allowPublicKeyRetrieval=true&useSSL=false"
    # 数据库账号
    username: "root"
    # 数据库密码
    password: "123456"
 # 修改redis连接
  data:
    redis:
      # redis地址
      host: "127.0.0.1"
      # redis端口
      port: 6379
      # redis密码
      password:
  # Kafka
  kafka:
    bootstrap-servers: "kafka的连接地址"

./mvnw clean package 

java –jar playedu-api-xxx.jar

playedu
├── playedu-api                           // 接口模块
│       └── controller                    // controller层
│       └── event                         // 事件发布器
│       └── listener                      // 事件监听器
│       └── interceptor                   // 拦截器
│       └── request                       // 自定义请求实体
│       └── task                          // 定时任务
│
├── playedu-common                        // 公共模块
│       └── annotation                    // 自定义注解
│       └── bus                           // 全局权限数据
│       └── caches                        // 全局缓存
│       └── config                        // 全局配置
│       └── constant                      // 通用常量
│       └── context                       // 用户全局数据
│       └── exception                     // 通用异常
│       └── type                          // 自定义实体
│       └── utils                         // 工具类
│       └── domain                        // 数据实体层
│       └── mapper                        // mapper层
│       └── service                       // service层
│   ├── resource                          // 静态资源
│       └── mapper                        // sql映射文件
│       └── i18n                          // 多语言
│       └── ipdb                          // IP地址资源文件
│       └── lua                           // lua文件
│
├── playedu-course                        // 线上课模块
├── playedu-exam                          // 考试模块
├── playedu-resource                      // 资源模块
├── playedu-system                        // 系统模块
│       └── aspectj                       // 切面代码
│       └── checks                        // 内置数据

sa-token:
  token-name: "Authorization" # 也就是对应HTTP头的属性名
  timeout: 1296000 #token有效期[单位:秒,默认15天]
  is-concurrent: false #限制同时登录,false就是一个账号只允许一台设备登录
  jwt-secret-key: "playeduxyz"  # jwt秘钥，用户加密分发的token内容，请尽量设置复杂
  token-prefix: "Bearer" # token前缀。ps：Authorization: Bearer {token}
  is-log: false # 是否输出操作日志

// 1.判断管理员是否登录
 if (!authService.check()) {
    return responseTransform(response, 401, "请登录");
}
// 1.具体实现
@Override
public boolean check(String prv) {
    // 获取当前会话是否已经登录, 返回true或false
    if (!StpUtil.isLogin()) {
        return false;
    }
    // 
    String tokenPrv = (String) StpUtil.getExtra("prv");
    return prv.equals(tokenPrv);
}

// 2.获取当前登录管理员的ID
authService.userId();
// 2.具体实现 
 @Override
public Integer userId() {
    return StpUtil.getLoginIdAsInt();
}

// 3.根据管理员ID获取管理员信息，包含邮箱，名称等信息
AdminUser adminUser = adminUserService.findById(authService.userId());

// 4.根据管理员ID获取所有权限信息
backendBus.adminUserPermissions(adminUser.getId())
// 4.具体实现
public HashMap<String, Boolean> adminUserPermissions(Integer userId) {
    // 读取超级管理角色
    AdminRole superRole = adminRoleService.getBySlug(BackendConstant.SUPER_ADMIN_ROLE);

    HashMap<String, Boolean> permissions = new HashMap<>();
    // 根据管理员ID获取所属角色
    List<Integer> roleIds = adminUserService.getRoleIdsByUserId(userId);
    if (roleIds.isEmpty()) {
        return permissions;
    }

    List<Integer> permissionIds;

    if (roleIds.contains(superRole.getId())) { // 包含超级管理角色的话返回全部权限
        permissionIds = permissionService.allIds();
    } else { // 根据相应的roleIds读取权限
        permissionIds = adminRoleService.getPermissionIdsByRoleIds(roleIds);
        if (permissionIds.isEmpty()) {
            return permissions;
        }
    }

    return permissionService.getSlugsByIds(permissionIds);
}

// 5.当前请求上下文下，获取已登录管理员的id和详细信息
BCtx.getId();//获取id
BCtx.getAdminUser();//获取adminUser

// 1.判断学员是否登录，未登录返回错误信息
 if (!authService.check()) {
    return responseTransform(response, 401, "请登录");
}
// 1.具体实现
@Override
public boolean check(String prv) {
    // 获取当前会话是否已经登录, 返回true或false
    if (!StpUtil.isLogin()) {
        return false;
    }
    // 
    String tokenPrv = (String) StpUtil.getExtra("prv");
    return prv.equals(tokenPrv);
}

// 2.获取当前登录学员的ID
authService.userId();
// 2.具体实现
@Override
public Integer userId() {
    return StpUtil.getLoginIdAsInt();
}

// 3.根据学员ID获取学员信息，包含邮箱，名称等信息
User user = userService.find(authService.userId());

// 4.当前请求上下文下，获取已登录管理员的id和详细信息
FCtx.getId();//获取id
FCtx.getAdminUser();//获取user

   put(
      // 权限类型[行为:action,数据:data]                    
      BPermissionConstant.TYPE_DATA,
      // 权限对象
      new HashMap<>() {
          {
              put(
                "权限分组", // 权限分组
                new AdminPermission[] {
                    new AdminPermission() {
                        {
                            setSort(0); // 升序
                            setName("权限名");// 权限名
                            setSlug("slug");// 权限slug
                        }
                    },
                });
          }
      });

roleService.updateWithPermissionIds(role, request.getName(), request.getPermissionIds());

// 下面注解可以加到 Controller 的 method 上实现行为权限的控制
@BackendPermission(slug = BPermissionConstant.ADMIN_ROLE)

// 行为权限控制的具体实现原理
@Around("doPointcut()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    BackendPermission middleware = signature.getMethod().getAnnotation(BackendPermission.class);
    Integer adminUserId = BCtx.getId();
    HashMap<String, Boolean> permissions = backendBus.adminUserPermissions(adminUserId);
    if (permissions.get(middleware.slug()) == null) {
        return JsonResponse.error("权限不足", 403);
    }
    return joinPoint.proceed();
}

@TableName(value = "admin_users")
@Data
@Slf4j
public class AdminUser implements Serializable {

    @JsonGetter("email")
    public String transformEmail() {
        return BackendBus.valueHidden(
                BPermissionConstant.DATA_ADMIN_EMAIL,
                BackendConstant.PRIVACY_FIELD_TYPE_EMAIL,
                email,
                CommonConstant.ZERO);
    }
}

<plugin>
    <groupId>com.diffplug.spotless</groupId>
    <artifactId>spotless-maven-plugin</artifactId>
    <version>2.36.0</version>
    <configuration>
        <java>
            <googleJavaFormat>
                <version>1.16.0</version>
                <style>AOSP</style>
                <reflowLongStrings>true</reflowLongStrings>
            </googleJavaFormat>

            <licenseHeader>
                <file>license-header.txt</file>
            </licenseHeader>
        </java>
    </configuration>
</plugin>

# 查看哪些代码不符合代码格式
./mvnw spotless:check

# 代码格式化
./mvnw spotless:apply

// 禁止并发执行(Quartz不要并发地执行同一个job定义（这里指一个job类的多个实例）)
@DisallowConcurrentExecution
@Slf4j
public class TestJob extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        // 执行业务逻辑
    }
}

// 添加定时任务
        addJob(
                scheduler, // 任务调度器
                TestJob.class, // 上面创建的job
                "test",  // 分组名称
                "TestJob", // 任务名称
                "0/30 * * * * ?"); // 调度频率 每30秒执行一次