Clojure Functional Programming & JVM Backend Development · 课时

系统设计与可扩展性模式

应用高级系统设计模式，构建高可用、容错且可扩展的 Clojure 后端服务。

系统设计与可扩展性模式 是 CoddyKit 上的免费 Clojure Functional Programming & JVM Backend Development 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Clojure Functional Programming & JVM Backend Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Clojure Functional Programming & JVM Backend Development 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Designing for Scale

Building robust Clojure backend systems means more than just writing code. It involves designing for high availability, fault tolerance, and scalability.

These principles ensure your application can handle increased load, recover from failures, and remain accessible to users.

Ensuring High Availability

High Availability (HA) means your system remains operational even when components fail. It's about minimizing downtime.

Redundancy: Having duplicate components (e.g., multiple servers) so if one fails, another takes over.
Load Balancing: Distributing incoming traffic across multiple instances of your service to prevent overload and ensure even resource use.

Load Balancer's Role

Imagine many users hitting your Clojure service. A load balancer acts as a traffic cop, directing each request to an available server instance.

This prevents any single server from becoming a bottleneck and improves overall system responsiveness and reliability.

Fault Tolerance: Circuit Breaker

Fault tolerance means your system can continue operating despite failures in some of its parts. A common pattern for this is the Circuit Breaker.

When a service calls another (e.g., a database or an external API), the circuit breaker monitors these calls. If too many fail, it "opens" the circuit, preventing further calls to the failing service and allowing it to recover.

Circuit Breaker Demo

Here's a simplified Clojure example of a circuit breaker. It prevents repeated calls to a failing function after a certain number of errors.

(def circuit (atom {:state :closed :failures 0 :last-open 0}))
(def failure-threshold 3)
(def reset-timeout-ms 5000)

(defn- current-time-ms [] (System/currentTimeMillis))

(defn with-circuit-breaker [f]
  (let [{:keys [state failures last-open]} @circuit]
    (cond
      (= state :open)
      (if (> (- (current-time-ms) last-open) reset-timeout-ms)
        (do (swap! circuit assoc :state :half-open)
            (println "Circuit half-open, trying call...")
            (try
              (f)
              (do (swap! circuit assoc :state :closed :failures 0)
                  (println "Circuit closed!"))
              (catch Exception e
                (swap! circuit assoc :state :open :last-open (current-time-ms))
                (println "Circuit back to open!")
                (throw e))))
        (throw (ex-info "Circuit is open!" {:circuit-state :open})))

      (= state :half-open)
      (try
        (f)
        (do (swap! circuit assoc :state :closed :failures 0)
            (println "Circuit closed!"))
        (catch Exception e
          (swap! circuit assoc :state :open :last-open (current-time-ms))
          (println "Circuit back to open!")
          (throw e)))

      :else ; :closed
      (try
        (f)
        (do (swap! circuit assoc :failures 0)
            (println "Call successful!"))
        (catch Exception e
          (swap! circuit update :failures inc)
          (if (>= (:failures @circuit) failure-threshold)
            (do (swap! circuit assoc :state :open :last-open (current-time-ms))
                (println "Circuit opened!"))
            (println "Failure count:" (:failures @circuit)))
          (throw e)))))

(defn unreliable-service []
  (if (> (rand) 0.7)
    (throw (RuntimeException. "Service failed!"))
    (println "Service call successful.")))

(defn -main [& args]
  (println "--- Running Circuit Breaker Demo ---")
  (dotimes [i 10]
    (println "\nAttempt" (inc i))
    (try
      (with-circuit-breaker unreliable-service)
      (catch Exception e
        (println "Caught exception:" (.getMessage e))))
    (Thread/sleep 1000)) ; Wait for a bit
  (println "\n--- Demo End ---"))

More Fault Tolerance

Beyond circuit breakers, other patterns enhance fault tolerance:

Retries with Exponential Backoff: Automatically re-attempt failed operations, waiting longer between attempts to avoid overwhelming a recovering service.
Bulkheads: Isolating components (like using separate thread pools for different services) so one failing part doesn't take down the entire application.

Scaling Up or Out?

Scalability is the ability of a system to handle a growing amount of work. There are two main strategies:

Vertical Scaling (Scaling Up): Increasing the resources of a single server (e.g., more CPU, RAM). This has limits.
Horizontal Scaling (Scaling Out): Adding more servers or instances to distribute the load. This is often preferred for cloud-native applications.

Embrace Statelessness

For effective horizontal scaling, your Clojure backend services should ideally be stateless.

A stateless service doesn't store any client-specific data between requests. Each request contains all necessary information. This makes it easy to add or remove service instances without losing user session data.

Boost with Distributed Cache

Distributed caching is a key scalability pattern. Instead of hitting your database for every request, frequently accessed data can be stored in a fast, in-memory cache shared across all service instances.

This reduces database load, improves response times, and allows your backend to serve more requests efficiently.

Check Your Knowledge

Consider a Clojure microservice that relies on an external payment gateway. Which pattern would be most effective to prevent cascading failures if the payment gateway becomes unresponsive?

System Design Recap

In this lesson, we explored crucial system design patterns for building scalable, highly available, and fault-tolerant Clojure backend services.

We covered High Availability with redundancy and load balancing.
We delved into Fault Tolerance using circuit breakers, retries, and bulkheads.
We understood Scalability through horizontal scaling, stateless services, and distributed caching.

Applying these patterns will help you build robust systems ready for real-world demands!

常见问题解答

「系统设计与可扩展性模式」课时是免费的吗？

是的 — 「系统设计与可扩展性模式」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Clojure Functional Programming & JVM Backend Development 课程的其余内容，请升级到 CoddyKit PRO。 Clojure Functional Programming & JVM Backend Development 课程共包含 4 节课。

「系统设计与可扩展性模式」这节课中我会学到什么？

应用高级系统设计模式，构建高可用、容错且可扩展的 Clojure 后端服务。你通过在浏览器中直接运行的动手代码来练习 Clojure Functional Programming & JVM Backend Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Clojure Functional Programming & JVM Backend Development 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Clojure Functional Programming & JVM Backend Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「系统设计与可扩展性模式」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Clojure Functional Programming & JVM Backend Development 课中编写并运行代码吗？

能。每节 Clojure Functional Programming & JVM Backend Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

构建 RESTful API
事件驱动架构
系统设计与可扩展性模式
认证与授权

← 返回 Clojure Functional Programming & JVM Backend Development