dependency injection - ¿Pasar el estado como parámetro a un manejador de anillo?

dependency-injection clojure

Question

¿Cómo se puede inyectar el estado en controladores de anillo de la manera más conveniente (sin usar vars globales)?

Aquí hay un ejemplo:

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

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

Me gustaría obtener the-state en el controlador de compojure para main-routes . El estado podría ser algo así como un mapa creado con:

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

En una aplicación sin anillo, crearía el estado en una función principal y comenzaría a inyectarlo, o partes de él, como parámetros de función a los diferentes componentes de la aplicación.

¿Se puede hacer algo similar con ring''s :init function sin usar una var global?

Answer 1

He visto esto hecho de varias maneras. El primero es usar middleware que inyecta el estado como una nueva clave en el mapa de solicitud. Por ejemplo:

(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))

El otro enfoque es reemplazar la llamada a defroutes , que detrás de las escenas creará un controlador y lo asignará a una var, con una función que aceptará algún estado y luego creará las rutas, inyectando el estado como parámetros para las llamadas de función dentro del definiciones de ruta:

(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))

Si tuviera una opción, probablemente iría con el segundo enfoque.

Answer 2

La forma "correcta" de hacer esto es usar una var. Dinámicamente unida. Usted define una var con:

(def ^:dynamic some-state nil)

Y luego creas un middleware de anillo que vincula la var para cada llamada de controlador:

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

Usted usaría esto para inyectar dependencias al usar esto en su función ''principal'' donde ejecuta el servidor:

(def app (-> handler
             (wrap-some-state-middleware {:db ... :log ...})))