/**
 * 導(dǎo)出線程池配置
 */
@Configuration
@Slf4j
public class ThreadPoolExportExecutorConfig {
 
    @Bean("ExportServiceExecutor")
    @Primary
    public Executor exportServiceExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心線程數(shù)
        executor.setCorePoolSize(12);
        //配置最大線程數(shù)
        executor.setMaxPoolSize(20);
        //空閑時(shí)間
        executor.setKeepAliveSeconds(60);
        //配置隊(duì)列大小
        executor.setQueueCapacity(100);
        //配置線程池中的線程的名稱前綴
        executor.setThreadNamePrefix("ExportThread-");
        // rejection-policy：當(dāng)pool已經(jīng)達(dá)到max size的時(shí)候，如何處理新任務(wù)
        // CALLER_RUNS：不在新線程中執(zhí)行任務(wù)，而是有調(diào)用者所在的線程來(lái)執(zhí)行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //執(zhí)行初始化
        executor.initialize();
        return executor;
    }
}

public class PojoInfoUtil {
 
    /**
     * ListDTO轉(zhuǎn)換
     *
     * @param <E>       entity類
     * @param <D>       DTO類
     * @param listInfoE listInfoE<E>類對(duì)象
     * @return List<D>  轉(zhuǎn)換后List<D>
     */
    public static <E, D> List<D> listInfoToDTO(List<E> listInfo, Class<D> dtoClass) {
 
        if (CollectionUtils.isEmpty(listInfo)) {
            return Lists.newArrayList();
        }
 
        // 創(chuàng)建 ModelMapper 實(shí)例
        ModelMapper modelMapper = new ModelMapper();
 
        // 設(shè)置匹配策略為基于字段名稱
        modelMapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
 
        // 使用流和 ModelMapper 進(jìn)行轉(zhuǎn)換
        List<D> list = listInfo.stream()
                .map(entity -> modelMapper.map(entity, dtoClass))
                .collect(Collectors.toList());
 
        // 釋放舊數(shù)據(jù)
        listInfo.clear();
 
        return list;
    }

@Component
public class MultiThreadExportUtil {
 
    @Resource(name = "ExportServiceExecutor")
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 
    @Autowired
    private DicAdapter dicAdapter;
 
    /**
     *
     * @param exportClazz 導(dǎo)出實(shí)體類
     * @param dictFieldNames 字典轉(zhuǎn)換字段
     * @param fileName 導(dǎo)出文件名稱
     * @param SheetNamePre sheet頁(yè)名前綴
     * @param service 查詢接口類
     * @param queryWrapper 查詢條件
     */
    public void exprtBythread(Class<?> exportClazz,List<String> dictFieldNames,String fileName,String SheetNamePre,IService service, LambdaQueryWrapper<?> queryWrapper){
        HttpServletResponse response = HttpServletUtil.getResponse();
        Map<String, String> threadExportLimit = dicAdapter.getBasicInfoDicMapInfo("threadExportLimit");
 
        if(ObjectUtils.isEmpty(threadExportLimit) || !threadExportLimit.containsKey("limit") || !threadExportLimit.containsKey("maxLimit")){
            throw new BizException("請(qǐng)?zhí)崆芭渲脤?dǎo)出數(shù)量限制");
        }
 
        //每次請(qǐng)求限制條數(shù)
        int limit = Integer.parseInt(threadExportLimit.get("limit"));
        //最大限制條數(shù)
        int maxLimit = Integer.parseInt(threadExportLimit.get("maxLimit"));
 
        int count = service.count(queryWrapper);
 
        if(count > maxLimit) throw new BizException("導(dǎo)出條數(shù)超出最大條數(shù)" + maxLimit + "限制,請(qǐng)調(diào)整查詢條件");
 
 
        //設(shè)置響應(yīng)頭
        response.setContentType("application/vnd.ms-excel");
        response.setCharacterEncoding("utf-8");
        try {
            String name = URLEncoder.encode(fileName, "UTF-8");
            response.setHeader("Content-disposition", "attachment;filename=" + name + ".xlsx");
        } catch (Exception e) {
            throw new BizException(e.getMessage());
        }
 
        // 查詢次數(shù)
        int i = (count + limit - 1) / limit;
 
        AtomicReference<ExcelWriter> excelWriterRef = new AtomicReference<>();
        ServletOutputStream outputStream = null;
 
        try {
            outputStream = response.getOutputStream();
            excelWriterRef.set(EasyExcel.write(outputStream, exportClazz).build());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
 
        if(i == 0){
            WriteSheet writeSheet = EasyExcel.writerSheet(SheetNamePre).head(exportClazz)
                    .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
            excelWriterRef.get().write(null, writeSheet);
            excelWriterRef.get().finish();
            return;
        }
 
 
        //計(jì)數(shù)器
        CountDownLatch countDownLatch = new CountDownLatch(i);
 
 
        // 使用 PriorityBlockingQueue 作為查詢結(jié)果的緩沖區(qū)
        BlockingQueue<ThreadQueryResult> resultQueue = new PriorityBlockingQueue<ThreadQueryResult>();
 
 
        for(int j = 0; j < i; j++){
 
            int pageNo =  j + 1;
            String sheetName = SheetNamePre + pageNo;
            threadPoolTaskExecutor.execute(()->{
                try {
 
                    IPage<T> page = service.page(new Page<>(pageNo, limit), queryWrapper);
 
                    List<T> records = page.getRecords();
 
                    //轉(zhuǎn)換
                    List<?> exportList = PojoInfoUtil.listInfoToDTO(records, exportClazz);
                    //處理字典數(shù)據(jù)
                    convertFieldWithDictionary(exportList,dictFieldNames);
 
                    resultQueue.put(new ThreadQueryResult(pageNo, sheetName, exportList));
 
                }catch (Exception e){
                    e.printStackTrace();
                    LogUtil.info("查詢第" + pageNo + "頁(yè)時(shí)，發(fā)生異常" + e.getMessage());
                    throw new BizException("查詢第" + pageNo + "頁(yè)時(shí)，發(fā)生異常" + e.getMessage());
                }
            });
            countDownLatch.countDown();
        }
 
        // 啟動(dòng)一個(gè)寫入線程  按照查詢順序讀取 寫入
        CompletableFuture<Void> writeFuture  = CompletableFuture.runAsync(() -> {
            for (int pageNo = 1; pageNo <= i; ) {
                boolean interrupted = false;
                try {
                    while (true) {
                        ThreadQueryResult result = resultQueue.take();
                        if (result.getPageNo() == pageNo) {
 
                            WriteSheet writeSheet = EasyExcel.writerSheet(result.getSheetName()).head(exportClazz)
                                    .registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
 
                            ExcelWriter excelWriter = excelWriterRef.get();
                            excelWriter.write(result.getRecords(), writeSheet);
                            result.getRecords().clear(); //及時(shí)釋放寫入數(shù)據(jù)
 
                            pageNo++;
                            break;
                        } else {
                            // 如果不是當(dāng)前需要的 pageNo，則放回隊(duì)列
                            resultQueue.put(result);
                        }
                    }
                } catch (InterruptedException e) {
                    interrupted = true;
                    LogUtil.error("寫入線程被中斷: " + e.getMessage());
                } finally {
                    if (interrupted) {
                        Thread.currentThread().interrupt(); // 重新設(shè)置中斷標(biāo)志
                    }
                }
            }
        }, threadPoolTaskExecutor);
 
        // 等待所有任務(wù)完成
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //等待寫入線程完成
        writeFuture.join();
 
        // 關(guān)閉 ExcelWriter
        ExcelWriter excelWriter = excelWriterRef.get();
        if (excelWriter != null) {
            excelWriter.finish();
        }
    }
 
 
 
 
    /**
     * 對(duì)給定的對(duì)象列表中的指定字段進(jìn)行字典轉(zhuǎn)換。
     *
     * @param records   要轉(zhuǎn)換的對(duì)象列表
     * @param fieldDictNames 字段名列表(帶前綴)
     * @param <T>       對(duì)象類型
     */
    public <T> void convertFieldWithDictionary(List<T> records, List<String> fieldDictNames) {
        if (CollectionUtils.isEmpty(records) || CollectionUtils.isEmpty(fieldDictNames)) {
            return;
        }
 
        Map<String, Map<String, String>> dictMap = dicAdapter.handleStaticBasicInfoDicMap();
        try {
            for (String fieldDictName : fieldDictNames) {
                //前綴區(qū)分各實(shí)體類字段
                if(StringUtils.isBlank(fieldDictName) || !fieldDictName.contains("-")){
                    return;
                }
                String fieldName = fieldDictName.split("-")[1];
                for (T record : records) {
 
                    Field field = record.getClass().getDeclaredField(fieldName);
                    field.setAccessible(true);
 
                    Object fieldValue = field.get(record);
                    if (fieldValue != null && dictMap.containsKey(fieldDictName)) {
 
                        Map<String, String> dictValueMap = dictMap.get(fieldDictName);
 
                        if (dictValueMap != null && dictValueMap.containsKey(fieldValue)) {
                            String dictValue = dictValueMap.get(fieldValue);
                            if (dictValue != null) {
                                field.set(record, dictValue);
                            }
                        }
                    }
                }
            }
        } catch(Exception e){
            LogUtil.error("導(dǎo)出轉(zhuǎn)換字典失敗，請(qǐng)聯(lián)系管理員" + e);
            throw new BizException("導(dǎo)出轉(zhuǎn)換字典失敗，請(qǐng)聯(lián)系管理員"+ e);
        }
    }
}