¿Cómo se hace una aplicación web en Clojure? [cerrado]

Supongo que esta es una pregunta extraña para la gran mayoría de los programadores que trabajan diariamente con Java. Yo no. Sé Java-the-language, porque trabajé en proyectos Java, pero no Java-the-world. Nunca hice una aplicación web desde cero en Java. Si tengo que hacerlo con Python, Ruby, sé a dónde ir (Django o Rails), pero si quiero hacer una aplicación web en Clojure, no porque me vean obligado a vivir en un mundo Java, sino porque me gusta el lenguaje y quiero probarlo, ¿qué bibliotecas y marcos debo usar?

Con mucho, el mejor marco web de Clojure que he encontrado es Compojure: http://github.com/weavejester/compojure/tree/master

Es pequeño pero potente y tiene una sintaxis bellamente elegante. (Utiliza Jetty debajo del capó, pero te oculta la API de Servlet a menos que lo desees, lo cual no será frecuente). Mire el archivo README en esa URL, luego descargue una instantánea y comience a jugar.

Compojure ya no es un marco completo para desarrollar aplicaciones web. Desde la versión 0.4, el componente se ha dividido en varios proyectos.

Ring proporciona la base al abstraer la solicitud HTTP y el proceso de respuesta. Ring analizará la solicitud entrante y generará un mapa que contiene todas las partes de la solicitud, como uri, nombre del servidor y método de solicitud. La aplicación manejará la solicitud y, en función de la solicitud, generará una respuesta. Una respuesta se representa como un mapa que contiene las siguientes claves: estado, encabezados y cuerpo. Entonces una aplicación simple se vería así:

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

Otra parte de Ring es el concepto de middleware. Este es el código que se encuentra entre el controlador y la solicitud entrante y / o la respuesta saliente. Algunos construidos en middleware incluyen sesiones y stacktrace. El middleware de la sesión agregará: clave de sesión al mapa de solicitud que contiene toda la información de la sesión para el usuario que realiza la solicitud. Si la clave: sesión está presente en el mapa de respuesta, se almacenará para la próxima solicitud realizada por el usuario actual. Mientras que el middleware de seguimiento de pila capturará cualquier excepción que ocurra mientras procesa la solicitud y generará un seguimiento de pila que se envía de vuelta como respuesta si se produce alguna excepción.

Trabajar directamente con Ring puede ser tedioso, por lo que Compojure se basa en Ring abstrayendo los detalles. La aplicación ahora se puede expresar en términos de enrutamiento para que pueda tener algo como esto:

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

Compojure sigue trabajando con los mapas de solicitud / respuesta para que siempre pueda acceder a ellos si es necesario:

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

En este caso, la parte {uri: uri} accede a la clave: uri en el mapa de solicitud y establece uri en ese valor.

El último componente es Hiccup, lo que facilita la generación del html. Las diversas etiquetas html se representan como vectores con el primer elemento que representa el nombre de la etiqueta y el resto es el cuerpo de la etiqueta. "<h2>A header</h2>"se convierte [:h2 "A Header"]. Los atributos de una etiqueta están en un mapa opcional. "<a href='/login'>Log In Page</a>"se convierte [:a {:href "/login"} "Log In Page"]. Aquí hay un pequeño ejemplo usando una plantilla para generar el 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)))

Aquí hay un enlace a un borrador de una documentación que el autor del compuesto está redactando actualmente y que puede resultarle útil: Doc. Compojure

También hay "Noir" ( http://www.webnoir.org/ ), que es un nuevo marco web de Clojure (tan nuevo que los documentos aún no están allí). Viniendo de Django / Rails, excavo la sintaxis simple y directa y es bastante simple.

Considere el marco web de Luminus . No tengo afiliación pero he escuchado cosas buenas de amigos a los que respeto.

Mi biblioteca web actual es ahora yada .

Si recién está comenzando, el servidor introductorio es Compojure. Lo veo como el apachede los servidores web en el mundo de Clojure (en cuyo caso yada / aleph sería nginx). Podrías usar Luminuscomo plantilla. Hay variantes de eso, como compojure-api.

Lo intenté Pedestaly estuve globalmente satisfecho con eso. No pretendo dominarlo, pero tiene una sintaxis agradable, se siente muy coherente y parece que tiene un gran rendimiento. También está respaldado por Cognitect(la compañía Clojure / Datomic donde trabaja Rich Hickey).

Descubrí Alephque presentaba una abstracción interesante, y la contrapresión incorporada parece interesante. Todavía tengo que jugar con él, pero definitivamente está en mi lista.

Después de jugar un poco con varios servidores web, aquí está mi lista rápida de Pro / Contras:

Respuesta corta: eche un vistazo a Luminus para comenzar rápidamente, tal vez pasar a otra cosa a medida que sus necesidades evolucionen (Yada tal vez).

Compojure

• Pros (1):

  • fácil, muchas plantillas / ejemplos (ej. Luminous)

• Contras (2):

  • No funciona (un hilo por solicitud), espera un rendimiento ligeramente mejor que los rieles
  • No es simple, el modelo de middleware tiene inconvenientes

Pedestal

• Pros (3):

  • modelo de interceptor, sintaxis agradable para agregar interceptores a un subconjunto de rutas
  • enrutador de rendimiento
  • admite formularios json / transit / multipart de forma transparente, sin preguntar nada. Muy genial !

• Contras (4):

  • no es compatible con websocket (todavía), devolver canales core.async sería bueno
  • un poco lento para recargar si lo coloca en un componente de Stuart Sierra (creo que se supone que debe usar el interceptor de recarga)
  • no hay instalaciones de prueba para interceptores asíncronos
  • requiere compra (?)

Aleph

Pro (3):

• Performante
• contrapresión
• Soporte de Websocket / SSE al devolver una secuencia múltiple

Contras (1):

• Nivel bajo, hágalo usted mismo al estilo (es decir, solo le da una forma de hacer que sus controladores hagan algo. Sin enrutador, sin nada). No es realmente una desventaja, solo ten en cuenta.

Yada

Pro (3):

• construido sobre Aleph
• negociación de contenido
• integración de arrogancia
• bidi está bastante bien (aunque me gusta más la sintaxis del enrutador de pedestal)

Contras (1):

• documentación (aunque no tan mala como nginx-clojure, que mejora rápidamente).

HttpKit

Pro (2):

• Escrito en Clojure! (y Java ...)
• el rendimiento se ve bien (vea la publicación de conexiones concurrentes 600K)

Contras (2):

• Sin soporte CORS
• Bichos? Además, no hay muchas confirmaciones recientes

Nginx-Clojure

Nota: no he jugado con él, principalmente debido a la falta de documentación. Sin embargo, parece interesante y muy eficaz.

Pros (2):

• Nginx (performant, descargar ssl, reiniciar trabajadores ...)
• ¿Podría este modelo permitir actualizaciones de tiempo de inactividad cero? ¡Eso sería genial!

Contras (1):

• Documentación (mejorando). Además, no quiero programar en cadenas incrustadas en un archivo de configuración nginx si esa es la única forma de hacerlo.
• Probablemente complica un poco el primer despliegue (?)

Inmutante

Nota: no he jugado con eso.

Pros:

• integrado (almacenamiento en caché, mensajería, programación, implementación de wildfly)

Contras :

• sin cliente http

Catacumba

Nota: no he jugado con él, aunque la documentación se ve excelente. Probablemente voy a intentarlo a continuación. Hay ejemplos de proyectos de chat que parecen interesantes, su uso intensivo de protocolos me desanimó al principio como desarrollador novato de Clojure.

Pros (6):

• documentación! Como todos los proyectos de funcool, el documento es muy agradable de leer.
• sintaxis de enrutamiento tipo pedestal
• debe ser eficiente (encima de Ratpack)
• contrapresión
• websockets, sse, cors, seguridad, ssl ...
• características únicas para excavar: postal

Contras (2):

• No estoy completamente seguro de cuán agradable es la sintaxis de ct / routes, y de deshacerse de la especificación Ring (supuestamente para la historia asincrónica, pero pensé que los chicos del pedestal lo arreglaron)
• No estoy seguro de cómo se integraría la arrogancia, etc.
• cuando lo probé, no pude hacerlo funcionar de inmediato

Nota : un punto de referencia de los servidores web Clojure está disponible, si el rendimiento bruto es lo único que importa

En estos días, Pedestal es un marco que vale la pena ver. Es un marco del lado del servidor que se basa en Ring , pero también libera la solicitud entrante del subproceso inicial al poder pausar y reanudar esa solicitud en particular (de lo contrario, una solicitud lenta realmente bloquea ese subproceso de servidor). Tal vez algo así como un JavaBean.

Otros frameworks geniales son hoplon.io y David Nolen's Om (basado en React)

Webjure , un marco de programación web para Clojure.

Características: El servlet de envío llama a las funciones de Clojure. Generación dinámica de HTML. Interfaz de consulta SQL (a través de JDBC).

Esta respuesta se entiende como un marcador de posición para la información de Webjure.

Compojure es lo que solía construir una pequeña aplicación de blogs. Está modelado en Sinatra, que es un marco web mínimo y liviano para Ruby. La mayoría de las veces solo usé el enrutamiento, que es como el de Sinatra. Parece que:

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

No hay una biblioteca de plantillas o ORM, pero tiene funciones que convierten los vectores en HTML.

También puede ver estos marcos (tomados de disclojure / projects ):

• cascada
• Conjurar

También hay una pregunta más relacionada sobre Stack Overflow: ¿marcos web maduros de Clojure?

Descargo de responsabilidad: soy el autor.

Creé una plantilla de leiningen que combina plantillas de luminusweb y castaño. Entonces obtienes algo con lo que puedes construir código clojure y código clojurescript para front y backend.
Además, proporciona administración de usuarios más una generación simple de CRUD y algunos más pequeños y agradables: https://github.com/sveri/closp

Pondré mis dos centavos para Duct , también de @weavejester , el responsable de Compojure y Ring.

En esencia, trae el componente y el enrutador de anillo bajo un mismo techo. Razones por las que uso Duct:

• Excelente base filosófica: lo alienta a crear su aplicación como una serie de componentes pequeños, y logra un buen equilibrio entre mantener pocas opiniones y proporcionar valores predeterminados razonables.
• Camino estable: hablo por mí mismo, pero a lo largo de los años he sentido que la comunidad Clojure ha presentado un marco web poco creíble tras otro. Una pareja simplemente se sintió demasiado experimental (mi experiencia con Om y el Pedestal del lado del cliente) para "hacer las cosas" (no es que no demuestren ser superiores en el futuro). Por otro lado, siento que @weavejester ha traído a Duct la misma estabilidad y el progreso medido que hizo a Compojure y Ring, que han nacido magníficamente en la comunidad.
• Es súper liviano y está fuera del alcance de mis componentes.

Características principales:

• Organiza rutas por "puntos finales", pequeños componentes que puede considerar como mini servidores web (o pequeñas secciones transversales de sus rutas HTTP).
• Compatibilidad inmediata con el flujo de trabajo recargado .
• Perfecta integración con Ring y Compojure.
• Configuraciones de desarrollo y producción (algo que he encontrado notablemente perdido en otro lugar).
• Buena documentación con ejemplos.

Nota: No hace falta decirlo, pero para beneficio de los recién llegados al desarrollo web, como la mayoría de las cosas de Clojurey, Duct requiere una comprensión sólida de Clojure el lenguaje. También recomiendo leer sobre Componente primero.

En otra nota personal, he estado usando Duct en varias aplicaciones de producción durante más de un año y estoy extremadamente contento con él.

también puede probar Clojure en bobinas, http://github.com/zubairq/coils - descargo de responsabilidad: soy el autor

Otro servidor web interesante es Http-kit . Tiene buen rendimiento y cumple con los requisitos de anillo, y también tiene soporte para WebSockets. Está hecho principalmente en clojure, y carece de algunas de las cosas extrañas en Jetty / Tomcat.

Es fácil jugar con ellos.

Reformule y om.next probablemente lo que está buscando.

Aracne es un marco web recién llegado. Citando la descripción del sitio:

Arachne es un marco de desarrollo web completo y altamente modular para Clojure. Enfatiza la facilidad, la simplicidad y un diseño sólido y escalable.

Tiene una campaña de kickstarter que dice ofrecer una experiencia de "inicio" similar a Rails. Está desarrollado por un Cognitect.

Aquí hay una buena discusión al respecto con el autor de Luminus (yogthos).

He estado usando Liberator con éxito en la producción durante un tiempo. Es un gran marco de trabajo si solo quieres lo básico, por ejemplo, si estás creando un servicio web RESTful o algo similar. Es esencialmente un contenedor para anillo y composición y proporciona un gráfico de decisión al validar las solicitudes entrantes. También es extremadamente rápido en comparación con otros frameworks web más voluminosos. Si desea comenzar en algún lugar rápido y construir lentamente, entonces Liberator es una excelente opción.