refactor(basic): 重构渲染机相关代码

- 移除了 RenderWorkerMapper 中的未使用的接口
- 精简了 RenderWorkerEntity 中的字段
-重构了 RenderWorkerRepository 中的缓存逻辑
- 更新了 RenderWorkerService 接口和实现类，使用新的 RenderWorkerRespVO 响应对象
- 调整了 TaskTaskServiceImpl 中的渲染机相关代码，使用新的配置管理方式

src/main/java/com/ycwl/basic/controller/pc/RenderWorkerV2Controller.java

@@ -0,0 +1,302 @@
+package com.ycwl.basic.controller.pc;
+
+import com.github.pagehelper.PageInfo;
+import com.ycwl.basic.model.pc.renderWorker.entity.RenderWorkerEntity;
+import com.ycwl.basic.model.pc.renderWorker.req.RenderWorkerReqQuery;
+import com.ycwl.basic.model.pc.renderWorker.resp.RenderWorkerRespVO;
+import com.ycwl.basic.service.pc.RenderWorkerService;
+import com.ycwl.basic.utils.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 渲染机管理 V2 版本控制器
+ * 
+ * @author Claude Code
+ * @date 2025-09-05
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/renderWorker/v2")
+@RequiredArgsConstructor
+public class RenderWorkerV2Controller {
+
+    private final RenderWorkerService renderWorkerService;
+
+    // ========== 渲染机基础 CRUD 操作 ==========
+
+    /**
+     * 渲染机分页列表查询
+     */
+    @GetMapping("/")
+    public ApiResponse<PageInfo<RenderWorkerRespVO>> listRenderWorkers(@RequestParam(defaultValue = "1") Integer page,
+                                                                       @RequestParam(defaultValue = "10") Integer pageSize,
+                                                                       @RequestParam(required = false) String name,
+                                                                       @RequestParam(required = false) String platform,
+                                                                       @RequestParam(required = false) Long scenicOnly,
+                                                                       @RequestParam(required = false) Integer testOnly,
+                                                                       @RequestParam(required = false) Integer online,
+                                                                       @RequestParam(required = false) Integer status) {
+        log.info("分页查询渲染机列表, page: {}, pageSize: {}, name: {}, platform: {}, scenicOnly: {}, testOnly: {}, online: {}, status: {}", 
+                page, pageSize, name, platform, scenicOnly, testOnly, online, status);
+        
+        // 参数验证：限制pageSize最大值为100
+        if (pageSize > 100) {
+            pageSize = 100;
+        }
+        
+        try {
+            RenderWorkerReqQuery queryReq = new RenderWorkerReqQuery();
+            queryReq.setPageNum(page);
+            queryReq.setPageSize(pageSize);
+            queryReq.setName(name);
+            queryReq.setPlatform(platform);
+            queryReq.setScenicOnly(scenicOnly);
+            queryReq.setTestOnly(testOnly);
+            queryReq.setOnline(online);
+            queryReq.setStatus(status);
+            
+            return renderWorkerService.pageQuery(queryReq);
+        } catch (Exception e) {
+            log.error("分页查询渲染机列表失败", e);
+            return ApiResponse.fail("分页查询渲染机列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据ID获取渲染机详情
+     */
+    @GetMapping("/{id}")
+    public ApiResponse<RenderWorkerRespVO> getRenderWorker(@PathVariable Long id) {
+        try {
+            return renderWorkerService.detail(id);
+        } catch (Exception e) {
+            log.error("获取渲染机详情失败, id: {}", id, e);
+            return ApiResponse.fail("获取渲染机详情失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建渲染机
+     */
+    @PostMapping("/")
+    public ApiResponse<Integer> createRenderWorker(@Valid @RequestBody RenderWorkerEntity renderWorker) {
+        log.info("创建渲染机, name: {}, accessKey: {}, scenicOnly: {}, testOnly: {}", 
+                renderWorker.getName(), renderWorker.getAccessKey(), renderWorker.getScenicOnly(), renderWorker.getTestOnly());
+        try {
+            return renderWorkerService.add(renderWorker);
+        } catch (Exception e) {
+            log.error("创建渲染机失败", e);
+            return ApiResponse.fail("创建渲染机失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 更新渲染机信息
+     */
+    @PutMapping("/{id}")
+    public ApiResponse<Integer> updateRenderWorker(@PathVariable Long id, @Valid @RequestBody RenderWorkerEntity renderWorker) {
+        log.info("更新渲染机信息, id: {}", id);
+        try {
+            renderWorker.setId(id);
+            return renderWorkerService.update(renderWorker);
+        } catch (Exception e) {
+            log.error("更新渲染机信息失败, id: {}", id, e);
+            return ApiResponse.fail("更新渲染机信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 删除渲染机
+     */
+    @DeleteMapping("/{id}")
+    public ApiResponse<Integer> deleteRenderWorker(@PathVariable Long id) {
+        log.info("删除渲染机, id: {}", id);
+        try {
+            return renderWorkerService.deleteById(id);
+        } catch (Exception e) {
+            log.error("删除渲染机失败, id: {}", id, e);
+            return ApiResponse.fail("删除渲染机失败: " + e.getMessage());
+        }
+    }
+
+    // ========== 状态管理操作 ==========
+
+    /**
+     * 启用渲染机
+     */
+    @PutMapping("/{id}/enable")
+    public ApiResponse<String> enableRenderWorker(@PathVariable Long id) {
+        log.info("启用渲染机, id: {}", id);
+        try {
+            // 获取渲染机信息
+            ApiResponse<RenderWorkerRespVO> detailResponse = renderWorkerService.detail(id);
+            if (!detailResponse.isSuccess()) {
+                return ApiResponse.fail("渲染机不存在");
+            }
+            
+            // 更新状态
+            RenderWorkerEntity entity = new RenderWorkerEntity();
+            entity.setId(id);
+            entity.setStatus(1); // 1表示启用
+            
+            ApiResponse<Integer> updateResponse = renderWorkerService.update(entity);
+            if (updateResponse.isSuccess()) {
+                return ApiResponse.success("渲染机启用成功");
+            } else {
+                return ApiResponse.fail("渲染机启用失败");
+            }
+        } catch (Exception e) {
+            log.error("启用渲染机失败, id: {}", id, e);
+            return ApiResponse.fail("启用渲染机失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 禁用渲染机
+     */
+    @PutMapping("/{id}/disable")
+    public ApiResponse<String> disableRenderWorker(@PathVariable Long id) {
+        log.info("禁用渲染机, id: {}", id);
+        try {
+            // 获取渲染机信息
+            ApiResponse<RenderWorkerRespVO> detailResponse = renderWorkerService.detail(id);
+            if (!detailResponse.isSuccess()) {
+                return ApiResponse.fail("渲染机不存在");
+            }
+            
+            // 更新状态
+            RenderWorkerEntity entity = new RenderWorkerEntity();
+            entity.setId(id);
+            entity.setStatus(0); // 0表示禁用
+            
+            ApiResponse<Integer> updateResponse = renderWorkerService.update(entity);
+            if (updateResponse.isSuccess()) {
+                return ApiResponse.success("渲染机禁用成功");
+            } else {
+                return ApiResponse.fail("渲染机禁用失败");
+            }
+        } catch (Exception e) {
+            log.error("禁用渲染机失败, id: {}", id, e);
+            return ApiResponse.fail("禁用渲染机失败: " + e.getMessage());
+        }
+    }
+
+    // ========== 配置管理操作 ==========
+    // 注意：以下配置管理方法需要根据实际的RenderWorker配置服务进行调整
+    // 目前暂时保留接口结构，等待配置相关服务的具体实现
+
+    /**
+     * 获取渲染机配置列表
+     */
+    @GetMapping("/{id}/config")
+    public ApiResponse<List<Map<String, Object>>> getRenderWorkerConfigs(@PathVariable Long id) {
+        log.info("获取渲染机配置列表, renderWorkerId: {}", id);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("获取渲染机配置列表失败, renderWorkerId: {}", id, e);
+            return ApiResponse.fail("获取渲染机配置列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 获取渲染机扁平化配置
+     */
+    @GetMapping("/{id}/flat-config")
+    public ApiResponse<Map<String, Object>> getRenderWorkerFlatConfig(@PathVariable Long id) {
+        log.info("获取渲染机扁平化配置, renderWorkerId: {}", id);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("获取渲染机扁平化配置失败, renderWorkerId: {}", id, e);
+            return ApiResponse.fail("获取渲染机扁平化配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据配置键获取配置
+     */
+    @GetMapping("/{id}/config/{configKey}")
+    public ApiResponse<Map<String, Object>> getRenderWorkerConfigByKey(@PathVariable Long id, 
+                                                                       @PathVariable String configKey) {
+        log.info("根据键获取渲染机配置, renderWorkerId: {}, configKey: {}", id, configKey);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("根据键获取渲染机配置失败, renderWorkerId: {}, configKey: {}", id, configKey, e);
+            return ApiResponse.fail("根据键获取渲染机配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建渲染机配置
+     */
+    @PostMapping("/{id}/config")
+    public ApiResponse<Map<String, Object>> createRenderWorkerConfig(@PathVariable Long id, 
+                                                                     @Valid @RequestBody Map<String, Object> request) {
+        log.info("创建渲染机配置, renderWorkerId: {}", id);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("创建渲染机配置失败, renderWorkerId: {}", id, e);
+            return ApiResponse.fail("创建渲染机配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 批量创建/更新渲染机配置
+     */
+    @PostMapping("/{id}/config/batch")
+    public ApiResponse<Map<String, Object>> batchUpdateRenderWorkerConfig(@PathVariable Long id, 
+                                                                          @Valid @RequestBody Map<String, Object> request) {
+        log.info("批量更新渲染机配置, renderWorkerId: {}", id);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("批量更新渲染机配置失败, renderWorkerId: {}", id, e);
+            return ApiResponse.fail("批量更新渲染机配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 更新渲染机配置
+     */
+    @PutMapping("/{id}/config/{configId}")
+    public ApiResponse<String> updateRenderWorkerConfig(@PathVariable Long id, @PathVariable Long configId,
+                                                        @Valid @RequestBody Map<String, Object> request) {
+        log.info("更新渲染机配置, renderWorkerId: {}, configId: {}", id, configId);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("更新渲染机配置失败, renderWorkerId: {}, configId: {}", id, configId, e);
+            return ApiResponse.fail("更新渲染机配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 删除渲染机配置
+     */
+    @DeleteMapping("/{id}/config/{configId}")
+    public ApiResponse<String> deleteRenderWorkerConfig(@PathVariable Long id, @PathVariable Long configId) {
+        log.info("删除渲染机配置, renderWorkerId: {}, configId: {}", id, configId);
+        try {
+            // TODO: 需要实现RenderWorker配置服务
+            return ApiResponse.fail("配置管理功能待实现");
+        } catch (Exception e) {
+            log.error("删除渲染机配置失败, renderWorkerId: {}, configId: {}", id, configId, e);
+            return ApiResponse.fail("删除渲染机配置失败: " + e.getMessage());
+        }
+    }
+}

src/main/java/com/ycwl/basic/mapper/RenderWorkerMapper.java

@@ -14,13 +14,9 @@ import java.util.List;
 @Mapper
 public interface RenderWorkerMapper {
     List<RenderWorkerEntity> list(RenderWorkerReqQuery renderWorkerReqQuery);
-    RenderWorkerEntity getById(Long id);
     int add(RenderWorkerEntity renderWorker);
     int deleteById(Long id);
     int update(RenderWorkerEntity renderWorker);
     int updateStatus(Long id);
 
-    RenderWorkerEntity findByAccessKey(String accessKey);
-
-    int updateHost(Long id, RenderWorkerEntity status);
 }

src/main/java/com/ycwl/basic/model/pc/renderWorker/entity/RenderWorkerEntity.java

@@ -22,42 +22,10 @@ public class RenderWorkerEntity {
      * 渲染机名称
      */
     private String name;
-    /**
-     * 系统
-     */
-    private String platform;
-    /**
-     * 运行环境
-     */
-    private String runtimeVersion;
-    /**
-     * 版本
-     */
-    private String version;
     /**
      * 访问秘钥
      */
     private String accessKey;
-    /**
-     * cpu数量
-     */
-    private Integer cpuCount;
-    /**
-     * cpu使用率
-     */
-    private BigDecimal cpuUsage;
-    /**
-     * 内存总量，MB
-     */
-    private BigDecimal memoryTotal;
-    /**
-     * 内存余量，MB
-     */
-    private BigDecimal memoryAvailable;
-    /**
-     * 支持的功能，逗号隔开
-     */
-    private String supportFeature;
     /**
      * 是否仅用于指定景区，空或0不适用，否则为景区ID
      */
@@ -66,24 +34,10 @@ public class RenderWorkerEntity {
      * 是否仅用于测试，0不是，1是
      */
     private Integer testOnly;
-    /**
-     * 是否在线，0不在，1在
-     */
-    private Integer online;
     /**
      * 状态，0禁用，1启用
      */
     private Integer status;
     private Date createAt;
     private Date updateAt;
-
-
-    /**
-     * 存储类型
-     */
-    private StorageType storeType;
-    /**
-     * 存储配置
-     */
-    private String storeConfigJson;
 }

src/main/java/com/ycwl/basic/repository/RenderWorkerRepository.java

@@ -1,7 +1,6 @@
 package com.ycwl.basic.repository;
 
 import com.ycwl.basic.utils.JacksonUtil;
-import com.ycwl.basic.mapper.RenderWorkerMapper;
 import com.ycwl.basic.model.pc.renderWorker.entity.RenderWorkerEntity;
 import com.ycwl.basic.model.task.req.ClientStatusReqVo;
 import com.ycwl.basic.integration.render.dto.worker.RenderWorkerV2DTO;
@@ -25,11 +24,7 @@ import java.util.concurrent.TimeUnit;
 public class RenderWorkerRepository {
     @Autowired
     private RedisTemplate<String, String> redisTemplate;
-    public static final String RENDER_WORKER_CACHE_KEY = "render_worker:%s";
     public static final String RENDER_WORKER_STATUS_CACHE_KEY = "render_worker:host_status:%s";
-    public static final String RENDER_WORKER_CONFIG_CACHE_KEY = "render_worker:%s:config";
-    @Autowired
-    private RenderWorkerMapper mapper;
     
     @Autowired
     private RenderWorkerIntegrationService renderWorkerIntegrationService;
@@ -61,21 +56,6 @@ public class RenderWorkerRepository {
             return;
         }
         status.setUpdateAt(new Date());
-        RenderWorkerEntity worker = new RenderWorkerEntity();
-        worker.setCpuCount(status.getCpu_count());
-        worker.setCpuUsage(status.getCpu_usage());
-        // 上报的是字节，存储的是兆
-        worker.setMemoryAvailable(status.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
-        worker.setMemoryTotal(status.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
-
-        worker.setPlatform(status.getPlatform());
-        worker.setRuntimeVersion(status.getRuntime_version());
-        worker.setSupportFeature(String.join(",", status.getSupport_feature()));
-        worker.setVersion(status.getVersion());
-        worker.setUpdateAt(status.getUpdateAt());
-        if (!redisTemplate.hasKey(key)) {
-            mapper.updateHost(id, worker);
-        }
         redisTemplate.opsForValue().set(key, JacksonUtil.toJSONString(status), 1, TimeUnit.HOURS);
     }
 
@@ -88,15 +68,6 @@ public class RenderWorkerRepository {
         return null;
     }
 
-    public void clearCache(Long id) {
-        RenderWorkerEntity worker = getWorker(id);
-        redisTemplate.delete(String.format(RENDER_WORKER_CACHE_KEY, id));
-        if (worker != null) {
-            redisTemplate.delete(String.format(RENDER_WORKER_CACHE_KEY, worker.getAccessKey()));
-        }
-        redisTemplate.delete(String.format(RENDER_WORKER_STATUS_CACHE_KEY, id));
-    }
-
     private RenderWorkerEntity convertToEntity(RenderWorkerV2DTO dto) {
         if (dto == null) {
             return null;

src/main/java/com/ycwl/basic/service/pc/RenderWorkerService.java

@@ -3,6 +3,7 @@ package com.ycwl.basic.service.pc;
 import com.github.pagehelper.PageInfo;
 import com.ycwl.basic.model.pc.renderWorker.entity.RenderWorkerEntity;
 import com.ycwl.basic.model.pc.renderWorker.req.RenderWorkerReqQuery;
+import com.ycwl.basic.model.pc.renderWorker.resp.RenderWorkerRespVO;
 import com.ycwl.basic.utils.ApiResponse;
 
 import java.util.List;
@@ -12,9 +13,9 @@ import java.util.List;
  * @Date：2024/12/3 15:07
  */
 public interface RenderWorkerService {
-    ApiResponse<PageInfo<RenderWorkerEntity>> pageQuery(RenderWorkerReqQuery renderWorkerReqQuery);
+    ApiResponse<PageInfo<RenderWorkerRespVO>> pageQuery(RenderWorkerReqQuery renderWorkerReqQuery);
-    ApiResponse<List<RenderWorkerEntity>> list(RenderWorkerReqQuery renderWorkerReqQuery);
+    ApiResponse<List<RenderWorkerRespVO>> list(RenderWorkerReqQuery renderWorkerReqQuery);
-    ApiResponse<RenderWorkerEntity> detail(Long id);
+    ApiResponse<RenderWorkerRespVO> detail(Long id);
     ApiResponse<Integer> add(RenderWorkerEntity renderWorker);
     ApiResponse<Integer> deleteById(Long id);
     ApiResponse<Integer> update(RenderWorkerEntity renderWorker);

src/main/java/com/ycwl/basic/service/pc/impl/RenderWorkerServiceImpl.java

@@ -5,6 +5,7 @@ import com.github.pagehelper.PageInfo;
 import com.ycwl.basic.mapper.RenderWorkerMapper;
 import com.ycwl.basic.model.pc.renderWorker.entity.RenderWorkerEntity;
 import com.ycwl.basic.model.pc.renderWorker.req.RenderWorkerReqQuery;
+import com.ycwl.basic.model.pc.renderWorker.resp.RenderWorkerRespVO;
 import com.ycwl.basic.model.task.req.ClientStatusReqVo;
 import com.ycwl.basic.repository.RenderWorkerRepository;
 import com.ycwl.basic.service.pc.RenderWorkerService;
@@ -31,72 +32,96 @@ public class RenderWorkerServiceImpl implements RenderWorkerService {
     private RenderWorkerRepository renderWorkerRepository;
 
     @Override
-    public ApiResponse<PageInfo<RenderWorkerEntity>> pageQuery(RenderWorkerReqQuery renderWorkerReqQuery) {
+    public ApiResponse<PageInfo<RenderWorkerRespVO>> pageQuery(RenderWorkerReqQuery renderWorkerReqQuery) {
         PageHelper.startPage(renderWorkerReqQuery.getPageNum(), renderWorkerReqQuery.getPageSize());
         List<RenderWorkerEntity> list = renderWorkerMapper.list(renderWorkerReqQuery);
-        list.forEach(worker -> {
+        List<RenderWorkerRespVO> workerList = list.stream().map(worker -> {
+            RenderWorkerRespVO resp = new RenderWorkerRespVO();
+            resp.setId(worker.getId());
+            resp.setName(worker.getName());
+            resp.setAccessKey(worker.getAccessKey());
+            resp.setStatus(worker.getStatus());
+            resp.setCreateAt(worker.getCreateAt());
+            resp.setUpdateAt(worker.getUpdateAt());
             ClientStatusReqVo clientStatus = renderWorkerRepository.getWorkerHostStatus(worker.getId());
             if (clientStatus == null) {
-                return;
+                return resp;
             }
-            worker.setCpuCount(clientStatus.getCpu_count());
+            resp.setCpuCount(clientStatus.getCpu_count());
-            worker.setCpuUsage(clientStatus.getCpu_usage());
+            resp.setCpuUsage(clientStatus.getCpu_usage());
             // 上报的是字节，存储的是兆
-            worker.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
-            worker.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
 
-            worker.setPlatform(clientStatus.getPlatform());
+            resp.setPlatform(clientStatus.getPlatform());
-            worker.setRuntimeVersion(clientStatus.getRuntime_version());
+            resp.setRuntimeVersion(clientStatus.getRuntime_version());
-            worker.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
+            resp.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
-            worker.setVersion(clientStatus.getVersion());
+            resp.setVersion(clientStatus.getVersion());
-            worker.setUpdateAt(clientStatus.getUpdateAt());
+            resp.setUpdateAt(clientStatus.getUpdateAt());
-        });
+            return resp;
-        PageInfo<RenderWorkerEntity> pageInfo = new PageInfo<>(list);
+        }).toList();
+        PageInfo<RenderWorkerRespVO> pageInfo = new PageInfo<>(workerList);
         return ApiResponse.success(pageInfo);
     }
 
     @Override
-    public ApiResponse<List<RenderWorkerEntity>> list(RenderWorkerReqQuery renderWorkerReqQuery) {
+    public ApiResponse<List<RenderWorkerRespVO>> list(RenderWorkerReqQuery renderWorkerReqQuery) {
         List<RenderWorkerEntity> list = renderWorkerMapper.list(renderWorkerReqQuery);
-        list.forEach(worker -> {
+        List<RenderWorkerRespVO> workerList = list.stream().map(worker -> {
+            RenderWorkerRespVO resp = new RenderWorkerRespVO();
+            resp.setId(worker.getId());
+            resp.setName(worker.getName());
+            resp.setAccessKey(worker.getAccessKey());
+            resp.setStatus(worker.getStatus());
+            resp.setCreateAt(worker.getCreateAt());
+            resp.setUpdateAt(worker.getUpdateAt());
             ClientStatusReqVo clientStatus = renderWorkerRepository.getWorkerHostStatus(worker.getId());
             if (clientStatus == null) {
-                return;
+                return resp;
             }
-            worker.setCpuCount(clientStatus.getCpu_count());
+            resp.setCpuCount(clientStatus.getCpu_count());
-            worker.setCpuUsage(clientStatus.getCpu_usage());
+            resp.setCpuUsage(clientStatus.getCpu_usage());
             // 上报的是字节，存储的是兆
-            worker.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
-            worker.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
 
-            worker.setPlatform(clientStatus.getPlatform());
+            resp.setPlatform(clientStatus.getPlatform());
-            worker.setRuntimeVersion(clientStatus.getRuntime_version());
+            resp.setRuntimeVersion(clientStatus.getRuntime_version());
-            worker.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
+            resp.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
-            worker.setVersion(clientStatus.getVersion());
+            resp.setVersion(clientStatus.getVersion());
-            worker.setUpdateAt(clientStatus.getUpdateAt());
+            resp.setUpdateAt(clientStatus.getUpdateAt());
-        });
+            return resp;
-        return ApiResponse.success(list);
+        }).toList();
+        return ApiResponse.success(workerList);
     }
 
     @Override
-    public ApiResponse<RenderWorkerEntity> detail(Long id) {
+    public ApiResponse<RenderWorkerRespVO> detail(Long id) {
-        RenderWorkerEntity worker = renderWorkerMapper.getById(id);
+        RenderWorkerEntity worker = renderWorkerRepository.getWorker(id);
+
+        RenderWorkerRespVO resp = new RenderWorkerRespVO();
+        resp.setId(worker.getId());
+        resp.setName(worker.getName());
+        resp.setAccessKey(worker.getAccessKey());
+        resp.setStatus(worker.getStatus());
+        resp.setCreateAt(worker.getCreateAt());
+        resp.setUpdateAt(worker.getUpdateAt());
 
         ClientStatusReqVo clientStatus = renderWorkerRepository.getWorkerHostStatus(worker.getId());
         if (clientStatus != null) {
-            worker.setCpuCount(clientStatus.getCpu_count());
+            resp.setCpuCount(clientStatus.getCpu_count());
-            worker.setCpuUsage(clientStatus.getCpu_usage());
+            resp.setCpuUsage(clientStatus.getCpu_usage());
             // 上报的是字节，存储的是兆
-            worker.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryAvailable(clientStatus.getMemory_available().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
-            worker.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
+            resp.setMemoryTotal(clientStatus.getMemory_total().divide(BigDecimal.valueOf(1024 * 1024), RoundingMode.CEILING));
 
-            worker.setPlatform(clientStatus.getPlatform());
+            resp.setPlatform(clientStatus.getPlatform());
-            worker.setRuntimeVersion(clientStatus.getRuntime_version());
+            resp.setRuntimeVersion(clientStatus.getRuntime_version());
-            worker.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
+            resp.setSupportFeature(String.join(",", clientStatus.getSupport_feature()));
-            worker.setVersion(clientStatus.getVersion());
+            resp.setVersion(clientStatus.getVersion());
-            worker.setUpdateAt(clientStatus.getUpdateAt());
+            resp.setUpdateAt(clientStatus.getUpdateAt());
         }
-        return ApiResponse.success(worker);
+        return ApiResponse.success(resp);
     }
 
     @Override
@@ -116,13 +141,11 @@ public class RenderWorkerServiceImpl implements RenderWorkerService {
 
     @Override
     public ApiResponse<Integer> deleteById(Long id) {
-        renderWorkerRepository.clearCache(id);
         return ApiResponse.success(renderWorkerMapper.deleteById(id));
     }
 
     @Override
     public ApiResponse<Integer> update(RenderWorkerEntity renderWorker) {
-        renderWorkerRepository.clearCache(renderWorker.getId());
         int update = renderWorkerMapper.update(renderWorker);
         if (update == 0) {
             return ApiResponse.fail("渲染机修改失败");
@@ -133,7 +156,6 @@ public class RenderWorkerServiceImpl implements RenderWorkerService {
 
     @Override
     public ApiResponse<Integer> updateStatus(Long id) {
-        renderWorkerRepository.clearCache(id);
         return ApiResponse.success(renderWorkerMapper.updateStatus(id));
     }
 }

src/main/java/com/ycwl/basic/service/task/impl/TaskTaskServiceImpl.java

@@ -1,6 +1,7 @@
 package com.ycwl.basic.service.task.impl;
 
 import cn.hutool.core.date.DateUtil;
+import com.ycwl.basic.integration.common.manager.RenderWorkerConfigManager;
 import com.ycwl.basic.utils.JacksonUtil;
 import com.ycwl.basic.biz.OrderBiz;
 import com.ycwl.basic.biz.TaskStatusBiz;
@@ -10,7 +11,6 @@ import com.ycwl.basic.constant.TaskConstant;
 import com.ycwl.basic.mapper.FaceMapper;
 import com.ycwl.basic.mapper.FaceSampleMapper;
 import com.ycwl.basic.mapper.MemberMapper;
-import com.ycwl.basic.mapper.RenderWorkerMapper;
 import com.ycwl.basic.mapper.SourceMapper;
 import com.ycwl.basic.mapper.TaskMapper;
 import com.ycwl.basic.mapper.TemplateMapper;
@@ -134,7 +134,6 @@ public class TaskTaskServiceImpl implements TaskService {
         if (worker == null) {
             return null;
         }
-        worker.setOnline(1);
         worker.setName(null);
         worker.setStatus(null);
         // get status
@@ -174,7 +173,6 @@ public class TaskTaskServiceImpl implements TaskService {
                     taskList.forEach(task -> {
                         taskMapper.assignToWorker(task.getId(), worker.getId());
                         videoTaskRepository.clearTaskCache(task.getId());
-                        repository.clearCache(worker.getId());
                     });
                 } finally {
                     lock.unlock();
@@ -540,10 +538,11 @@ public class TaskTaskServiceImpl implements TaskService {
         if (worker == null) {
             return null;
         }
+        RenderWorkerConfigManager config = repository.getWorkerConfigManager(worker.getId());
         IStorageAdapter adapter;
         try {
-            adapter = StorageFactory.get(worker.getStoreType());
+            adapter = StorageFactory.get(config.getString("store_type"));
-            adapter.loadConfig(JacksonUtil.parseObject(worker.getStoreConfigJson(), Map.class));
+            adapter.loadConfig(config.getObject("store_config_json", Map.class));
         } catch (Exception e) {
             adapter = scenicService.getScenicStorageAdapter(task.getScenicId());
         }