5 bibliotecas de herramientas de código abierto súper fáciles de usar para compartir ~

En el desarrollo de proyectos reales, desde la perspectiva de la estabilidad y la eficiencia, no se recomienda reinventar la rueda. Sin embargo, construir ruedas en el proceso de aprendizaje definitivamente es beneficioso para usted y no es dañino.La construcción de ruedas es un medio que puede mejorar especialmente la capacidad de programación de su sistema.

Hoy comparto varias bibliotecas de herramientas de código abierto que uso comúnmente:

1. MyExcel: una herramienta de procesamiento de Excel con funciones completas con bajo uso de memoria y excelente rendimiento.

2. OSHI: un sistema operativo (nativo) basado en JNA y un repositorio de hardware para el lenguaje Java .

3. JsonPath: Java DSL para leer JSON

4. Cafeína: poderoso caché local

5. Hutool: una completa biblioteca de herramientas Java

La siguiente es una introducción más detallada. Se recomienda que los amigos la lean para que puedan comenzar rápidamente y utilizarla en sus propios proyectos para mejorar la eficiencia de la producción.

MyExcel: procesamiento de Excel

Introducción al proyecto

Todo el mundo debería estar familiarizado con EasyExcel. Esta es una herramienta de procesamiento de Excel de código abierto de Ali, que puede evitar el problema de desbordamiento de memoria de archivos grandes. He recomendado este proyecto varias veces antes.

MyExcel también es una herramienta de procesamiento de Excel, que también puede evitar el problema de desbordamiento de memoria de archivos grandes y tiene funciones más completas, menor uso de memoria y mejor rendimiento (según los resultados de la comparación de pruebas oficiales).

De acuerdo con los datos de prueba en la wiki del proyecto:

24,3 millones de Excel, 500 000 filas, 8 columnas, 40 ciclos de lectura, el uso de memoria promedio es de aproximadamente 75 megabytes, en comparación con la misma prueba de archivo de Ali EasyExcel (V2.1.6), el uso de memoria es aproximadamente un tercio de MyExcel

Comparación del uso de memoria entre MyExcel y EasyExcel

Las principales ventajas de MyExcel son las siguientes:

Beneficios principales de MyExcel

confiar en la información

Dirección del repositorio de Maven: https://mvnrepository.com/artifact/com.github.liaochong/myexcel .

Experto:

<dependency>
    <groupId>com.github.liaochong</groupId>
    <artifactId>myexcel</artifactId>
    <version>4.3.0.RC4</version>
</dependency>

Gradle:

implementation 'com.github.liaochong:myexcel:4.3.0.RC4'

Manifestación

MyExcel tiene muchas funciones, aquí solo seleccionamos introducciones individuales, para introducciones detalladas, consulte la wiki oficial: https://github.com/liaochong/myexcel/wiki .

1. Exportación de flujo

MyExcel admite la exportación de transmisión, adopta el modo productor-consumidor, permite obtener datos en lotes y tiene un uso de memoria extremadamente bajo. Además, la exportación de transmisión admite características únicas, como archivos zip.

DefaultStreamExcelBuilder<ArtCrowd> streamExcelBuilder = DefaultStreamExcelBuilder
        .of(ArtCrowd.class) // 如导出Map类型数据，请使用of(Map.class)
        .threadPool(Executors.newFixedThreadPool(10))// 线程池，可选
        .templateHandler(FreemarkerTemplateHandler.class)// 追加模板数据，可选，适合极度个性化数据导出
        .capacity(10_000)// 容量设定，在主动划分excel使用，可选
        .start();

2. Estilo personalizado

MyExcel admite estilos personalizados, incluido el ajuste de ancho, alto, color de fondo, borde, fuente y otros estilos. Para obtener más información, consulte: https://github.com/liaochong/myexcel/wiki/Style-support .

Personalización del estilo del título (título):

ExcelColumn(style={"title->color:red","cell->color:green"})
Integer age;

Personalización del estilo de fila de contenido:

@ExcelColumn(style="cell->color:green")
Integer age;

La llamada al método establece el estilo:

DefaultExcelBuilder.of(ArtCrowd.class)
                   .style("title->color:red","background-color:green;")
                   .build(dataList);

3. Lista desplegable

MyExcel admite la generación de listas desplegables, simplemente pase los parámetros List o Array.

@ExcelColumn(title="下拉列表")
List<String> options;

dirección relevante

Dirección del proyecto: https://github.com/liaochong/myexcel
Documento oficial: https://github.com/liaochong/myexcel/wiki

OSHI: adquisición de información de la máquina local

Introducción al proyecto

OSHI es un sistema operativo (nativo) basado en JNA y un repositorio de hardware para el lenguaje Java .

[JNA(Java Native Access)](https://github.com/java-native-access/jna "JNA(Java Native Access "JNA(Java Native Access)")") es un marco Java de código abierto, es el Sun Una tecnología para invocar métodos locales lanzada por la empresa es un marco basado en el clásico JNI. La razón por la que se dice que es un sustituto de JNI es que JNA simplifica enormemente el proceso de llamar a métodos locales, es muy cómodo de usar y, básicamente, se puede completar sin salir del entorno Java.

JNI (Java Native Interface) es la interfaz nativa de Java, que construye un puente entre Java y otros lenguajes de programación, lo que permite que los programas de Java llamen a programas o codifiquen bibliotecas escritas en otros lenguajes (especialmente C/C++). Además, la implementación de JDK en sí también utiliza ampliamente la tecnología JNI para llamar a la biblioteca C local.

Con OSHI, no necesitamos instalar ninguna otra biblioteca nativa para ver el uso de la memoria y la CPU, el uso del disco y la partición, los dispositivos, los sensores, etc.

OSHI tiene como objetivo proporcionar una implementación multiplataforma para recuperar información del sistema, compatible con los principales sistemas operativos como Windows, Linux, MacOS y Unix.

La presentación oficial de oshi es la siguiente: (complemento de traducción de Chrome: Mate Translate ):

Usando oshi, puede crear fácilmente funciones de monitoreo del sistema que se usan comúnmente en proyectos, como se muestra en la siguiente figura:

confiar en la información

Dirección del almacén de Maven: https://mvnrepository.com/artifact/com.github.oshi/oshi-core .

experto:

<dependency>
  <groupId>com.github.oshi</groupId>
  <artifactId>oshi-parent</artifactId>
  <version>6.4.1</version>
  <type>pom</type>
</dependency>

grado:

implementation 'com.github.oshi:oshi-core:6.4.1'

Manifestación

Obtenga el objeto de información de hardware HardwareAbstractionLayer :

//系统信息
SystemInfo si = new SystemInfo();
//操作系统信息
OperatingSystem os = si.getOperatingSystem();
//硬件信息
HardwareAbstractionLayer hal = si.getHardware();
// 磁盘信息
List<HWDiskStore> diskStores = hal.getDiskStores();

Ahora que tenemos un objeto que representa información de hardware HardwareAbstractionLayer , ¡podemos obtener información relacionada con el hardware!

La siguiente es una breve demostración de cómo obtener información relacionada con la memoria y la CPU.

1. Obtener información relacionada con la memoria

//内存相关信息
GlobalMemory memory = hal.getMemory();
//获取内存总容量
String totalMemory = FormatUtil.formatBytes(memory.getTotal());
//获取可用内存的容量
String availableMemory = FormatUtil.formatBytes(memory.getAvailable());

Con la capacidad de memoria total y la capacidad de memoria disponible, puede calcular la utilización actual de la memoria.

2. Obtenga información relacionada con la CPU

//CPU相关信息
CentralProcessor processor = hal.getProcessor();
//获取CPU名字
String processorName = processor.getProcessorIdentifier().getName();
//获取物理CPU数
int physicalPackageCount = processor.getPhysicalPackageCount();
//获取物理核心数
int physicalProcessorCount = processor.getPhysicalProcessorCount();

dirección relevante

Dirección del proyecto: https://github.com/oshi/oshi
Sitio web oficial: https://www.oshi.ooo/

JsonPath: un DSL de Java para leer JSON

Introducción al proyecto

JsonPath es un lenguaje de consulta para estructuras JSON. Equivalentes a XPATH para XML y SQL para bases de datos relacionales, son DSL relativamente comunes.

JsonPath proporciona implementaciones en varios idiomas, incluidos: Java, Javascript, Python, PHP, Ruby, Go, etc. Aquí tomamos como ejemplo la implementación de la versión Java.

confiar en la información

Dirección del repositorio de Maven: https://mvnrepository.com/artifact/com.jayway.jsonpath/json-path .

experto:

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.8.0</version>
</dependency>

grado:

implementation 'com.jayway.jsonpath:json-path:2.8.0'

Manifestación

El contenido del documento json de prueba es el siguiente:

{
    "store": {
        "book": [
            {
                "category": "reference",
                "author": "Nigel Rees",
                "title": "Sayings of the Century",
                "price": 8.95
            },
            {
                "category": "fiction",
                "author": "Evelyn Waugh",
                "title": "Sword of Honour",
                "price": 12.99
            },
            {
                "category": "fiction",
                "author": "Herman Melville",
                "title": "Moby Dick",
                "isbn": "0-553-21311-3",
                "price": 8.99
            },
            {
                "category": "fiction",
                "author": "J. R. R. Tolkien",
                "title": "The Lord of the Rings",
                "isbn": "0-395-19395-8",
                "price": 22.99
            }
        ],
        "bicycle": {
            "color": "red",
            "price": 19.95
        }
    },
    "expensive": 10
}

Para leer los autores de todos los libros:

List<String> authors = JsonPath.read(json, "$.store.book[*].author");

Leer todos los libros y filtrar:

// 所有价格低于 10 的书籍
List<Map<String, Object>> books =  JsonPath.parse(json)
                                     .read("$.store.book[?(@.price < 10)]");

// 也可以通过 Filter API 来进行过滤
Filter cheapFictionFilter = filter(
   where("category").is("fiction").and("price").lte(10D)
);

List<Map<String, Object>> books = JsonPath.parse(json).read("$.store.book[?]", cheapFictionFilter);

dirección relevante

Dirección del proyecto: https://github.com/json-path/JsonPath
Introducción a JSONPath: https://goessner.net/articles/JsonPath/

Cafeína: un potente caché local

Introducción al proyecto

Caffeine es mi caché local más utilizada. Es similar a Caffeine ConcurrentMap, pero proporciona funciones de almacenamiento en caché más completas y un rendimiento potente.

¿Qué tan bueno es el rendimiento? Se ha dado una respuesta detallada en la prueba comparativa del documento oficial, dirección: https://github.com/ben-manes/caffeine/wiki/Benchmarks .

La siguiente figura muestra la comparación de rendimiento de las implementaciones comunes de caché local cuando 8 subprocesos realizan lecturas y escrituras simultáneas en una caché configurada con la capacidad máxima.

Lectura concurrente:

Comparación de rendimiento de lectura simultánea de caché local común

Escrituras simultáneas:

Comparación de rendimiento de escritura simultánea de caché local común

Además de las funciones básicas de almacenamiento en caché, Caffeine también proporciona funciones como caducidad y carga asíncrona.

Se considera que Caffeine es la mejor opción para el almacenamiento en caché local. Proyectos de código abierto conocidos como Redisson, Cassandra, Hbase, Neo4j y Druid utilizan Caffeine.

confiar en la información

Dirección del repositorio de Maven: https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine .

Utilizado por Java 11 y superior 3.x , de lo contrario 2.x.

experto:

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.5</version>
</dependency>

grado:

implementation 'com.github.ben-manes.caffeine:caffeine:3.1.5'

Manifestación

La cafeína y el API son muy similares a la guayaba y se inspiran en el diseño de la guayaba.

Crear caché:

Cache<Key, Graph> cache = Caffeine.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .maximumSize(10_000)
    .build();

Eliminar el caché manualmente:

// 单个key
cache.invalidate(key)
// 批量key
cache.invalidateAll(keys)
// 所有key
cache.invalidateAll()

Estadísticas:

// 统计缓存命中率、缓存回收数量、加载新值的平均时间
Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats()
    .build();

dirección relevante

Dirección del proyecto: https://github.com/ben-manes/caffeine
Documentación oficial: https://github.com/ben-manes/caffeine/wiki

Hutool: una completa biblioteca de herramientas Java

Introducción al proyecto

Hutool es una biblioteca de herramientas Java muy útil, que encapsula métodos JDK como archivos, flujos, cifrado y descifrado, transcodificación, regularización, subprocesos y XML.

Realmente es una buena biblioteca de herramientas con funciones completas, muy adecuada para usar en sus propios proyectos.

La presentación oficial de Hutool es la siguiente:

Hutool Introducción

confiar en la información

Dirección del almacén de Maven: https://mvnrepository.com/artifact/cn.hutool/hutool-all .

experto:

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.16</version>
</dependency>

grado:

implementation 'cn.hutool:hutool-all:5.8.16'

Manifestación

Una simple demostración de algunas funciones que personalmente encuentro más prácticas.

conversión de tipo

Convert Las clases encapsulan conversiones a tipos comunes de Java.

long[] b = {1,2,3,4,5};
String bStr = Convert.toStr(b);//"[1, 2, 3, 4, 5]"

double a = 67556.32;
String digitUppercase = Convert.digitToChinese(a);//"陆万柒仟伍佰伍拾陆元叁角贰分"

correo

El envío de correos electrónicos en Java depende principalmente del javax.mail paquete, pero debido a que es engorroso de usar, Hutool lo encapsula.

src/main/resourcesCree un nuevo archivo en el directorio de configuración de classpath (en un proyecto Maven estándar ) mail.setting, y la configuración completa es la siguiente (el servidor de correo debe admitir y abrir el protocolo SMTP):

# 邮件服务器的SMTP地址，可选，默认为smtp.<发件人邮箱后缀>
host = smtp.yeah.net
# 邮件服务器的SMTP端口，可选，默认25
port = 25
# 发件人（必须正确，否则发送失败）
from = [email protected]
# 用户名，默认为发件人邮箱前缀
user = hutool
# 密码（注意，某些邮箱需要为SMTP服务单独设置授权码，详情查看相关帮助）
pass = q1w2e3

Enviar correo es muy sencillo:

MailUtil.send("[email protected]", "测试", "邮件来自Hutool测试", false);

Envío de grupos de apoyo:

ArrayList<String> tos = CollUtil.newArrayList(
    "[email protected]",
    "[email protected]",
    "[email protected]",
    "[email protected]");

MailUtil.send(tos, "测试", "邮件来自Hutool群发测试", false);

Admite agregar uno o más archivos adjuntos:

MailUtil.send("[email protected]", "测试", "<h1>邮件来自Hutool测试</h1>", true, FileUtil.file("d:/aaa.xml"));

Además de usar el archivo de configuración para definir la cuenta global, MailUtil.sendel método también proporciona un método sobrecargado para pasar un MailAccountobjeto, que es un bean común que registra la información del servidor de correo.

MailAccount account = new MailAccount();
account.setHost("smtp.yeah.net");
account.setPort("25");
account.setAuth(true);
account.setFrom("[email protected]");
account.setUser("hutool");
account.setPass("q1w2e3");

MailUtil.send(account, CollUtil.newArrayList("[email protected]"), "测试", "邮件来自Hutool测试", false);

Identificación única

En un entorno distribuido, la generación de ID única se usa ampliamente y los métodos de generación también son variados. Hutool crea un paquete simple para algunas estrategias de generación comunes.

La clase única de herramienta generadora de ID proporcionada por Hutool cubre:

UUID
ID de objeto (MongoDB)
Copo de nieve (Twitter)

¡Tome UUID por ejemplo!

La lógica reescrita por Hutool java.util.UUIDcorresponde a la clase cn.hutool.core.lang.UUID, por lo que la generación de cadenas UUID sin - no necesita reemplazar caracteres, y el rendimiento mejora aproximadamente una vez .

//生成的UUID是带-的字符串，类似于：a5c8a5e8-df2b-4706-bea4-08d0939410e3
String uuid = IdUtil.randomUUID();

//生成的是不带-的字符串，类似于：b17f24ff026d40949c85a24f4f375d42
String simpleUUID = IdUtil.simpleUUID();

Clase de herramienta de solicitud HTTP

Para las solicitudes GET y POST más utilizadas, HttpUtil encapsula dos métodos,

HttpUtil.get
HttpUtil.post

OBTENER solicitud:

// 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS
String result1= HttpUtil.get("https://www.baidu.com");

// 当无法识别页面编码的时候，可以自定义请求页面的编码
String result2= HttpUtil.get("https://www.baidu.com", CharsetUtil.CHARSET_UTF_8);

//可以单独传入http参数，这样参数会自动做URL编码，拼接在URL中
HashMap<String, Object> paramMap = new HashMap<>();
paramMap.put("city", "北京");

String result3= HttpUtil.get("https://www.baidu.com", paramMap);

Solicitud POST:

HashMap<String, Object> paramMap = new HashMap<>();
paramMap.put("city", "北京");

String result= HttpUtil.post("https://www.baidu.com", paramMap);

Subir archivo:

HashMap<String, Object> paramMap = new HashMap<>();
//文件上传只需将参数中的键指定（默认file），值设为文件对象即可，对于使用者来说，文件上传与普通表单提交并无区别
paramMap.put("file", FileUtil.file("D:\\face.jpg"));

String result= HttpUtil.post("https://www.baidu.com", paramMap);

cache

Hutool proporciona la implementación de varias estrategias comunes de almacenamiento en caché:

FIFO (primero en entrar, primero en salir) : política de primero en entrar, primero en salir.
LFU (menor frecuencia utilizada) : la estrategia menos utilizada.
LRU (usado menos recientemente) : la estrategia no se ha utilizado durante mucho tiempo.
Cronometrado : estrategia de cronometraje.
Débil : estrategia de referencia débil.

Además, Hutool también admite el almacenamiento en caché de archivos pequeños byte[] en contenido en forma de correo electrónico, lo que reduce el acceso a los archivos y resuelve los problemas de rendimiento causados por la lectura frecuente de archivos.

Usos de caché de política FIFO (primero en entrar, primero en salir):

Cache<String,String> fifoCache = CacheUtil.newFIFOCache(3);

//加入元素，每个元素可以设置其过期时长，DateUnit.SECOND.getMillis()代表每秒对应的毫秒数，在此为3秒
fifoCache.put("key1", "value1", DateUnit.SECOND.getMillis() * 3);
fifoCache.put("key2", "value2", DateUnit.SECOND.getMillis() * 3);
fifoCache.put("key3", "value3", DateUnit.SECOND.getMillis() * 3);

//由于缓存容量只有3，当加入第四个元素的时候，根据FIFO规则，最先放入的对象将被移除
fifoCache.put("key4", "value4", DateUnit.SECOND.getMillis() * 3);

//value1为null
String value1 = fifoCache.get("key1");

Paquete de impresión de consola

En circunstancias normales, imprimimos información en la consola, ¡los amigos deberían estar familiarizados con ella!

System.out.println("Hello World");

Sin embargo, este enfoque no satisface las necesidades de muchos escenarios:

Los parámetros no son compatibles y la impresión de objetos debe concatenar cadenas
La matriz no se puede imprimir directamente, debe llamarse manualmenteArrays.toString

Para ello, Hutool encapsula Consoleobjetos.

ConsoleEl uso de objetos es más similar al console.log()método de Javascript, que también es un azúcar sintáctico prestado de JS.

String[] a = {"java", "c++", "c"};
Console.log(a);//控制台输出：[java, c++, c]

Console.log("This is Console log for {}.", "test");//控制台输出：This is Console log for test.

cifrar y decodificar

Hutool admite cifrado simétrico, cifrado asimétrico, cifrado de resumen, algoritmo de código de autenticación de mensajes y secretos nacionales.

Aquí tomamos el algoritmo secreto nacional como ejemplo. Hutool ha Bouncy Castlecreado un paquete simplificado para implementar SM2, SM3 y SM4 en el algoritmo secreto nacional.

El Algoritmo Secreto Nacional necesita introducir Bouncy Castledependencias de biblioteca:

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15to18</artifactId>
    <version>1.69</version>
</dependency>

SM2 cifra o descifra mediante un par de claves personalizadas :

String text = "JavaGuide:一份涵盖大部分 Java 程序员所需要掌握的核心知识。准备 Java 面试，首选 JavaGuide！";
System.out.println("原文：" + text);

KeyPair pair = SecureUtil.generateKeyPair("SM2");
// 公钥
byte[] privateKey = pair.getPrivate().getEncoded();
// 私钥
byte[] publicKey = pair.getPublic().getEncoded();

SM2 sm2 = SmUtil.sm2(privateKey, publicKey);
// 公钥加密，私钥解密
String encryptStr = sm2.encryptBcd(text, KeyType.PublicKey);
System.out.println("加密后：" + encryptStr);

String decryptStr = StrUtil.utf8Str(sm2.decryptFromBcd(encryptStr, KeyType.PrivateKey));
System.out.println("解密后：" + decryptStr);

Firma y verificación SM2 :

//加签
String sign = sm2.signHex(HexUtil.encodeHexStr(text));
System.out.println("签名：" + sign);
//验签
boolean verify = sm2.verifyHex(HexUtil.encodeHexStr(text), sign);
System.out.println("验签：" + verify);

Grupo de subprocesos

Hutool admite el uso del patrón de construcción para crear un grupo de subprocesos personalizado, lo que facilita su visualización.

private static ExecutorService pool = ExecutorBuilder.create()
              .setCorePoolSize(10)//初始池大小
              .setMaxPoolSize(20) //最大池大小
              .setWorkQueue(new LinkedBlockingQueue<>(100))//最大等待数为100
              .setThreadFactory(ThreadFactoryBuilder.create().setNamePrefix("IM-Pool-").build())// 线程池命名
              .build();

En proyectos reales, si un objeto tiene muchos atributos, se debe dar una consideración limitada al uso del patrón de construcción para crear el objeto.

Además, Hutool también proporciona un grupo de subprocesos global, y todos los métodos asincrónicos se ejecutan en este grupo de subprocesos de forma predeterminada.

ThreadUtil.execute : Ejecutar subprocesos directamente en el grupo de subprocesos públicos
ThreadUtil.execAsync: Ejecutar un método asíncrono
......

Hutool en sí mismo es ampliamente utilizado ThreadUtil, como la clase de herramientas de palabras sensibles SensitiveUtil:

public static void init(final Collection<String> sensitiveWords, boolean isAsync){
  if(isAsync){
    // 异步初始化敏感词树
    ThreadUtil.execAsync(new Callable<Boolean>(){
      @Override
      public Boolean call() throws Exception {
        init(sensitiveWords);
        return true;
      }

    });
  }else{
    // 同步初始化敏感词树
    init(sensitiveWords);
  }
}

dirección relevante

Dirección del proyecto: https://github.com/dromara/hutool
Sitio web oficial: https://hutool.cn/

posdata

Una de las ventajas de Java es que tiene una ecología particularmente buena, que incluye muchas bibliotecas de herramientas y marcos útiles, que cubren casi todos los escenarios de demanda. No necesitamos hacer muchas cosas desde cero, el uso de bibliotecas de herramientas estables y confiables existentes puede mejorar en gran medida la eficiencia del desarrollo.

Por ejemplo, para el procesamiento de documentos de Excel, puede considerar las siguientes bibliotecas de herramientas de código abierto:

easyexcel[1] : Una herramienta de Excel de procesamiento de Java rápida y simple que evita OOM.
excel-streaming-reader[2]: herramienta de lectura de estilo de código de transmisión de Excel (solo admite la lectura de archivos XLSX), basada en el paquete de puntos de interés de Apache, al tiempo que conserva la sintaxis de la API de puntos de interés estándar.
myexcel[3]: un conjunto de herramientas que integra múltiples funciones, como importar, exportar y cifrar Excel.

Otro ejemplo es el procesamiento de documentos PDF:

pdfbox[4] : Una herramienta Java de código abierto para procesar documentos PDF. El proyecto permite crear nuevos documentos PDF, operar en documentos existentes y extraer contenido de los documentos. PDFBox también incluye varias utilidades de línea de comandos. PDFBox se publica bajo la licencia Apache versión 2.0.
OpenPDF[5]: OpenPDF es una biblioteca Java gratuita para crear y editar archivos PDF bajo las licencias de código abierto LGPL y MPL. OpenPDF se basa en una bifurcación de iText.
itext7[6]: iText 7 representa un SDK de nivel superior para los desarrolladores que desean aprovechar PDF. Equipado con un mejor motor de documentos, funciones de programación de alto y bajo nivel y la capacidad de crear, editar y mejorar documentos PDF, iText 7 beneficia a casi todos los flujos de trabajo.
FOP[7]: el principal destino de salida del proyecto Apache FOP es PDF.

Algunas bibliotecas de herramientas que se usan comúnmente en el desarrollo de Java se resumen en mi sitio web, que se puede usar como referencia: https://javaguide.cn/open-source-project/tool-library.html.

Referencias

[1]

easyexcel: https://github.com/alibaba/easyexcel

[2]

Excel-streaming-reader: https://github.com/monitorjbl/excel-streaming-reader

[3]

myexcel: https://github.com/liaochong/myexcel

[4]

pdfbox: https://github.com/apache/pdfbox

[5]

OpenPDF: https://github.com/LibrePDF/OpenPDF

[6]

itext7: https://github.com/itext/itext7

[7]

FOP: https://xmlgraphics.apache.org/fop/