mustache.java

Estado de compilación de Moustache.java

Moustache.java no está diseñado para permitir que partes que no son de confianza proporcionen plantillas. Es posible bloquearlo para proporcionarlo de forma segura, pero de forma predeterminada NO ES SEGURO. Utilice SafeMustacheFactory y incluya en la lista blanca todas las plantillas y parciales.

A partir de la versión 0.9.0, mustache.java ahora es solo Java 8. Para compatibilidad con Java 6/7, utilice 0.8.x.

No hay dependencias externas y la biblioteca del compilador es de ~100k.

Moustache.java es un derivado de bigote.js.

Hay un grupo de Google para soporte y preguntas: http://groups.google.com/group/mustachejava

CI de Github: https://github.com/spullara/mustache.java/actions/workflows/maven.yml

Documentación API: http://spullara.github.io/mustache/apidocs/

Mayor implementación de producción de Moustache.java:

• Twitter (el sitio web, correo electrónico, widgets distribuidos, etc.)

Gracias a YourKit por muchas mejoras de rendimiento:

YourKit apoya amablemente el proyecto de código abierto mustache.java con su Java Profiler con todas las funciones. YourKit, LLC es el creador de herramientas innovadoras e inteligentes para crear perfiles de aplicaciones Java y .NET. Eche un vistazo a los productos de software líderes de YourKit:

• Perfilador Java YourKit
• Perfilador YourKit .NET

Solicitud de contribuciones:

• Puntos de referencia del mundo real que importan: actualmente, los puntos de referencia se basan en plantillas de Twitter
• Documentación
• Informes/correcciones de errores
• Comentarios de API
• Optimizaciones

Documentación:

• Javadocs
• manual de bigote.js
• Pasa todas las pruebas de especificación de mustache , diferencias de módulo de espacios en blanco
• La mayor diferencia entre mustache.js y mustache.java es la evaluación concurrente opcional
• Los datos son proporcionados por objetos en una variedad de ámbitos y se accede a ellos a través de campos, métodos o mapas no privados.
• Cualquier Iterable se puede utilizar para comportamientos similares a listas.
• Devolver un Callable permite la evaluación simultánea si se configura un ExecutorService
• Esta implementación admite la herencia de plantillas; consulte bigote/especificación n.º 38 (p. ej., {{<super}}{{$content}}...{{/content}}{{/super}} )
• Funciones/lambdas adicionales (por ejemplo, {{#func1}}...{{/func1}} ) se implementan utilizando Function de Java 8 (post-sustitución)
• Utilice TemplateFunction si desea que mustache.java analice los resultados de su función/lambda (pre-sustitución)
• Se admiten raíces de plantilla basadas en el sistema de archivos y en la ruta de clases predeterminadas y configuradas manualmente.
• Está disponible una versión compilada e invocada dinámicamente. Las mejoras de rendimiento suelen ser específicas de la aplicación.
• El servidor handlebar representará plantillas + datos json para que los diseñadores realicen maquetas rápidas de plantillas.
• Sistema completamente conectable para anular casi todo el comportamiento en el proceso de compilación y renderizado.
• Puede extraer datos de muestra de sistemas activos utilizando CapturingMustacheVisitor para simulacros y pruebas.
• DecoratedCollection puede proporcionar el primer/último/índice de los elementos de una colección.
• La llamada invert puede tomar texto y una plantilla y resolver los datos.

Actuación:

• Consulte el paquete com.github.mustachejavabenchmarks en el módulo compiler
• Compila más de 4000 plantillas timeline.html por segundo por núcleo
• Representa más de 3000 de 50 líneas de tiempo de tweets por segundo por núcleo en hardware Macbook Pro/MacPro 2011
• El nuevo módulo codegen genera código para guardias y bigotes
• El módulo indy utiliza el módulo codegen e invokedynamic para compilar plantillas hasta el código de bytes.

Sugerencias de construcción:

• No construyas, usa dependencias de Maven
• Si debe construir pero no probar:
  • clon de git https://github.com/spullara/mustache.java.git
  • configura tu JAVA_HOME en un JDK 8 JDK
  • mvn -DskipTests instalación limpia
• Si debe construir y probar pero no comparar:
  • CI=1 mvn instalación limpia -pl :compilador -am
• Si debe construir, probar y comparar:
  • instalación limpia de mvn

Información de dependencia de Maven (es decir, para los casos más comunes, solo necesitará el módulo compiler ):

Java 8+:

< dependency >
  < groupId >com.github.spullara.mustache.java</ groupId >
  < artifactId >compiler</ artifactId >
  < version >0.9.10</ version >
</ dependency >

Java 6/7:

< dependency >
  < groupId >com.github.spullara.mustache.java</ groupId >
  < artifactId >compiler</ artifactId >
  < version >0.8.18</ version >
</ dependency >

Archivo de plantilla de ejemplo:

 {{#items}}
Name: {{name}}
Price: {{price}}
  {{#features}}
  Feature: {{description}}
  {{/features}}
{{/items}}

Podría funcionar con algún código de respaldo:

 public class Context {
  List < Item > items () {
    return Arrays . asList (
      new Item ( "Item 1" , "$19.99" , Arrays . asList ( new Feature ( "New!" ), new Feature ( "Awesome!" ))),
      new Item ( "Item 2" , "$29.99" , Arrays . asList ( new Feature ( "Old." ), new Feature ( "Ugly." )))
    );
  }

  static class Item {
    Item ( String name , String price , List < Feature > features ) {
      this . name = name ;
      this . price = price ;
      this . features = features ;
    }
    String name , price ;
    List < Feature > features ;
  }

  static class Feature {
    Feature ( String description ) {
       this . description = description ;
    }
    String description ;
  }
}

Y resultaría en:

 Name: Item 1
Price: $19.99
  Feature: New!
  Feature: Awesome!
Name: Item 2
Price: $29.99
  Feature: Old.
  Feature: Ugly.

La evaluación de la plantilla se realiza en serie. Por ejemplo, si tiene un código de bloqueo dentro de una de sus devoluciones de llamada, el sistema se detendrá mientras las ejecuta:

 static class Feature {
  Feature ( String description ) {
    this . description = description ;
  }

  String description () throws InterruptedException {
    Thread . sleep ( 1000 );
    return description ;
  }
}

Si cambia la descripción para devolver un Callable , se ejecutará automáticamente en un hilo separado si proporcionó un ExecutorService cuando creó su MustacheFactory .

 Callable < String > description () throws InterruptedException {
  return new Callable < String >() {

    @ Override
    public String call () throws Exception {
      Thread . sleep ( 1000 );
      return description ;
    }
  };
}

Esto permite tareas programadas, comportamiento de transmisión y E/S asincrónicas. Consulte el módulo example para ver un ejemplo completo de un extremo a otro:

 package mustachejava ;

import com . github . mustachejava . DefaultMustacheFactory ;
import com . github . mustachejava . Mustache ;
import com . github . mustachejava . MustacheFactory ;

import java . io . IOException ;
import java . io . PrintWriter ;
import java . io . Writer ;
import java . util . Arrays ;
import java . util . List ;

public class Example {

  List < Item > items () {
    return Arrays . asList (
      new Item ( "Item 1" , "$19.99" , Arrays . asList ( new Feature ( "New!" ), new Feature ( "Awesome!" ))),
      new Item ( "Item 2" , "$29.99" , Arrays . asList ( new Feature ( "Old." ), new Feature ( "Ugly." )))
    );
  }

  static class Item {
    Item ( String name , String price , List < Feature > features ) {
      this . name = name ;
      this . price = price ;
      this . features = features ;
    }

    String name , price ;
    List < Feature > features ;
  }

  static class Feature {
    Feature ( String description ) {
      this . description = description ;
    }

    String description ;
  }

  public static void main ( String [] args ) throws IOException {
    MustacheFactory mf = new DefaultMustacheFactory ();
    Mustache mustache = mf . compile ( "template.mustache" );
    mustache . execute ( new PrintWriter ( System . out ), new Example ()). flush ();
  }
}

Un enfoque alternativo para proporcionar variables sería utilizar un objeto Map, como:

  public static void main ( String [] args ) throws IOException {
    HashMap < String , Object > scopes = new HashMap < String , Object >();
    scopes . put ( "name" , "Mustache" );
    scopes . put ( "feature" , new Feature ( "Perfect!" ));

    Writer writer = new OutputStreamWriter ( System . out );
    MustacheFactory mf = new DefaultMustacheFactory ();
    Mustache mustache = mf . compile ( new StringReader ( "{{name}}, {{feature.description}}!" ), "example" );
    mustache . execute ( writer , scopes );
    writer . flush ();
  }

Licencia