Merge remote-tracking branch 'origin/master'

aurora-springboot/src/main/java/com/aurora/config/AsyncConfig.java

@@ -1,23 +1,37 @@
 package com.aurora.config;
+/// 主要负责应用的配置与初始化工作，它不直接处理业务逻辑，而是为整个应用提供运行所需的基础设施、组件行为、安全策略、数据访问方式等配置
 
+//配置 Spring 的异步任务执行器（线程池），使得应用能够支持 @Async注解实现方法的异步调用
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.task.TaskExecutor;
 import org.springframework.scheduling.annotation.EnableAsync;
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
-@EnableAsync
-@Configuration
+@EnableAsync//Spring框架的注解，用于启用异步方法执行功能
+
+@Configuration//注解将普通的Java类标记为Spring的配置源
 public class AsyncConfig {
 
     @Bean
+    /*
+     * 创建并配置任务执行
+     * @return 配置好的ThreadPoolTaskExecutor实例
+     */
     public TaskExecutor taskExecutor() {
+        // 创建线程池任务执行器
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        // 设置核心线程数为10
         executor.setCorePoolSize(10);
+        // 设置最大线程数为20
         executor.setMaxPoolSize(20);
+        // 设置队列容量为20
         executor.setQueueCapacity(20);
+        // 设置线程空闲时间60秒
         executor.setKeepAliveSeconds(60);
+        // 设置线程名称前缀
         executor.setThreadNamePrefix("async-task-thread-");
         return executor;
     }
+
 }

aurora-springboot/src/main/java/com/aurora/config/GlobalZoneConfig.java

@@ -1,18 +1,28 @@
 package com.aurora.config;
 
 import org.springframework.context.annotation.Configuration;
-
 import javax.annotation.PostConstruct;
 import java.util.TimeZone;
 
 import static com.aurora.enums.ZoneEnum.SHANGHAI;
 
+/**
+ * 全局时区配置类
+ * 用于设置应用程序的默认时区
+ */
 @Configuration
 public class GlobalZoneConfig {
 
+    /**
+     * 设置全局默认时区
+     * 在Spring容器初始化完成后自动执行，将系统默认时区设置为上海时区
+     */
     @PostConstruct
     public void setGlobalZone() {
+        // 设置系统默认时区为上海时区
         TimeZone.setDefault(TimeZone.getTimeZone(SHANGHAI.getZone()));
     }
 
 }
+
+

aurora-springboot/src/main/java/com/aurora/config/RabbitMQConfig.java

@@ -8,53 +8,93 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import static com.aurora.constant.RabbitMQConstant.*;
-
+//用于实现消息的发布与订阅
+/**
+ * RabbitMQ配置类
+ * 用于配置消息队列的相关组件，包括队列、交换机和绑定关系
+ */
 @Configuration
 public class RabbitMQConfig {
 
+    /**
+     * 创建文章队列Bean
+     * @return Queue 配置持久化的文章队列实例
+     */
     @Bean
     public Queue articleQueue() {
         return new Queue(MAXWELL_QUEUE, true);
     }
 
+    /**
+     * 创建MaxWell交换机Bean
+     * @return FanoutExchange 配置持久化、非自动删除的Fanout类型交换机
+     */
     @Bean
     public FanoutExchange maxWellExchange() {
         return new FanoutExchange(MAXWELL_EXCHANGE, true, false);
     }
 
+    /**
+     * 绑定文章队列到MaxWell交换机
+     * @return Binding 文章队列与MaxWell交换机的绑定关系
+     */
     @Bean
     public Binding bindingArticleDirect() {
         return BindingBuilder.bind(articleQueue()).to(maxWellExchange());
     }
 
+    /**
+     * 创建邮件队列Bean
+     * @return Queue 配置持久化的邮件队列实例
+     */
     @Bean
     public Queue emailQueue() {
         return new Queue(EMAIL_QUEUE, true);
     }
 
+    /**
+     * 创建邮件交换机Bean
+     * @return FanoutExchange 配置持久化、非自动删除的Fanout类型交换机
+     */
     @Bean
     public FanoutExchange emailExchange() {
         return new FanoutExchange(EMAIL_EXCHANGE, true, false);
     }
 
+    /**
+     * 绑定邮件队列到邮件交换机
+     * @return Binding 邮件队列与邮件交换机的绑定关系
+     */
     @Bean
     public Binding bindingEmailDirect() {
         return BindingBuilder.bind(emailQueue()).to(emailExchange());
     }
 
+    /**
+     * 创建订阅队列Bean
+     * @return Queue 配置持久化的订阅队列实例
+     */
     @Bean
     public Queue subscribeQueue() {
         return new Queue(SUBSCRIBE_QUEUE, true);
     }
 
+    /**
+     * 创建订阅交换机Bean
+     * @return FanoutExchange 配置持久化、非自动删除的Fanout类型交换机
+     */
     @Bean
     public FanoutExchange subscribeExchange() {
         return new FanoutExchange(SUBSCRIBE_EXCHANGE, true, false);
     }
 
+    /**
+     * 绑定订阅队列到订阅交换机
+     * @return Binding 订阅队列与订阅交换机的绑定关系
+     */
     @Bean
     public Binding bindingSubscribeDirect() {
         return BindingBuilder.bind(subscribeQueue()).to(subscribeExchange());
     }
 
-}
+}

aurora-springboot/src/main/java/com/aurora/config/RedisConfig.java

@@ -1,5 +1,7 @@
 package com.aurora.config;
 
+//配置 Spring Data Redis 的 RedisTemplate，用于以更加灵活和可读的方式操作 Redis，尤其是对存储对象进行序列化
+
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
@@ -10,24 +12,42 @@ import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
+/**
+ * Redis配置类，用于配置RedisTemplate及相关序列化器
+ */
 @Configuration
 public class RedisConfig {
 
+    /**
+     * 配置RedisTemplate实例，设置键值的序列化方式
+     *
+     * @param factory Redis连接工厂，用于创建Redis连接
+     * @return 配置好的RedisTemplate实例，键为String类型，值为Object类型
+     */
     @Bean
     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
         redisTemplate.setConnectionFactory(factory);
+
+        // 配置JSON序列化器，用于对象的序列化和反序列化
         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
         ObjectMapper mapper = new ObjectMapper();
         mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
         jackson2JsonRedisSerializer.setObjectMapper(mapper);
+
+        // 配置字符串序列化器，用于键的序列化
         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
+
+        // 设置RedisTemplate的序列化器
         redisTemplate.setKeySerializer(stringRedisSerializer);
         redisTemplate.setHashKeySerializer(stringRedisSerializer);
         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
+
         redisTemplate.afterPropertiesSet();
         return redisTemplate;
     }
 
 }
+
+

aurora-springboot/src/main/java/com/aurora/config/properties/MinioProperties.java

@@ -4,18 +4,37 @@ import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
 
+/**
+ 这段Java代码定义了一个名为[MinioProperties]的配置属性类，用于读取和存储MinIO对象存储服务的相关配置信息。通过`@ConfigurationProperties`注解，
+ 该类会自动从配置文件中读取以"upload.minio"为前缀的属性值，并将其映射到对应的字段中，包括服务URL、端点地址、访问密钥、私有密钥和存储桶名称等核心配置参数。
+ */
 @Data
 @Configuration
 @ConfigurationProperties(prefix = "upload.minio")
 public class MinioProperties {
 
+    /**
+     * MinIO服务URL地址
+     */
     private String url;
 
+    /**
+     * MinIO服务端点地址
+     */
     private String endpoint;
 
+    /**
+     * MinIO访问密钥
+     */
     private String accessKey;
 
+    /**
+     * MinIO私有密钥
+     */
     private String secretKey;
 
+    /**
+     * MinIO存储桶名称
+     */
     private String bucketName;
 }

aurora-springboot/src/main/java/com/aurora/quartz/AbstractQuartzJob.java

@@ -17,50 +17,98 @@ import java.util.Date;
 import static com.aurora.constant.CommonConstant.ONE;
 import static com.aurora.constant.CommonConstant.ZERO;
 
+/**
+ * 抽象 Quartz 任务执行类，用于统一处理定时任务的执行流程。
+ * <p>
+ * 此类实现了 {@link org.quartz.Job} 接口，并提供了任务执行前、执行中和执行后的通用逻辑，
+ * 包括日志记录、异常捕获等。
+ */
 public abstract class AbstractQuartzJob implements org.quartz.Job {
 
     private static final Logger log = LoggerFactory.getLogger(AbstractQuartzJob.class);
 
+    /**
+     * 使用 ThreadLocal 存储任务开始时间，保证线程安全。
+     */
     private static final ThreadLocal<Date> THREAD_LOCAL = new ThreadLocal<>();
 
+    /**
+     * Quartz 调度器调用的任务入口方法。
+     * <p>
+     * 从上下文中获取任务配置信息并封装成 {@link Job} 对象，然后依次调用前置处理、核心执行与后置处理方法。
+     *
+     * @param context 任务执行上下文，包含调度相关数据
+     * @throws JobExecutionException 当任务执行过程中发生错误时抛出
+     */
     @Override
     public void execute(JobExecutionContext context) throws JobExecutionException {
+        // 从上下文中提取任务属性并复制到 Job 实体对象中
         Job job = new Job();
         BeanUtils.copyProperties(context.getMergedJobDataMap().get(ScheduleConstant.TASK_PROPERTIES), job);
+
         try {
-            before(context, job);
-            doExecute(context, job);
-            after(context, job, null);
+            before(context, job);             // 执行前置操作（如记录开始时间）
+            doExecute(context, job);          // 执行具体的任务逻辑（由子类实现）
+            after(context, job, null);        // 成功执行后处理（如记录成功日志）
         } catch (Exception e) {
-            log.error("任务执行异常:", e);
-            after(context, job, e);
+            log.error("任务执行异常:", e);      // 记录异常日志
+            after(context, job, e);           // 异常情况下的后置处理（如记录失败日志）
         }
     }
 
+    /**
+     * 在任务执行之前进行预处理操作。
+     * <p>
+     * 默认将当前时间存入 ThreadLocal 中作为任务开始时间。
+     *
+     * @param context 任务执行上下文
+     * @param job     封装了任务信息的对象
+     */
     protected void before(JobExecutionContext context, Job job) {
         THREAD_LOCAL.set(new Date());
     }
 
+    /**
+     * 在任务执行之后进行收尾操作。
+     * <p>
+     * 主要功能包括：计算任务耗时、构建任务日志实体、保存至数据库。
+     *
+     * @param context 任务执行上下文
+     * @param job     封装了任务信息的对象
+     * @param e       若任务执行出现异常，则传递该异常；否则为 null
+     */
     protected void after(JobExecutionContext context, Job job, Exception e) {
-        Date startTime = THREAD_LOCAL.get();
-        THREAD_LOCAL.remove();
-        final JobLog jobLog = new JobLog();
+        Date startTime = THREAD_LOCAL.get();   // 获取任务开始时间
+        THREAD_LOCAL.remove();                 // 清理 ThreadLocal 避免内存泄漏
+
+        final JobLog jobLog = new JobLog();    // 构建任务日志对象
         jobLog.setJobId(job.getId());
         jobLog.setJobName(job.getJobName());
         jobLog.setJobGroup(job.getJobGroup());
         jobLog.setInvokeTarget(job.getInvokeTarget());
         jobLog.setStartTime(startTime);
         jobLog.setEndTime(new Date());
+
         long runMs = jobLog.getEndTime().getTime() - jobLog.getStartTime().getTime();
         jobLog.setJobMessage(jobLog.getJobName() + " 总共耗时：" + runMs + "毫秒");
+
         if (e != null) {
-            jobLog.setStatus(ZERO);
-            jobLog.setExceptionInfo(ExceptionUtil.getTrace(e));
+            jobLog.setStatus(ZERO);              // 设置状态为失败
+            jobLog.setExceptionInfo(ExceptionUtil.getTrace(e)); // 记录异常堆栈信息
         } else {
-            jobLog.setStatus(ONE);
+            jobLog.setStatus(ONE);               // 设置状态为成功
         }
+
+        // 插入任务日志到数据库
         SpringUtil.getBean(JobLogMapper.class).insert(jobLog);
     }
 
+    /**
+     * 定义任务的具体执行逻辑，需由子类实现。
+     *
+     * @param context 任务执行上下文
+     * @param job     封装了任务信息的对象
+     * @throws Exception 可能抛出的任意异常
+     */
     protected abstract void doExecute(JobExecutionContext context, Job job) throws Exception;
 }

aurora-springboot/src/main/java/com/aurora/quartz/AuroraQuartz.java

@@ -29,11 +29,15 @@ import java.util.stream.Collectors;
 import static com.aurora.constant.CommonConstant.UNKNOWN;
 import static com.aurora.constant.RedisConstant.*;
 
+/**
+ * 定时任务调度类，用于执行各种定时任务逻辑。
+ * 包括统计唯一访问量、清理缓存、用户地区统计、百度SEO推送、清除任务日志、导入Swagger资源以及将文章数据导入Elasticsearch等操作。
+ */
 @Slf4j
 @Component("auroraQuartz")
 public class AuroraQuartz {
 
-    @Autowired
+    @Autowired//注解，用于装配依赖注入，无需手动创建对象
     private RedisService redisService;
 
     @Autowired
@@ -64,8 +68,15 @@ public class AuroraQuartz {
     @Value("${website.url}")
     private String websiteUrl;
 
+    /**
+     * 将Redis中记录的昨日唯一访客数保存到数据库，并清空对应键值。
+     * 每天凌晨调用此方法进行持久化处理。
+     */
     public void saveUniqueView() {
+        // 获取当前Redis中的唯一访客数量
         Long count = redisService.sSize(UNIQUE_VISITOR);
+
+        // 构造并插入新的唯一访问记录（时间为昨天）
         UniqueView uniqueView = UniqueView.builder()
                 .createTime(LocalDateTimeUtil.offset(LocalDateTime.now(), -1, ChronoUnit.DAYS))
                 .viewsCount(Optional.of(count.intValue()).orElse(0))
@@ -73,12 +84,21 @@ public class AuroraQuartz {
         uniqueViewMapper.insert(uniqueView);
     }
 
+    /**
+     * 清除Redis中与访客相关的临时统计数据。
+     * 主要包括：唯一访客集合、访客区域分布信息。
+     */
     public void clear() {
         redisService.del(UNIQUE_VISITOR);
         redisService.del(VISITOR_AREA);
     }
 
+    /**
+     * 统计所有用户的注册来源地区分布情况，并将结果存储至Redis中供前端展示使用。
+     * 使用IP地址解析工具获取省份信息，未知归属地统一标记为"UNKNOWN"。
+     */
     public void statisticalUserArea() {
+        // 查询所有用户认证信息中的IP来源字段
         Map<String, Long> userAreaMap = userAuthMapper.selectList(new LambdaQueryWrapper<UserAuth>().select(UserAuth::getIpSource))
                 .stream()
                 .map(item -> {
@@ -88,22 +108,34 @@ public class AuroraQuartz {
                     return UNKNOWN;
                 })
                 .collect(Collectors.groupingBy(item -> item, Collectors.counting()));
+
+        // 转换为DTO列表格式并存入Redis
         List<UserAreaDTO> userAreaList = userAreaMap.entrySet().stream()
                 .map(item -> UserAreaDTO.builder()
                         .name(item.getKey())
                         .value(item.getValue())
                         .build())
                 .collect(Collectors.toList());
+
         redisService.set(USER_AREA, JSON.toJSONString(userAreaList));
     }
 
+    /**
+     * 向百度搜索引擎提交网站的文章链接以加快收录速度。
+     * 遍历所有已发布的文章ID拼接URL后通过HTTP POST方式发送给百度服务器。
+     */
     public void baiduSeo() {
+        // 提取所有文章ID构造完整URL路径
         List<Integer> ids = articleService.list().stream().map(Article::getId).collect(Collectors.toList());
+
+        // 设置请求头模拟curl行为
         HttpHeaders headers = new HttpHeaders();
         headers.add("Host", "data.zz.baidu.com");
         headers.add("User-Agent", "curl/7.12.1");
         headers.add("Content-Length", "83");
         headers.add("Content-Type", "text/plain");
+
+        // 对每篇文章发起POST请求通知百度爬虫更新索引
         ids.forEach(item -> {
             String url = websiteUrl + "/articles/" + item;
             HttpEntity<String> entity = new HttpEntity<>(url, headers);
@@ -111,13 +143,26 @@ public class AuroraQuartz {
         });
     }
 
+    /**
+     * 清理历史任务执行日志记录。
+     * 委托JobLogService完成实际的日志删除工作。
+     */
     public void clearJobLogs() {
         jobLogService.cleanJobLogs();
     }
 
+    /**
+     * 导入Swagger接口文档定义的API资源到系统资源表中，
+     * 并自动赋予管理员角色全部新增资源权限。
+     */
     public void importSwagger() {
+        // 执行Swagger资源导入动作
         resourceService.importSwagger();
+
+        // 获取刚导入的所有资源ID
         List<Integer> resourceIds = resourceService.list().stream().map(Resource::getId).collect(Collectors.toList());
+
+        // 构建管理员角色与这些资源之间的关联关系对象列表
         List<RoleResource> roleResources = new ArrayList<>();
         for (Integer resourceId : resourceIds) {
             roleResources.add(RoleResource.builder()
@@ -125,12 +170,23 @@ public class AuroraQuartz {
                     .resourceId(resourceId)
                     .build());
         }
+
+        // 批量保存角色-资源映射关系
         roleResourceService.saveBatch(roleResources);
     }
 
+    /**
+     * 全量同步MySQL中的文章数据到Elasticsearch搜索引擎中。
+     * 在每次全量导入前会先删除原有的索引内容确保一致性。
+     */
     public void importDataIntoES() {
+        // 删除旧有全文检索索引数据
         elasticsearchMapper.deleteAll();
+
+        // 加载最新文章列表
         List<Article> articles = articleService.list();
+
+        // 复制转换为搜索专用DTO结构体并逐条写入ES
         for (Article article : articles) {
             elasticsearchMapper.save(BeanCopyUtil.copyObject(article, ArticleSearchDTO.class));
         }

aurora-springboot/src/main/java/com/aurora/quartz/QuartzDisallowConcurrentExecution.java

@@ -4,9 +4,24 @@ import com.aurora.entity.Job;
 import com.aurora.util.JobInvokeUtil;
 import org.quartz.JobExecutionContext;
 
+/**
+ * Quartz禁止并发执行的任务类
+ * 该类继承自AbstractQuartzJob，用于执行禁止并发调度的定时任务
+ */
 public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob {
+    /**
+     * 执行具体的任务逻辑
+     * 该方法通过JobInvokeUtil工具类来调用任务对应的方法
+     *
+     * @param context Quartz任务执行上下文，包含任务执行的相关环境信息
+     * @param job 任务实体对象，包含任务的具体配置和执行信息
+     * @throws Exception 任务执行过程中可能抛出的异常
+     */
     @Override
     protected void doExecute(JobExecutionContext context, Job job) throws Exception {
+        // 调用任务执行工具类的方法来执行具体的业务逻辑
         JobInvokeUtil.invokeMethod(job);
     }
 }
+
+

aurora-springboot/src/main/java/com/aurora/quartz/QuartzJobExecution.java

@@ -3,11 +3,13 @@ package com.aurora.quartz;
 import com.aurora.entity.Job;
 import com.aurora.util.JobInvokeUtil;
 import org.quartz.JobExecutionContext;
-
+/**
+ * 主要功能是作为定时任务的执行入口，将配置好的作业任务进行实际调用执行。
+ */
 public class QuartzJobExecution extends AbstractQuartzJob {
-
     @Override
     protected void doExecute(JobExecutionContext context, Job job) throws Exception {
         JobInvokeUtil.invokeMethod(job);
     }
-}
+
+}