Annotationen statt XML Konfigurationen

Beispielprojekt

Das Beispielprojekt für dieses Beispiel kann unter diesem Link heruntergeladen werden.

Was wird benötigt

Damit man ein Projekt mit Spring MVC und Thymeleaf ohne XML-Konfigurationen und nur mit Annotationen umsetzen kann, werden die folgenden Dinge benötigt:

• ein ServletContextTemplateResolver
• eine SpringTemplateEngine
• sowie ein ThymeleafViewResolver bean in JavaConfig.

Um die Message Source aufzulösen wird zudem ein Bean für die MessageSource Spring Klasse verwendet.

Um Daten vom Controller an das Model zu schicken, wird die addObject()-Methode verwendet.

Natürlich muss man daran denken, Spring und Thymeleaf über Maven oder Gradle zum eigenen Projekt hinzuzufügen.

AppConfig.java ¹

In der Klasse AppConfig.java wird angegeben, wo sich der templateResolver, die templateEngine, der viewResolver sowie die MessageSource befinden.

Die ServletContextTemplateResolver löst alle Templates auf, welche bestimmte Kriterien erfüllen. (Im Beispiel sind Prefix und Suffix angegben)

Ein SpringTemplateEngine verarbeitet das Template. Im Beispel sieht man, wie der SpringTemplateEngine ein templateResolver injected wird.

Dem ThymeleafViewResolver wird später der name der zu verarbeitenden View mitgegeben.

package com.concretepage.config;  
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.thymeleaf.spring4.SpringTemplateEngine;
import org.thymeleaf.spring4.view.ThymeleafViewResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
@Configuration 
@ComponentScan("com.concretepage") 
@EnableWebMvc
public class AppConfig extends WebMvcConfigurerAdapter  {
    //start Thymeleaf specific configuration
    @Bean(name ="templateResolver")    
    public ServletContextTemplateResolver getTemplateResolver() {
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("XHTML");
    return templateResolver;
    }
    @Bean(name ="templateEngine")        
    public SpringTemplateEngine getTemplateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(getTemplateResolver());
    return templateEngine;
    }
    @Bean(name="viewResolver")
    public ThymeleafViewResolver getViewResolver(){
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver(); 
        viewResolver.setTemplateEngine(getTemplateEngine());
    return viewResolver;
    }
    //end Thymeleaf specific configuration
    @Bean(name ="messageSource")
    public MessageSource getMessageSource() {
        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("/WEB-INF/i18/blogmsg");
        messageSource.setDefaultEncoding("UTF-8");
        return messageSource;
    }
}

Der WebAppInitializer

Eine Implementation der Klasse WebAppInitializer wird verwendet, damit die gesamte Spring-Web-Applikation überhaupt starten kann. Dieser Implementation wird mitgeteilt, von welcher Klasse der WebMvcConfigurerAdapter implementiert wird (in diesem Beispiel ist es die Klasse AppConfig).

Eine Klasse WebAppInitializer könnte so aussehen:

package com.concretepage.config;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration.Dynamic;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class WebAppInitializer implements WebApplicationInitializer {
    public void onStartup(ServletContext servletContext) throws ServletException {  
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();  
        ctx.register(AppConfig.class);  
        ctx.setServletContext(servletContext);    
        Dynamic dynamic = servletContext.addServlet("dispatcher", new DispatcherServlet(ctx));  
        dynamic.addMapping("/");  
        dynamic.setLoadOnStartup(1);  
   }  
}

Writer.java und Property-File

Hinweis: Damit dieses Dokument nicht unübersichtlich wird, habe ich die Impelemtationen der Klasse Writer.java (Ein Bean mit der Annotation @Service) sowie das Properties-File zur Internationalisierung weggelassen.

Ein Controller

Der Controller sieht folgendermassen aus und gibt dem Template unter anderem das Objekt "writers" mit.

package com.concretepage.controller;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.concretepage.bean.Writer;
@Controller
public class BlogController {
    @Autowired
    private Writer writer;
    @RequestMapping(value = "/blog")
     public ModelAndView getBlog(ModelAndView mv) {
        mv.addObject("currentDate", new Date());
        mv.addObject("writers", writer.getWriters());
            mv.setViewName("myblog");
            return mv;
    }
}

Quellen

¹ http://www.concretepage.com/spring-4/spring-4-mvc-thymeleaf-annotation-integration-tutorial-with-internationalization-example-using-springtemplateengine-and-thymeleafviewresolver