1

TL;博士

如何减少重复代码以下，例如创建两个作业/触发器job-inventory，而不是重复两次并创建术语


;; deps in project.clj
;; [clojurewerkz/quartzite "2.1.0"]


(ns hello.scheduler
  (:require [clojurewerkz.quartzite.scheduler :as qs]
            [clojurewerkz.quartzite.triggers :as t]
            [clojurewerkz.quartzite.jobs :as j]
            [clojurewerkz.quartzite.jobs :refer [defjob]]
            [clojurewerkz.quartzite.schedule.cron :as cron])
  (:use clojure.tools.logging)
  (:gen-class))

(def job-inventory
  [{:name "add" :task '(+ 1 1) :cron "0/5 * * ? * *"}
   {:name "multiply" :task '(* 4 5)  :cron "0/3 * * ? * *"}])

(defjob add [ctx] (info "add called, return" (+ 1 1)))
(defjob multiply [ctx] (info "multiply called, return" (* 2 3)))

(defn auto
  []
  (let [s   (-> (qs/initialize) qs/start)
        _ (qs/clear! s)
        job (j/build
             (j/of-type add)
             (j/with-identity (j/key "job.add")))
        trigger (t/build
                 (t/with-identity (t/key "trigger.add"))
                 (t/start-now)
                 (t/with-schedule (cron/schedule
                                   (cron/cron-schedule "0/5 * * ? * *"))))
        _ (qs/schedule s job trigger)
        
        job (j/build
             (j/of-type multiply)
             (j/with-identity (j/key "job.multiply")))
        trigger (t/build
                 (t/with-identity (t/key "trigger.multiply"))
                 (t/start-now)
                 (t/with-schedule (cron/schedule
                                   (cron/cron-schedule "0/3 * * ? * *"))))
        _ (qs/schedule s job trigger)
        ]
    ))

类似于http://clojurequartz.info/articles/getting_started.html中描述的内容，我有代码块来创建作业并将它们挂钩以执行

问题是，当我得到越来越多的它们时，我想知道我是否可以有更好的方法来管理它们，比如 create / spawn from that job-inventory，而不是实际创建像addor这样的变量multiply

所以，要求多一层循环 有没有办法利用函数编程，并避免创建新名称（用传统语言说 python qt，如果我有一组按钮，我可以砸进一个巨大的字典，然后循环创建/禁用，而不是实际将每个名称创建为顶级变量）

我试过宏，但它说无法解析类添加，所以猜我用错了

4

1 回答 1

1

要记住的关键是函数是数据。虽然您不能很容易地动态创建类型（与实现接口的实例相反， via reify），但您可以静态创建一个类，然后代理您的函数。

首先让我们制作:taskajob-inventory函数。

(def job-inventory
  [{:name "add" :task (fn [] (println (+ 1 1))) :cron "0/5 * * ? * *"}
   {:name "multiply" :task (fn [] (println (* 4 5)))  :cron "0/3 * * ? * *"}])

然后我们需要代理作业类。这将执行它在作业数据中找到的函数。

;; require clojurewerkz.quartzite.conversion :as qc
(defjob proxy-job [ctx]
  (let [ctx (qc/from-job-data ctx)]
    ((ctx "proxied-fn"))))

然后我们创建一个调度函数，它从作业库存中获取一个映射，并使用代理作业将其调度到间接。

(defn schedule [scheduler {:keys [:name :task :cron]}]
  (let [job (j/build
             (j/of-type proxy-job)
             (j/using-job-data {"proxied-fn" task})
             (j/with-identity (j/key (str "job." name))))
        trigger (t/build
                 (t/with-identity (t/key (str "trigger." name)))
                 (t/start-now)
                 (t/with-schedule (cron/schedule
                                   (cron/cron-schedule "0/3 * * ? * *"))))]
  (qs/schedule scheduler job trigger)
  scheduler)

(reduce scheduler schedule job-inventory)

如果石英决定序列化/反序列化作业数据，这种方法可能会失败。对于感兴趣的读者，我将使用另一层间接来解决这个问题，作为一个简单的练习 - 老实说，我最初的想法是我们创建命名函数，然后我们通过符号引用，但它使代理复杂化，让你想知道为什么不只是使用defjob。如果您准备取消您的功能，您仍然可以在工作清单中引用它们并拥有基于数据的工作构建器功能。

于 2021-06-01T10:32:43.927 回答