# 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;
        }
    }
}
```

【小工具】Jaocb之COM调用WPS Convert PDF

# docker命令大全
https://www.runoob.com/docker/docker-command-manual.html
***
1. 首先停止mysql容器避免在备份中写入数据无法完整备份导出
```shell
docker stop [ps-name]

# [ps-name] 为需要停止容器的名称（可使用[docker ps]命令查看容器信息） 例如：sudo docker stop mysql
```



2. 由于离线无法使用[docker pull]拉取镜像故采用另一种方式[docker load]
```shell
docker load -i /[your_path]/mysql-8.0.40.tar

# [your_path] 为镜像包路径
# 找到目录后使用[docker images]命令查看确认镜像包是否已被成功导入加载到images list[docker镜像列表]
```
3. 镜像导入完毕之后先恢复原有的数据

4. 使用[docker run]启动load好的镜像

```shell
docker run --name mysql8 -e MYSQL_ROOT_PASSWORD=root -d -v /var/lib/mysql:/var/lib/mysql [mysql:8.0.40]

# --name 为容器启动的名称[可后续通过此name管理容器]
# -e 为环境变量 这里的 MYSQL_ROOT_PASSWORD=[root] 意为设置mysql容器的数据库root账号密码为root(忽略root)
# -d 为容器在后台运行
# [mysql:8.0.40] 为要使用的镜像 例如：a:1 a为镜像名称 1为镜像tag(标签) <此处在使用[docker save]时声明创建关联与镜像包文件名称无关>
# -v 为容器的目录数据挂载到宿主机目录中<常用目录一般为镜像核心数据存储目录容器>，例如将mysql容器的/var/lib/mysql数据目录挂载到宿主机的/var/lib/mysql中 这样便可以创建多个mysql版本容器共享其数据

# 拓展
# -v 可使用此参数挂载卷用于数据持久化或共享数据[即使mysql容器删除也不会影响数据]
```


:::tip{title="拓展"}
**使用 [docker save]生成镜像包**

docker save -o /opt/docker-images/docker-mysql-8.0.40.tar mysql:8.0.40

**意为将mysql:8.0.40镜像导出 在/opt/docker-images/目录下名为docker-mysql-8.0.40.tar的镜像包**
:::

【Ubuntu】MySQL之Docker镜像离线安装数据持久化容器流程

> **数据来源** http://www.stats.gov.cn/
> 
> **代码仓库** https://github.com/airyland/china-area-data
```python
# -*- coding: UTF-8 -*-
"""
@description 获取统计用区划代码和城乡划分代码 (一级：省、直辖市、自治区)
@author wendell



"""
from source.area.china.util import DbUtil, RequestUtil
from pyquery import PyQuery


def start_requests(domain_url, encoding, headers):
    """
    开始请求一级：省、直辖市、自治区
    :param domain_url url
    :param encoding 编码
    :param headers header
    :return:
    """
    res = RequestUtil.get(url=domain_url, headers=headers, encoding=encoding)
    if not res:
        print('请求失败...')
        return None
    doc = PyQuery(res, url=domain_url, encoding=encoding).find('.provincetr')
    if not doc:
        print('首页省份信息获取错误,检查页面变化...')
        return None
    # 获取到数据库链接
    client = DbUtil.get_client()
    # 选择数据库
    db = client["python"]
    provinces = []
    for td in doc('td').items():
        a_tag = td('a')
        if a_tag:
            # 生成URL绝对路径
            a_tag.make_links_absolute()
            # print('%s %s' % (a_tag.attr('href'), a_tag.text()))
            provinces.append({
                'code': a_tag.attr('href').split('/')[-1].split('.')[0],  # 统计汇总识别码-划分代码
                'name': a_tag.text(),  # 省份名称
                'url': a_tag.attr('href'),  # 下级链接地址
                'searched': False  # 是否搜索过下级链接地址
            })
    print(provinces)
    # 准备入库, 省份信息, 添加到collection集合(数据库表)里
    db['province'].insert_many(provinces)
    DbUtil.close_client(client)


def main():
    headers = {
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
        'Accept-Encoding': 'gzip, deflate',
        'Accept-Language': 'zh-CN,zh;q=0.9',
        'Cache-Control': 'max-age=0',
        'Connection': 'keep-alive',
        'Host': 'www.stats.gov.cn',
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 '
                      'Safari/537.36'
    }
    # 更改年份只需要更改这里即可,明年2020年的时候会发布2019年的数据，如果想获取2019年的就把这里改为2019再重新执行程序即可
    year = '2018'
    domain_url = 'http://www.stats.gov.cn/tjsj/tjbz/tjyqhdmhcxhfdm/' + year + '/index.html'
    encoding = 'gb2312'
    start_requests(domain_url, encoding, headers)


if __name__ == '__main__':
    main()

```

【小工具】爬虫获取省市区级联

# 【数据库三大范式】
:::tip{title="提示"}
**若出现，则需要分表，但不一定要求满足三大范式**
:::



- **第一  每个列不可再分**
- **第二  每列都依赖于主键列**
- **第三  每列不可依赖于除主键列的其它列**

![961544cb1a9c97a1698e745e234baaf.jpg](/static/img/259e4937fd8b8dfb3e5d729fd13467af.961544cb1a9c97a1698e745e234baaf.webp)

【小知识】数据库三大范式

# 【正向代理和反向代理】

> 目的都是 接收客户端请求然后从源服务器拿到响应内容返回给客户端

:::tip{title="提示"}
**不同点是 正向代理代理的是客户端而反向代理代理的是服务器端。**
:::



- **（正向：代理服务器是 我-客户端 的经纪人。）**
![15ca8ed971be4ef8995ed7e2d78cc2b.jpg](/static/img/d81f123b05c8132a28dee9215cfcaadd.15ca8ed971be4ef8995ed7e2d78cc2b.webp)

- **（反向：代理服务器是 我-服务器端 的经纪人）**
![f037a39468d4da383ab646827d24e47.jpg](/static/img/56db723fa184fde6ddde0821290043e6.f037a39468d4da383ab646827d24e47.webp)