Aspose导出word使用记录

背景：Aspose系列的控件，功能实现都比较强大，可以实现多样化的报表设计及输出。
通过这次业务机会，锂宝碳审核中业务功需要实现Word文档表格的动态导出功能，因此学习了相关内容，在学习和参考了官方API文档的帮助下，将学习和简单的使用记录在wiki中。下面由我来简单介绍这个控件在实际业务中的使用过程。

一、开发前准备

1. 问题产生： 在实际的开发过程中会遇到Aspose依赖无法导入的情况，如下图所示

2. 原因分析： 主要原因是因为Maven的pom配置中使用的是阿里的镜像源，而阿里云镜像无法下载aspose依赖

3. 解决方法：
（1）先将 aspose的jar包 下载到本地，然后添加到本地的maven，再上传到公司的仓库（文档选择了第一种方式）
（2）提供aspose的仓库地址，将仓库地址加入nexusjar包下载地址

4. 方法步骤：
（1）在配置好后创建项目后，在配置文件需要引用依赖，可以选择本地依赖，而本地依赖需要导入， 所以就需要进行jar包的导入

（2）导入包的语句：

mvn install:install-file "-Dfile=D:\software\Jar\aspose-words-15.12.0-jdk16.jar" 
				"-DgroupId=com.aspose" 
				"-DartifactId=aspose-words" 
				"-Dversion=15.12.0" 
				"-Dpackaging=jar"
1
2
3
4
5

（3）解释一下这些参数意思：

-Dfile: jar包所在本地的绝对路径

-DgroupId： 在导入包后会在本地仓库创建一个com.aspose的路径，包就会存放在jar里面

-DartifactId=spring： jar包的名字

-Dversion： jar包的版本

-Dpackaging： 导入包的类型

（4）进入cmd运行上面的命令：显示如下即加入成功!这就是Maven的下载和在IDEA的配置以及jar包的导入

二、word表格的基本操作

1. 建立word模板

（1）在word文档中，在菜单栏中依次点击 插入 -> 域
（2）接着在弹出框中选择 邮件合并 域，在域属性中填写域名，该域名即为变量名，填写完毕后点击 确定 即可

（3）生成如图所示的样式，即为添加成功

2. 定义集合变量

当单一变量无法满足需求后，我们就需要定义集合变量，我就拿员工薪资统计来举例，一个表格里面会有多个数据。此时，我们应该插入List数据到模板文件中

（1）模板关键字：TableStart:集合名称， TableEnd:集合名称
（2）同样的，在域中选择邮件合并，域名要用TableStart打头，紧接冒号:，再然后就是定义集合的名称。需要注意的是，TableStart意为集合的开始，所以我们再集合结束的地方，需要添加结束标识TableEnd
（3）TableStart 和 TableEnd 之间的变量，就是集合中每个属性的变量名称
（4）添加完毕之后，如图所示，模板 也可点击这里下载(5vy5)

3. 员工薪资数据插入Demo案例

3.1 导入工具类

package org.example;

import com.aspose.words.*;
import com.aspose.words.net.System.Data.DataRow;
import com.aspose.words.net.System.Data.DataTable;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author fangxiang
 * @date 2023/7/7 13:46
 */
public class ContractUtil {

    private ContractUtil() {
    }

    /**
     * 调整图片的大小格式属性
     *
     * @param source  BufferedImage 原始image
     * @param targetW int  目标宽
     * @param targetH int  目标高
     * @param flag    boolean 是否同比例调整
     * @return BufferedImage  返回新image
     */
    public static BufferedImage resizeBufferedImage(BufferedImage source, int targetW, int targetH, boolean flag) {
        int type = source.getType();
        BufferedImage target = null;

        // 计算缩放比例
        double sx = (double) targetW / source.getWidth();
        double sy = (double) targetH / source.getHeight();

        // 根据保持纵横比的标志调整缩放比例
        if (flag && sx > sy) {
            sx = sy;
            targetW = (int) (sx * source.getWidth());
        } else if (flag && sx <= sy) {
            sy = sx;
            targetH = (int) (sy * source.getHeight());
        }

        // 创建目标BufferedImage
        if (type == BufferedImage.TYPE_CUSTOM) {
            ColorModel cm = source.getColorModel();
            WritableRaster raster = cm.createCompatibleWritableRaster(targetW, targetH);
            boolean alphaPremultiplied = cm.isAlphaPremultiplied();
            target = new BufferedImage(cm, raster, alphaPremultiplied, null);
        } else {
            target = new BufferedImage(targetW, targetH, type);
        }

        // 绘制调整大小后的图像
        Graphics2D g = target.createGraphics();
        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));
        // 释放资源
        g.dispose();
        return target;
    }


    /**
     * 使用对象数据填充Word模板
     *
     * @param modelWordByte Word模板的二进制数据
     * @param obj           要填充的数据对象
     * @return 填充数据后的Word二进制数据
     */
    public static byte[] fillWordDataByDomain(byte[] modelWordByte, Object obj) {
        try {
            // 获取对象的Class
            Class<?> aClass = obj.getClass();
            // 获取对象的所有字段
            Field[] fields = aClass.getDeclaredFields();
            // 创建一个Map来存储字段名和字段值
            Map<String, Object> data = new HashMap<>(fields.length);
            // 遍历字段，获取字段值并存入Map中
            for (Field field : fields) {
                // 获取字段的属性描述器
                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), aClass);
                // 获取字段的读取方法
                Method method = pd.getReadMethod();
                // 获取字段名
                String key = field.getName();
                // 调用读取方法获取字段值
                Object value = method.invoke(obj);
                // 如果字段值不为空，则将字段名和字段值存入Map中
                if (value != null) {
                    data.put(key, value);
                }
            }
            // 使用Map数据填充Word模板并返回填充后的Word二进制数据
            return fillWordDataByBinary(modelWordByte, data);
        } catch (Exception e) {
            // 出现异常时返回空的字节数组
            return new byte[0];
        }
    }


    /**
     * 填充 word 模板（map数据格式）
     *
     * @param file word二进制
     * @param data 要填充的数据
     * @return 组合数据之后的word二进制
     */
    public static byte[] fillWordDataByBinary(byte[] file, Map<String, Object> data) throws Exception {
        byte[] ret = null;
        if (CollectionUtils.isEmpty(data)) {
            return ret;
        }

        try (InputStream is = new ByteArrayInputStream(file);
             ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            // 读取Word文档
            Document doc = new Document(is);

            // 用于存储需要替换的字段和对应的值
            Map<String, String> toData = new HashMap<>();

            // 遍历数据Map
            for (Map.Entry<String, Object> en : data.entrySet()) {
                String key = en.getKey();
                Object value = en.getValue();

                // 如果值是List类型，则填充表格数据
                if (value instanceof List) {
                    //写入表数据
                    DataTable dataTable = fillListData((List) value, key);
                    doc.getMailMerge().executeWithRegions(dataTable);
                }

                String valueStr = String.valueOf(en.getValue());
                // 如果值为空或者为字符串"null"，则跳过该字段
                if (StringUtils.isEmpty(value)) {
                    continue;
                }
                // 将字段和值存入toData
                toData.put(key, valueStr);
            }
            // 将toData中的字段和值分别存入两个数组
            String[] fieldNames = new String[toData.size()];
            String[] values = new String[toData.size()];

            int i = 0;
            for (Map.Entry<String, String> entry : toData.entrySet()) {
                fieldNames[i] = entry.getKey();
                values[i] = entry.getValue();
                i++;
            }

            // 执行合并数据操作
            doc.getMailMerge().execute(fieldNames, values);
            // 保存修改后的文档到输出流
            doc.save(out, SaveOptions.createSaveOptions(SaveFormat.DOCX));
            ret = out.toByteArray();
        }

        return ret;
    }

    /**
     * 封装 list 数据到 word 模板中（word表格）
     *
     * @param list      数据
     * @param tableName 表格列表变量名称
     * @return word表格数据DataTable
     */
    private static DataTable fillListData(List<Object> list, String tableName) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
        //创建DataTable,并绑定字段
        DataTable dataTable = new DataTable(tableName);
        // 遍历 list 中的每个对象
        for (Object obj : list) {
            // 创建DataRow，封装该行数据
            DataRow dataRow = dataTable.newRow();
            Class<?> objClass = obj.getClass();
            Field[] fields = objClass.getDeclaredFields();
            // 遍历对象的每个字段
            for (int i = 0; i < fields.length; i++) {
                Field field = fields[i];
                // 将字段名添加到 dataTable 的列中
                dataTable.getColumns().add(fields[i].getName());
                // 通过反射获取字段的值，并将其设置到 dataRow 中
                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), objClass);
                Method method = pd.getReadMethod();
                dataRow.set(i, method.invoke(obj));
            }
            // 将 dataRow 添加到 dataTable 的行中
            dataTable.getRows().add(dataRow);
        }
        return dataTable;
    }


    /**
     * 利用反射将字段转为Map键值对
     *
     * @param obj
     * @return
     * @throws IntrospectionException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    public static Map<String, Object> getStringObjectMap(Object obj) throws IntrospectionException, IllegalAccessException, InvocationTargetException {
        Class<?> aClass = obj.getClass();
        Field[] fields = aClass.getDeclaredFields();
        Map<String, Object> data = new HashMap<>(fields.length);

        // 遍历对象的所有属性
        for (Field field : fields) {
            // 获取属性的名称
            String fieldName = field.getName();
            // 创建属性描述器，用于获取属性的读取方法
            PropertyDescriptor pd = new PropertyDescriptor(fieldName, aClass);
            // 获取属性的读取方法
            Method method = pd.getReadMethod();
            // 获取属性的值
            Object value = method.invoke(obj);
            // 如果属性的值不为空，则将属性名和属性值添加到Map中
            if (value != null) {
                data.put(fieldName, value);
            }
        }
        return data;
    }

    /**
     * 通过Map的方式填充word模板
     *
     * @param templatePath
     * @param targetPath
     * @param data
     * @param fileType
     */
    public static void fillWordDataByMap(String templatePath, String targetPath, Map<String, Object> data, int fileType) {
        try (InputStream is = new FileInputStream(templatePath);
             OutputStream out = new FileOutputStream(targetPath)) {
            // 加载模板文件
            Document doc = new Document(is);
            DocumentBuilder builder = new DocumentBuilder(doc);
            Map<String, String> toData = new HashMap<>();

            // 遍历数据，填充模板
            for (Map.Entry<String, Object> en : data.entrySet()) {
                String key = en.getKey();
                Object value = en.getValue();
                if (key == null || value == null) {
                    continue;
                }
                if (value instanceof List) {
                    // 填充表格数据
                    DataTable dataTable = fillListData((List) value, key);
                    doc.getMailMerge().executeWithRegions(dataTable);
                }

                if (value instanceof BufferedImage) {
                    // 填充图像数据
                    builder.moveToMergeField(key);
                    builder.insertImage((BufferedImage) value);
                }
                String valueStr = String.valueOf(en.getValue());
                toData.put(key, valueStr);
            }

            // 准备合并数据的数组
            String[] fieldNames = new String[toData.size()];
            String[] values = new String[toData.size()];
            int i = 0;
            for (Map.Entry<String, String> entry : toData.entrySet()) {
                fieldNames[i] = entry.getKey();
                values[i] = entry.getValue();
                i++;
            }

            // 合并数据到模板
            doc.getMailMerge().execute(fieldNames, values);
            // 保存目标文件
            doc.save(out, SaveOptions.createSaveOptions(fileType));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }


//    private static License license = null;

//    /**
//     * 加载 license
//     * 由于 aspose是商业组件，若没有license(可自行在网上查询license.xml)，则会出现水印。
//     */
//    static {
//        try {
//            InputStream is = ContractUtil.class.getResourceAsStream("/license.xml");
//            license = new License();
//            license.setLicense(is);
//        } catch (Exception e) {
//            throw new RuntimeException("自动加载aspose证书文件失败!");
//        }
//    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

3.2 创建实体Bean

（1）首先，我们先定义和模板对应的数据，我们先定义列表里面的 员工薪资信息中 Worker 的数据

package VO;

import lombok.Data;
import lombok.AllArgsConstructor;
import lombok.Builder;
import java.math.BigDecimal;
import java.util.List;

/**
 * 员工薪资信息
 *
 * @author fangxiang
 * @date 2023/7/7 13:47
 */
@Data
@Builder
@AllArgsConstructor
public class Worker {
    /**
     * 员工姓名
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private String sex;
    /**
     * 工资
     */
    private BigDecimal salary;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

（2）接着我们定义整个模板的基本数据：SalaryData

package VO;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.awt.image.BufferedImage;
import java.math.BigDecimal;
import java.util.List;

/**
 * 文档模板数据
 *
 * @author fangxiang
 * @date 2023/7/7 13:46
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class SalaryData {
    /**
     * 公司名称
     */
    private String companyName;
    /**
     * 员工薪资列表
     */
    private List<Worker> workerList;
    /**
     * 工资总和
     */
    private BigDecimal totalSalary;

    /**
     * 公司log
     */
    private BufferedImage logImg;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

（3）定义好以上数据之后，我们就可以开始进行数据的填充，工具类提供两种填充方法（代码案例是在本地执行的，所以记得替换本地的图片和文件地址）

1.一种是传递 Object 数据进行数据填充
2.另一种是传递 Map 数据进行数据填充
这里采用第一种方式进行数据的填充，个人也比较推荐使用domain数据

package org.example;

import VO.SalaryData;
import VO.Worker;
import com.aspose.words.SaveFormat;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.beans.IntrospectionException;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 *
 * @author fangxiang
 * @date 2023/7/7 13:47
 * */
public class Test {

    public static void main(String[] args) throws IOException, IntrospectionException, InvocationTargetException, IllegalAccessException {

        // 封装员工薪资信息
        Worker worker1 = Worker.builder()
                .name("李雄")
                .age(25)
                .sex("男")
                .salary(BigDecimal.valueOf(1000))
                .build();
        Worker worker2 = Worker.builder()
                .name("李浩")
                .age(25)
                .sex("男")
                .salary(BigDecimal.valueOf(2000))
                .build();
        List<Worker> workerList = Arrays.asList(worker1, worker2);

        // 计算工资总和
        BigDecimal totalSalary = workerList.stream()
                .map(Worker::getSalary)
                .reduce(BigDecimal.ZERO, BigDecimal::add);

        // 读取图片
        BufferedImage image = ImageIO.read(new FileInputStream("C:\\Users\\fangxiang\\Desktop\\鱼.png"));
        BufferedImage bufferedImage = ContractUtil.resizeBufferedImage(image, 100, 100, true);

        // 封装文档模板数据
        SalaryData data = SalaryData.builder()
                .companyName("上班不摸鱼有限公司")
                .workerList(workerList)
                .totalSalary(totalSalary)
                .logImg(bufferedImage)
                .build();

        // 读取模板文件
        Map<String, Object> dataMap = ContractUtil.getStringObjectMap(data);
        String templatePath2 = "C:\\Users\\fangxiang\\Desktop\\模板.docx";
        String docxPath = "C:\\Users\\fangxiang\\Desktop\\员工薪资统计表.docx";
        ContractUtil.fillWordDataByMap(templatePath2, docxPath, dataMap, SaveFormat.DOCX);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

3.3 结果展示

（1）水印说明
看上方的图相比大家也不难发现，文档生成的同时，也多了红色的一串字体。
由于aspose是商业组件的，所以想要去水印使用，需要添加 license.xml，由于实际业务中使用的是公司提供的凭证，所以我就不传上来了，如有需要，可以选择购买 aspose 的服务，或者上网搜一个 license.xml

（2）如何添加 license
我已经在工具类中提供了一个静态初始化方法，大家下载好 license.xml 之后，放入对应的目录，将注释部分去掉即可