导入导出工具类（ruoyi注解版）

最新推荐文章于 2024-06-11 16:13:37 发布
最新推荐文章于 2024-06-11 16:13:37 发布
阅读量4.8k 收藏 8
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42712168/article/details/103892943
版权

一.自定义注解

1.Excel注解类

/**
 * 自定义导出Excel数据注解
 * 
 * @author ruoyi
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel
{
   
    /**
     * 导出到Excel中的名字.
     */
    public String name() default "";

    /**
     * 日期格式, 如: yyyy-MM-dd
     */
    public String dateFormat() default "";

    /**
     * 读取内容转表达式 (如: 0=男,1=女,2=未知)
     */
    public String readConverterExp() default "";

    /**
     * 导出类型（0数字 1字符串）
     */
    public ColumnType cellType() default ColumnType.STRING;

    /**
     * 导出时在excel中每个列的高度 单位为字符
     */
    public double height() default 14;

    /**
     * 导出时在excel中每个列的宽 单位为字符
     */
    public double width() default 16;

    /**
     * 文字后缀,如% 90 变成90%
     */
    public String suffix() default "";

    /**
     * 当值为空时,字段的默认值
     */
    public String defaultValue() default "";

    /**
     * 提示信息
     */
    public String prompt() default "";

    /**
     * 设置只能选择不能输入的列内容.
     */
    public String[] combo() default {
   };

    /**
     * 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
     */
    public boolean isExport() default true;

    /**
     * 另一个类中的属性名称,支持多级获取,以小数点隔开
     */
    public String targetAttr() default "";

    /**
     * 字段类型（0：导出导入；1：仅导出；2：仅导入）
     */
    Type type() default Type.ALL;

    public enum Type
    {
   
        ALL(0), EXPORT(1), IMPORT(2);
        private final int value;

        Type(int value)
        {
   
            this.value = value;
        }

        public int value()
        {
   
            return this.value;
        }
    }

    public enum ColumnType
    {
   
        NUMERIC(0), STRING(1);
        private final int value;

        ColumnType(int value)
        {
   
            this.value = value;
        }

        public int value()
        {
   
            return this.value;
        }
    }
}

2.Excels注解类

/**
 * Excel注解集
 * 
 * @author ruoyi
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Excels
{
   
    Excel[] value();
}

二.工具类

1.类转换器工具类 Convert

package com.ruoyi.common.core.text;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Set;
import com.ruoyi.common.utils.StringUtils;

/**
 * 类型转换器
 * 
 * @author ruoyi
 */
public class Convert
{
   
    /**
     * 转换为字符串<br>
     * 如果给定的值为null，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static String toStr(Object value, String defaultValue)
    {
   
        if (null == value)
        {
   
            return defaultValue;
        }
        if (value instanceof String)
        {
   
            return (String) value;
        }
        return value.toString();
    }

    /**
     * 转换为字符串<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static String toStr(Object value)
    {
   
        return toStr(value, null);
    }

    /**
     * 转换为字符<br>
     * 如果给定的值为null，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Character toChar(Object value, Character defaultValue)
    {
   
        if (null == value)
        {
   
            return defaultValue;
        }
        if (value instanceof Character)
        {
   
            return (Character) value;
        }

        final String valueStr = toStr(value, null);
        return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
    }

    /**
     * 转换为字符<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Character toChar(Object value)
    {
   
        return toChar(value, null);
    }

    /**
     * 转换为byte<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Byte toByte(Object value, Byte defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Byte)
        {
   
            return (Byte) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).byteValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return Byte.parseByte(valueStr);
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为byte<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Byte toByte(Object value)
    {
   
        return toByte(value, null);
    }

    /**
     * 转换为Short<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Short toShort(Object value, Short defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Short)
        {
   
            return (Short) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).shortValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return Short.parseShort(valueStr.trim());
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为Short<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Short toShort(Object value)
    {
   
        return toShort(value, null);
    }

    /**
     * 转换为Number<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Number toNumber(Object value, Number defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Number)
        {
   
            return (Number) value;
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return NumberFormat.getInstance().parse(valueStr);
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为Number<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Number toNumber(Object value)
    {
   
        return toNumber(value, null);
    }

    /**
     * 转换为int<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Integer toInt(Object value, Integer defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Integer)
        {
   
            return (Integer) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).intValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return Integer.parseInt(valueStr.trim());
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为int<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Integer toInt(Object value)
    {
   
        return toInt(value, null);
    }

    /**
     * 转换为Integer数组<br>
     * 
     * @param str 被转换的值
     * @return 结果
     */
    public static Integer[] toIntArray(String str)
    {
   
        return toIntArray(",", str);
    }

    /**
     * 转换为Long数组<br>
     * 
     * @param str 被转换的值
     * @return 结果
     */
    public static Long[] toLongArray(String str)
    {
   
        return toLongArray(",", str);
    }

    /**
     * 转换为Integer数组<br>
     * 
     * @param split 分隔符
     * @param split 被转换的值
     * @return 结果
     */
    public static Integer[] toIntArray(String split, String str)
    {
   
        if (StringUtils.isEmpty(str))
        {
   
            return new Integer[] {
   };
        }
        String[] arr = str.split(split);
        final Integer[] ints = new Integer[arr.length];
        for (int i = 0; i < arr.length; i++)
        {
   
            final Integer v = toInt(arr[i], 0);
            ints[i] = v;
        }
        return ints;
    }

    /**
     * 转换为Long数组<br>
     * 
     * @param split 分隔符
     * @param str 被转换的值
     * @return 结果
     */
    public static Long[] toLongArray(String split, String str)
    {
   
        if (StringUtils.isEmpty(str))
        {
   
            return new Long[] {
   };
        }
        String[] arr = str.split(split);
        final Long[] longs = new Long[arr.length];
        for (int i = 0; i < arr.length; i++)
        {
   
            final Long v = toLong(arr[i], null);
            longs[i] = v;
        }
        return longs;
    }

    /**
     * 转换为String数组<br>
     * 
     * @param str 被转换的值
     * @return 结果
     */
    public static String[] toStrArray(String str)
    {
   
        return toStrArray(",", str);
    }

    /**
     * 转换为String数组<br>
     * 
     * @param split 分隔符
     * @param split 被转换的值
     * @return 结果
     */
    public static String[] toStrArray(String split, String str)
    {
   
        return str.split(split);
    }

    /**
     * 转换为long<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Long toLong(Object value, Long defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Long)
        {
   
            return (Long) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).longValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            // 支持科学计数法
            return new BigDecimal(valueStr.trim()).longValue();
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为long<br>
     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Long toLong(Object value)
    {
   
        return toLong(value, null);
    }

    /**
     * 转换为double<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Double toDouble(Object value, Double defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Double)
        {
   
            return (Double) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).doubleValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            // 支持科学计数法
            return new BigDecimal(valueStr.trim()).doubleValue();
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为double<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Double toDouble(Object value)
    {
   
        return toDouble(value, null);
    }

    /**
     * 转换为Float<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Float toFloat(Object value, Float defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Float)
        {
   
            return (Float) value;
        }
        if (value instanceof Number)
        {
   
            return ((Number) value).floatValue();
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return Float.parseFloat(valueStr.trim());
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为Float<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Float toFloat(Object value)
    {
   
        return toFloat(value, null);
    }

    /**
     * 转换为boolean<br>
     * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static Boolean toBool(Object value, Boolean defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof Boolean)
        {
   
            return (Boolean) value;
        }
        String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        valueStr = valueStr.trim().toLowerCase();
        switch (valueStr)
        {
   
            case "true":
                return true;
            case "false":
                return false;
            case "yes":
                return true;
            case "ok":
                return true;
            case "no":
                return false;
            case "1":
                return true;
            case "0":
                return false;
            default:
                return defaultValue;
        }
    }

    /**
     * 转换为boolean<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static Boolean toBool(Object value)
    {
   
        return toBool(value, null);
    }

    /**
     * 转换为Enum对象<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 
     * @param clazz Enum的Class
     * @param value 值
     * @param defaultValue 默认值
     * @return Enum
     */
    public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (clazz.isAssignableFrom(value.getClass()))
        {
   
            @SuppressWarnings("unchecked")
            E myE = (E) value;
            return myE;
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return Enum.valueOf(clazz, valueStr);
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为Enum对象<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 
     * @param clazz Enum的Class
     * @param value 值
     * @return Enum
     */
    public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
    {
   
        return toEnum(clazz, value, null);
    }

    /**
     * 转换为BigInteger<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof BigInteger)
        {
   
            return (BigInteger) value;
        }
        if (value instanceof Long)
        {
   
            return BigInteger.valueOf((Long) value);
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return new BigInteger(valueStr);
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为BigInteger<br>
     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static BigInteger toBigInteger(Object value)
    {
   
        return toBigInteger(value, null);
    }

    /**
     * 转换为BigDecimal<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @param defaultValue 转换错误时的默认值
     * @return 结果
     */
    public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
    {
   
        if (value == null)
        {
   
            return defaultValue;
        }
        if (value instanceof BigDecimal)
        {
   
            return (BigDecimal) value;
        }
        if (value instanceof Long)
        {
   
            return new BigDecimal((Long) value);
        }
        if (value instanceof Double)
        {
   
            return new BigDecimal((Double) value);
        }
        if (value instanceof Integer)
        {
   
            return new BigDecimal((Integer) value);
        }
        final String valueStr = toStr(value, null);
        if (StringUtils.isEmpty(valueStr))
        {
   
            return defaultValue;
        }
        try
        {
   
            return new BigDecimal(valueStr);
        }
        catch (Exception e)
        {
   
            return defaultValue;
        }
    }

    /**
     * 转换为BigDecimal<br>
     * 如果给定的值为空，或者转换失败，返回默认值<br>
     * 转换失败不会报错
     * 
     * @param value 被转换的值
     * @return 结果
     */
    public static BigDecimal toBigDecimal(Object value)
    {
   
        return toBigDecimal(value, null);
    }

    /**
     * 将对象转为字符串<br>
     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
     * 
     * @param obj 对象
     * @return 字符串
     */
    public static String utf8Str(Object obj)
    {
   
        return str(obj, CharsetKit.CHARSET_UTF_8);
    }

    /**
     * 将对象转为字符串<br>
     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
     * 
     * @param obj 对象
     * @param charsetName 字符集
     * @return 字符串
     */
    public static String str(Object obj, String charsetName)
    {
   
        return str(obj, Charset.forName(charsetName));
    }

    /**
     * 将对象转为字符串<br>
     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
     * 
     * @param obj 对象
     * @param charset 字符集
     * @return 字符串
     */
    public static String str(Object obj, Charset charset)
    {
   
        if
最低0.47元/天 解锁文章
骚动的键盘
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
16、若依导入导出
adsfds的博客
04-09 1957
有时候我们希望导出表格包含标题信息，我们可以这样做。​ 有时候我们希望数据展现为一个特殊的格式，或者需要对数据进行其它处理。Excel注解提供了自定义数据处理器以满足各种业务场景。而实现一个数据处理器也是非常简单的。@Excel(name = "用户名称" , handler = MyDataHandler . class , args = {有时候我们希望对列信息根据业务去动态显示，那么我们可以进行如下处理。示例：对用户进行条件判断，符合条件则隐藏属性。导出的文件则不会显示此列信息。
若依源码学习7：Excel 导入导出
小宇哥x的博客
04-11 8965
1、Excel 导出 1.1、自定义 @Excel 注解 /** * 自定义导出Excel数据注解 */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) public @interface Excel { /** * 导出时在excel中排序 */ public int sort() default Integer.MAX_VALUE; /** * 导出到Excel中的.
导出-若依(RuoYi）
最新发布
m0_65572741的博客
06-11 1128
（比如，字段的值否需要格式化，字段对应到表格中的列名称等等）使用List 存入类的Filed对象和注解对象。(比如导出的字段有10个，则该集合大小为10)根据注解信息完成List集合的赋值。根据导出的数据量，计算需要导出的sheet页。针对每一个sheet页进行处理。
Excel导入导出工具类，使用注解实现，基于若依框架工具类修改
qq_28452049的博客
06-04 1万+
Excel导入导出工具类，使用注解实现，基于若依框架工具类修改Maven依赖Java 代码使用案例 第六更，一个超级好用的工具类，只需要在实体类上加注解，就可以实现将 List 集合导出Excel，Excel数据导入生成 List ，支持日期转换，内容转换（如 0 -> 女，1 -> 男），默认值设置。用法也可参考：http://doc.ruoyi.vip/#/standard/hts...
excel导出动态表头以及二级三级表头，还有数据库动态的数据来源
qq_46804698的博客
11-04 3391
excel自定义导出二级三级表头
RuoYi-Vue框架的Excel学习总结
mu_zi_zheng的博客
11-09 4233
若依的Excel的代码解释基本都写在代码块中，读代码很痛苦，很多方法都不认识emmmm，还是菜~
若依框架下Excel 导出自定义列属性只能下垃选择
Stronger的博客
05-10 3967
Excel导入
Excel导入导出
03-28
在提供的压缩包文件中，可能包含已经封装好的方法和DLL，这些预封装的方法简化了Excel导入导出的过程，使得开发者可以直接调用，而无需关心底层的实现细节。这通常会提高开发效率，减少错误，并且便于代码维护。 ...
http请求工具类
04-23
http请求工具类 常见的post get请求
ruoyi框架包名修改工具
08-04
ruoyi框架包名修改工具，直接替换所有类的包名
RuoYi开发手册（离线版）
07-21
《RuoYi开发手册（离线版）》是一份专为开发者提供的详尽指南，主要涵盖了RuoYi框架的使用、配置、开发以及优化等多个方面。RuoYI是一个基于Spring Boot的企业级快速开发平台，旨在提高开发效率，减少重复工作。以下...
若依（ruoyi）导出的nacos配置文件
04-23
【标题】：“若依（ruoyi）导出的nacos配置文件”指的是 Ruoyi 框架在集成 Nacos 配置中心时导出的相关配置文件。Nacos 是一个阿里巴巴开源的分布式服务治理平台，它包含了服务注册与发现、配置管理、微服务流量控制...
若依配置教程（六）Excel导入功能实现
热门推荐
qq_46073825的博客
02-01 2万+
若依导入功能实现
Ruoyi框架使用easyExcel实现单元格合并
wuhuangji的博客
07-12 5436
/ 你也可以在创建行的时候进行拦截，也可以在创建单元格的时候拦截，不同功能实现不同的接口 public class TableHeadHandler implements SheetWriteHandler {// 基础的excel操作，可以在此处添加表头的样式 Workbook workbook = writeWorkbookHolder . getWorkbook();row0 . createCell(0) . setCellValue("第一行");
关于ruoyi框架如何在导入时做参数校验
mrSong1229787556的博客
04-04 2250
关于ruoyi框架如何在导入时做参数校验
Excel工具类
Just1like_this的博客
01-02 1061
/** Excel相关处理 @author hbt */ public class ExcelUtil extends DataDictConverUtil { private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class); /** * Excel sheet最大行数，默认65536 */ publi...
若依前后端分离如何给表格自适应高度和设置固定列？
猿小白的博客
08-14 1666
若依前后端分离如何给表格自适应高度和设置固定列？
java导出自定义Excel文件头
qq_25190901的博客
06-03 495
package *; import org.apache.poi.ss.usermodel.HorizontalAlignment; import org.apache.poi.ss.usermodel.VerticalAlignment; import org.apache.poi.xssf.usermodel.*; import javax.servlet.ServletOutputStream; import javax.servlet.http.HttpServletResponse; imp.
若依Excel导出单元格合并功能拓展
zigeweeiwu的博客
07-19 706
若依exce合并单元格
定时任务工具类ruoyi
08-16
你好！关于定时任务工具类ruoyi，我了解到Ruoyi是一个开源的Java快速开发平台，其中包含了定时任务模块。Ruoyi框架提供了一个名为"TaskUtils"的工具类，用于简化定时任务的操作。 在Ruoyi中，你可以使用TaskUtils类来创建、修改、删除定时任务，以及查询定时任务的执行情况。该工具类封装了Quartz框架的相关操作，为开发者提供了便捷的接口。 你可以通过调用TaskUtils类的方法来实现定时任务的管理，例如： - 创建定时任务：TaskUtils.createScheduleJob(job); - 修改定时任务：TaskUtils.updateScheduleJob(job); - 删除定时任务：TaskUtils.deleteScheduleJob(jobId); - 查询定时任务执行情况：TaskUtils.getJobLogList(jobLog); 需要注意的是，使用TaskUtils类之前，你需要先配置好Quartz框架，并在Ruoyi中进行相关的配置。 希望这能对你有所帮助！如果你还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值