Clojure 调用 Java 深度实践：从 JVM 互操作到性能优化

;; 创建 Java 对象（new 或尾随 . 类名）
(def sb (new StringBuilder))
(def sb2 (StringBuilder.))

;; 调用方法
(.append sb "Hello")
(.append sb " World")
(.toString sb)  ; => "Hello World"

;; 链式调用（doto 宏）
(doto (StringBuilder.)
  (.append "Hello")
  (.append " ")
  (.append "Clojure"))
;; => StringBuilder("Hello Clojure")

;; 静态方法
(Math/pow 2 10)           ; => 1024.0
(System/currentTimeMillis)

;; 静态字段
Math/PI                   ; => 3.14159...

;; 枚举类型
java.util.concurrent.TimeUnit/SECONDS

(def point (java.awt.Point. 10 20))
(.x point)                ; => 10（获取字段）
(set! (.x point) 100)     ; 设置字段（可变，谨慎使用）

(import '[java.util ArrayList HashMap])

;; Clojure -> Java
(def java-list (ArrayList. [1 2 3 4 5]))
(def java-map (HashMap. {:a 1 :b 2}))

;; Java -> Clojure
(vec java-list)           ; => [1 2 3 4 5]
(into {} java-map)        ; => {:a 1, :b 2}
(seq java-list)           ; => (1 2 3 4 5)

;; 实现 Runnable 接口
(def runnable
  (proxy [Runnable] []
    (run []
      (println "运行在:" (Thread/currentThread)))))

(.start (Thread. runnable))

;; 实现多个接口（Clojure 的多"重"实现）
(def listener
  (proxy [java.awt.event.ActionListener java.awt.event.MouseAdapter] []
    (actionPerformed [e]
      (println "点击事件:" (.getActionCommand e)))
    (mouseClicked [e]
      (println "鼠标点击:" (.getPoint e)))))

(def comparator
  (reify java.util.Comparator
    (compare [this a b]
      (compare (:priority b) (:priority a)))))

;; 用作排序
(sort comparator [{:priority 3} {:priority 1} {:priority 2}])
;; => ({:priority 3} {:priority 2} {:priority 1})

(ns myapp.Main
  (:gen-class
   :main true                        ; 需要 main 入口
   :methods [[greet [String] String]]))

(defn -main [& args]
  (println "Clojure 主程序启动")
  (doseq [arg args]
    (println (str "参数: " arg))))

(defn -greet [this name]
  (str "Hello, " name " from Clojure!"))

;; ❌ 无类型提示 — 反射调用（慢）
(defn slow-sum [^java.util.List numbers]
  (reduce + numbers))

;; ✅ 有类型提示 — 直接调用（快）
(defn fast-sum [^java.util.List numbers]
  (let [size (.size numbers)]        ; 直接字节码调用
    (loop [i 0 acc 0]
      (if (< i size)
        (recur (inc i) (+ acc (.get numbers i)))
        acc))))

(defn process-data
  [^String s                        ; String 提示
   ^long n                          ; primitive long
   ^doubles arr                     ; primitive double 数组
   ^java.util.Map m]                ; Map 接口提示
  ...)

;; 返回类型提示
(defn ^long calculate [^long x ^long y]
  (+ x y))

;; 创建原生类型数组
(def int-array (int-array [1 2 3 4 5]))
(def double-array (make-array Double/TYPE 1000))

;; amap 与 areduce — 高效数组操作
(areduce ^ints int-array i ret 0
  (+ ret (aget ^ints int-array i)))
; => 15

(amap ^ints int-array idx ret
  (* 2 (aget ^ints int-array idx)))
; => [2 4 6 8 10]

;; Java Arrays 工具类
(java.util.Arrays/sort ^ints int-array)

;; 定义与 Java 类性能相当的结构体
(deftype Point [^double x ^double y]
  Object
  (toString [this]
    (str "Point(" x ", " y ")")))

;; 字段访问是直接字段访问（非函数调用）
(def p (Point. 3.0 4.0))
(.x p)              ; => 3.0（直接字段，O(0)）

(import '[java.util.concurrent Executors ExecutorService Future])

(def ^ExecutorService executor (Executors/newFixedThreadPool 4))

;; 提交任务（返回 Future）
(def ^Future future-result
  (.submit executor
    ^Callable (fn [] (reduce + (range 1000000)))))

;; 获取结果（阻塞）
(.get future-result)    ; => 499999500000

;; Clojure 风格的包装
(defn submit-task [^ExecutorService executor f]
  (.submit executor ^Callable f))

(import '[java.util.concurrent CompletableFuture])

(defn async-fetch-user [id]
  (CompletableFuture/supplyAsync
    ^java.util.function.Supplier
    (fn [] (fetch-from-db id))))

(-> (async-fetch-user 42)
    (.thenApply
      ^java.util.function.Function
      (fn [user]
        (assoc user :display-name (str (:first-name user) " " (:last-name user)))))
    (.thenAccept
      ^java.util.function.Consumer
      (fn [user] (println "处理完成:" user))))

;; deps.edn
{:paths ["src" "resources"]
 :deps {org.clojure/clojure {:mvn/version "1.11.1"}
        com.google.guava/guava {:mvn/version "32.1.3-jre"}
        io.netty/netty-all {:mvn/version "4.1.100.Final"}}
 :aliases {:dev {:extra-paths ["dev"]
                 :extra-deps {org.clojure/tools.namespace {:mvn/version "1.4.4"}}}}}

;; project.clj
(defproject myapp "1.0.0"
  :dependencies [[org.clojure/clojure "1.11.1"]
                 [com.fasterxml.jackson.core/jackson-databind "2.15.2"]]
  :java-source-paths ["src/java"]
  :source-paths     ["src/clojure"]
  :aot [myapp.core]
  :main myapp.core)

// Spring Boot 启动时加载 Clojure 代码
@Configuration
public class ClojureConfig {
    @Bean
    public IFn clojureHandler() throws Exception {
        // 加载 Clojure 命名空间
        Clojure.var("clojure.core", "require")
               .invoke(Clojure.read("myapp.handlers"));

        return (IFn) Clojure.var("myapp.handlers", "handle-request");
    }
}

// Controller 中调用
@RestController
public class DynamicController {
    @Autowired private IFn clojureHandler;

    @PostMapping("/dynamic")
    public Object handle(@RequestBody Map<String, Object> payload) {
        return clojureHandler.invoke(payload);
    }
}

# 启动时开启反射警告
clojure -J-Dclojure.compiler.disable-locals-clearing=false \
        -J-Dclojure.compiler.direct-linking=true

# 或代码中设置
(set! *warn-on-reflection* true)