Motores de modelo para a primavera

1. Visão geral

A estrutura da Web Spring é construída em torno do padrão MVC (Model-View-Controller), o que facilita a separação de preocupações em um aplicativo. Isso permite a possibilidade de usar diferentes tecnologias de visualização, desde a bem estabelecida tecnologia JSP até uma variedade de mecanismos de modelo.

Neste artigo, vamos dar uma olhada nos principais motores de template que podem ser usados com Spring, sua configuração e exemplos de uso.

2. Tecnologias Spring View

Dado que as preocupações em um aplicativo Spring MVC são claramente separadas, a troca de uma tecnologia de visualização para outra é principalmente uma questão de configuração.

Para renderizar cada tipo de visualização, precisamos definir um beanViewResolver correspondente a cada tecnologia. Isso significa que podemos retornar os nomes das visualizações dos métodos de mapeamento@Controller da mesma forma que normalmente retornamos arquivos JSP.

Nas seções a seguir, vamos abordar tecnologias mais tradicionais comoJava Server Pages, bem como os principais mecanismos de template que podem ser usados com Spring:Thymeleaf,Groovy,FreeMarker, Jade.

Para cada um deles, revisaremos a configuração necessária em um aplicativo Spring padrão e em um aplicativo construído usandoSpring Boot.

3. Java Server Pages

O JSP é uma das tecnologias de visualização mais populares para aplicativos Java e é suportado pelo Spring imediatamente. Para renderizar arquivos JSP, um tipo comumente usado de beanViewResolver éInternalResourceViewResolver:

@EnableWebMvc
@Configuration
public class ApplicationConfiguration implements WebMvcConfigurer {
    @Bean
    public ViewResolver jspViewResolver() {
        InternalResourceViewResolver bean = new InternalResourceViewResolver();
        bean.setPrefix("/WEB-INF/views/");
        bean.setSuffix(".jsp");
        return bean;
    }
}

Em seguida, podemos começar a criar arquivos JSP no local/WEB-INF/views:

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

    
        
        User Registration
    
    
        
            Email: 
            
            Password:

Se estivermos adicionando os arquivos a um aplicativoSpring Boot, então, em vez de na classeApplicationConfiguration, podemos definir as seguintes propriedades em um arquivoapplication.properties:

spring.mvc.view.prefix: /WEB-INF/views/
spring.mvc.view.suffix: .jsp

Com base nessas propriedades,Spring Boot irá configurar automaticamente osViewResolver necessários.

4. Thymeleaf

Thymeleaf é um mecanismo de template Java que pode processar arquivos HTML, XML, texto, JavaScript ou CSS. Ao contrário de outros motores de template,Thymeleaf permite o uso de templates como protótipos, o que significa que eles podem ser vistos como arquivos estáticos.

4.1. Dependências do Maven

Para integrarThymeleaf com Spring, precisamos adicionar as dependênciasthymeleafethymeleaf-spring4:


    org.thymeleaf
    thymeleaf
    3.0.7.RELEASE


    org.thymeleaf
    thymeleaf-spring4
    3.0.7.RELEASE

Se tivermos um projeto Spring 3, precisamos adicionarthymeleaf-spring3.

4.2. Configuração da mola

Em seguida, precisamos adicionar a configuração que requer um beanSpringTemplateEngine, bem como um beanTemplateResolver que especifica a localização e o tipo dos arquivos de visualização.

OSpringResourceTemplateResolver é integrado ao mecanismo de resolução de recursos do Spring:

@Configuration
@EnableWebMvc
public class ThymeleafConfiguration {

    @Bean
    public SpringTemplateEngine templateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(thymeleafTemplateResolver());
        return templateEngine;
    }

    @Bean
    public SpringResourceTemplateResolver thymeleafTemplateResolver() {
        SpringResourceTemplateResolver templateResolver
          = new SpringResourceTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML5");
        return templateResolver;
    }
}

Além disso, precisamos de um beanViewResolver do tipoThymeleafViewResolver:

@Bean
public ThymeleafViewResolver thymeleafViewResolver() {
    ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    viewResolver.setTemplateEngine(templateEngine());
    return viewResolver;
}

**4.3. Thymeleaf modelos**

Agora podemos adicionar um arquivo HTML no localWEB-INF/views:


    
        
        User Registration
    
    
        
            Email:
            Password:

Os modelosThymeleaf são muito semelhantes em sintaxe aos modelos HTML.

Alguns dos recursos que estão disponíveis ao usarThymeleaf em um aplicativo Spring são:

suporte para definir o comportamento dos formulários
Ligando Entradas de Formulário a Modelos de Dados
validação para entradas de formulário
exibindo valores de fontes de mensagem
fragmentos do modelo de renderização

Você pode ler mais sobre o uso de modelosThymeleaf em nosso artigoThymeleaf in Spring MVC.

**4.4. Thymeleaf emSpring Boot**

Spring Boot fornecerá configuração automática paraThymeleaf adicionando a dependênciaspring-boot-starter-thymeleaf:


    org.springframework.boot
    spring-boot-starter-thymeleaf
    1.5.6.RELEASE

Nenhuma configuração explícita é necessária. Por padrão, os arquivos HTML devem ser colocados no localresources/templates.

5. FreeMarker

FreeMarker é um mecanismo de modelo baseado em Java construído porApache Software Foundation. Ele pode ser usado para gerar páginas da Web, mas também código fonte, arquivos XML, arquivos de configuração, emails e outros formatos baseados em texto.

A geração é feita com base em arquivos de modelo escritos usandoFreeMarker Template Language.

5.1. Dependências do Maven

Para começar a usar os modelos em nosso projeto, precisamos da dependênciafreemarker:


    org.freemarker
    freemarker
    2.3.23

Para integração Spring, também precisamos da dependênciaspring-context-support:


    org.springframework
    spring-context-support
    4.3.10.RELEASE

5.2. Configuração da mola

IntegrarFreeMarker com Spring MVC requer a definição de um beanFreemarkerConfigurer que especifica a localização dos arquivos de modelo:

@Configuration
@EnableWebMvc
public class FreemarkerConfiguration {

    @Bean
    public FreeMarkerConfigurer freemarkerConfig() {
        FreeMarkerConfigurer freeMarkerConfigurer = new FreeMarkerConfigurer();
        freeMarkerConfigurer.setTemplateLoaderPath("/WEB-INF/views/");
        return freeMarkerConfigurer;
    }
}

Em seguida, precisamos definir um beanViewResolver apropriado do tipoFreeMarkerViewResolver:

@Bean
public FreeMarkerViewResolver freemarkerViewResolver() {
    FreeMarkerViewResolver resolver = new FreeMarkerViewResolver();
    resolver.setCache(true);
    resolver.setPrefix("");
    resolver.setSuffix(".ftl");
    return resolver;
}

**5.3. FreeMarker modelos**

Podemos criar um modelo HTML usandoFreeMarker no localWEB-INF/views:

<#import "/spring.ftl" as spring/>

    
        
        User Registration
    
    
        
            <@spring.bind path="user" />
            Email: <@spring.formInput "user.email"/>
            Password: <@spring.formPasswordInput "user.password"/>

No exemplo acima, importamos um conjunto de macros definidas pelo Spring para trabalhar com formulários emFreeMarker, incluindo entradas de formulário de ligação a modelos de dados.

Além disso, oFreeMarker Template Language contém um grande número de tags, diretivas e expressões para trabalhar com coleções, estruturas de controle de fluxo, operadores lógicos, formatação e análise de strings, números e muitos outros recursos.

**5.4. FreeMarker emSpring Boot**

Em um aplicativoSpring Boot, podemos simplificar a configuração necessária usando a dependênciaspring-boot-starter-freemarker:


    org.springframework.boot
    spring-boot-starter-freemarker
    1.5.6.RELEASE

Este iniciador adiciona a configuração automática necessária. Tudo o que precisamos fazer é começar a colocar nossos arquivos de modelo na pastaresources/templates.

6. Groovy

Visualizações do Spring MVC também podem ser geradas usandoGroovy Markup Template Engine. Esse mecanismo é baseado em uma sintaxe do construtor e pode ser usado para gerar qualquer formato de texto.

6.1. Dependências do Maven

A dependênciagroovy-templates precisa ser adicionada ao nossopom.xml:


    org.codehaus.groovy
    groovy-templates
    2.4.12

6.2. Configuração da mola

A integração deMarkup Template Engine com Spring MVC requer a definição de um beanGroovyMarkupConfigurer e umViewResolver do tipoGroovyMarkupViewResolver:

@Configuration
@EnableWebMvc
public class GroovyConfiguration {

    @Bean
    public GroovyMarkupConfigurer groovyMarkupConfigurer() {
        GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer();
        configurer.setResourceLoaderPath("/WEB-INF/views/");
        return configurer;
    }

    @Bean
    public GroovyMarkupViewResolver thymeleafViewResolver() {
        GroovyMarkupViewResolver viewResolver = new GroovyMarkupViewResolver();
        viewResolver.setSuffix(".tpl");
        return viewResolver;
    }
}

**6.3. Groovy Markup modelos**

Os modelos são escritos na linguagem Groovy e têm várias características:

eles são compilados no bytecode
eles contêm suporte para fragmentos e layouts
eles fornecem suporte para internacionalização
a renderização é rápida

Vamos criar um modelo do Groovy para nosso formulário de "Registro de usuário", que inclui ligações de dados:

yieldUnescaped ''
html(lang:'en') {
    head {
        meta('http-equiv':'"Content-Type" ' +
          'content="text/html; charset=utf-8"')
        title('User Registration')
    }
    body {
        form (id:'userForm', action:'register', method:'post') {
            label (for:'email', 'Email')
            input (name:'email', type:'text', value:user.email?:'')
            label (for:'password', 'Password')
            input (name:'password', type:'password', value:user.password?:'')
            div (class:'form-actions') {
                input (type:'submit', value:'Submit')
            }
        }
    }
}

**6.4. Groovy Template Engine emSpring Boot**

Spring Boot contém configuração automática paraGroovy Template Engine, que é adicionado incluindo a dependênciaspring-boot-starter-groovy-templates:


    org.springframework.boot
    spring-boot-starter-groovy-templates
    1.5.6.RELEASE

O local padrão para os modelos é/resources/templates.

7. Jade4j

Jade4j é a implementação Java do mecanismo de modeloPug (originalmente conhecido comoJade) para Javascript. Os modelosJade4j podem ser usados para gerar arquivos HTML.

7.1. Dependências do Maven

Para integração Spring, precisamos da dependênciaspring-jade4j:


    de.neuland-bfi
    spring-jade4j
    1.2.5

7.2. Configuração da mola

Para usarJade4j com Spring, temos que definir um beanSpringTemplateLoader que configura a localização dos modelos, bem como um beanJadeConfiguration:

@Configuration
@EnableWebMvc
public class JadeTemplateConfiguration {

    @Bean
    public SpringTemplateLoader templateLoader() {
        SpringTemplateLoader templateLoader
          = new SpringTemplateLoader();
        templateLoader.setBasePath("/WEB-INF/views/");
        templateLoader.setSuffix(".jade");
        return templateLoader;
    }

    @Bean
    public JadeConfiguration jadeConfiguration() {
        JadeConfiguration configuration
          = new JadeConfiguration();
        configuration.setCaching(false);
        configuration.setTemplateLoader(templateLoader());
        return configuration;
    }
}

Em seguida, precisamos do beanViewResolver usual, neste caso do tipoJadeViewResolver:

@Bean
public ViewResolver viewResolver() {
    JadeViewResolver viewResolver = new JadeViewResolver();
    viewResolver.setConfiguration(jadeConfiguration());
    return viewResolver;
}

**7.3. Jade4j modelos**

Os modelosJade4j são caracterizados por uma sintaxe sensível a espaços em branco fácil de usar:

doctype html
html
  head
    title User Registration
  body
    form(action="register" method="post" )
      label(for="email") Email:
      input(type="text" name="email")
      label(for="password") Password:
      input(type="password" name="password")
      input(type="submit" value="Submit")

O projeto também fornece uminteractive documentation muito útil, onde você pode ver a saída do seu modelo à medida que o escreve.

Spring Boot não fornece um iniciadorJade4j, portanto, em um projetoBoot, teríamos que adicionar a mesma configuração Spring conforme definido acima.

8. Outros motores de modelo

Além dos mecanismos de gabarito descritos até agora, há muito mais disponíveis que podem ser usados.

Vamos revisar alguns dos brevemente.

Velocity é um mecanismo de template mais antigo, que é muito complexo, mas tem a desvantagem de que o Spring tornou seu uso obsoleto desde a versão 4.3.

JMustache é um mecanismo de modelo que pode ser facilmente integrado a um aplicativo Spring Boot usando a dependênciaspring-boot-starter-mustache.

Pebble contém suporte para Spring eSpring Boot em suas bibliotecas.

Outras bibliotecas de modelos, comoHandlebars ouReact, rodando sobre um mecanismo de scriptJSR-223, comoNashorn,, também podem ser usadas.

9. Conclusão

Neste artigo, examinamos alguns dos mecanismos de modelos mais populares para aplicativos da Web Spring.

E, como sempre, o código-fonte completo dos exemplos pode ser encontradoover on GitHub.

TOC

Motores de modelo para a primavera