Comment faire une application web à Clojure? [fermé]

Question

Je suppose que cette question est étrange pour la grande majorité des programmeurs travaillant quotidiennement avec Java. Je ne. Je connais le langage Java, car j'ai travaillé sur des projets Java, mais pas Java le monde. Je n'ai jamais créé une application Web à partir de zéro en Java. Si je dois le faire avec Python, Ruby, je sais où aller (Django ou Rails), mais si je veux créer une application Web dans Clojure, non pas parce que je suis obligé de vivre dans un monde Java, mais parce que comme la langue et je veux essayer, quelles bibliothèques et quels frameworks dois-je utiliser?

Answer 1

Le meilleur framework web Clojure que j'ai rencontré à ce jour est Compojure: http: // github. com / weavejester / compojure / tree / master

Il est petit mais puissant et sa syntaxe est élégante et élégante. (Il utilise Jetty sous le capot, mais il cache l’API Servlet à moins que vous ne le souhaitiez, ce qui ne sera pas souvent le cas). Allez regarder le fichier README à cette URL, puis téléchargez un instantané et commencez à jouer.

Answer 2

Compojure n'est plus un cadre complet pour développer des applications Web. Depuis la publication de la version 0.4, Compojure a été divisé en plusieurs projets.

Ring fournit les bases en résumant le processus de requête et de réponse HTTP. Ring analysera la requête entrante et générera une carte contenant toutes les parties de la requête, telles que l'URI, le nom du serveur et la méthode de la requête. L'application traitera ensuite la demande et générera une réponse sur la base de la demande. Une réponse est représentée sous forme de carte contenant les clés suivantes: statut, en-têtes et corps. Donc, une application simple ressemblerait à ceci:

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

Un autre élément de Ring est le concept de middleware. Ce code se situe entre le gestionnaire et la demande entrante et / ou la réponse sortante. Certains middle-ware intégrés incluent des sessions et stacktrace. L'intermédiaire de session ajoutera une clé: session à la mappe de requête contenant toutes les informations de session de l'utilisateur à l'origine de la requête. Si la clé: session est présente dans la mappe de réponse, elle sera stockée pour la prochaine requête de l'utilisateur actuel. Alors que le middleware de trace de pile capturera toutes les exceptions qui se produisent lors du traitement de la demande et générera une trace de pile qui sera renvoyée comme réponse si des exceptions se produisent.

Travailler directement avec Ring peut s'avérer fastidieux. Compojure est construit au-dessus de Ring pour supprimer les détails. L'application peut maintenant être exprimée en termes de routage afin que vous puissiez avoir quelque chose comme ceci:

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

Compojure fonctionne toujours avec les mappes demande / réponse afin que vous puissiez toujours y accéder si nécessaire:

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

Dans ce cas, la partie {uri: uri} accède à la clé: uri dans la mappe de requête et définit uri sur cette valeur.

Le dernier composant est Hiccup , ce qui facilite la génération du code HTML. Les différentes balises html sont représentées sous forme de vecteurs, le premier élément représentant le nom de la balise et le reste constituant le corps de la balise. "<h2>A header</h2>" devient [:h2 "A Header"]. Les attributs d'une balise sont dans une carte facultative. "<a href='/login'>Log In Page</a>" devient [:a {:href "/login"} "Log In Page"]. Voici un petit exemple d'utilisation d'un modèle pour générer le code 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)))

Voici un lien vers un brouillon de la documentation en cours de rédaction par l'auteur de compojure qui pourrait vous être utile: Document de synthèse

Answer 3

Il y a aussi " Noir " ( http://www.webnoir.org/ ), qui est un nouveau cadre Web Clojure (donc le nouveau les documents ne sont pas encore là). Venant de Django / Rails, j’ai creusé avec une syntaxe simple et directe, c’est plutôt maigre.

Answer 4

Considérez le cadre Web Luminus . Je n'ai aucune affiliation, mais j'ai entendu de bonnes choses d'amis que je respecte.

Answer 5

My current go-to web library is now yada.

If you are just starting out, the introductory server is Compojure. I see it as the apache of web servers in the Clojure world (in which case yada/aleph would be nginx). You could use Luminus as a template. There are variants of it, like compojure-api.

I tried ou Pedestal and was globally satisfied with it. I don't claim to master it, but it has a pleasant syntax, feels very cohesive, and looks like it does have great performance. It is also backed by Cognitect (the Clojure/Datomic company where Rich Hickey works).

I found Aleph to present an interesting abstraction, and the built-in backpressure seems interesting. I have yet to play with it, but it's definitely on my list.

After playing a bit with various web servers, here is my quick Pro/Cons list :

Short answer : have a look at Luminus to get started quickly, maybe move on to something else as your needs evolve (Yada maybe).

Compojure

• Pros (1):

  • easy, lots of templates/examples (ex. Luminous)

• Cons (2):

  • Not performant (a thread per request), expect performances slightly better than rails
  • Not simple, the middleware model has inconvenients

Pedestal

• Pros (3):

  • interceptor model, pleasant syntax to add interceptors to a subset of routes
  • performant router
  • supports json/transit/multipart forms transparently out of the box, without asking anything. Very cool !

• Cons (4):

  • no websocket support (yet), returning core.async channels would be nice
  • a bit slow to reload if putting it in a Stuart Sierra's component (I think you are supposed to use the reload interceptor)
  • no testing facility for async interceptors
  • requires buy-in (?)

Aleph

Pro (3):

• Performant
• backpressure
• Websocket/SSE support when returning a manifold stream

Cons (1):

• Low level, do it yourself style (ie. it just gives you a way to make your handlers do something. No router, no nothing). Not really a cons, just be aware of it.

Yada

Pro (3):

• built on Aleph
• content negociation
• swagger integration
• bidi is quite ok (though I like pedestal router syntax better)

Cons (1):

• documentation (although not as bad as nginx-clojure, quickly improving).

HttpKit

Pro (2):

• Written in Clojure ! (and Java...)
• performance looks good (see the 600K concurrent connections post)

Cons (2):

• No CORS support
• Bugs ? Also, not a lot of recent commits

Nginx-Clojure

Note : I haven't played with it, mainly because of the lack of documentation. It looks interesting though, and very performant.

Pros (2):

• Nginx (performant, offload ssl, restart workers...)
• Could this model allow zero-downtime updates ? That would be so awesome !

Cons (1):

• Documentation (improving). Also, I don't want to program in strings embedded in an nginx config file if that is the only way to do it.
• Probably complicates a bit the first deployment (?)

Immutant

Note : I haven't played with it.

Pros :

• integrated (caching, messaging, scheduling, wildfly deploy)

Cons :

• no http client

Catacumba

Note : I haven't played with it, although the documentation looks excellent. I am probably going to try it next. There are example chat projects that look interesting, their heavy use of protocols put me off at first as a novice Clojure dev.

Pros (6):

• documentation ! Like all funcool projects, the doc is very pleasant to read.
• pedestal-like routing syntax
• should be performant (on top of Ratpack)
• backpressure
• websockets, sse, cors, security, ssl...
• unique features to dig : postal

Cons (2):

• Not completely sure about how pleasant the ct/routes syntax is, and about ditching the Ring spec (supposedly for the async story, but I thought the pedestal guys fixed that)
• Not sure how one would integrate swagger etc.
• when I tried it, I was not able to make it work straight away

Note : a benchmark of Clojure web servers is available, if raw performance is all that matters.

Answer 6

These days Pedestal is a framework worth a look. It's a server-side framework that builds on top of Ring, but also frees the incoming request from the initial thread by being able to pause and resume that particular request (otherwise a slow request actually block that serverthread). Maybe sort of like a JavaBean.

Other cool frameworks are hoplon.io and David Nolen's Om (based on React)

Answer 7

Webjure, a web programming framework for Clojure.

Features: Dispatch servlet calls Clojure functions. Dynamic HTML generation. SQL query interface (through JDBC).

This answer is meant as a placeholder for Webjure information.

Answer 8

Compojure's what I used to build a tiny blogging application. It's modeled on Sinatra, which is a minimal, light-weight web framework for Ruby. I mostly just used the routing, which is just like Sinatra's. It looks like:

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

There's no ORM or templating library, but it does have functions that turn vectors into HTML.

Answer 9

You can also have look at these frameworks (taken from disclojure/projects):

• Cascade
• Conjure

There is also one more related question on Stack Overflow: Mature Clojure web frameworks?

Answer 10

Disclaimer: I am the author.

I put together a leiningen template which combines luminusweb and chestnut templates. So you get something that you can build clojure code with and clojurescript code for front and backend.
Additionally it provides user management plus some simple CRUD generation and some more small nice to haves: https://github.com/sveri/closp

Answer 11

I'll throw in my two cents for Duct, also from @weavejester, the maintainer of Compojure and Ring.

At it's core, it brings Component and the Ring router under one roof. Reasons why I use Duct:

• Excellent philosophical foundation: it encourages you to build your app as a series of small components, and it strikes a nice balance between holding few opinions while providing sane defaults.
• Stable path: I speak for myself, but over the years I've felt that the Clojure community has presented one less-than-credible web framework after another. A couple simply felt too experimental (my experience with Om and client-side Pedestal) for "getting things done" (not that they won't prove superior down the road). On the other hand, I feel like @weavejester has brought the same stability and measured progress to Duct that he did to Compojure and Ring, which have been superbly born out in the community.
• It's super lightweight, and out of the way of my components.

Major features:

• Organizes routes by "endpoints", small components that can you can think of as mini web servers (or, small cross sections of your HTTP routes).
• Out-of-the-box support for the Reloaded Workflow.
• Perfect integration with Ring and Compojure.
• Development and production configurations (something I've found conspicuously missing elsewhere).
• Good documentation with examples.

Note: It goes without saying, but for the benefit of web development newcomers, like most Clojurey things Duct requires a solid grasp of Clojure the language. I also recommend reading about Component first.

On another personal note, I've been using Duct in several production applications for over a year now and am extremely happy with it.

Answer 12

you can also try Clojure on Coils, http://github.com/zubairq/coils - disclaimer: I am the author

Answer 13

Another interesting webserver is Http-kit. It has good performance and is ring compliant, and has support for WebSockets as well. It is made mostly in clojure, and lacks some of the strange things in Jetty/Tomcat.

It's easy to tinker with.

Answer 14

Reframe and om.next probably what you are looking for.

Answer 15

Arachne is a newcomer web framework. Quoting the site's description:

Arachne is a full, highly modular web development framework for Clojure. It emphasizes ease, simplicity, and a solid, scalable design.

It has a kickstarter campaign claiming to offer a "getting started" experience similar to Rails. It is developed by a Cognitect.

Here is a good discussion about it with the author of Luminus (yogthos).

Answer 16

I've been using Liberator successfully in production for a while now. It's a great framework if you want just the bare bones e.g. if you're building a RESTful web service or something similar. It's essentially a wrapper for ring and compojure and provides a decision graph when validating incoming requests. It's also extremely fast compared to other more bulky web frameworks. If you want to start somewhere fast and slowly build out then Liberator is a great choice.