Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHDERUPTENFRES

Elysia Tools

导航

编程语言

Clojure 语言示例

基本的Clojure编程示例,用于JVM上的函数式编程

案例

这个案例集合中的条目

代码clojure简单

Clojure Hello World

基本Clojure Hello World程序和Lisp风格的函数式编程基础概念

难度

3/10

预计时间

20 min

标签

clojure, functional, lisp, jvm, syntax

前置条件

Basic programming concepts, Understanding of functional programming

clojure
;; Clojure Hello World Examples

;; Load clojure.string for string helpers in script mode
(require '[clojure.string :as str])

;; 1. Basic Hello World
(println "Hello, World!")

;; 2. Hello World with function definition
(defn hello-world []
  (println "Hello, World!"))

(hello-world)

;; 3. Hello World with parameters
(defn greet [name]
  (println (str "Hello, " name "!")))

(greet "Clojure")
(greet "World")

;; 4. Hello World with multiple arities
(defn multi-greet
  ([] (println "Hello, World!"))
  ([name] (println (str "Hello, " name "!")))
  ([greeting name] (println (str greeting ", " name "!"))))

(multi-greet)
(multi-greet "Clojure")
(multi-greet "Good morning" "Clojure")

;; 5. Hello World with anonymous function
(let [greet-fn (fn [name] (println (str "Hello, " name "!")))]
  (greet-fn "Anonymous"))

;; 6. Hello World with higher-order function
(defn greet-twice [greet-fn name]
  (greet-fn name)
  (greet-fn name))

(greet-twice greet "Twice")

;; Basic data types and operations

;; Numbers
(def num1 42)
(def num2 3.14)
(def num3 2/3)  ; Rational number

(println "Integer:" num1)
(println "Float:" num2)
(println "Rational:" num3)
(println "Addition:" (+ num1 num2))
(println "Multiplication:" (* num1 2))

;; Strings
(def text "Clojure Programming")
(println "String:" text)
(println "Length:" (count text))
(println "Uppercase:" (str/upper-case text))
(println "Substring:" (subs text 0 6))

;; Keywords (efficient identifiers)
(def status :active)
(def user {:name "Alice" :age 30 :status status})
(println "User:" user)
(println "User name:" (:name user))
(println "User age:" (:age user))

;; Vectors (ordered collections)
(def numbers [1 2 3 4 5])
(println "Vector:" numbers)
(println "First element:" (first numbers))
(println "Last element:" (last numbers))
(println "Rest:" (rest numbers))
(println "Conj:" (conj numbers 6))

;; Maps (key-value collections)
(def person {
  :name "Bob"
  :age 25
  :city "New York"
  :hobbies ["reading" "coding" "music"]
})

(println "Person:" person)
(println "Person name:" (:name person))
(println "Person hobbies:" (:hobbies person))

;; Sets (unique collections)
(def unique-numbers #{1 2 3 4 5})
(println "Set:" unique-numbers)
(println "Contains 3?" (contains? unique-numbers 3))
(println "Add element:" (conj unique-numbers 6))

;; Lists (linked lists)
(def list-data '(1 2 3 4 5))
(println "List:" list-data)
(println "First:" (first list-data))
(println "Rest:" (rest list-data))

;; Basic functions

;; Function with multiple return values (using vector)
(defn divide-and-remainder [dividend divisor]
  (let [quotient (quot dividend divisor)
        remainder (rem dividend divisor)]
    [quotient remainder]))

(let [[q r] (divide-and-remainder 17 5)]
  (println "17 ÷ 5 =" q "remainder" r))

;; Conditional logic
(defn describe-number [n]
  (cond
    (< n 0) "negative"
    (= n 0) "zero"
    (< n 10) "small positive"
    :else "large positive"))

(println "-5 is" (describe-number -5))
(println "0 is" (describe-number 0))
(println "5 is" (describe-number 5))
(println "15 is" (describe-number 15))

;; Pattern matching with case
(defn describe-value [x]
  (case x
    1 "one"
    2 "two"
    3 "three"
    "hello" "greeting"
    :keyword "a keyword"
    "unknown value"))

(println "Value of 1:" (describe-value 1))
(println "Value of 'hello':" (describe-value "hello"))

;; Recursion
(defn factorial [n]
  (if (<= n 1)
    1
    (* n (factorial (dec n)))))

(println "5! =" (factorial 5))

;; Tail recursion optimization
(defn factorial-tail [n acc]
  (if (<= n 1)
    acc
    (recur (dec n) (* n acc))))

(defn factorial [n]
  (factorial-tail n 1))

(println "10! =" (factorial 10))

;; Loop/recur for iteration
(defn sum-to [n]
  (loop [i 1 total 0]
    (if (> i n)
      total
      (recur (inc i) (+ total i)))))

(println "Sum of 1 to 100:" (sum-to 100))

;; Higher-order functions

;; Map - transform each element
(def doubled (map #(* % 2) [1 2 3 4 5]))
(println "Doubled:" doubled)

;; Filter - select elements
(def evens (filter even? [1 2 3 4 5 6]))
(println "Even numbers:" evens)

;; Reduce - aggregate elements
(def sum (reduce + [1 2 3 4 5]))
(println "Sum:" sum)

;; Function composition
(defn add-and-double [x]
  (-> x
      (+ 5)
      (* 2)))

(println "Add 5 and double 10:" (add-and-double 10))

;; Destructuring
(defn process-person [{:keys [name age city] :as person}]
  (println (str name " is " age " years old and lives in " city))
  (println "Full person data:" person))

(process-person {:name "Charlie" :age 35 :city "Boston"})

;; Vector destructuring
(defn process-coordinates [[x y z]]
  (println (str "X: " x ", Y: " y ", Z: " z)))

(process-coordinates [10 20 30])

;; Lazy sequences
(def naturals (iterate inc 1))
(def first-10 (take 10 naturals))
(println "First 10 natural numbers:" first-10)

(def even-numbers (filter even? naturals))
(def first-5-evens (take 5 even-numbers))
(println "First 5 even numbers:" first-5-evens)

;; Interoperability with Java
(import 'java.util.Date)
(import 'java.text.SimpleDateFormat)

(defn format-date [date]
  (let [formatter (SimpleDateFormat. "yyyy-MM-dd HH:mm:ss")]
    (.format formatter date)))

(def now (Date.))
(println "Current time:" (format-date now))

;; Using Java collections
(def java-list (java.util.ArrayList.))
(.add java-list "Java element")
(.add java-list "Another element")
(println "Java list:" (vec java-list))

;; Namespaces and requires (in real usage)
;; (ns my-app.core
;;   (:require [clojure.string :as str]
;;             [clojure.set :as set]))

;; Exception handling
(defn safe-divide [a b]
  (try
    (/ a b)
    (catch ArithmeticException e
      (println "Division by zero error!")
      nil)
    (finally
      (println "Division operation completed"))))

(println "10 ÷ 2 =" (safe-divide 10 2))
(println "10 ÷ 0 =" (safe-divide 10 0))

;; Atom for state management
(def counter (atom 0))

(defn increment-counter []
  (swap! counter inc))

(defn get-counter []
  @counter)

(println "Initial counter:" @counter)
(increment-counter)
(increment-counter)
(println "Final counter:" @counter)

;; Basic meta-programming
(defmacro debug [x]
  (let [result# ~x]
     (println (str '~x " = " result#))
     result#))

(def a 10)
(def b 20)
(debug (+ a b))
代码clojure中等

Clojure 函数式编程模式

高级函数式编程技术、不可变数据结构和常见的Clojure模式

难度

7/10

预计时间

30 min

标签

clojure, functional, patterns, immutable, protocols

前置条件

Clojure basics, Functional programming concepts, Data structures

clojure
;; Clojure Functional Programming Patterns

;; 1. Pure Functions and Immutability

;; Pure function - no side effects
(defn calculate-discount [price discount-rate]
  (* price (- 1 discount-rate)))

(println "Discounted price:" (calculate-discount 100 0.2))

;; Always return new data structures instead of modifying
(defn add-item-to-cart [cart item]
  (conj cart item))

(def original-cart [:book :pen])
(def new-cart (add-item-to-cart original-cart :notebook))
(println "Original cart:" original-cart)  ; Unchanged
(println "New cart:" new-cart)            ; New cart with added item

;; 2. Function Composition and Transducers

;; Function composition
(defn transform-data [data]
  (->> data
       (map #(* % 2))           ; Double each number
       (filter even?)            ; Keep only even numbers
       (take 5)                  ; Take first 5
       (reduce +)))              ; Sum them up

(def numbers (range 1 20))
(println "Transform result:" (transform-data numbers))

;; Transducers - composable algorithmic transformations
(def xf-map-double (map #(* % 2)))
(def xf-filter-evens (filter even?))
(def xf-take-five (take 5))

(def process-numbers
  (comp xf-map-double xf-filter-evens xf-take-five))

(println "Transducer result:" (into [] process-numbers numbers))

;; 3. Lazy Sequences and Infinite Data

;; Infinite sequence of Fibonacci numbers
(def fib-seq
  (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

(def first-10-fib (take 10 fib-seq))
(println "First 10 Fibonacci numbers:" first-10-fib)

;; Lazy prime numbers
(defn prime? [n]
  (and (> n 1)
       (not-any? #(zero? (rem n %)) (range 2 (Math/sqrt n)))))

(def primes (filter prime? (iterate inc 2)))
(def first-10-primes (take 10 primes))
(println "First 10 prime numbers:" first-10-primes)

;; 4. Higher-Order Functions and Closures

;; Function factory - creates functions with captured values
(defn make-adder [increment]
  (fn [x] (+ x increment)))

(def add-5 (make-adder 5))
(def add-10 (make-adder 10))
(println "Add 5 to 10:" (add-5 10))
(println "Add 10 to 10:" (add-10 10))

;; Predicate factory
(defn make-predicate [operator value]
  (fn [x] (operator x value)))

(def greater-than-5 (make-predicate > 5))
(def less-than-10 (make-predicate < 10))
(println "Numbers >5:" (filter greater-than-5 [1 3 6 8 2 10]))
(println "Numbers <10:" (filter less-than-10 [1 3 6 8 2 10]))

;; 5. Data Transformation Pipelines

;; Pipeline for processing user data
(defn process-user-data [raw-users]
  (->> raw-users
       ;; Remove inactive users
       (filter #(:active %))
       ;; Calculate age group
       (map #(assoc % :age-group
                    (cond
                      (< (:age %) 18) "minor"
                      (< (:age %) 65) "adult"
                      :else "senior")))
       ;; Sort by age
       (sort-by :age)
       ;; Extract only relevant fields
       (map #(select-keys % [:name :age :age-group]))))

(def raw-users [
  {:name "Alice" :age 25 :active true :email "alice@example.com"}
  {:name "Bob" :age 17 :active true :email "bob@example.com"}
  {:name "Charlie" :age 70 :active false :email "charlie@example.com"}
  {:name "Diana" :age 30 :active true :email "diana@example.com"}])

(println "Processed users:" (process-user-data raw-users))

;; 6. Recursive Patterns and Tree Processing

;; Generic tree processing
(defn process-tree [node f-leaf f-node]
  (if (:children node)
    (f-node (:value node)
            (map #(process-tree % f-leaf f-node) (:children node)))
    (f-leaf (:value node))))

(def sample-tree
  {:value "root"
   :children [
    {:value "left" :children [
      {:value "left-left"}
      {:value "left-right"}
    ]}
    {:value "right" :children [
      {:value "right-left"}
    ]}
  ]})

(defn sum-leaves [x]
  (if (number? x) x 0))

(defn sum-node [value child-sums]
  (+ (sum-leaves value) (reduce + child-sums)))

(def numeric-tree
  {:value 1
   :children [
    {:value 2 :children [{:value 3} {:value 4}]}
    {:value 5 :children [{:value 6}]}
  ]})

(println "Tree sum:" (process-tree numeric-tree sum-leaves sum-node))

;; 7. Memoization and Caching

;; Memoized expensive function
(defn slow-fibonacci [n]
  (if (< n 2)
    n
    (+ (slow-fibonacci (dec n)) (slow-fibonacci (- n 2)))))

(def memo-fibonacci (memoize slow-fibonacci))

(println "Memoized fib 40:" (memo-fibonacci 40))  ; Much faster

;; Cache with TTL (time-to-live)
(defn create-ttl-cache [ttl-ms]
  (let [cache (atom {})]
    (fn [key f]
      (let [now (System/currentTimeMillis)
            cached-value (get @cache key)]
        (if (and cached-value (< (- now (:timestamp cached-value)) ttl-ms))
          (:value cached-value)
          (let [new-value (f)]
            (swap! cache assoc key {:value new-value :timestamp now})
            new-value))))))

(def expensive-cache (create-ttl-cache 5000))  ; 5 second TTL

(defn expensive-calculation [x]
  (println "Performing expensive calculation for" x)
  (* x x x))

(println "Cached result:" (expensive-cache 10 expensive-calculation))
(println "Cached result again:" (expensive-cache 10 expensive-calculation))

;; 8. State Management Patterns

;; Event sourcing pattern
(defn add-event [state event]
  (case (:type event)
    :add-item (update state :items conj (:item event))
    :remove-item (update state :items disj (:item event))
    :update-quantity (assoc-in state [:quantities (:item event)] (:quantity event))
    state))

(def initial-state {:items #{} :quantities {}})

(def events [
  {:type :add-item :item :book}
  {:type :add-item :item :pen}
  {:type :update-quantity :item :book :quantity 2}
  {:type :remove-item :item :pen}
])

(def final-state (reduce add-event initial-state events))
(println "Final state:" final-state)

;; 9. Protocol and Multimethod Patterns

;; Multimethods for polymorphic behavior
(defmulti area :shape)

(defmethod area :circle [{:keys [radius]}]
  (* Math/PI radius radius))

(defmethod area :rectangle [{:keys [width height]}]
  (* width height))

(defmethod area :triangle [{:keys [base height]}]
  (* 0.5 base height))

(def shapes [
  {:shape :circle :radius 5}
  {:shape :rectangle :width 4 :height 6}
  {:shape :triangle :base 3 :height 8}
])

(println "Areas:" (map area shapes))

;; Protocols for interface-like behavior
(defprotocol Drawable
  (draw [this]))

(defrecord Circle [radius]
  Drawable
  (draw [this]
    (println (str "Drawing circle with radius " radius))))

(defrecord Rectangle [width height]
  Drawable
  (draw [this]
    (println (str "Drawing rectangle " width "x" height))))

(def shapes-objects [(->Circle 10) (->Rectangle 5 8)])
(dorun (map draw shapes-objects))

;; 10. Error Handling and Validation

;; Result pattern with explicit success/failure
(defn safe-divide [a b]
  (if (zero? b)
    {:success false :error "Division by zero"}
    {:success true :result (/ a b)}))

(defn chain-operations [initial operations]
  (reduce (fn [acc op]
            (if (:success acc)
              (op (:result acc))
              acc))
          initial
          operations))

(def calculation-pipeline [
  #(safe-divide % 2)    ; Divide by 2
  #(safe-divide % 0)    ; This will fail
  #(safe-divide % 3)])  ; This won't be reached

(println "Calculation result:" (chain-operations 100 calculation-pipeline))

;; Validation with accumulation
(defn validate-user [user]
  (let [errors (cond-> []
                 (empty? (:name user)) (conj "Name is required")
                 (not (:email user)) (conj "Email is required")
                 (and (:age user) (< (:age user) 0)) (conj "Age must be non-negative"))]
    (if (empty? errors)
      {:success true :user user}
      {:success false :errors errors})))

(def test-users [
  {:name "Alice" :email "alice@example.com" :age 25}
  {:name "" :email "bob@example.com" :age -5}
  {}])

(println "Validation results:" (map validate-user test-users))
代码clojure复杂

Clojure Web开发和宏编程

使用Ring/Compojure进行Web开发和高级宏编程用于元编程

难度

9/10

预计时间

45 min

标签

clojure, web, macros, ring, compojure, api

前置条件

Advanced Clojure, Web concepts, Database knowledge, Macro understanding

clojure
;; Clojure Web Development and Advanced Macros

;; 1. Ring and Compojure Web Framework Basics

;; Basic Ring handler
(defn hello-handler [request]
  {:status 200
   :headers {"Content-Type" "text/html"}
   :body "<h1>Hello from Clojure!</h1>"})

;; Route-based handler with Compojure
(require '[compojure.core :refer [defroutes GET POST]])
(require '[ring.adapter.jetty :as jetty])

(defroutes app-routes
  (GET "/" [] "Welcome to the homepage!")
  (GET "/hello/:name" [name] (str "Hello, " name "!"))
  (GET "/api/users" []
    {:status 200
     :headers {"Content-Type" "application/json"}
     :body "[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]"})
  (POST "/api/users" [name email]
    {:status 201
     :headers {"Content-Type" "application/json"}
     :body (str "{"id":3,"name":"" name "","email":"" email ""}")})
  (GET "/files/:filename" [filename]
    (java.io.File. "public/" filename)))

;; Middleware for logging
(defn wrap-logging [handler]
  (fn [request]
    (println (str "Processing " (:request-method request) " " (:uri request)))
    (let [response (handler request)]
      (println (str "Response status: " (:status response)))
      response)))

;; Middleware for JSON responses
(defn wrap-json [handler]
  (fn [request]
    (let [response (handler request)]
      (if (map? (:body response))
        (assoc-in response [:headers "Content-Type"] "application/json")
        response))))

;; Middleware stack
(def app
  (-> app-routes
      wrap-logging
      wrap-json))

;; 2. Advanced Macro Programming

;; Macro for route definition with automatic documentation
(defmacro defpage [route description & body]
  (do
     (defn ~(symbol (str "page-" (hash route))) [request#]
       ~@body)
     (alter-var-root #'*routes* conj {:path ~route :description ~description})
     ~(symbol (str "page-" (hash route)))))

(def *routes* (atom []))

(defpage "/about" "About page"
  {:status 200
   :headers {"Content-Type" "text/html"}
   :body "<h1>About Us</h1><p>We are a Clojure web application!</p>"})

;; Debugging macro with expression information
(defmacro dbg [x]
  (let [result# ~x]
     (println (str "Debug: " '~x " = " result#))
     result#))

;; Time execution macro
(defmacro time-execution [& body]
  (let [start# (System/nanoTime)
         result# (do ~@body)
         end# (System/nanoTime)
         duration# (/ (- end# start#) 1000000.0)]
     (println (str "Execution time: " duration# " ms"))
     result#))

;; Usage example:
;; (time-execution
;;   (Thread/sleep 100)
;;   (println "Done"))

;; Conditional compilation macro
(defmacro when-dev [& body]
  (when (= "development" (or (System/getenv "ENV") "development"))
     ~@body))

(when-dev
  (println "Development mode enabled"))

;; 3. Database Operations and Transactions

(require '[clojure.java.jdbc :as jdbc])

(def db-spec {:subprotocol "h2"
              :subname "mem:example"
              :user "sa"
              :password ""})

;; Table creation
(defn create-users-table! []
  (jdbc/db-do-commands db-spec
    [(jdbc/create-table-ddl :users
       [[:id :int "PRIMARY KEY"]
        [:name "VARCHAR(50)"]
        [:email "VARCHAR(100)"]
        [:created_at :timestamp]])]))

;; CRUD operations
(defn create-user! [user-data]
  (jdbc/insert! db-spec :users
    (assoc user-data :created_at (java.sql.Timestamp. (System/currentTimeMillis)))))

(defn get-user [id]
  (first (jdbc/query db-spec ["SELECT * FROM users WHERE id = ?" id])))

(defn update-user! [id user-data]
  (jdbc/update! db-spec :users user-data ["id = ?" id]))

(defn delete-user! [id]
  (jdbc/delete! db-spec :users ["id = ?" id]))

(defn list-users []
  (jdbc/query db-spec ["SELECT * FROM users ORDER BY created_at DESC"]))

;; Transaction example
(defn transfer-users! [from-id to-id]
  (jdbc/with-db-transaction [t-conn db-spec]
    (let [from-user (first (jdbc/query t-conn ["SELECT * FROM users WHERE id = ?" from-id]))
          to-user (first (jdbc/query t-conn ["SELECT * FROM users WHERE id = ?" to-id]))]
      (when (and from-user to-user)
        ;; Update both users in a single transaction
        (jdbc/update! t-conn :users
          {:name (str (:name from-user) "_transferred")}
          ["id = ?" from-id])
        (jdbc/update! t-conn :users
          {:name (str (:name to-user) "_received")}
          ["id = ?" to-id])
        true))))

;; 4. Authentication and Authorization

;; Password hashing
(require '[buddy.hashers :as hashers])

(defn hash-password [password]
  (hashers/derive password {:algorithm :bcrypt}))

(defn verify-password [password hashed-password]
  (hashers/verify password hashed-password))

;; JWT token generation (requires buddy-sign)
(require '[buddy.sign.jwt :as jwt])

(def secret-key "your-secret-key-here")

(defn generate-token [user-id]
  (jwt/sign {:user-id user-id :exp (+ (System/currentTimeMillis) 3600000)} secret-key))

(defn verify-token [token]
  (try
    (jwt/unsign token secret-key)
    (catch Exception e
      {:error "Invalid token"})))

;; Authentication middleware
(defn wrap-authentication [handler]
  (fn [request]
    (let [token (get-in request [:headers "authorization"])
          auth-result (when token (verify-token token))]
      (if (:error auth-result)
        {:status 401 :body {:error "Unauthorized"}}
        (handler (assoc request :user (:data auth-result)))))))

;; Authorization macro
(defmacro require-role [role & body]
  (let [user# (:user *request*)]
     (if (= (:role user#) ~role)
       (do ~@body)
       {:status 403 :body {:error "Forbidden"}})))

;; 5. RESTful API with Data Validation

;; Validation library usage
(require '[clojure.spec.alpha :as s])

(s/def ::name string?)
(s/def ::email #(re-matches #".+@.+..+" %))
(s/def ::age int?)
(s/def ::user (s/keys :req-un [::name ::email]
                    :opt-un [::age]))

(defn validate-request [data spec]
  (if (s/valid? spec data)
    {:success true :data data}
    {:success false :errors (s/explain-data spec data)}))

;; API endpoint with validation
(defn create-user-api [request]
  (let [user-data (:body request)
        validation (validate-request user-data ::user)]
    (if (:success validation)
      (try
        (let [created-user (create-user! (:data validation))]
          {:status 201 :body created-user})
        (catch Exception e
          {:status 500 :body {:error "Database error"}}))
      {:status 400 :body {:errors (:errors validation)}})))

;; 6. Real-time WebSocket Communication

(require '[ring.adapter.jetty :as jetty])
(require '[clojure.data.json :as json])

(def websocket-connections (atom #{}))

(defn websocket-handler [request]
  {:status 101
   :headers {"Upgrade" "websocket"
            "Connection" "Upgrade"}})

(defn broadcast-message! [message]
  (doseq [connection @websocket-connections]
    (try
      (.send connection (json/write-str message))
      (catch Exception e
        (swap! websocket-connections disj connection)))))

(defn handle-websocket-message [connection message]
  (let [parsed (json/read-str message)]
    (case (:type parsed)
      :chat (broadcast-message!
             {:type :chat
              :user (:user parsed)
              :message (:message parsed)
              :timestamp (System/currentTimeMillis)})
      :join (swap! websocket-connections conj connection))))

;; 7. Background Jobs and Task Queue

;; Simple task queue using atoms
(def task-queue (atom clojure.lang.PersistentQueue/EMPTY))
(def workers (atom {}))

(defn enqueue-task! [task]
  (swap! task-queue conj task))

(defn dequeue-task! []
  (first (swap-vals! task-queue pop)))

(defn start-worker! [worker-id]
  (future
    (loop []
      (when-let [task (dequeue-task!)]
        (try
          (println (str "Worker " worker-id " processing task: " (:type task)))
          ((:handler task) task)
          (catch Exception e
            (println (str "Worker " worker-id " error: " (.getMessage e)))))
        (recur)))))

(defn stop-worker! [worker-id]
  (when-let [worker-future (get @workers worker-id)]
    (future-cancel worker-future)
    (swap! workers dissoc worker-id)))

;; Example tasks
(defn send-email-task [task]
  (Thread/sleep 2000)  ; Simulate sending email
  (println (str "Email sent to " (:to task))))

(defn process-image-task [task]
  (Thread/sleep 5000)  ; Simulate image processing
  (println (str "Image processed: " (:image-path task))))

;; Enqueue tasks
(enqueue-task! {:type :send-email
                :to "user@example.com"
                :handler send-email-task})

(enqueue-task! {:type :process-image
                :image-path "/path/to/image.jpg"
                :handler process-image-task})

;; Start worker threads
(swap! workers assoc :worker1 (start-worker! 1))
(swap! workers assoc :worker2 (start-worker! 2))

;; 8. Configuration Management

;; Configuration loading
(defn load-config [env]
  (case env
    :development {:port 3000 :db-url "jdbc:h2:mem:dev" :debug true}
    :test {:port 3001 :db-url "jdbc:h2:mem:test" :debug false}
    :production {:port 80 :db-url "jdbc:postgresql://prod/db" :debug false}
    {:port 3000 :db-url "jdbc:h2:mem:default" :debug false}))

(def config (load-config (keyword (or (System/getenv "ENV") "development"))))

;; Environment-specific middleware
(defn wrap-dev-only [handler]
  (if (:debug config)
    handler
    (fn [request] {:status 404 :body "Not found"})))

;; 9. Error Handling and Logging

;; Structured logging
(defn log-event [level message data]
  (let [log-entry {:timestamp (System/currentTimeMillis)
                   :level level
                   :message message
                   :data data}]
    (println (clojure.data.json/write-str log-entry))
    log-entry))

;; Global error handler
(defn wrap-error-handling [handler]
  (fn [request]
    (try
      (handler request)
      (catch Exception e
        (log-event :error "Unhandled exception"
                   {:exception (.getMessage e)
                    :stack-trace (map str (.getStackTrace e))})
        {:status 500 :body {:error "Internal server error"}}))))

;; 10. Testing and Development Tools

;; Test data generation
(defn generate-test-user []
  {:name (str "Test User " (rand-int 1000))
   :email (str "test" (rand-int 1000) "@example.com")
   :age (+ 18 (rand-int 50))})

;; Route testing helper
(defn test-route [app-routes request-method uri]
  ((app-routes {:request-method request-method :uri uri}) {}))

;; Start the server (comment out in production)
;; (jetty/run-jetty app {:port (:port config) :join? false})

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

多语言网页字体配对与交付验证

检查字体字形覆盖,用真实文案比较标题与正文字体,配置可变轴和响应式字号,并验收上线后的字体加载与回退表现。

专题

文本分析、可读性与内容检查工具

在编辑、审核、分类或发布前,检查文本文件、字数、模式、语言、可读性、情绪、内容风险、词频和用词选择。

专题

提示词工程与大模型输入准备

在使用大模型前,结构化提示词、估算 token、翻译或识别语言、清洗 PDF 证据,并审查注入、数学、正则和数据风险。

专题

药代动力学教学模型与结果核查

用于教学或 QA 的药代公式、模型假设和结果一致性核查,不提供用药剂量、诊断或临床建议。

首页
工具3212
案例593
可视化471
文件查看器103
专题239
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融647

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

潜客测验发布与联系人交接
讣告、悼词与纪念卡的家属复核及交付
本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Development

变量名验证器 - 多语言命名规范检查

根据多种编程语言的命名规范和标准验证变量名

AI Tools

AI语言检测器

使用AI检测文本片段的语言并返回语言代码

Media

语言学习循环制作器

将语音短语制作为可重复练习音频,并可设置每次重复之间的停顿。

AI Tools

无限制AI多语言标题翻译器

专业的AI驱动多语言标题翻译工具,支持同时翻译到多种语言,输出JSON格式,适用于电影、电视剧、动漫、游戏等各类作品

编程语言

Scala 语言示例

Scala编程示例和函数式编程概念

编程语言

F# 语言示例

基本的F#编程示例,用于函数式编程和.NET开发

编程语言

Haskell 语言示例

Haskell编程示例,用于函数式编程和类型系统探索

编程语言

Kotlin 示例

基础Kotlin代码示例,包括Android开发、JVM后端和现代Kotlin特性

编程语言

Swift 示例

基础Swift代码示例,包括iOS开发、现代Swift特性和SwiftUI