Come si crea un'applicazione Web in Clojure? [chiuso]

Suppongo che questa sia una strana domanda per la stragrande maggioranza dei programmatori che lavorano quotidianamente con Java. Io non. Conosco Java-the-language, perché ho lavorato su progetti Java, ma non Java-the-world. Non ho mai creato un'app Web da zero in Java. Se devo farlo con Python, Ruby, so dove andare (Django o Rails), ma se voglio creare un'applicazione Web in Clojure, non perché sono costretto a vivere in un mondo Java, ma perché come il linguaggio e voglio provarlo, quali librerie e framework dovrei usare?

Di gran lunga il miglior framework Web Clojure che abbia mai incontrato è Compojure: http://github.com/weavejester/compojure/tree/master

È piccolo ma potente e ha una sintassi meravigliosamente elegante. (Usa Jetty sotto il cofano, ma ti nasconde l'API Servlet a meno che tu non lo desideri, il che non sarà frequente). Guarda il file README dell'URL, quindi scarica un'istantanea e inizia a giocare.

Compojure non è più un framework completo per lo sviluppo di applicazioni Web. Dalla versione 0.4, la composizione è stata suddivisa in diversi progetti.

Ring fornisce le basi sottraendo il processo di richiesta e risposta HTTP. Ring analizzerà la richiesta in arrivo e genererà una mappa contenente tutte le parti della richiesta come uri, nome server e metodo richiesta. L'applicazione gestirà quindi la richiesta e in base alla richiesta genererà una risposta. Una risposta è rappresentata come una mappa contenente i seguenti tasti: stato, intestazioni e corpo. Quindi una semplice applicazione sarebbe simile a:

(def app [req]
  (if (= "/home" (:uri req))
    {:status 200
     :body "<h3>Welcome Home</h3>"}
    {:status 200 
     :body "<a href='/home'>Go Home!</a>"}))

Un'altra parte di Ring è il concetto di middleware. Questo è il codice che si trova tra il gestore e la richiesta in arrivo e / o la risposta in uscita. Alcuni middleware integrati includono sessioni e stacktrace. Il middleware di sessione aggiungerà una: chiave di sessione alla mappa di richiesta che contiene tutte le informazioni sulla sessione per l'utente che effettua la richiesta. Se la chiave di sessione è presente nella mappa di risposta, verrà memorizzata per la richiesta successiva effettuata dall'utente corrente. Mentre il middleware di traccia dello stack acquisirà eventuali eccezioni che si verificano durante l'elaborazione della richiesta e genererà una traccia di stack che viene restituita come risposta se si verificano eccezioni.

Lavorare direttamente con l'Anello può essere noioso, quindi Compojure è costruito sulla parte superiore dell'Anello per sottrarre i dettagli. L'applicazione ora può essere espressa in termini di routing in modo da poter avere qualcosa del genere:

(defroutes my-routes
  (GET "/" [] "<h1>Hello all!</h1>")
  (GET "/user/:id" [id] (str "<h1>Hello " id "</h1>")))

Compojure sta ancora lavorando con le mappe di richiesta / risposta, quindi puoi sempre accedervi se necessario:

(defroutes my-routes
  (GET "*" {uri :uri} 
           {:staus 200 :body (str "The uri of the current page is: " uri)}))

In questo caso la parte {uri: uri} accede alla chiave: uri nella mappa della richiesta e imposta uri su quel valore.

L'ultimo componente è il singhiozzo che semplifica la generazione dell'html. I vari tag html sono rappresentati come vettori con il primo elemento che rappresenta il nome del tag e il resto è il corpo del tag. "<h2>A header</h2>"diventa [:h2 "A Header"]. Gli attributi di un tag sono in una mappa opzionale. "<a href='/login'>Log In Page</a>"diventa [:a {:href "/login"} "Log In Page"]. Ecco un piccolo esempio che utilizza un modello per generare l'html.

(defn layout [title & body]
  (html
    [:head [:title title]]
    [:body [:h1.header title] body])) 

(defn say-hello [name]
  (layout "Welcome Page" [:h3 (str "Hello " name)]))

(defn hiccup-routes
  (GET "/user/:name" [name] (say-hello name)))

Ecco un link a una bozza di alcuni documenti attualmente scritti dall'autore di compojure che potresti trovare utili: Compojure Doc

C'è anche "Noir" ( http://www.webnoir.org/ ), che è un nuovo framework web Clojure (quindi i nuovi documenti non sono ancora arrivati). Provenendo da Django / Rails, scavo la sintassi semplice e diretta ed è piuttosto snella.

Considera il framework Web Luminus . Non ho affiliazioni ma ho sentito cose positive da amici che rispetto.

La mia attuale libreria web go-to è ora yada .

Se hai appena iniziato, il server introduttivo è Compojure. Lo vedo come apachedei server web nel mondo Clojure (nel qual caso yada / aleph sarebbe nginx). Puoi usare Luminuscome modello. Ci sono varianti di esso, comecompojure-api .

Ci ho provato Pedestale ne sono rimasto soddisfatto a livello globale. Non pretendo di dominarlo, ma ha una sintassi piacevole, sembra molto coesivo e sembra che abbia grandi prestazioni. È anche supportato da Cognitect(la società Clojure / Datomic dove lavora Rich Hickey).

Ho scoperto Alephdi presentare un'astrazione interessante e la contropressione integrata sembra interessante. Devo ancora giocarci, ma è sicuramente nella mia lista.

Dopo aver giocato un po 'con vari server Web, ecco la mia rapida lista Pro / Contro:

Risposta breve: dai un'occhiata a Luminus per iniziare rapidamente, magari passare a qualcos'altro in base all'evolversi delle tue esigenze (forse Yada).

Compojure

• Pro (1):

  • facile, molti modelli / esempi (es. luminoso)

• Contro (2):

  • Non performante (un thread per richiesta), si aspettano prestazioni leggermente migliori rispetto alle guide
  • Non semplice, il modello di middleware presenta inconvenienti

Piedistallo

• Pro (3):

  • modello di intercettore, sintassi piacevole per aggiungere intercettori a un sottoinsieme di rotte
  • router performante
  • supporta i moduli json / transit / multipart in modo trasparente e immediato, senza chiedere nulla. Molto bello!

• Contro (4):

  • nessun supporto per websocket (ancora), restituire i canali core.async sarebbe bello
  • un po 'lento da ricaricare se lo inseriamo in un componente di Stuart Sierra (penso che dovresti usare l'intercettore di ricarica)
  • nessuna struttura di test per intercettori asincroni
  • richiede il buy-in (?)

Aleph

Pro (3):

• performant
• contropressione
• Supporto Websocket / SSE durante la restituzione di un flusso molteplice

Contro (1):

• Basso livello, fai da te stile (cioè ti dà solo un modo per far fare qualcosa ai tuoi gestori. Nessun router, niente di niente). Non è un vero svantaggio, basta esserne consapevoli.

Yada

Pro (3):

• costruito su Aleph
• negoziazione dei contenuti
• integrazione spavalderia
• bidi è abbastanza ok (anche se mi piace meglio la sintassi del router del piedistallo)

Contro (1):

• documentazione (anche se non negativa come il nginx-clojure, in rapido miglioramento).

HttpKit

Pro (2):

• Scritto in Clojure! (e Java ...)
• le prestazioni sembrano buone (vedi il post delle connessioni simultanee da 600K)

Contro (2):

• Nessun supporto CORS
• Bug? Inoltre, non ci sono molti impegni recenti

Nginx-Clojure

Nota: non ci ho giocato, principalmente a causa della mancanza di documentazione. Sembra interessante e molto performante.

Pro (2):

• Nginx (performant, offload ssl, riavvio dei lavoratori ...)
• Questo modello potrebbe consentire aggiornamenti zero-downtime? Sarebbe fantastico!

Contro (1):

• Documentazione (miglioramento). Inoltre, non voglio programmare in stringhe incorporate in un file di configurazione nginx se questo è l'unico modo per farlo.
• Probabilmente complica un po 'il primo schieramento (?)

Immutant

Nota: non ci ho giocato.

Professionisti :

• integrato (memorizzazione nella cache, messaggistica, pianificazione, distribuzione wildfly)

Contro:

• nessun client http

Catacumba

Nota: non ci ho giocato, anche se la documentazione sembra eccellente. Probabilmente lo proverò dopo. Ci sono esempi di progetti di chat che sembrano interessanti, il loro uso pesante di protocolli mi ha inizialmente scoraggiato come un principiante Clojure dev.

Pro (6):

• documentazione ! Come tutti i progetti funcool, il documento è molto piacevole da leggere.
• sintassi di routing simile a piedistallo
• dovrebbe essere performante (sopra Ratpack)
• contropressione
• websocket, sse, cors, security, ssl ...
• caratteristiche uniche da scavare: postale

Contro (2):

• Non sono completamente sicuro di quanto sia piacevole la sintassi ct / route e di abbandonare la specifica Ring (presumibilmente per la storia asincrona, ma pensavo che i ragazzi del piedistallo lo avessero risolto)
• Non sono sicuro di come si integrerebbe la spavalderia ecc.
• quando l'ho provato, non sono riuscito a farlo funzionare immediatamente

Nota : è disponibile un benchmark dei server Web Clojure , se le prestazioni non elaborate sono tutto ciò che conta.

In questi giorni il piedistallo è un quadro degno di nota. È un framework lato server che si basa su Ring , ma libera anche la richiesta in arrivo dal thread iniziale essendo in grado di mettere in pausa e riprendere quella particolare richiesta (altrimenti una richiesta lenta in realtà blocca quel serverthread). Forse un po 'come un JavaBean.

Altri fantastici framework sono hoplon.io e Om di David Nolen (basato su React)

Webjure , un framework di programmazione web per Clojure.

Caratteristiche: Il servlet di invio chiama le funzioni Clojure. Generazione HTML dinamica. Interfaccia di query SQL (tramite JDBC).

Questa risposta è intesa come segnaposto per le informazioni Webjure.

Compojure è quello che ho usato per creare una piccola applicazione di blog. È modellato su Sinatra, che è un framework web minimale e leggero per Ruby. Ho usato principalmente il routing, che è proprio come Sinatra. Sembra:

(GET "/post/:id/:slug"
  (some-function-that-returns-html :id :slug))

Non esiste una libreria ORM o di template, ma ha funzioni che trasformano i vettori in HTML.

Puoi anche dare un'occhiata a questi framework (presi da disclojure / progetti ):

• Cascata
• Evocare

C'è anche un'altra domanda correlata su Stack Overflow: i framework web di Clojure maturo?

Disclaimer: sono l'autore.

Ho messo insieme un modello di leiningen che combina modelli di luminusweb e castagne. Quindi ottieni qualcosa con cui puoi costruire codice clojure e codice clojurescript per front e backend.
Inoltre fornisce la gestione degli utenti oltre a una semplice generazione di CRUD e altri piccoli e carini: https://github.com/sveri/closp

Getterò i miei due centesimi per Duct , anche da @weavejester , il manutentore di Compojure e Ring.

Alla base, porta Component e il router Ring sotto lo stesso tetto. Ragioni per cui utilizzo Duct:

• Eccellente base filosofica: ti incoraggia a costruire la tua app come una serie di piccoli componenti e trova un buon equilibrio tra mantenere alcune opinioni e fornire impostazioni predefinite sane.
• Percorso stabile: parlo da solo, ma nel corso degli anni ho sentito che la comunità Clojure ha presentato uno schema web poco credibile dopo l'altro. Una coppia si è semplicemente sentita troppo sperimentale (la mia esperienza con Om e il piedistallo lato client) per "fare le cose" (non che non si dimostreranno superiori lungo la strada). D'altra parte, mi sento come se @weavejester abbia portato la stessa stabilità e misurato i progressi a Duct che ha fatto a Compojure e Ring, che sono nati in modo superbo nella comunità.
• È super leggero e fuori dai miei componenti.

Caratteristiche principali:

• Organizza le rotte per "endpoint", piccoli componenti che puoi immaginare come mini server web (o piccole sezioni trasversali delle tue rotte HTTP).
• Supporto immediato per il flusso di lavoro ricaricato .
• Perfetta integrazione con Ring e Compojure.
• Configurazioni di sviluppo e produzione (qualcosa che ho trovato evidentemente mancante altrove).
• Buona documentazione con esempi.

Nota: Va da sé, ma a beneficio dei neofiti dello sviluppo web, come la maggior parte delle cose di Clojurey, Duct richiede una solida conoscenza della lingua di Clojure. Consiglio anche di leggere prima il componente.

In un'altra nota personale, sto usando Duct in diverse applicazioni di produzione da oltre un anno e ne sono estremamente soddisfatto.

puoi anche provare Clojure su bobine, http://github.com/zubairq/coils - disclaimer: sono l'autore

Un altro server web interessante è Http-kit . Ha buone prestazioni, è conforme agli anelli e ha supporto anche per i WebSocket. È fatto principalmente in clojure e manca alcune delle cose strane in Jetty / Tomcat.

È facile armeggiare.

Reframe e om.next probabilmente quello che stai cercando.

Arachne è un nuovo framework web. Citando la descrizione del sito:

Arachne è un framework di sviluppo web completo e altamente modulare per Clojure. Sottolinea facilità, semplicità e un design solido e scalabile.

Ha una campagna kickstarter che afferma di offrire un'esperienza di "avvio" simile a Rails. È sviluppato da un Cognitect.

Ecco una buona discussione a riguardo con l'autore di Luminus (yogthos).

Uso Liberator con successo nella produzione da un po 'di tempo. È un ottimo framework se vuoi solo le ossa nude, ad esempio se stai costruendo un servizio web RESTful o qualcosa di simile. È essenzialmente un wrapper per ring e compojure e fornisce un grafico decisionale durante la convalida delle richieste in arrivo. È anche estremamente veloce rispetto ad altri framework Web più voluminosi. Se vuoi iniziare da qualche parte velocemente e costruire lentamente, Liberator è un'ottima scelta.