Vistas XSLT

XSLT es un lenguaje de transformación XML que es popular como tecnología de presentación en aplicaciones web. XSLT puede ser una buena elección como tecnología de presentación si su aplicación funciona de forma natural con XML o si su modelo se puede convertir fácilmente a XML. La siguiente sección muestra cómo crear un documento XML como datos de modelo y transformarlo usando XSLT en una aplicación Spring Web MVC.

Este ejemplo es una aplicación Spring simple que crea una lista de palabras en un Controller y las agrega a un mapa modelo. Se devuelve un mapa, así como el nombre de nuestra vista XSLT. El controlador XSLT convierte una lista de palabras en un documento XML simple listo para la transformación.

Frijoles

La configuración es estándar para una aplicación web Spring simple: la configuración MVC debe definir el bean XsltViewResolver y la configuración habitual de anotaciones MVC. El siguiente ejemplo muestra cómo hacer esto:

@EnableWebMvc
@ComponentScan
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Bean
    public XsltViewResolver xsltViewResolver() {
        XsltViewResolver viewResolver = new XsltViewResolver();
        viewResolver.setPrefix("/WEB-INF/xsl/");
        viewResolver.setSuffix(".xslt");
        return viewResolver;
    }
}

@EnableWebMvc
@ComponentScan
@Configuration
class WebConfig : WebMvcConfigurer {
    @Bean
    fun xsltViewResolver() = XsltViewResolver().apply {
        setPrefix("/WEB-INF/xsl/")
        setSuffix(".xslt")
    }
}

Controlador

También necesitamos un controlador que encapsule nuestra lógica de generación de palabras.

La lógica del controlador está contenida en una clase marcada con la anotación @Controller y el método del controlador se define de la siguiente manera:

@Controller
public class XsltController {
    @RequestMapping("/")
    public String home(Model model) throws Exception {
        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        Element root = document.createElement("wordList");
        List<String> words = Arrays.asList("Hello", "Spring", "Framework");
        for (String word : words) {
            Element wordNode = document.createElement("word");
            Text textNode = document.createTextNode(word);
            wordNode.appendChild(textNode);
            root.appendChild(wordNode);
        }
        model.addAttribute("wordList", root);
        return "home";
    }
}

import org.springframework.ui.set
@Controller
class XsltController {
    @RequestMapping("/")
    fun home(model: Model): String {
        val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
        val root = document.createElement("wordList")
        val words = listOf("Hello", "Spring", "Framework")
        for (word in words) {
            val wordNode = document.createElement("word")
            val textNode = document.createTextNode(word)
            wordNode.appendChild(textNode)
            root.appendChild(wordNode)
        }
        model["wordList"] = root
        return "home"
    }
}

Hasta ahora solo hemos creado un documento DOM y lo hemos agregado al mapa modelo. Tenga en cuenta que también puede cargar un archivo XML como Resource y usarlo en lugar de un documento DOM personalizado.

Hay paquetes de software que automáticamente "DOMifican" un gráfico de objetos, pero Spring proporciona total flexibilidad para crear el DOM a partir de su modelo de la forma que elija. Esto ayuda a evitar que la transformación XML desempeñe un papel demasiado importante en la estructura de datos de su modelo, lo cual es un peligro cuando se utilizan herramientas para administrar el proceso de DOMificación.

Transformar

Finalmente, XsltViewResolver resuelve el archivo de plantilla XSLT de inicio y concatena el documento DOM en él para crear nuestra vista. Como se muestra en la configuración XsltViewResolver, las plantillas XSLT se ejecutan en un archivo war en el directorio WEB-INF/xsl y tienen la extensión de archivo xslt.

El siguiente ejemplo muestra una transformación XSLT:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" omit-xml-declaration="yes"/>
    <xsl:template match="/">
        <html>
            <head><title>Hello!</title></head>
            <body>
                <h1>My First Words</h1>
                <ul>
                    <xsl:apply-templates/>
                </ul>
            </body>
        </html>
    </xsl:template>
    <xsl:template match="word">
        <li><xsl:value-of select="."/></li>
    </xsl:template>
</xsl:stylesheet>

La transformación anterior se representa como el siguiente HTML:

<html>
    <head>
        <META http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Hello!</title>
    </head>
    <body>
        <h1>My First Words</h1>
        <ul>
            <li>Hello</li>
            <li>Spring</li>
            <li>Framework</li>
        </ul>
    </body>
</html>