基于vue与element ui的vue-cron插件的使用及将定时任务cron表达式解析成中文

最新推荐文章于 2024-05-27 09:37:06 发布
最新推荐文章于 2024-05-27 09:37:06 发布
阅读量1.6w 收藏 41
点赞数 11
分类专栏： 前端 后端 文章标签： java vue.js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41863697/article/details/109294333
版权

vue-cron插件的使用及将cron解析成中文

vue-cron插件的使用

第一步：安装依赖

执行下面npm命令：
npm install vue-cron --save

第二步：引用

在想使用cron的vue页面引入以下:

import VueCron from ‘vue-cron’
import Vue from ‘vue’
Vue.use(VueCron)

第三步：在vue页面的用法

          <el-col :span="12">
            <el-form-item label="同步时间" prop="execTime">
              <el-popover v-model="cronPopover">
                <vueCron @change="changeCron" @close="cronPopover=false" i18n="cn"/>
                <el-input
                  slot="reference"
                  v-model="ruleForm.execTime"
                  placeholder="定时策略"
                  @click="cronPopover=true"
                />
              </el-popover>
            </el-form-item>
          </el-col>
        </el-row>

效果

完整界面去掉秒和年

去掉秒和年

在vue页面“style scoped”中通过控制样式去掉秒年

#changeContab /deep/ #tab-0 { display: none; }
#changeContab /deep/ #tab-5 { display: none; }

定时任务cron解析成中文

简易的工具类

可根据需要进行修改

package com.mingyong.util;

import org.redisson.executor.CronExpression;
import org.springframework.util.StringUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

//import  org.quartz.CronExpression;

public class CornUtil {
    /**
     * 解析corn表达式，生成指定日期的时间序列
     *
     * @param cronExpression cron表达式
     * @param cronDate cron解析日期
     * @param result crom解析时间序列
     * @return 解析成功失败
     */
    public  static  boolean  parser(String cronExpression, String cronDate, List<String> result)
    {
        if  (cronExpression ==  null  || cronExpression.length() <  1  || cronDate ==  null  || cronDate.length() <  1 )
        {
            return  false ;
        }
        else
        {
            CronExpression exp =  null ;
            // 初始化cron表达式解析器
            try
            {
                exp =  new  CronExpression(cronExpression);
            }
            catch  (Exception e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return  false ;
            }

            // 定义生成时间范围
            // 定义开始时间，前一天的23点59分59秒
            Calendar c = Calendar.getInstance();
            String sStart = cronDate +  " 00:00:00" ;
            SimpleDateFormat sdf =  new  SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
            Date dStart =  null ;
            try
            {
                dStart = sdf.parse(sStart);
            }
            catch  (ParseException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            c.setTime(dStart);
            c.add(Calendar.SECOND, - 1 );
            dStart = c.getTime();

            // 定义结束时间，当天的23点59分59秒
            c.add(Calendar.DATE,  1 );
            Date dEnd = c.getTime();

            // 生成时间序列
            Date dd = dStart;
            dd = exp.getNextValidTimeAfter(dd);
            while  ((dd.getTime() >= dStart.getTime()) && (dd.getTime() <= dEnd.getTime()))
            {
                result.add(sdf.format(dd));
                dd = exp.getNextValidTimeAfter(dd);
            }
            exp =  null ;
        }
        return  true ;
    }

    public  static  String translateToChinese(String cronExp)
    {
        if  (cronExp ==  null  || cronExp.length() <  1 )
        {
            return  "cron表达式为空" ;
        }
        CronExpression exp =  null ;
        // 初始化cron表达式解析器
        try
        {
            exp =  new  CronExpression(cronExp);
        }
        catch  (Exception e)
        {
            return  "corn表达式不正确" ;
        }
        String[] tmpCorns = cronExp.split( " " );
        StringBuffer sBuffer =  new  StringBuffer();
        if (tmpCorns.length ==  6 )
        {
            //解析月
            if (tmpCorns[ 4 ].equals( "*" ))
            {
                sBuffer.append( "每月" );
            }
            else if (tmpCorns[ 4 ].contains("/")){
                String[] str = StringUtils.split(tmpCorns[ 4 ],"/");
                String first = str[0];
                String last = str[1];
                sBuffer.append( "第" + first + "月开始每隔" + last + "月");
            }
            else
            {
                sBuffer.append(tmpCorns[ 4 ]).append( "月" );
            }
            //解析周
            if (!tmpCorns[ 5 ].equals( "*" ) && !tmpCorns[ 5 ].equals( "?" ))
            {
                if (tmpCorns[ 5 ].contains("/")){
                    String[] str = StringUtils.split(tmpCorns[ 5 ],"/");
                    String first = str[0];
                    String last = str[1];
                    switch  (first)
                    {
                        case  "1" :
                            sBuffer.append( "从星期天开始每隔" + last + "周");
                            break ;
                        case  "2" :
                            sBuffer.append( "从星期一开始每隔" + last + "周");
                            break ;
                        case  "3" :
                            sBuffer.append( "从星期二开始每隔" + last + "周");
                            break ;
                        case  "4" :
                            sBuffer.append( "从星期三开始每隔" + last + "周");
                            break ;
                        case  "5" :
                            sBuffer.append( "从星期四开始每隔" + last + "周");
                            break ;
                        case  "6" :
                            sBuffer.append( "从星期五开始每隔" + last + "周");
                            break ;
                        case  "7" :
                            sBuffer.append( "从星期六开始每隔" + last + "周");
                            break ;
                    }
                }else if (tmpCorns[ 5 ].contains("#")){
                    String[] str = StringUtils.split(tmpCorns[ 5 ],"#");
                    String first = str[0];
                    String last = str[1];
                    switch  (first)
                    {
                        case  "1" :
                            sBuffer.append( "第" + last + "个" + "星期天");
                            break ;
                        case  "2" :
                            sBuffer.append( "第" + last + "个" + "星期一");
                            break ;
                        case  "3" :
                            sBuffer.append( "第" + last + "个" + "星期二");
                            break ;
                        case  "4" :
                            sBuffer.append( "第" + last + "个" + "星期三");
                            break ;
                        case  "5" :
                            sBuffer.append( "第" + last + "个" + "星期四");
                            break ;
                        case  "6" :
                            sBuffer.append( "第" + last + "个" + "星期五");
                            break ;
                        case  "7" :
                            sBuffer.append( "第" + last + "个" + "星期六");
                            break ;
                    }
                }
                else if (tmpCorns[ 5 ].contains("L") && !tmpCorns[ 5 ].contains("W") && tmpCorns[ 5 ].toCharArray().length == 2){
                    switch  (tmpCorns[ 5 ])
                    {
                        case  "1L" :
                            sBuffer.append( "最后一个星期天" );
                            break ;
                        case  "2L" :
                            sBuffer.append( "最后一个星期一" );
                            break ;
                        case  "3L" :
                            sBuffer.append( "最后一个星期二" );
                            break ;
                        case  "4L" :
                            sBuffer.append( "最后一个星期三" );
                            break ;
                        case  "5L" :
                            sBuffer.append( "最后一个星期四" );
                            break ;
                        case  "6L" :
                            sBuffer.append( "最后一个星期五" );
                            break ;
                        case  "7L" :
                            sBuffer.append( "最后一个星期六" );
                            break ;
                    }
                }
                else {
                    String [] tmpArray =  tmpCorns[ 5 ].split(",");
                    for ( String  tmp:tmpArray)
                    {
                        switch  (tmp)
                        {
                            case  "SUN" :
                                sBuffer.append( "星期天" );
                                break ;
                            case  "MON" :
                                sBuffer.append( "星期一" );
                                break ;
                            case  "TUE" :
                                sBuffer.append( "星期二" );
                                break ;
                            case  "WED" :
                                sBuffer.append( "星期三" );
                                break ;
                            case  "THU" :
                                sBuffer.append( "星期四" );
                                break ;
                            case  "FRI" :
                                sBuffer.append( "星期五" );
                                break ;
                            case  "SAT" :
                                sBuffer.append( "星期六" );
                                break ;
                            case  "-" :
                                sBuffer.append( "至" );
                                break ;
                            default :
                                sBuffer.append(tmp);
                                break ;
                        }
                    }
                }
            }

            //解析日
            if (!tmpCorns[ 3 ].equals( "?" ))
            {
                if (tmpCorns[ 3 ].equals( "*" ))
                {
                    sBuffer.append( "每日" );
                }
                else if (tmpCorns[ 3 ].contains("/")){
                    String[] str = StringUtils.split(tmpCorns[ 3 ],"/");
                    String first = str[0];
                    String last = str[1];
                    sBuffer.append( "第" + first + "天开始每隔" + last + "天");
                }
                else if (tmpCorns[ 3 ].contains("L") && tmpCorns[ 3 ].toCharArray().length == 1){
                    sBuffer.append("最后一天");
                }
                else if (tmpCorns[ 3 ].contains("LW") && tmpCorns[ 3 ].toCharArray().length == 2){
                    sBuffer.append("最后一个工作日");
                }
                else if (tmpCorns[ 3 ].contains("L-")){
                    switch  (tmpCorns[ 3 ])
                    {
                        case  "L-1" :
                            sBuffer.append( "月底前1日" );
                            break ;
                        case  "L-2" :
                            sBuffer.append( "月底前2日" );
                            break ;
                        case  "L-3" :
                            sBuffer.append( "月底前3日" );
                            break ;
                        case  "L-4" :
                            sBuffer.append( "月底前4日" );
                            break ;
                        case  "L-5" :
                            sBuffer.append( "月底前5日" );
                            break ;
                        case  "L-6" :
                            sBuffer.append( "月底前6日" );
                            break ;
                        case  "L-7" :
                            sBuffer.append( "月底前7日" );
                            break ;
                        case  "L-8" :
                            sBuffer.append( "月底前8日" );
                            break ;
                        case  "L-9" :
                            sBuffer.append( "月底前9日" );
                            break ;
                        case  "L-10" :
                            sBuffer.append( "月底前10日" );
                            break ;
                        case  "L-11" :
                            sBuffer.append( "月底前11日" );
                            break ;
                        case  "L-12" :
                            sBuffer.append( "月底前12日" );
                            break ;
                        case  "L-13" :
                            sBuffer.append( "月底前13日" );
                            break ;
                        case  "L-14" :
                            sBuffer.append( "月底前14日" );
                            break ;
                        case  "L-15" :
                            sBuffer.append( "月底前15日" );
                            break ;
                        case  "L-16" :
                            sBuffer.append( "月底前16日" );
                            break ;
                        case  "L-17" :
                            sBuffer.append( "月底前17日" );
                            break ;
                        case  "L-18" :
                            sBuffer.append( "月底前18日" );
                            break ;
                        case  "L-19" :
                            sBuffer.append( "月底前19日" );
                            break ;
                        case  "L-20" :
                            sBuffer.append( "月底前20日" );
                            break ;
                        case  "L-21" :
                            sBuffer.append( "月底前21日" );
                            break ;
                        case  "L-22" :
                            sBuffer.append( "月底前22日" );
                            break ;
                        case  "L-23" :
                            sBuffer.append( "月底前23日" );
                            break ;
                        case  "L-24" :
                            sBuffer.append( "月底前24日" );
                            break ;
                        case  "L-25" :
                            sBuffer.append( "月底前25日" );
                            break ;
                        case  "L-26" :
                            sBuffer.append( "月底前26日" );
                            break ;
                        case  "L-27" :
                            sBuffer.append( "月底前27日" );
                            break ;
                        case  "L-28" :
                            sBuffer.append( "月底前28日" );
                            break ;
                        case  "L-29" :
                            sBuffer.append( "月底前29日" );
                            break ;
                        case  "L-30" :
                            sBuffer.append( "月底前30日" );
                            break ;
                        case  "L-31" :
                            sBuffer.append( "月底前31日" );
                            break ;
                    }
                }
                else if (tmpCorns[ 3 ].contains("W") && !tmpCorns[ 3 ].contains("L")){
                    switch  (tmpCorns[ 3 ])
                    {
                        case  "1W" :
                            sBuffer.append( "最近的工作日至本月1日" );
                            break ;
                        case  "2W" :
                            sBuffer.append( "最近的工作日至本月2日" );
                            break ;
                        case  "3W" :
                            sBuffer.append( "最近的工作日至本月3日" );
                            break ;
                        case  "4W" :
                            sBuffer.append( "最近的工作日至本月4日" );
                            break ;
                        case  "5W" :
                            sBuffer.append( "最近的工作日至本月5日" );
                            break ;
                        case  "6W" :
                            sBuffer.append( "最近的工作日至本月6日" );
                            break ;
                        case  "7W" :
                            sBuffer.append( "最近的工作日至本月7日" );
                            break ;
                        case  "8W" :
                            sBuffer.append( "最近的工作日至本月8日" );
                            break ;
                        case  "9W" :
                            sBuffer.append( "最近的工作日至本月9日" );
                            break ;
                        case  "10W" :
                            sBuffer.append( "最近的工作日至本月10日" );
                            break ;
                        case  "11W" :
                            sBuffer.append( "最近的工作日至本月11日" );
                            break ;
                        case  "12W" :
                            sBuffer.append( "最近的工作日至本月12日" );
                            break ;
                        case  "13W" :
                            sBuffer.append( "最近的工作日至本月13日" );
                            break ;
                        case  "14W" :
                            sBuffer.append( "最近的工作日至本月14日" );
                            break ;
                        case  "15W" :
                            sBuffer.append( "最近的工作日至本月15日" );
                            break ;
                        case  "16W" :
                            sBuffer.append( "最近的工作日至本月16日" );
                            break ;
                        case  "17W" :
                            sBuffer.append( "最近的工作日至本月17日" );
                            break ;
                        case  "18W" :
                            sBuffer.append( "最近的工作日至本月18日" );
                            break ;
                        case  "19W" :
                            sBuffer.append( "最近的工作日至本月19日" );
                            break ;
                        case  "20W" :
                            sBuffer.append( "最近的工作日至本月20日" );
                            break ;
                        case  "21W" :
                            sBuffer.append( "最近的工作日至本月21日" );
                            break ;
                        case  "22W" :
                            sBuffer.append( "最近的工作日至本月22日" );
                            break ;
                        case  "23W" :
                            sBuffer.append( "最近的工作日至本月23日" );
                            break ;
                        case  "24W" :
                            sBuffer.append( "最近的工作日至本月24日" );
                            break ;
                        case  "25W" :
                            sBuffer.append( "最近的工作日至本月25日" );
                            break ;
                        case  "26W" :
                            sBuffer.append( "最近的工作日至本月26日" );
                            break ;
                        case  "27W" :
                            sBuffer.append( "最近的工作日至本月27日" );
                            break ;
                        case  "28W" :
                            sBuffer.append( "最近的工作日至本月28日" );
                            break ;
                        case  "29W" :
                            sBuffer.append( "最近的工作日至本月29日" );
                            break ;
                        case  "30W" :
                            sBuffer.append( "最近的工作日至本月30日" );
                            break ;
                        case  "31W" :
                            sBuffer.append( "最近的工作日至本月31日" );
                            break ;
                    }
                }
                else
                {
                    sBuffer.append(tmpCorns[ 3 ]).append( "日" );
                }
            }

            //解析时
            if (tmpCorns[ 2 ].equals( "*" ))
            {
                sBuffer.append( "每时" );
            }
            else if (tmpCorns[ 2 ].contains("/")){
                String[] str = StringUtils.split(tmpCorns[ 2 ],"/");
                String first = str[0];
                String last = str[1];
                sBuffer.append( "第" + first + "时开始每隔" + last + "时");
            }
            else
            {
                sBuffer.append(tmpCorns[ 2 ]).append( "时" );
            }

            //解析分
            if (tmpCorns[ 1 ].equals( "*" ))
            {
                sBuffer.append( "每分" );
            }
            else if (tmpCorns[ 1 ].contains("/")){
                String[] str = StringUtils.split(tmpCorns[ 1 ],"/");
                String first = str[0];
                String last = str[1];
                sBuffer.append( "第" + first + "分开始每隔" + last + "分");
            }
            else
            {
                sBuffer.append(tmpCorns[ 1 ]).append( "分" );
            }

            //解析秒
            /*if (!tmpCorns[ 0 ].equals( "*" ))
            {
                sBuffer.append(tmpCorns[ 0 ]).append( "秒" );
            }
            else
            {
                sBuffer.append( "每秒" );
            }*/
        }

        return  sBuffer.toString();

    }

    //测试方法
//    public  static  void  main(String[] args)
//    {
//        String CRON_EXPRESSION =  "01 * * 2L * ?" ;
//        // 生成指定日期的CRON时间序列
//        String CRON_DATE =  "2016-04-26" ;
//        System.out.println(CRON_EXPRESSION);
//        System.out.println(translateToChinese(CRON_EXPRESSION));
//
//        List<String> lTime =  new  ArrayList<String>();
//        if (!parser(CRON_EXPRESSION, CRON_DATE, lTime)){
//            System.out.println( "无法生成Cron表达式：日期," +CRON_DATE+ ";不符合规则cron表达式：" +CRON_EXPRESSION);
//        }
//        for ( int  i= 0 ;i<lTime.size();i++){
//            System.out.println(lTime.get(i));
//        }
//
//    }
}

该插件存在的一个缺陷

在这里插入图片描述
如图中生成的cron表达式 * * * 1L * ？* 是错误的表达式，应为 * * * ？ * 1L *才对
解决办法：

/*cron插件缺陷修复*/
        String[] str = execTime.split(" ");
        if((str[2].equalsIgnoreCase("1L")  || str[2].equalsIgnoreCase("2L")  || str[2].equalsIgnoreCase("3L")  || str[2].equalsIgnoreCase("4L")  || str[2].equalsIgnoreCase("5L")  || str[2].equalsIgnoreCase("6L")|| str[2].equalsIgnoreCase("7L")) && str[4].equalsIgnoreCase("?")){
            str[4] = str[2];
            str[2] = "?";
            execTime = str[0] + " " + str[1] + " " + str[2] + " " + str[3] + " " + str[4];
            paramJson.put("execTime",execTime);
        }

附：一个非常好的学习网站：https://how2j.cn?p=37994

醉卧雕龙舫 、
关注
  • 11
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
vue校验cron7子表达式
Dolphin_bobo的博客
11-01 1290
vue校验cron6子或七子表达式
vue-cron:这是一个cron表达式ui组件
05-02
vue-cron这是一个cron表达式生成插件,基于vue与element-ui实现依赖Vue 2.0.0+element-ui 2.0.0+安装方式npm install vue-cron引入方式//前置配置import Vue from 'vue'import ElementUI from 'element-ui';...
cron定时任务表达式组件（vue3+ts+naiveUI）
09-30
vue3+ts+naive UI,有执行时间的中文解析，还有10次执行时间（需要后端写接口）. 1.将文件放在你想放的项目文件夹下，引入import vue3CronComponent from "xxxx";如果需要中文解析功能，同理引入即可。 3.需要传的值，maxHeight="450px"//最大高， @changeCron="changeCron"//方法，:cronValue="cronValue"//cron表达式， :showCronModal="showCronModal"//打开弹框，style="flex: 0.25"//样式 4.// cron子组件传的方法 const changeCron = (val: string) => { showCronModal.value = false; if (val) { //赋值更新 } }
定时任务cron表达式详解
Amanda_wmy的博客
10-09 2886
0 * * * * ? 每1分钟触发一次 0 0 * * * ? 每天每1小时触发一次 0 0 10 * * ? 每天10点触发一次 0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发 0 30 9 1 * ? 每月1号上午9点半 0 15 10 15 * ? 每月15日上午10:15触发 */5 * * * * ? 每隔5秒执行一次 0 */1 * * * ? 每隔1分钟执行一次 0 0 5-15 * * ? 每天5-15点整点触发 0 0/3 * * * ? 每三分钟触发一次 0
推荐使用：Vue-Cron——打造直观的Cron表达式管理体验
最新发布
gitblog_00067的博客
05-27 540
推荐使用：Vue-Cron——打造直观的Cron表达式管理体验 项目地址:https://gitcode.com/1615450788/vue-cron 在追求高效自动化调度的今天，精确到秒的时间安排变得尤为重要。Vue-Cron，一个专门为Vue.js框架设计的cron表达式生成插件，携手Element UI，为您的前端项目带来了时间规则设置的强大工具。让我们深入探索Vue-Cron的魅力所在。...
vue[分享一个cron表达式生成插件]
墨水白云的博客
09-15 5146
目标 前端进行各种操作之后，最终生成两个cron表达式，分别为开始时间和结束时间的cron表达式，且结束时间表达式的时间必须在开始时间之后，并且符合cron表达式的规则。 任务类型有：一次性任务 和 循环任务两种 一次性任务只需要选择任务周期，即任务的开始时间和结束时间，其范围可以是秒段，分段、时段、日段、月段、年段。 循环任务需要选择周期类型，分别为周期类型：秒、分、时、日、周、月、年。根据不同的选择要默认生成一些自带的内容 ...
把Cron表达式 转换成中文，提供给前端展示执行间隔。
qq_32960927的博客
10-27 1648
private static final String QUESTION_MARK = "?"; private static final String STAR = "*"; private static final int NORMAL_CRON_LENGTH = 6; private final static String ZERO = "00"; private final static String SLASH = "/"; private fi...
把el-element的日期格式改为CRON
肥晨开发的学习之路
05-25 229
在日常的开发当中，经常会遇到格式的不匹配造成的困扰。 在日期管理上，el-element也是贴心的准备了相关的日期选择器，但是在取值的时候发现，el-element所给出的值格式可能并不是我们常用的。 el-element地址：https://element.eleme.cn/#/zh-CN Sat May 29 2021 01:44:01 GMT+0800 (中国标准时间) 我这次正好遇到的...
vue3 my-cron-vue3插件的使用
路虽远，行则必至！
07-14 1689
这是一个cron表达式生成插件,基于vue3.0与element-plus实现。
vue仿Element从0到1实现自己的组件库并发布到npm
weixin_42374089的博客
03-14 596
十二、封装成ui组件库 用vue创建的脚手架项目在compontent下写好组件一定要定义name，写完封装好，现在我们要将组件打包成组件库，上传到github上。由于是模仿element-ui进行的组件封装，所以在发布时也是用element-ui的打包结构。 12.1目录调整 我们新建一个vue项目，并且在根目录创建两个文件夹就packages和examples。 packages：用于存放所有的组件 examples：用于进行测试，把src改为examples 我们将之前写好的组件以及字体图标copy到
cron中英文表达式
09-14
cron 表达式 包含 秒 分 时 天 月 年 粗浅的cron 表达式
js cron 表达式生成器
02-21
cron 调度器 js cron表达式 生成秒循环 分循环 有开始日期结束日 最全面的cron表达式生成器 可嵌入html 网页 jsp asp等
cron表达式生成器（web版）
07-26
Cron表达式插件此表达式生成器，可以直接打开，可以应用到自己的web页面 Quartz 中的 Cron 表达式。 可以再页面根据用户的选择自动获取Cron表达式传递到后台进行操作。 各种格式的Cron表达式获取： 日、月、年、每隔几日、几月、几年、执行几次等等。 修复报错 tab切换等bug 安心使用
Cron表达式插件
06-13
自己幸幸苦苦扣出来的，还望好评。程序猿何必为难程序猿
Cornr-crx插件
04-01
语言:English (United States) 目的： 为小型商业网站生成更多流量，尤其是少数民族拥有的流量。 用法： 在... 目的的衣物项上： 为小型商业网站生成更多流量，尤其是少数民族拥有的流量。 用法： 虽然在亚马逊的服装项目上，单击延期的徽标，以查看小企业的类似产品。 此扩展将使您有机会支持小型企业！
vue-cron_vue-cron_vuecrond组件_vuecron_
10-04
Vue-Cron是一款基于Vue.js开发的时间周期（Cron）表达式组件，用于在前端应用程序中创建、编辑和处理定时任务。Vue-Cron旨在提供一种直观的用户界面，让用户能够通过图形化的方式设置复杂的Cron表达式，从而实现定时...
vue3+ElementPlus cron组件
04-09
Vue3 + ElementPlus Cron 组件是前端开发中的一个强大工具，它允许开发者在Web应用中实现复杂的定时任务调度功能。这个组件基于Vue3框架，并利用了ElementPlus UI库的组件和设计风格，为用户提供了友好的界面和丰富...
定时任务cron 解析为中文.docx
06-26
2 ... ... 5 import org.apache.commons.lang.StringUtils; 6 import org.assertj.core.util.Lists;... 7 import org.quartz.CronExpression;... 8 import org.springframework.util.Assert;... 15 * ************************...
vue-cron 插件
03-31
vue-cron 插件是一个基于 Vue.js 的开源插件，它可以帮助你轻松地创建一个 cron 表达式编辑器，用于生成定时任务的时间表达式。该插件基于 Bootstrap 和 Font Awesome，具有良好的界面风格和用户交互体验。 使用 vue-cron 插件，你可以快速创建一个 cron 表达式编辑器，通过选择或输入相应的参数，生成符合 cron 规则的时间表达式，用于定时任务的调度。同时，该插件提供了多种可定制的选项，如时区、语言、格式等，使得你可以根据自己的需求进行灵活的配置。 此外，vue-cron 插件还支持多语言和多时区，可以根据浏览器的语言和时区自动切换，也可以手动设置。总之，vue-cron 插件是一个功能强大、易于使用、高度可定制的 cron 表达式编辑器，可帮助你轻松实现定时任务的调度。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值