将变量与不同的字符进行比较时避免重复变量（x == a或x == b或x == ...）[重复](Avoid repeating variable when comparing it to different characters (x == a or x == b or x==…) [duplicate])

 实现此目的的一种简单方法是检查路由中传入请求的方案，例如： 
 
(defroutes app-routes
  (POST "/route-one" request
        (if (= (:scheme req) :http)
          (process-requet request)
          {:status 403 :body "https not supported"}))
  (POST "/route-two" request
        (if (= (:scheme req) :https)
          (process-requet request)
          {:status 403 :body "http not supported"})))
 
 你当然可以将这个方案检查提取到一个单独的函数或宏中，所以即使你有很多路由，那么这可能是一个可行的选择，而你的代码中没有太多的噪音。 
 
 如果您有许多路由，并且您不想为每个路由添加额外的呼叫或检查，那么实现此目的的另一种方法是向您的应用程序添加一些中间件。 中间件可以检查请求中包含的:scheme并拒绝不符合的请求。 例如： 
 
(defn wrap-https-only [handler]
  (fn [req]
    (if (= (:scheme req) :https)
      (handler req)
      {:status 403 :body "http not supported"})))

(defn wrap-http-only [handler]
  (fn [req]
    (if (= (:scheme req) :http)
      (handler req)
      {:status 403 :body "https not supported"})))
 
 棘手的部分是你想要有选择地将这个中间件应用于某些路由而不是其他路由，而Compojure并没有提供一种简单的方法来实现这一点。 如果您的所有http路由中都有一些共同的路径，以及所有的https路由（将它们分组），那么您可以使用如下模式： 
 
(def http-routes
  (-> (routes (POST "/http-only/route-one" request
                    (process-requet request)))
      wrap-http-only))

(def https-routes
  (-> (routes (POST "/http-only/route-two" request
                    (process-requet request)))
      wrap-https-only))


(defroutes app-routes
  (ANY "/http-only/*" [] http-routes)
  (ANY "/https-only/*" [] https-routes))
 
 您可以在此处看到中间件应用于每个路由子集，因此只有在路径的第一部分匹配时才会执行。 现在您可以添加任意数量的路由，中间件将负责所有这些路由的方案检查。 注意，这种方法要求您可以在初始的“app-routes”路由中以某种方式识别路由的子集，在这种情况下，我已经通过路径识别它们。 
 
 检查方案时需要注意的一点是：如果您决定将SSL卸载到负载均衡器，请注意这不会起作用。 在这种情况下，您的应用程序将始终收到HTTP（而非HTTPS）请求。 您通常可以通过简单地检查X-Forwarded-Proto标头而不是:scheme值来实现相同的目的。 

One simple way to achieve this is to check the scheme of the incoming request inside your route, for example:
 
(defroutes app-routes
  (POST "/route-one" request
        (if (= (:scheme req) :http)
          (process-requet request)
          {:status 403 :body "https not supported"}))
  (POST "/route-two" request
        (if (= (:scheme req) :https)
          (process-requet request)
          {:status 403 :body "http not supported"})))
 
You can of course extract this scheme check into a separate function or macro, so even if you have many routes then this could be a viable option without too extra noise in your code.
 
If you have many routes, and you don't want to add an extra call or check to each, then another way to achieve this is to add some middleware to your application. Middleware can check the :scheme included in the request and reject requests that don't conform. For example:
 
(defn wrap-https-only [handler]
  (fn [req]
    (if (= (:scheme req) :https)
      (handler req)
      {:status 403 :body "http not supported"})))

(defn wrap-http-only [handler]
  (fn [req]
    (if (= (:scheme req) :http)
      (handler req)
      {:status 403 :body "https not supported"})))
 
The tricky part is that you want to selectively apply this middleware to some routes and not others, and Compojure does not offer a simple way to do this. If you have some common path in all your http routes, and all your https routes (to group them) then you can use a pattern like this:
 
(def http-routes
  (-> (routes (POST "/http-only/route-one" request
                    (process-requet request)))
      wrap-http-only))

(def https-routes
  (-> (routes (POST "/http-only/route-two" request
                    (process-requet request)))
      wrap-https-only))


(defroutes app-routes
  (ANY "/http-only/*" [] http-routes)
  (ANY "/https-only/*" [] https-routes))
 
You can see here that the middleware is applied to each subset of routes, and so it will only be executed if the first part of the path matches. Now you can add as many routes as you like, and the middleware will take care of the scheme check for all of them. Note, this approach requires that you can identify the subsets of routes in some way in the initial 'app-routes' routes, in this case I've identified them by the path.
 
One thing to note when checking the scheme: be warned that this wont work if you decide to offload SSL to a load balancer. In that case, your application will always receive HTTP (not HTTPS) requests. You can usually achieve the same by simply checking the X-Forwarded-Proto header instead of the :scheme value.