# 言
寒不冻，心冻；云不散，人散。

# 旨
> 极限不被定义，领域不被约束。


![Logo.png](/static/img/898b0779c4d8f02d973f4f6b82c4a900.Logo.webp)

极 · 域

# 【极域云】https://cloud.zhoudeshui.top
:::tip{title="提示"}
历经磨难，空间数据丢失、代理混乱、证书过期，终于它来了😀👍

【极域云】我分享文件需要QQ微信去传输，各种商业网盘又是限速又是需要下载APP，不爽！咱有这条件为什么不搭建一个呢🤔

此云盘不需要注册不需要下载APP上传即可使用，用于必要时的文件传输，但切不可当做永久存储空间噢☝

【地址】https://cloud.zhoudeshui.top 😋
:::

![极域云盘.png](https://zhoudeshui.top/static/img/eefb718933264c46b4957970daea9474.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
> **双击进入文件夹，文件支持预览，例如图片视频等还有office相关文件，不过可能需要注册相应服务账号**

## 服务公告
![极域云盘服务协议.png](https://zhoudeshui.top/static/img/d69ed44e12321966acac12756231f038.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

【极域云】ADomain · Cloud

# pom依赖
```xml
        
        <dependency>
            <groupId>com.luhuiguo</groupId>
            <artifactId>aspose-cells</artifactId>
            
            <version>23.1</version>
        </dependency>
```



# Excel2Utils
```java
package top.zhoudeshui.utils;

import com.aspose.cells.SaveFormat;
import com.aspose.cells.Workbook;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.uuid.UUID;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@Slf4j
/**
 * Excel转换工具 - 支持Excel与PDF/其他格式互转
 * @author zhoudeshui
 */
public class Excel2Utils {

    // 验证Aspose许可证（需自行配置）
//    static {
//        try {
//            // 加载许可证文件（如果有商业授权）
////             License license = new License();
////             license.setLicense(new FileInputStream("path/to/license.xml"));
//            log.info("Aspose.Cells 许可证加载成功");
//        } catch (Exception e) {
//            log.warn("Aspose.Cells 许可证未找到，将使用评估模式（可能有水印限制）");
//        }
//    }

    // 输入流 -> 输出流
    public static void convert(InputStream inputStream, OutputStream outputStream, int saveFormat) {
        try {
            Workbook workbook = new Workbook(inputStream);
            workbook.save(outputStream, saveFormat);
            outputStream.flush();
            log.info("Excel转换成功：输入流 -> 输出流，格式: {}", getFormatName(saveFormat));
        } catch (Exception e) {
            log.error("Excel转换失败：输入流 -> 输出流", e);
            throw new ServiceException("Excel转换失败：" + e.getMessage());
        }
    }

    // 输入流 -> 输出文件
    public static File convert(InputStream inputStream, String outputPath, int saveFormat) {
        try (FileOutputStream fos = new FileOutputStream(createOutputFile(outputPath))) {
            convert(inputStream, fos, saveFormat);
            return new File(outputPath); // 直接通过路径创建File对象（与原逻辑一致）
        } catch (Exception e) {
            log.error("Excel转换失败：输入流 -> 输出文件", e);
            throw new ServiceException("Excel转换失败：" + e.getMessage());
        }
    }

    // 输入文件 -> 输出流
    public static void convert(String inputPath, OutputStream outputStream, int saveFormat) {
        try (FileInputStream fis = new FileInputStream(inputPath)) {
            convert(fis, outputStream, saveFormat);
        } catch (Exception e) {
            log.error("Excel转换失败：输入文件 -> 输出流", e);
            throw new ServiceException("Excel转换失败：" + e.getMessage());
        }
    }

    // 输入文件 -> 输出文件
    public static File convert(String inputPath, String outputPath, int saveFormat) {
        try (FileInputStream fis = new FileInputStream(inputPath)) {
            return convert(fis, outputPath, saveFormat);
        } catch (Exception e) {
            log.error("Excel转换失败：输入文件 -> 输出文件", e);
            throw new ServiceException("Excel转换失败：" + e.getMessage());
        }
    }

    // 处理MultipartFile输入
    public static File convert(MultipartFile file, String outputPath, int saveFormat) {
        try {
            return convert(file.getInputStream(), outputPath, saveFormat);
        } catch (Exception e) {
            log.error("Excel转换失败：MultipartFile -> 输出文件", e);
            throw new ServiceException("Excel转换失败：" + e.getMessage());
        }
    }

    // 辅助方法：创建输出文件
    private static File createOutputFile(String outputPath) throws IOException {
        Path outputFilePath = Paths.get(outputPath);
        File outputFile = outputFilePath.toFile();

        // 确保目录存在（合并嵌套的 if 语句）
        Path parentDirPath = outputFilePath.getParent();
        if (parentDirPath != null) {
            File parentDir = parentDirPath.toFile();
            if (!parentDir.exists() && !parentDir.mkdirs()) {
                throw new IOException("无法创建目录: " + parentDir.getAbsolutePath());
            }
        }

        // 如果文件已存在，删除它（使用 Files.delete 获取更详细的错误信息）
        if (Files.exists(outputFilePath)) {
            try {
                Files.delete(outputFilePath);
            } catch (IOException e) {
                throw new IOException("无法删除已存在的文件: " + outputFile.getAbsolutePath(), e);
            }
        }

        return outputFile;
    }

    // 辅助方法：获取格式名称
    private static String getFormatName(int saveFormat) {
        switch (saveFormat) {
            case SaveFormat.PDF:
                return "PDF";
            case SaveFormat.XLSX:
                return "XLSX";
            case SaveFormat.CSV:
                return "CSV";
            case SaveFormat.HTML:
                return "HTML";
            default:
                return String.valueOf(saveFormat);
        }
    }

    // 辅助方法：安静关闭流
    private static void closeQuietly(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                log.warn("关闭流失败", e);
            }
        }
    }

    // 生成随机文件名
    public static String generateRandomFileName(String originalFilename) {
        String extension = FilenameUtils.getExtension(originalFilename);
        return UUID.randomUUID().toString() + (extension.isEmpty() ? "" : "." + extension);
    }

    // 使用示例
    public static void main(String[] args) {
        try {
            // 示例1：Excel转PDF（文件到文件）
            Excel2Utils.convert("C:\\Users\\zhoudeshui\\Desktop\\result.xlsx", "C:\\Users\\zhoudeshui\\Desktop\\output.pdf", SaveFormat.PDF);

            // 示例2：Excel转CSV（流到流）
            try (FileInputStream fis = new FileInputStream("input.xlsx");
                 FileOutputStream fos = new FileOutputStream("output.csv")) {
                Excel2Utils.convert(fis, fos, SaveFormat.CSV);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

【小工具】Excel2Utils之aspose转换类

## src\router\index.js

> 添加允许获取路由Url参数
```vue
  {
    path: "/",
    component: Layout,
    redirect: "/dashboard",
    children: [
      {
        path: "dashboard", // 路由路径
        name: "控制台", // 路由名称
        component: () => import("@/views/dashboard/index"), // 组件路径
        meta: { title: "控制台", icon: "dashboard", affix: true },
        props: true, // 启用参数传递
      },
    ],
  },
```
> **关键代码: props: true**



## src\layout\index.vue

> 捕获freelogin路由参数 隐藏组件
```vue
<template>
  <div :class="classObj" class="app-wrapper">
    <div v-if="device==='mobile'&&sidebar.opened" class="drawer-bg" @click="handleClickOutside" />
    <sidebar class="sidebar-container" v-if="!isSidebarHidden"/>
    <div class="main-container">
      <div :class="{'fixed-header':fixedHeader}" v-if="!isSidebarHidden">
        <navbar />
      </div>
      <tags-View v-if="!isSidebarHidden"/>
      <app-main />
    </div>
  </div>
</template>

<script>
<template>
  <div :class="[classObj, {'sidebar-hidden': isSidebarHidden}]" class="app-wrapper">
    <div v-if="device==='mobile'&&sidebar.opened" class="drawer-bg" @click="handleClickOutside" />
    <sidebar class="sidebar-container" v-if="!isSidebarHidden"/>
    <div class="main-container">
      <div :class="{'fixed-header':fixedHeader}" v-if="!isSidebarHidden">
        <navbar />
      </div>
      <tags-View v-if="!isSidebarHidden"/>
      <app-main />
    </div>
  </div>
</template>

<script>
import { Navbar, Sidebar, AppMain, TagsView } from './components'
import ResizeMixin from './mixin/ResizeHandler'

export default {
  name: 'Layout',
  components: {
    Navbar,
    Sidebar,
    AppMain,
    TagsView
  },
  mixins: [ResizeMixin],
  computed: {
    sidebar() {
      return this.$store.state.app.sidebar
    },
    device() {
      return this.$store.state.app.device
    },
    fixedHeader() {
      return this.$store.state.settings.fixedHeader
    },
    classObj() {
      return {
        hideSidebar: !this.sidebar.opened,
        openSidebar: this.sidebar.opened,
        withoutAnimation: this.sidebar.withoutAnimation,
        mobile: this.device === 'mobile'
      }
    },
    // 控制侧边栏隐藏的计算属性
    isSidebarHidden() {
      return this.$route?.query?.freelogin === '1'
    }
  },
  methods: {
    handleClickOutside() {
      this.$store.dispatch('app/closeSideBar', { withoutAnimation: false })
    }
  }
}
</script>

<style lang="scss" scoped>
  @import "~@/styles/mixin.scss";
  @import "~@/styles/variables.scss";

  .app-wrapper {
    @include clearfix;
    position: relative;
    height: 100%;
    width: 100%;
    &.mobile.openSidebar{
      position: fixed;
      top: 0;
    }
  }
  .drawer-bg {
    background: #000;
    opacity: 0.3;
    width: 100%;
    top: 0;
    height: 100%;
    position: absolute;
    z-index: 999;
  }

  .fixed-header {
    position: fixed;
    top: 0;
    right: 0;
    z-index: 9;
    width: calc(100% - #{$sideBarWidth});
    transition: width 0.28s;
  }

  .hideSidebar .fixed-header {
    width: calc(100% - 54px)
  }

  .mobile .fixed-header {
    width: 100%;
  }

  // 侧边栏隐藏时的样式调整
  .app-wrapper.sidebar-hidden .main-container {
    margin-left: 0 !important; // 移除左侧边距
    width: 100% !important; // 主内容占满全屏
  }

  .app-wrapper.sidebar-hidden .fixed-header {
    width: 100% !important; // 顶部导航占满全屏
  }
</style>
```
> **关键代码: this.$route?.query?.freelogin**

【技术分享】vue-element-template/admin的IFrame嵌入页面之隐藏侧边栏、隐藏标签页

# Jaocb_v1.21调用WPS COM组件😀👍
> https://sourceforge.net/projects/jacob-project/
> 
![https://sourceforge.net/projects/jacob-project/](https://zhoudeshui.top/static/img/cbffbf26811fb0441761836c6c03fe50.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)




```java
package top.zhoudeshui.utils;

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.common.PDRectangle;
import org.apache.pdfbox.pdmodel.graphics.image.LosslessFactory;
import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.concurrent.*;

public class WPSConvertUtils {

    private static final Logger logger = LoggerFactory.getLogger(WPSConvertUtils.class);
    private static final int WD_FORMAT_PDF = 17;
    private static final int XL_TYPE_PDF = 0;
    private static final int PP_SAVE_AS_PDF = 32;
    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static CompletableFuture<String> convertToPDF(String inputFilePath, String outputDirOrFilePath) {
        File inputFile = new File(inputFilePath);
        if (!inputFile.exists()) {
            logger.warn("原文件不存在: {}", inputFilePath);
            return CompletableFuture.completedFuture(null);
        }

        String kind = getFileSuffix(inputFile.getName());
        // 检查文件是否为PDF
        if ("pdf".equalsIgnoreCase(kind)) {
            try {
                Path source = new File(inputFilePath).toPath();
                Path target = new File(outputDirOrFilePath).toPath();

                // 检查源文件是否存在
                if (!Files.exists(source)) {
                    logger.error("Source file does not exist: {}", source);
                    return CompletableFuture.completedFuture(null);
                }

                // 如果目标是目录，创建一个以源文件名命名的新文件
                if (Files.isDirectory(target)) {
                    target = target.resolve(source.getFileName());
                }

                // 确保目标目录存在
                Path targetParent = target.getParent();
                if (targetParent != null && !Files.exists(targetParent)) {
                    Files.createDirectories(targetParent);
                }

                Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
                logger.info("PDF 文件已复制: {} -> {}", source, target);
                return CompletableFuture.completedFuture(target.toString());
            } catch (IOException e) {
                logger.error("Error copying PDF file", e);
                return CompletableFuture.completedFuture(null);
            }
        }

        String baseName = inputFile.getName().substring(0, inputFile.getName().lastIndexOf("."));

        File outputDirOrFile = new File(outputDirOrFilePath);
        String outputFilePath;

        // 检查输出路径是否包含.pdf
        if (outputDirOrFilePath.toLowerCase().endsWith(".pdf")) {
            // 输出路径已经包含.pdf，直接使用该文件名
            File pdfFile = new File(outputDirOrFilePath);
            // 确保文件的父目录存在，如果不存在则创建
            if (!pdfFile.getParentFile().exists() && !pdfFile.getParentFile().mkdirs()) {
                logger.error("创建目录失败，请检查目录权限！");
                return CompletableFuture.completedFuture(null);
            }
            outputFilePath = outputDirOrFilePath;
        } else {
            // 输出路径不包含.pdf，使用源文件的基本名称作为输出文件名
            if (!outputDirOrFile.exists() && !outputDirOrFile.mkdirs()) {
                logger.error("创建目录失败，请检查目录权限！");
                return CompletableFuture.completedFuture(null);
            }
            outputFilePath = new File(outputDirOrFile, baseName + ".pdf").getAbsolutePath();
        }

        // 提交任务到线程池并返回 CompletableFuture
        return CompletableFuture.supplyAsync(() -> processTask(inputFilePath, outputFilePath, kind), executorService)
                .thenApply(result -> {
                    if (result) {
                        logger.info("转换成功: {} -> {}", inputFilePath, outputFilePath);
                        return outputFilePath;
                    } else {
                        logger.error("转换失败: {}", inputFilePath);
                        return null;
                    }
                });
    }

    private static boolean processTask(String inputFilePath, String outputFilePath, String kind) {
        switch (kind.toLowerCase()) {
            case "doc":
            case "docx":
            case "txt":
                return wordToPDF(inputFilePath, outputFilePath);
            case "ppt":
            case "pptx":
            case "pptm":
            case "ppsx":
                return pptToPDF(inputFilePath, outputFilePath);
            case "xls":
            case "xlsx":
                return exToPDF(inputFilePath, outputFilePath);
            case "png":
            case "jpg":
            case "jpeg":
            case "gif":
                return imageToPDF(inputFilePath, outputFilePath);
            default:
                logger.warn("不支持的文件格式: {}", kind);
                return false;
        }
    }

    private static String getFileSuffix(String fileName) {
        int splitIndex = fileName.lastIndexOf(".");
        return splitIndex == -1 ? "" : fileName.substring(splitIndex + 1);
    }

    private static boolean wordToPDF(String inputFile, String pdfFile) {
        ActiveXComponent app = null;
        try {
            ComThread.InitSTA();
            app = new ActiveXComponent("KWPS.Application");
            app.setProperty("Visible", new Variant(false));
            app.setProperty("AutomationSecurity", new Variant(3)); // 禁用宏

            Dispatch docs = app.getProperty("Documents").toDispatch();
            Dispatch doc = Dispatch.call(docs, "Open", inputFile, false, true).toDispatch();
            Dispatch.call(doc, "ExportAsFixedFormat", pdfFile, WD_FORMAT_PDF);
            Dispatch.call(doc, "Close", false);
            logger.info("Word 文件转换成功: {} -> {}", inputFile, pdfFile);
            return true;
        } catch (Exception e) {
            logger.error("Word 文件转换失败: {}", inputFile, e);
            return false;
        } finally {
            if (app != null) {
                app.invoke("Quit", 0);
                app.safeRelease(); // 释放 ActiveXComponent 资源
            }
            ComThread.Release();
        }
    }

    private static boolean exToPDF(String inputFile, String pdfFile) {
        ActiveXComponent app = null;
        try {
            ComThread.InitSTA();
            app = new ActiveXComponent("KET.Application");
            app.setProperty("Visible", new Variant(false));
            app.setProperty("AutomationSecurity", new Variant(3)); // 禁用宏

            Dispatch excels = app.getProperty("Workbooks").toDispatch();
            Dispatch excel = Dispatch.invoke(excels, "Open", Dispatch.Method, new Object[]{inputFile, new Variant(false), new Variant(false)}, new int[9]).toDispatch();
            Dispatch.invoke(excel, "ExportAsFixedFormat", Dispatch.Method, new Object[]{new Variant(XL_TYPE_PDF), pdfFile}, new int[1]);
            Dispatch.call(excel, "Close", new Variant(false));
            logger.info("Excel 文件转换成功: {} -> {}", inputFile, pdfFile);
            return true;
        } catch (Exception e) {
            logger.error("Excel 文件转换失败: {}", inputFile, e);
            return false;
        } finally {
            if (app != null) {
                app.invoke("Quit");
                app.safeRelease(); // 释放 ActiveXComponent 资源
            }
            ComThread.Release();
        }
    }

    private static boolean pptToPDF(String inputFile, String pdfFile) {
        ActiveXComponent app = null;
        try {
            ComThread.InitSTA();
            app = new ActiveXComponent("KWPP.Application");
            Dispatch ppts = app.getProperty("Presentations").toDispatch();
            Dispatch ppt = Dispatch.call(ppts, "Open", inputFile, true, false).toDispatch();
            Dispatch.invoke(ppt, "SaveAs", Dispatch.Method, new Object[]{pdfFile, new Variant(PP_SAVE_AS_PDF)}, new int[1]);
            Dispatch.call(ppt, "Close");
            logger.info("PPT 文件转换成功: {} -> {}", inputFile, pdfFile);
            return true;
        } catch (Exception e) {
            logger.error("PPT 文件转换失败: {}", inputFile, e);
            return false;
        } finally {
            if (app != null) {
                app.invoke("Quit");
                app.safeRelease(); // 释放 ActiveXComponent 资源
            }
            ComThread.Release();
        }
    }

    /**
     * 将图片转换为PDF
     *
     * @param inputFile 图片文件路径
     * @param pdfFile   输出PDF文件路径
     * @return 是否转换成功
     */
    public static boolean imageToPDF(String inputFile, String pdfFile) {
        try (PDDocument document = new PDDocument()) {
            PDPage page = new PDPage(PDRectangle.A4); // 创建一个A4页面
            document.addPage(page);

            // 加载图片并创建一个PDF图像对象
            File file = new File(inputFile);
            BufferedImage bufferedImage = ImageIO.read(file);
            PDImageXObject pdImage = LosslessFactory.createFromImage(document, bufferedImage);

            // 计算图片缩放比例以适应页面
            float originalWidth = pdImage.getWidth();
            float originalHeight = pdImage.getHeight();
            float scaleX = PDRectangle.A4.getWidth() / originalWidth;
            float scaleY = PDRectangle.A4.getHeight() / originalHeight;
            float scale = Math.min(scaleX, scaleY); // 取较小的缩放比例以完全适应页面

            // 开始在页面上绘制内容
            try (PDPageContentStream contentStream = new PDPageContentStream(document, page)) {
                // 将图片绘制到页面上，居中并按比例缩放
                float x = (PDRectangle.A4.getWidth() - originalWidth * scale) / 2;
                float y = (PDRectangle.A4.getHeight() - originalHeight * scale) / 2;
                contentStream.drawImage(pdImage, x, y, originalWidth * scale, originalHeight * scale);
            }

            // 保存PDF文件
            document.save(pdfFile);
            logger.info("图片转换成功: {} -> {}", inputFile, pdfFile);
            return true;
        } catch (IOException e) {
            logger.error("图片转换失败: {}", inputFile, e);
            return false;
        }
    }
}
```