高效编程Hutool工具分析：Hutool设计方案与工具使用案例(设计与实战篇)

Solomon_肖哥弹架构

于 2024-10-04 12:57:44 发布

阅读量1.1k

点赞数 22

分类专栏：高并发 Java 框架应用文章标签： Java hutool 框架应用

本文链接：https://blog.csdn.net/alises1314/article/details/142702123

版权

Java 同时被 3 个专栏收录

256 篇文章 1 订阅

订阅专栏

高并发

21 篇文章 0 订阅

订阅专栏

框架应用

13 篇文章 0 订阅

订阅专栏

在这里插入图片描述

Hutool 是一个 Java 工具包集合，旨在提供一系列简单、易用的工具类，帮助开发者在项目开发中减少重复代码，提高开发效率。它涵盖了文件操作、日期处理、加密解密、HTTP通信等多个领域，通过静态方法封装，使得 Java 代码更加简洁。Hutool 以其小而全的特点，成为 Java 开发者的工具箱，无论是大型项目还是小型应用，都能从中受益。

肖哥弹架构 跟大家“弹弹” 框架注解使用，需要代码关注

欢迎点赞，关注，评论。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

0. Hutool设计方案

在这里插入图片描述

hutool-bloomFilter: 提供布隆过滤器工具类 BloomFilterUtil。
hutool-cron: 提供 Cron 表达式解析工具类 CronUtil 和计划任务工具类 CronScheduleUtil。
hutool-db: 提供数据库操作工具类 DbUtil。
hutool-dfa: 提供确定有限自动机工具类 DfaUtil。
hutool-script: 提供脚本执行工具类 ScriptUtil。
hutool-system: 提供系统信息工具类 SysUtil。
hutool-json: 提供 JSON 处理工具类 JsonUtil。
hutool-captcha: 提供验证码生成工具类 CaptchaUtil。
hutool-extra: 提供额外的工具类集合，如二维码生成工具类 QrCodeUtil、FTP 客户端工具类 Ftp 以及其他实用工具类。

1、BloomFilterUtil - 布隆过滤器工具类

BloomFilterUtil 是 Hutool 中用于创建和管理布隆过滤器的工具类，布隆过滤器是一种空间效率很高的概率型数据结构，用于判断一个元素是否可能存在于一个集合中。

常用方法

add: 向布隆过滤器中添加元素。
exists: 检查布隆过滤器中是否可能包含某个元素。
delete: 从布隆过滤器中删除元素（如果支持）。

import cn.hutool.extra.bloomfilter.BitMap;
import cn.hutool.extra.bloomfilter.BloomFilter;

public class EmailService {

    private final BloomFilter<String> bloomFilter;

    public EmailService() {
        // 初始化布隆过滤器，预计元素数量为10000，误判率为0.03
        this.bloomFilter = BloomFilterUtil.create(10000, 0.03);
    }

    /**
     * 检查用户是否发送过特定内容的邮件
     * 
     * @param userId 用户ID
     * @param content 邮件内容
     * @return 如果用户发送过则返回true，否则返回false
     */
    public boolean checkEmailSent(String userId, String content) {
        String key = userId + ":" + content;
        return bloomFilter.exists(key);
    }

    /**
     * 记录用户发送邮件的行为
     * 
     * @param userId 用户ID
     * @param content 邮件内容
     */
    public void recordEmailSent(String userId, String content) {
        String key = userId + ":" + content;
        bloomFilter.add(key);
    }

    public static void main(String[] args) {
        EmailService emailService = new EmailService();
        
        // 模拟用户发送邮件
        String userId = "user123";
        String emailContent = "Hello, this is a test email.";
        emailService.recordEmailSent(userId, emailContent);
        
        // 检查用户是否发送过该邮件
        boolean isSent = emailService.checkEmailSent(userId, emailContent);
        System.out.println("Has the email been sent? " + isSent);
    }
}

2、CronUtil - 定时任务工具类

CronUtil 是 Hutool 中用于处理定时任务的工具类，提供 Cron 表达式的解析和任务调度功能。

常用方法

getCronPattern: 根据给定的时间参数生成 Cron 表达式。
getNextTime: 根据 Cron 表达式获取下次执行时间。
isMatch: 检查给定的时间是否匹配 Cron 表达式。
schedule: 根据 Cron 表达式安排任务执行。
start: 启动定时任务调度。
stop: 停止定时任务调度。

import cn.hutool.cron.CronUtil;
import cn.hutool.cron.task.Task;
import cn.hutool.core.date.DateUtil;

import java.util.concurrent.TimeUnit;

public class DataBackupService {

    /**
     * 执行数据备份任务
     */
    public void performBackup() {
        System.out.println("Data backup is performed at " + DateUtil.now());
    }

    /**
     * 安排每日数据备份任务
     */
    public void scheduleDailyBackup() {
        String cronExpression = CronUtil.getCronPattern("0", "23", "*", "*", "?", "*");
        CronUtil.schedule(cronExpression, new Task() {
            @Override
            public void execute() {
                performBackup();
            }
        });
    }

    public static void main(String[] args) {
        DataBackupService service = new DataBackupService();
        service.scheduleDailyBackup();

        //等待一段时间以观察定时任务的执行
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 停止定时任务
        CronUtil.stop();
    }
}

3、CronScheduleUtil - 定时任务调度工具类

CronScheduleUtil 是 Hutool 中用于处理定时任务调度的工具类，它提供了基于 Cron 表达式的定时任务执行功能。

常用方法

schedule: 根据 Cron 表达式安排任务执行。
scheduleAtFixedRate: 根据固定频率安排任务执行。
scheduleWithFixedDelay: 根据固定延迟安排任务执行。
getScheduledFuture: 获取 ScheduledFuture 对象，用于管理任务。
shutdown: 关闭调度器。

import cn.hutool.cron.CronScheduleUtil;
import cn.hutool.cron.task.Task;

public class ScheduledTaskService {

    /**
     * 安排每日数据备份任务
     */
    public void scheduleDailyBackup() {
        String cronExpression = "0 0 23 * * ? *"; // 每天23:00执行
        CronScheduleUtil.schedule(cronExpression, new Task() {
            @Override
            public void execute() {
                performBackup();
            }
        });
    }

    /**
     * 安排健康检查任务
     */
    public void scheduleHealthCheck() {
        CronScheduleUtil.scheduleAtFixedRate("0/5 * * * * * ?", new Task() {
            @Override
            public void execute() {
                performHealthCheck();
            }
        }, 5, TimeUnit.MINUTES); // 每5分钟执行一次
    }

    /**
     * 执行数据备份任务
     */
    private void performBackup() {
        System.out.println("Data backup is performed at " + cn.hutool.core.date.DateUtil.now());
    }

    /**
     * 执行健康检查任务
     */
    private void performHealthCheck() {
        System.out.println("Health check is performed at " + cn.hutool.core.date.DateUtil.now());
    }

    public static void main(String[] args) {
        ScheduledTaskService service = new ScheduledTaskService();
        service.scheduleDailyBackup();
        service.scheduleHealthCheck();

        // 演示：等待一段时间以观察定时任务的执行
        try {
            Thread.sleep(10000); // 10秒后停止任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 停止所有定时任务
        CronScheduleUtil.shutdown();
    }
}

说明

安排每日数据备份任务: 使用 CronScheduleUtil.schedule 方法根据 Cron 表达式安排每日数据备份任务。
安排健康检查任务: 使用 CronScheduleUtil.scheduleAtFixedRate 方法安排健康检查任务，每隔一定时间执行一次。
执行数据备份和健康检查任务: performBackup 和 performHealthCheck 方法模拟执行数据备份和健康检查任务。
启动和停止定时任务: CronScheduleUtil.schedule 和 CronScheduleUtil.shutdown 方法分别用于启动和停止定时任务。

4、DbUtil - 数据库操作工具类

DbUtil 是 Hutool 中用于简化数据库操作的工具类，提供了执行 SQL 语句的简便方法。

常用方法

query: 执行查询并返回结果。
queryValue: 执行查询并返回第一行第一列的结果。
queryInt: 执行查询并返回第一行第一列的整数值。
queryForList: 执行查询并返回 List<Map<String, Object>>。
queryForMap: 执行查询并返回 Map<String, Object>。
queryForMapList: 执行查询并返回 List<Map<String, Object>>。
queryRecord: 执行查询并返回 Record 对象。
queryRecordList: 执行查询并返回 List<Record>。
queryForSet: 执行查询并返回 Set<Map<String, Object>>。
queryForBean: 执行查询并返回与给定类类型匹配的对象。
queryForBeanList: 执行查询并返回与给定类类型匹配的对象列表。
execute: 执行非查询 SQL 语句。
batch: 执行批量插入或更新。
update: 执行更新操作。
insert: 执行插入操作。
delete: 执行删除操作。
updateByWrapper: 使用 UpdateWrapper 执行条件更新。
use: 使用特定的数据库连接。
use: 使用自定义的数据库连接。
close: 关闭数据库连接。

import cn.hutool.db.Db;
import cn.hutool.db.DbUtil;
import cn.hutool.db.Entity;

import java.sql.Connection;
import java.util.List;

public class BookStoreService {

    /**
     * 查询所有书籍
     * 
     * @return 书籍列表
     */
    public List<Entity> queryBooks() {
        // query: 执行查询并返回结果。
        return Db.use().query("SELECT * FROM books");
    }

    /**
     * 带参数的查询书籍
     * 
     * @param bookName 书籍名称
     * @return 符合条件的书籍列表
     */
    public List<Entity> queryBooks(String bookName) {
        // query (with params): 带参数的查询。
        return Db.use().query("SELECT * FROM books WHERE name LIKE ?", "%" + bookName + "%");
    }

    /**
     * 更新书籍库存
     * 
     * @param bookId 书籍ID
     * @param quantity 更新的数量
     * @return 更新是否成功
     */
    public boolean updateBookStock(Long bookId, int quantity) {
        // execute: 执行非查询 SQL 语句，如插入、更新或删除。
        String sql = "UPDATE books SET stock = stock + ? WHERE id = ?";
        return Db.use().execute(sql, quantity, bookId) > 0;
    }

    /**
     * 带参数的非查询 SQL 语句执行
     * 
     * @param bookId 书籍ID
     * @param quantity 更新的数量
     * @return 更新是否成功
     */
    public boolean updateBookStockWithParams(Long bookId, int quantity) {
        // execute (with params): 带参数的非查询 SQL 语句执行。
        String sql = "UPDATE books SET stock = ? WHERE id = ?";
        return Db.use().execute(sql, quantity, bookId) > 0;
    }

    /**
     * 使用特定的数据库连接
     * 
     * @return 自定义连接的Db对象
     */
    public Db useCustomConnection() {
        // use: 使用特定的数据库连接。
        return Db.use("url", "username", "password");
    }

    /**
     * 使用自定义的数据库连接
     * 
     * @param connection 数据库连接
     * @return 自定义连接的Db对象
     */
    public Db useCustomConnection(Connection connection) {
        // use (with Connection): 使用自定义的数据库连接。
        return Db.use(connection);
    }

    public static void main(String[] args) {
        BookStoreService service = new BookStoreService();
        
        // 查询所有书籍
        List<Entity> books = service.queryBooks();
        books.forEach(book -> System.out.println(book.toMap()));

        // 带参数的查询
        List<Entity> searchedBooks = service.queryBooks("Java");
        searchedBooks.forEach(book -> System.out.println(book.toMap()));

        // 更新书籍库存
        boolean updated = service.updateBookStock(1L, 3);
        System.out.println("Stock updated successfully: " + updated);

        // 使用特定的数据库连接
        Db customDb = service.useCustomConnection();
        List<Entity> customBooks = customDb.query("SELECT * FROM books");
        customBooks.forEach(book -> System.out.println(book.toMap()));
    }
}

5、DfaUtil - 基于 DFA 模型的多关键字查找工具类

DfaUtil 是 Hutool 中用于基于 DFA（确定性有限自动机）模型进行多关键字查找的工具类。

常用方法

addKeyword: 添加单个关键字到 DFA 中。
addKeywords: 批量添加关键字到 DFA 中。
contains: 检查给定文本是否包含 DFA 中的任意关键字。
find: 在给定文本中查找 DFA 中的关键字，并返回首次匹配到的关键字。
findAll: 在给定文本中查找 DFA 中的所有关键字，并返回所有匹配到的关键字列表。
getKeywords: 获取 DFA 中的所有关键字。
clear: 清除 DFA 中的所有关键字。

import cn.hutool.dfa.Dfa;
import cn.hutool.dfa.DfaBuilder;
import cn.hutool.dfa.IDfa;

import java.util.List;

public class DfaUtilExample {

    public static void main(String[] args) {
        // 创建 DFA 构建器
        DfaBuilder dfaBuilder = new DfaBuilder();

        // 1. 添加单个关键字
        dfaBuilder.addKeyword("Hutool");

        // 2. 批量添加关键字
        dfaBuilder.addKeywords(new String[]{"Java", "Python", "C++"});

        // 构建 DFA 实例
        IDfa dfa = dfaBuilder.build();

        // 3. 检查字符串是否包含任何一个关键字
        boolean contains = dfa.contains("Hutool is a great Java library.");
        System.out.println("Contains keyword: " + contains);

        // 4. 查找字符串中的关键字并返回匹配结果
        String found = dfa.find("Hutool is a great Java library.");
        System.out.println("Found keyword: " + found);

        // 5. 查找字符串中所有关键字的匹配结果
        List<String> findAll = dfa.findAll("Hutool is a great Java library.");
        System.out.println("Found all keywords: " + findAll);

        // 6. 获取 DFA 中的所有关键字
        List<String> keywords = dfa.getKeywords();
        System.out.println("Keywords: " + keywords);

        // 7. 清除 DFA 中的所有关键字
        dfa.clear();
    }
}

说明

addKeyword: 使用 DfaBuilder.addKeyword(String keyword) 方法添加单个关键字。
addKeywords: 使用 DfaBuilder.addKeywords(String... keywords) 方法批量添加关键字。
contains: 使用 IDfa.contains(String text) 方法检查文本是否包含 DFA 中的任意关键字。
find: 使用 IDfa.find(String text) 方法在文本中查找首次匹配到的关键字。
findAll: 使用 IDfa.findAll(String text) 方法在文本中查找所有匹配到的关键字。
getKeywords: 使用 IDfa.getKeywords() 方法获取 DFA 中的所有关键字。
clear: 使用 IDfa.clear() 方法清除 DFA 中的所有关键字。

6、ScriptUtil - 脚本执行工具类

ScriptUtil 是 Hutool 中用于执行各种脚本语言的工具类，支持动态脚本执行。

常用方法

eval: 执行字符串形式的脚本，并返回执行结果。
execJavaScript: 执行 JavaScript 脚本。
execJRuby: 执行 JRuby 脚本。
execJPython: 执行 JPython 脚本。
exec: 执行指定类型的脚本。

import cn.hutool.script.ScriptUtil;

public class ScriptUtilExample {

    /**
     * 执行 JavaScript 脚本
     */
    public static Object execJavaScript(String script) {
        return ScriptUtil.execJavaScript(script);
    }

    /**
     * 执行 JRuby 脚本
     */
    public static Object execJRuby(String script) {
        return ScriptUtil.execJRuby(script);
    }

    /**
     * 执行 JPython 脚本
     */
    public static Object execJPython(String script) {
        return ScriptUtil.execJPython(script);
    }

    /**
     * 执行通用脚本
     */
    public static Object exec(String script, String engineName) {
        return ScriptUtil.exec(script, engineName);
    }

    public static void main(String[] args) {
        // JavaScript 
        Object result = execJavaScript("var sum = 0; for (var i = 0; i < 10; i++) { sum += i; } sum");
        System.out.println("JavaScript result: " + result);

        // JRuby 
        result = execJRuby("sum = 0; (0..9).each {|i| sum += i}; sum");
        System.out.println("JRuby result: " + result);

        // JPython 
        result = execJPython("sum = 0; for i in range(10): sum += i; sum");
        System.out.println("JPython result: " + result);

        // 通用脚本执行
        result = exec("print('Hello, Script!')", "python");
        System.out.println("General script result: " + result);
    }
}

说明

execJavaScript: 使用 ScriptUtil.execJavaScript(String script) 方法执行 JavaScript 脚本。
execJRuby: 使用 ScriptUtil.execJRuby(String script) 方法执行 JRuby 脚本。
execJPython: 使用 ScriptUtil.execJPython(String script) 方法执行 JPython 脚本。
exec: 使用 ScriptUtil.exec(String script, String engineName) 方法执行指定类型的脚本。

7、SysUtil - 系统工具类

SysUtil 是 Hutool 中用于获取系统相关信息的工具类。

常用方法

getJavaVersion: 获取 Java 版本。
getJavaVendor: 获取 Java 提供商。
getJavaVendorUrl: 获取 Java 提供商 URL。
getJavaHome: 获取 Java 安装目录。
getJavaTmpDir: 获取 Java 临时目录。
getUserDir: 获取用户的当前工作目录。
getOSName: 获取操作系统名称。
getOSVersion: 获取操作系统版本。
getOSArch: 获取操作系统架构。
getHostName: 获取主机名。
getHostIp: 获取本机IP地址。
getEnv: 获取环境变量。
getSystemProperties: 获取系统属性。
shutdown: 关闭系统。

import cn.hutool.system.SysUtil;

public class SysUtilExample {

    public static void main(String[] args) {
        // 获取 Java 版本
        String javaVersion = SysUtil.getJavaVersion();
        System.out.println("Java Version: " + javaVersion);

        // 获取 Java 提供商
        String javaVendor = SysUtil.getJavaVendor();
        System.out.println("Java Vendor: " + javaVendor);

        // 获取 Java 提供商 URL
        String javaVendorUrl = SysUtil.getJavaVendorUrl();
        System.out.println("Java Vendor URL: " + javaVendorUrl);

        // 获取 Java 安装目录
        String javaHome = SysUtil.getJavaHome();
        System.out.println("Java Home: " + javaHome);

        // 获取 Java 临时目录
        String javaTmpDir = SysUtil.getJavaTmpDir();
        System.out.println("Java Temp Dir: " + javaTmpDir);

        // 获取用户的当前工作目录
        String userDir = SysUtil.getUserDir();
        System.out.println("User Dir: " + userDir);

        // 获取操作系统名称
        String osName = SysUtil.getOSName();
        System.out.println("OS Name: " + osName);

        // 获取操作系统版本
        String osVersion = SysUtil.getOSVersion();
        System.out.println("OS Version: " + osVersion);

        // 获取操作系统架构
        String osArch = SysUtil.getOSArch();
        System.out.println("OS Architecture: " + osArch);

        // 获取主机名
        String hostName = SysUtil.getHostName();
        System.out.println("Host Name: " + hostName);

        // 获取本机IP地址
        String hostIp = SysUtil.getHostIp();
        System.out.println("Host IP: " + hostIp);

        // 获取环境变量
        String pathVariable = SysUtil.getEnv("PATH");
        System.out.println("PATH Variable: " + pathVariable);

        // 获取系统属性
        String userLanguage = SysUtil.getSystemProperty("user.language");
        System.out.println("User Language: " + userLanguage);

        // 关闭系统（谨慎使用）
        // SysUtil.shutdown();
    }
}

说明

getJavaVersion: 使用 SysUtil.getJavaVersion() 获取 Java 版本。
getJavaVendor: 使用 SysUtil.getJavaVendor() 获取 Java 提供商。
getJavaVendorUrl: 使用 SysUtil.getJavaVendorUrl() 获取 Java 提供商 URL。
getJavaHome: 使用 SysUtil.getJavaHome() 获取 Java 安装目录。
getJavaTmpDir: 使用 SysUtil.getJavaTmpDir() 获取 Java 临时目录。
getUserDir: 使用 SysUtil.getUserDir() 获取用户的当前工作目录。
getOSName: 使用 SysUtil.getOSName() 获取操作系统名称。
getOSVersion: 使用 SysUtil.getOSVersion() 获取操作系统版本。
getOSArch: 使用 SysUtil.getOSArch() 获取操作系统架构。
getHostName: 使用 SysUtil.getHostName() 获取主机名。
getHostIp: 使用 SysUtil.getHostIp() 获取本机IP地址。
getEnv: 使用 SysUtil.getEnv(String name) 获取指定的环境变量。
getSystemProperties: 使用 SysUtil.getSystemProperties() 获取所有系统属性。
shutdown: 使用 SysUtil.shutdown() 关闭系统（此方法需要谨慎使用，因为它将关闭 JVM 进程）。

8、JsonUtil - JSON 处理工具类

JsonUtil 是 Hutool 中用于处理 JSON 数据的工具类，支持 JSON 的序列化和反序列化。

常用方法

toJsonStr: 将对象转换为 JSON 字符串。
.toBean: 将 JSON 字符串转换为 Java 对象。
.toList: 将 JSON 字符串转换为 List。
.getStr: 从 JSON 对象中获取字符串值。
.getInt: 从 JSON 对象中获取整数值。
.getLong: 从 JSON 对象中获取长整数值。
.getDouble: 从 JSON 对象中获取双精度浮点数值。
.getBool: 从 JSON 对象中获取布尔值。
.getJSONObject: 从 JSON 对象中获取嵌套的 JSON 对象。
.getJSONArray: 从 JSON 对象中获取 JSON 数组。

import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONUtil;

import java.util.List;
import java.util.Map;

public class JsonUtilExample {

    /**
     * 将对象转换为 JSON 字符串
     */
    public static String toJsonStr(Object obj) {
        return JSONUtil.toJsonStr(obj);
    }

    /**
     * 将 JSON 字符串转换为 Java 对象
     */
    public static <T> T toBean(String json, Class<T> beanClass) {
        return JSONUtil.toBean(json, beanClass);
    }

    /**
     * 将 JSON 字符串转换为 List
     */
    public static <T> List<T> toList(String json, Class<T> beanClass) {
        return JSONUtil.toList(json, beanClass);
    }

    /**
     * 从 JSON 对象中获取值
     */
    public static void getJsonValues(String json) {
        // 获取字符串值
        String str = JSONUtil.getStr(json, "key");
        System.out.println("String value: " + str);

        // 获取整数值
        Integer intValue = JSONUtil.getInt(json, "key");
        System.out.println("Integer value: " + intValue);

        // 获取长整数值
        Long longValue = JSONUtil.getLong(json, "key");
        System.out.println("Long value: " + longValue);

        // 获取双精度浮点数值
        Double doubleValue = JSONUtil.getDouble(json, "key");
        System.out.println("Double value: " + doubleValue);

        // 获取布尔值
        Boolean boolValue = JSONUtil.getBool(json, "key");
        System.out.println("Boolean value: " + boolValue);

        // 获取嵌套的 JSON 对象
        String jsonObjectStr = JSONUtil.toJsonStr(json);
        System.out.println("Nested JSON object: " + jsonObjectStr);

        // 获取 JSON 数组
        String jsonArrayStr = JSONUtil.toJsonStr(json);
        System.out.println("JSON Array: " + jsonArrayStr);
    }

    public static void main(String[] args) {
        // 创建一个 Java 对象
        Map<String, Object> map =(Map<String, Object>) JSONUtil.parse("{"name":"Hutool","version":"5.7.16"}");

        // 将对象转换为 JSON 字符串
        String jsonStr = toJsonStr(map);
        System.out.println("JSON String: " + jsonStr);

        // 将 JSON 字符串转换为 Java 对象
        Map<String, Object> mapObj = toBean(jsonStr, Map.class);
        System.out.println("Bean: " + mapObj);

        // 将 JSON 字符串转换为 List
        List<Map<String, Object>> list = toList(jsonStr, Map.class);
        System.out.println("List: " + list);

        // 获取 JSON 值
        getJsonValues(jsonStr);
    }
}

说明

toJsonStr: 使用 JSONUtil.toJsonStr(Object obj) 方法将对象转换为 JSON 字符串。
toBean: 使用 JSONUtil.toBean(String json, Class<T> beanClass) 方法将 JSON 字符串转换为 Java 对象。
toList: 使用 JSONUtil.toList(String json, Class<T> beanClass) 方法将 JSON 字符串转换为 List。
getStr: 使用 JSONUtil.getStr(String json, String key) 方法从 JSON 对象中获取字符串值。
getInt: 使用 JSONUtil.getInt(String json, String key) 方法从 JSON 对象中获取整数值。
getLong: 使用 JSONUtil.getLong(String json, String key) 方法从 JSON 对象中获取长整数值。
getDouble: 使用 JSONUtil.getDouble(String json, String key) 方法从 JSON 对象中获取双精度浮点数值。
getBool: 使用 JSONUtil.getBool(String json, String key) 方法从 JSON 对象中获取布尔值。
getJSONObject: 使用 JSONUtil.getJSONObject(String json, String key) 方法从 JSON 对象中获取嵌套的 JSON 对象。
getJSONArray: 使用 JSONUtil.getJSONArray(String json, String key) 方法从 JSON 对象中获取 JSON 数组。

9、CaptchaUtil - 验证码生成工具类

CaptchaUtil 是 Hutool 中用于生成验证码的工具类，支持多种配置和样式。

常用方法

create: 创建指定长度和宽度的验证码,同时重载了其他参数类型的方法。

import cn.hutool.extra.captcha.CaptchaUtil;
import cn.hutool.extra.captcha.ICaptcha;

import java.awt.image.BufferedImage;

public class CaptchaUtilExample {

    /**
     * 生成默认配置的验证码
     */
    public static BufferedImage createDefaultCaptcha() {
        ICaptcha captcha = CaptchaUtil.create();
        return captcha.getImage();
    }

    /**
     * 生成自定义配置的验证码
     */
    public static BufferedImage createCustomCaptcha() {
        ICaptcha captcha = CaptchaUtil.create(120, 40, 6, 10);
        return captcha.getImage();
    }

    /**
     * 生成带干扰线的验证码
     */
    public static BufferedImage createCaptchaWithLine() {
        ICaptcha captcha = CaptchaUtil.create(120, 40, 6, 10, true, true);
        return captcha.getImage();
    }

    /**
     * 生成带干扰线和噪点的验证码
     */
    public static BufferedImage createCaptchaWithLineAndNoise() {
        ICaptcha captcha = CaptchaUtil.create(120, 40, 6, 10, true, true, true);
        return captcha.getImage();
    }

    public static void main(String[] args) {
        // 生成默认验证码
        BufferedImage defaultCaptchaImage = createDefaultCaptcha();
        // 保存或输出验证码图片...

        // 生成自定义验证码
        BufferedImage customCaptchaImage = createCustomCaptcha();
        // 保存或输出验证码图片...

        // 生成带干扰线的验证码
        BufferedImage captchaImageWithLine = createCaptchaWithLine();
        // 保存或输出验证码图片...

        // 生成带干扰线和噪点的验证码
        BufferedImage captchaImageWithLineAndNoise = createCaptchaWithLineAndNoise();
        // 保存或输出验证码图片...
    }
}

说明

create: 使用 CaptchaUtil.create() 方法创建默认配置的验证码。
create: 使用 CaptchaUtil.create(width, height, codeCount, lineCount) 方法创建自定义大小和长度的验证码。
create: 使用 CaptchaUtil.create(width, height, codeCount, lineCount, hasLine, hasNoise) 方法创建具有干扰线的验证码。
create: 使用 CaptchaUtil.create(width, height, codeCount, lineCount, hasLine, hasNoise, hasNoise) 方法创建具有干扰线和噪点的验证码。

10、QrCodeUtil - 二维码生成工具类

QrCodeUtil 是 Hutool 中用于生成二维码的工具类。

常用方法

generate: 生成默认大小的二维码。
generate: 生成指定大小的二维码。
generate: 生成带有 logo 的二维码。
generate: 生成带有 logo 和颜色的二维码。
generate: 生成带有版本号的二维码。
generate: 生成带有错误校正级别的二维码。

import cn.hutool.extra.qrcode.QrCodeUtil;
import cn.hutool.extra.qrcode.QrConfig;
import java.awt.image.BufferedImage;

public class QrCodeUtilExample {

    /**
     * 生成默认大小的二维码
     */
    public static BufferedImage generateDefaultQrCode(String content) {
        return QrCodeUtil.generate(content);
    }

    /**
     * 生成指定大小的二维码
     */
    public static BufferedImage generateCustomSizeQrCode(String content, int width, int height) {
        QrConfig config = QrConfig.create().setSize(width, height);
        return QrCodeUtil.generate(content, config);
    }

    /**
     * 生成带有 logo 的二维码
     */
    public static BufferedImage generateQrCodeWithLogo(String content, String logoPath) {
        QrConfig config = QrConfig.create().setLogoPath(logoPath);
        return QrCodeUtil.generate(content, config);
    }

    /**
     * 生成带有 logo 和颜色的二维码
     */
    public static BufferedImage generateQrCodeWithColor(String content, String logoPath, int logoWidth) {
        QrConfig config = QrConfig.create()
                .setLogoPath(logoPath)
                .setLogoWidth/logoWidth)
                .setColorBlack(true) // 设置黑色
                .setColorWhite(true); // 设置白色
        return QrCodeUtil.generate(content, config);
    }

    /**
     * 生成带有版本号的二维码
     */
    public static BufferedImage generateQrCodeWithVersion(String content, int version) {
        QrConfig config = QrConfig.create().setVersion(version);
        return QrCodeUtil.generate(content, config);
    }

    /**
     * 生成带有错误校正级别的二维码
     */
    public static BufferedImage generateQrCodeWithErrorCorrection(String content, int errorCorrection) {
        QrConfig config = QrConfig.create().setErrorCorrection(errorCorrection);
        return QrCodeUtil.generate(content, config);
    }

    public static void main(String[] args) {
        // 生成默认二维码
        BufferedImage defaultQrCode = generateDefaultQrCode("https://hutool.cn/");
        // 保存或输出二维码图片...

        // 生成自定义大小的二维码
        BufferedImage customSizeQrCode = generateCustomSizeQrCode("https://hutool.cn/", 200, 200);
        // 保存或输出二维码图片...

        // 生成带有 logo 的二维码
        BufferedImage qrCodeWithLogo = generateQrCodeWithLogo("https://hutool.cn/", "path/to/logo.png");
        // 保存或输出二维码图片...

        // 生成带有 logo 和颜色的二维码
        BufferedImage qrCodeWithColor = generateQrCodeWithColor("https://hutool.cn/", "path/to/logo.png", 50);
        // 保存或输出二维码图片...

        // 生成带有版本号的二维码
        BufferedImage qrCodeWithVersion = generateQrCodeWithVersion("https://hutool.cn/", 5);
        // 保存或输出二维码图片...

        // 生成带有错误校正级别的二维码
        BufferedImage qrCodeWithErrorCorrection = generateQrCodeWithErrorCorrection("https://hutool.cn/", 1);
        // 保存或输出二维码图片...
    }
}

说明

generate: 使用 QrCodeUtil.generate(String content) 方法生成默认大小的二维码。
generate: 使用 QrCodeUtil.generate(String content, QrConfig config) 方法生成自定义配置的二维码。
generate: 使用 QrConfig 设置二维码的 logo、大小、版本号、错误校正级别等。