百度360必应搜狗淘宝本站头条
yum下载包及依赖到本地vuexstoregitcommit-ambashecho控制台打印
当前位置：网站首页 > 博客教程 > 正文

高效编程Hutool工具分析:Hutool设计方案与使用案例(第二部分)

connygpt 2024-12-15 11:39 11 浏览

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

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

欢迎 点赞，关注，评论。

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

历史热点文章

  • 28个验证注解，通过业务案例让你精通Java数据校验(收藏篇)
  • Java 8函数式编程全攻略：43种函数式业务代码实战案例解析(收藏版)
  • 69 个Spring mvc 全部注解：真实业务使用案例说明(必须收藏)
  • 24 个Spring bean 全部注解：真实业务使用案例说明(必须收藏)
  • MySQL索引完全手册：真实业务图文讲解17种索引运用技巧(必须收藏)
  • 一个项目代码讲清楚DO/PO/BO/AO/E/DTO/DAO/ POJO/VO

0. Hutool设计方案

1. SettingUtil - 配置文件工具类

常用方法

  1. 加载配置文件 ( SettingUtil.getSetting)
  2. 获取配置项 ( Setting.getProperty)
  3. 设置配置项 ( Setting.setProperty)
  4. 删除配置项 ( Setting.remove)
  5. 保存配置文件 ( Setting.save)
  6. 遍历配置项 ( Setting.getKeys)
  7. 获取所有配置项 ( Setting.getProperties)
import cn.hutool.setting.Setting;
import cn.hutool.setting.SettingUtil;

import java.util.Properties;

public class AppConfigManager {

    /**
     * 加载配置文件
     * 
     * @param path 配置文件路径
     * @return 配置文件对象
     */
    public Setting loadConfig(String path) {
        // 使用 SettingUtil.getSetting 加载配置文件
        return SettingUtil.getSetting(path);
    }

    /**
     * 获取配置项
     * 
     * @param setting 配置文件对象
     * @param key 配置项键
     * @return 配置项值
     */
    public String getConfigValue(Setting setting, String key) {
        // 使用 Setting.getProperty 获取配置项
        return setting.getProperty(key);
    }

    /**
     * 设置配置项
     * 
     * @param setting 配置文件对象
     * @param key 配置项键
     * @param value 配置项值
     */
    public void setConfigValue(Setting setting, String key, String value) {
        // 使用 Setting.setProperty 设置配置项
        setting.setProperty(key, value);
    }

    /**
     * 删除配置项
     * 
     * @param setting 配置文件对象
     * @param key 配置项键
     */
    public void removeConfigValue(Setting setting, String key) {
        // 使用 Setting.remove 删除配置项
        setting.remove(key);
    }

    /**
     * 保存配置文件
     * 
     * @param setting 配置文件对象
     */
    public void saveConfig(Setting setting) {
        // 使用 Setting.save 保存配置文件
        setting.save();
    }

    public static void main(String[] args) {
        AppConfigManager configManager = new AppConfigManager();

        // 加载配置文件
        Setting setting = configManager.loadConfig("config/app.properties");

        // 获取配置项
        String dbUrl = configManager.getConfigValue(setting, "db.url");
        System.out.println("Database URL: " + dbUrl);

        // 设置新的配置项
        configManager.setConfigValue(setting, "db.username", "newUsername");

        // 删除配置项
        configManager.removeConfigValue(setting, "db.password");

        // 保存配置文件
        configManager.saveConfig(setting);
    }
}

2. ExcelUtil - Excel 操作工具类

常用方法

  1. 写入数据到 Excel ( ExcelUtil.getWriter)
  2. 读取 Excel 数据 ( ExcelUtil.getReader)
  3. 写入并自动关闭 ( ExcelUtil.write)
  4. 读取并自动关闭 ( ExcelUtil.read)
  5. 合并多个 Excel 文件 ( ExcelUtil.merge)
  6. 拆分 Excel 文件 ( ExcelUtil.split)
  7. 获取 Excel 行数 ( ExcelUtil.getRowCount)
  8. 获取 Excel 列数 ( ExcelUtil.getColumnCount)
import cn.hutool.poi.excel.ExcelReader;
import cn.hutool.poi.excel.ExcelUtil;
import cn.hutool.poi.excel.ExcelWriter;

import java.util.List;

public class SalesManagementSystem {

    /**
     * 从 Excel 文件读取销售数据
     * 
     * @param filePath Excel 文件路径
     * @return 销售数据列表
     */
    public List<SalesData> readSalesData(String filePath) {
        // 使用 ExcelUtil.getReader 读取 Excel 数据
        ExcelReader reader = ExcelUtil.getReader(filePath);
        return reader.readAll();
    }

    /**
     * 将新的销售记录写入 Excel 文件
     * 
     * @param filePath Excel 文件路径
     * @param salesData 销售数据
     */
    public void writeSalesData(String filePath, List<SalesData> salesData) {
        // 使用 ExcelUtil.getWriter 创建 Excel 写入器
        ExcelWriter writer = ExcelUtil.getWriter(filePath);
        writer.write(salesData, true);
        writer.close();
    }

    /**
     * 合并多个 Excel 文件
     * 
     * @param outputPath 输出文件路径
     * @param inputPaths 输入文件路径列表
     */
    public void mergeExcelFiles(String outputPath, List<String> inputPaths) {
        // 使用 ExcelUtil.merge 合并多个 Excel 文件
        ExcelUtil.merge(inputPaths, outputPath, true);
    }

    /**
     * 拆分 Excel 文件
     * 
     * @param filePath Excel 文件路径
     * @param sheetName 拆分后的文件名
     */
    public void splitExcelFile(String filePath, String sheetName) {
        // 使用 ExcelUtil.split 拆分 Excel 文件
        ExcelUtil.split(filePath, sheetName, 0);
    }

    public static void main(String[] args) {
        SalesManagementSystem system = new SalesManagementSystem();

        // 读取销售数据
        List<SalesData> salesData = system.readSalesData("sales_data.xlsx");
        System.out.println("Read Sales Data: " + salesData);

        // 写入新的销售记录
        system.writeSalesData("updated_sales_data.xlsx", salesData);

        // 合并 Excel 文件
        system.mergeExcelFiles("merged_sales_data.xlsx", List.of("sales_data1.xlsx", "sales_data2.xlsx"));

        // 拆分 Excel 文件
        system.splitExcelFile("merged_sales_data.xlsx", "Sheet1");
    }
}

class SalesData {
    // 定义销售数据的字段
    private String date;
    private String product;
    private double amount;

    // 省略构造器、getter和setter方法
}

3. ReflectUtil - 反射工具类

常用方法

  1. 获取类 ( ReflectUtil.getClass)
  2. 创建实例 ( ReflectUtil.newInstance)
  3. 调用方法 ( ReflectUtil.invoke)
  4. 获取字段值 ( ReflectUtil.getFieldValue)
  5. 设置字段值 ( ReflectUtil.setFieldValue)
  6. 获取方法 ( ReflectUtil.getMethod)
  7. 获取所有方法 ( ReflectUtil.getMethods)
  8. 检查是否可以访问 ( ReflectUtil.canAccess)
import cn.hutool.reflect.ReflectException;
import cn.hutool.reflect.ReflectUtil;

import java.lang.reflect.Method;

public class DynamicProxySystem {

    /**
     * 动态创建类的实例
     * 
     * @param className 完整类名
     * @param <T> 类型参数
     * @return 类的实例
     */
    public <T> T createInstance(String className) {
        // 使用 ReflectUtil.newInstance 动态创建类的实例
        return ReflectUtil.newInstance(className);
    }

    /**
     * 动态调用对象的方法
     * 
     * @param target 目标对象
     * @param methodName 方法名
     * @param args 方法参数
     * @return 方法返回值
     */
    public Object invokeMethod(Object target, String methodName, Object... args) {
        // 使用 ReflectUtil.invoke 动态调用对象的方法
        return ReflectUtil.invoke(target, methodName, args);
    }

    /**
     * 动态获取字段值
     * 
     * @param target 目标对象
     * @param fieldName 字段名
     * @return 字段值
     */
    public Object getFieldValue(Object target, String fieldName) {
        // 使用 ReflectUtil.getFieldValue 动态获取字段值
        return ReflectUtil.getFieldValue(target, fieldName);
    }

    /**
     * 动态设置字段值
     * 
     * @param target 目标对象
     * @param fieldName 字段名
     * @param value 字段值
     */
    public void setFieldValue(Object target, String fieldName, Object value) {
        // 使用 ReflectUtil.setFieldValue 动态设置字段值
        ReflectUtil.setFieldValue(target, fieldName, value);
    }

    public static void main(String[] args) {
        DynamicProxySystem system = new DynamicProxySystem();

        try {
            // 动态创建实例
            SomeService service = system.createInstance("com.example.SomeService");

            // 动态调用方法
            String result = (String) system.invokeMethod(service, "performAction", "argument");
            System.out.println("Method Result: " + result);

            // 动态获取字段值
            Object fieldValue = system.getFieldValue(service, "someField");
            System.out.println("Field Value: " + fieldValue);

            // 动态设置字段值
            system.setFieldValue(service, "someField", "newValue");

        } catch (ReflectException e) {
            e.printStackTrace();
        }
    }
}

class SomeService {
    public String performAction(String param) {
        return "Performed action with " + param;
    }

    private String someField = "initialValue";

    public String getSomeField() {
        return someField;
    }

    public void setSomeField(String someField) {
        this.someField = someField;
    }
}

4. ThreadUtil - 线程工具类（扩展）

常用方法

  1. 创建并启动线程 ( ThreadUtil.execute)
  2. 创建线程池 ( ThreadUtil.newExecutor)
  3. 执行定时任务 ( ThreadUtil.schedule)
  4. 执行周期性任务 ( ThreadUtil.scheduleAtFixedRate)
  5. 停止线程池 ( ThreadUtil.shutdown)
  6. 获取当前线程 ( ThreadUtil.currentThread)
  7. 命名线程 ( ThreadUtil.setName)
  8. 获取线程名称 ( ThreadUtil.getName)
  9. 等待线程结束 ( ThreadUtil.join)
  10. 创建并启动守护线程 ( ThreadUtil.daemon)
  11. 创建并启动单例线程 ( ThreadUtil.single)
  12. 创建线程工厂 ( ThreadUtil.threadFactory)
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.thread.ThreadFactoryBuilder;

public class BackgroundTaskSystem {

    /**
     * 执行一次性后台任务
     */
    public void executeBackgroundTask(Runnable task) {
        // 使用 ThreadUtil.execute 创建并启动线程
        ThreadUtil.execute(task);
    }

    /**
     * 执行定时任务
     *
     * @param task 任务
     * @param delay 延迟时间
     * @param unit 时间单位
     */
    public void scheduleTask(Runnable task, long delay, java.util.concurrent.TimeUnit unit) {
        // 使用 ThreadUtil.schedule 执行定时任务
        ThreadUtil.schedule(task, delay, unit);
    }

    /**
     * 执行周期性任务
     *
     * @param task 任务
     * @param period 周期时间
     * @param unit 时间单位
     */
    public void schedulePeriodicTask(Runnable task, long period, java.util.concurrent.TimeUnit unit) {
        // 使用 ThreadUtil.scheduleAtFixedRate 执行周期性任务
        ThreadUtil.scheduleAtFixedRate(task, 0, period, unit);
    }

    /**
     * 创建并启动线程池
     *
     * @param threadFactory 线程工厂
     * @param corePoolSize 核心线程数
     * @param maximumPoolSize 最大线程数
     * @param keepAliveTime 线程空闲存活时间
     * @param unit 时间单位
     * @param workQueue 工作队列
     */
    public void createAndStartThreadPool(ThreadFactoryBuilder threadFactory, int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<Runnable> workQueue) {
        // 使用 ThreadUtil.newExecutor 创建线程池
        java.util.concurrent.ExecutorService executorService = ThreadUtil.newExecutor(threadFactory.build(), corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        executorService.submit(() -> {
            System.out.println("Executing task in thread pool");
        });
    }

    /**
     * 等待线程结束
     *
     * @param thread 线程
     * @param timeout 超时时间
     * @param unit 时间单位
     */
    public void waitForThreadToEnd(Thread thread, long timeout, java.util.concurrent.TimeUnit unit) {
        // 使用 ThreadUtil.join 等待线程结束
        ThreadUtil.join(thread, timeout, unit);
    }

    /**
     * 创建并启动守护线程
     */
    public void createDaemonThread(Runnable task) {
        // 使用 ThreadUtil.daemon 创建并启动守护线程
        ThreadUtil.daemon(task);
    }

    /**
     * 创建并启动单例线程
     */
    public void createSingletonThread(Runnable task) {
        // 使用 ThreadUtil.single 创建并启动单例线程
        ThreadUtil.single(task);
    }

    public static void main(String[] args) {
        BackgroundTaskSystem system = new BackgroundTaskSystem();

        // 执行一次性后台任务
        system.executeBackgroundTask(() -> System.out.println("Running background task"));

        // 执行定时任务
        system.scheduleTask(() -> System.out.println("Running scheduled task"), 5, java.util.concurrent.TimeUnit.SECONDS);

        // 执行周期性任务
        system.schedulePeriodicTask(() -> System.out.println("Running periodic task"), 10, java.util.concurrent.TimeUnit.SECONDS);

        // 创建并启动线程池
        ThreadFactoryBuilder threadFactory = new ThreadFactoryBuilder();
        system.createAndStartThreadPool(threadFactory, 2, 4, 60, java.util.concurrent.TimeUnit.SECONDS, java.util.concurrent.LinkedBlockingQueue.create());

        // 等待线程结束
        Thread taskThread = new Thread(() -> System.out.println("Running long task"));
        taskThread.start();
        system.waitForThreadToEnd(taskThread, 1, java.util.concurrent.TimeUnit.MINUTES);

        // 创建并启动守护线程
        system.createDaemonThread(() -> System.out.println("Running daemon thread"));

        // 创建并启动单例线程
        system.createSingletonThread(() -> System.out.println("Running singleton thread"));
    }
}

5.LogUtil - 日志工具类（扩展）

常用方法

  1. 获取日志对象 ( LogUtil.get)
  2. 记录信息 ( LogUtil.info)
  3. 记录警告 ( LogUtil.warn)
  4. 记录错误 ( LogUtil.error)
  5. 记录调试信息 ( LogUtil.debug)
  6. 记录跟踪信息 ( LogUtil.trace)
  7. 格式化记录信息 ( LogUtil.format)
  8. 检查日志级别是否启用 ( LogUtil.isInfoEnabled, LogUtil.isDebugEnabled, etc.)
  9. 日志对象转换为其他日志框架对象 ( LogUtil.toLog)
  10. 获取当前线程的堆栈信息 ( LogUtil.getStackTrace)
  11. 获取日志配置文件路径 ( LogUtil.getLogConfigFilePath)
  12. 设置日志配置文件路径 ( LogUtil.setLogConfigFilePath)
import cn.hutool.log.Log;
import cn.hutool.log.LogUtil;

public class LoggingSystem {

    private static final Log log = LogUtil.get(LoggingSystem.class);

    /**
     * 记录用户登录信息
     */
    public void logUserLogin(String username) {
        log.info("User [{}] logged in.", username);
    }

    /**
     * 记录警告信息
     */
    public void logWarning(String message) {
        log.warn("Warning: {}", message);
    }

    /**
     * 记录错误信息
     */
    public void logError(Exception e) {
        log.error("Error occurred: ", e);
    }

    /**
     * 记录调试信息
     */
    public void logDebug(String message) {
        log.debug("Debug info: {}", message);
    }

    /**
     * 格式化记录信息
     */
    public void logFormattedInfo(String username, String action) {
        log.format("User [{}] performed action: {}", username, action);
    }

    /**
     * 检查是否启用了调试日志
     */
    public void checkDebugEnabled() {
        if (log.isDebugEnabled()) {
            log.debug("Debug logging is enabled.");
        }
    }

    /**
     * 获取当前线程的堆栈信息
     */
    public void logStackTrace() {
        String stackTrace = LogUtil.getStackTrace(new Exception("Stack Trace"));
        log.info("Stack Trace: {}", stackTrace);
    }

    /**
     * 获取日志配置文件路径
     */
    public void logConfigFilePath() {
        String configFilePath = LogUtil.getLogConfigFilePath();
        log.info("Log Config File Path: {}", configFilePath);
    }

    public static void main(String[] args) {
        LoggingSystem system = new LoggingSystem();

        // 记录用户登录
        system.logUserLogin("john_doe");

        // 记录警告
        system.logWarning("This is a test warning.");

        // 记录错误
        try {
            throw new Exception("Test exception");
        } catch (Exception e) {
            system.logError(e);
        }

        // 记录调试信息
        system.logDebug("This is a debug message.");

        // 格式化记录信息
        system.logFormattedInfo("jane_doe", "logged out");

        // 检查是否启用了调试日志
        system.checkDebugEnabled();

        // 获取当前线程的堆栈信息
        system.logStackTrace();

        // 获取日志配置文件路径
        system.logConfigFilePath();
    }
}

相关推荐

3分钟让你的项目支持AI问答模块，完全开源!

hello，大家好，我是徐小夕。之前和大家分享了很多可视化，零代码和前端工程化的最佳实践，今天继续分享一下最近开源的Next-Admin的最新更新。最近对这个项目做了一些优化，并集成了大家比较关注...

干货|程序员的副业挂，12个平台分享

1、D2adminD2Admin是一个完全开源免费的企业中后台产品前端集成方案，使用最新的前端技术栈，小于60kb的本地首屏js加载，已经做好大部分项目前期准备工作，并且带有大量示例代码，助...

Github标星超200K，这10个可视化面板你知道几个

在Github上有很多开源免费的后台控制面板可以选择，但是哪些才是最好、最受欢迎的可视化控制面板呢？今天就和大家推荐Github上10个好看又流行的可视化面板：1.AdminLTEAdminLTE是...

开箱即用的炫酷中后台前端开源框架第二篇

#头条创作挑战赛#1、SoybeanAdmin(1)介绍：SoybeanAdmin是一个基于Vue3、Vite3、TypeScript、NaiveUI、Pinia和UnoCSS的清新优...

搭建React+AntDeign的开发环境和框架

搭建React+AntDeign的开发环境和框架随着前端技术的不断发展，React和AntDesign已经成为越来越多Web应用程序的首选开发框架。React是一个用于构建用户界面的JavaScrip...

基于.NET 5实现的开源通用权限管理平台

??大家好，我是为广大程序员兄弟操碎了心的小编，每天推荐一个小工具/源码，装满你的收藏夹，每天分享一个小技巧，让你轻松节省开发效率，实现不加班不熬夜不掉头发，是我的目标！??今天小编推荐一款基于.NE...

StreamPark - 大数据流计算引擎

使用Docker完成StreamPark的部署??1.基于h2和docker-compose进行StreamPark部署wgethttps://raw.githubusercontent.com/a...

教你使用UmiJS框架开发React

1、什么是Umi.js?umi，中文可发音为乌米，是一个可插拔的企业级react应用框架。你可以将它简单地理解为一个专注性能的类next.js前端框架，并通过约定、自动生成和解析代码等方式来辅助...

简单在线流程图工具在用例设计中的运用

敏捷模式下，测试团队的用例逐渐简化以适应快速的发版节奏，大家很早就开始运用思维导图工具比如xmind来编写测试方法、测试点。如今不少已经不少利用开源的思维导图组件（如百度脑图...）来构建测试测试...

【开源分享】神奇的大数据实时平台框架,让Flink&amp;Spark开发更简单

这是一个神奇的框架，让Flink|Spark开发更简单，一站式大数据实时平台！他就是StreamX！什么是StreamX大数据技术如今发展的如火如荼，已经呈现百花齐放欣欣向荣的景象，实时处理流域...

聊聊规则引擎的调研及实现全过程

摘要本期主要以规则引擎业务实现为例,陈述在陌生业务前如何进行业务深入、调研、技术选型、设计及实现全过程分析,如果你对规则引擎不感冒、也可以从中了解一些抽象实现过程。诉求从硬件采集到的数据提供的形式多种...

【开源推荐】Diboot 2.0.5 发布，自动化开发助理

一、前言Diboot2.0.5版本已于近日发布，在此次发布中，我们新增了file-starter组件，完善了iam-starter组件，对core核心进行了相关优化，让devtools也支持对IAM...

微软推出Copilot Actions，使用人工智能自动执行重复性任务

IT之家11月19日消息，微软在今天举办的Ignite大会上宣布了一系列新功能，旨在进一步提升Microsoft365Copilot的智能化水平。其中最引人注目的是Copilot...

Electron 使用Selenium和WebDriver

本节我们来学习如何在Electron下使用Selenium和WebDriver。SeleniumSelenium是ThoughtWorks提供的一个强大的基于浏览器的开源自动化测试工具...

Quick &#39;n Easy Web Builder 11.1.0设计和构建功能齐全的网页的工具

一个实用而有效的应用程序，能够让您轻松构建、创建和设计个人的HTML网站。Quick'nEasyWebBuilder是一款全面且轻巧的软件，为用户提供了一种简单的方式来创建、编辑...

一周热门
最近发表
标签列表