14

如何最方便地将状态注入环处理程序（不使用全局变量）？

这是一个例子：

(defroutes main-routes
  (GET "/api/fu" [] (rest-of-the-app the-state)))

(def app
  (-> (handler/api main-routes)))

我想the-state进入main-routes. 状态可能类似于使用以下内容创建的地图：

(defn create-app-state []
  {:db (connect-to-db)
   :log (create-log)})

在非环形应用程序中，我将在主函数中创建状态并开始将其或其中的一部分作为函数参数注入到应用程序的不同组件中。

:init可以在不使用全局变量的情况下用环的功能完成类似的事情吗？

4

3 回答 3

22

我已经看到这有几种方法。第一种是使用中间件，将状态作为新键注入到请求映射中。例如：

(defroutes main-routes
  (GET "/api/fu" [:as request]
    (rest-of-the-app (:app-state request))))

(defn app-middleware [f state]
  (fn [request]
    (f (assoc request :app-state state))))

(def app
  (-> main-routes
      (app-middleware (create-app-state))
      handler/api))

另一种方法是替换对 的调用defroutes，它在幕后将创建一个处理程序并将其分配给一个 var，该函数将接受一些状态然后创建路由，将状态作为参数注入路由中的函数调用定义：

(defn app-routes [the-state]
  (compojure.core/routes
    (GET "/api/fu" [] (rest-of-the-app the-state))))

(def app
  (-> (create-app-state)
      app-routes
      api/handler))

如果可以选择，我可能会采用第二种方法。

于 2013-11-04T21:36:57.947 回答
1

除了 Alex 描述的一些路由框架之外，ring还有一个位置可以放置所有处理程序可以访问的附加参数。这reitit可以通过将自定义对象放在下面来工作:data：

 (reiti.ring/ring-handler
   (reiti.ring/router
    [ ["/api"
      ["/math" {:get {:parameters {:query {:x int?, :y int?}}
                      :responses  {200 {:body {:total pos-int?}}}
                      :handler    (fn [{{{:keys [x y]} :query} :parameters}]
                                    {:status 200
                                     :body   {:total (+ x y)}})}}]] ]
    {:syntax    :bracket
     :exception pretty/exception
     :data      {:your-custom-data your-custom-data
                 :coercion   reitit.coercion.spec/coercion
                 :muuntaja   m/instance
                 :middleware []}}))

在您的处理程序中，您应该只使用:parameters，但您将能够通过选择:reitit.core/match和访问您的自定义数据:data。处理程序接收的参数完全基于此：

(defrecord Match [template data result path-params path])
(defrecord PartialMatch [template data result path-params required])
于 2020-05-07T14:03:20.580 回答
-1

执行此操作的“正确”方法是使用动态绑定的 var。你定义一个var：

(def ^:dynamic some-state nil)

然后创建一些环中间件，为每个处理程序调用绑定 var：

(defn wrap-some-state-middleware [handler some-state-value]
  (fn [request]
    (bind [some-state some-state-value]
      (handler request))))

您可以在启动服务器的“主”函数中使用它来注入依赖项：

(def app (-> handler
             (wrap-some-state-middleware {:db ... :log ...})))
于 2013-11-04T21:49:04.620 回答