Kurzanleitung zum Spring MVC mit Geschwindigkeit

Kurzanleitung zu Spring MVC mit Velocity

1. Einführung

Velocity ist eine Vorlagen-Engine der Apache Software Foundation, die mit normalen Textdateien, SQL, XML, Java-Code und vielen anderen Typen arbeiten kann.

In diesem Artikel konzentrieren wir uns auf die Verwendung von Velocity mit einer typischen Spring MVC-Webanwendung.

2. Maven-Abhängigkeiten

Beginnen wir mit der Aktivierung der Velocity-Unterstützung - mit den folgenden Abhängigkeiten:


    org.apache.velocity
    velocity
    1.7



    org.apache.velocity
    velocity-tools
    2.0

Die neuesten Versionen von beiden finden Sie hier:velocity undvelocity-tools.

3. Aufbau

3.1. Webkonfiguration

Wenn wir keinweb.xml verwenden möchten, konfigurieren wir unser Webprojekt mit Java und einem Initialisierer:

public class MainWebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext sc) throws ServletException {
        AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext();
        root.register(WebConfig.class);

        sc.addListener(new ContextLoaderListener(root));

        ServletRegistration.Dynamic appServlet =
          sc.addServlet("mvc", new DispatcherServlet(new GenericWebApplicationContext()));
        appServlet.setLoadOnStartup(1);
    }
}

Alternativ können wir natürlich die traditionellenweb.xml verwenden:


    Spring MVC Velocity
    
        mvc
    org.springframework.web.servlet.DispatcherServlet
        
        contextConfigLocation
        /WEB-INF/mvc-servlet.xml
     
     1
    

    
        mvc
    /*
    

    
        contextConfigLocation
    /WEB-INF/spring-context.xml
    

    
        org.springframework.web.context.ContextLoaderListener

Beachten Sie, dass wir unser Servlet auf dem Pfad „/ *“ abgebildet haben.

3.2. Frühlingskonfiguration

Lassen Sie uns nun eine einfache Spring-Konfiguration durchgehen - wieder beginnend mit Java:

@Configuration
@EnableWebMvc
@ComponentScan(basePackages= {
  "com.example.mvc.velocity.controller",
  "com.example.mvc.velocity.service" })
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry
          .addResourceHandler("/resources/**")
          .addResourceLocations("/resources/");
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public ViewResolver viewResolver() {
        VelocityLayoutViewResolver bean = new VelocityLayoutViewResolver();
        bean.setCache(true);
        bean.setPrefix("/WEB-INF/views/");
        bean.setLayoutUrl("/WEB-INF/layouts/layout.vm");
        bean.setSuffix(".vm");
        return bean;
    }

    @Bean
    public VelocityConfigurer velocityConfig() {
        VelocityConfigurer velocityConfigurer = new VelocityConfigurer();
        velocityConfigurer.setResourceLoaderPath("/");
        return velocityConfigurer;
    }
}

Lassen Sie uns auch einen kurzen Blick auf die XML-Version der Konfiguration werfen:

Hier teilen wir Spring mit, wo nach mit Anmerkungen versehenen Bohnendefinitionen gesucht werden soll:

[.s1] #Wir geben an, dass wir in unserem Projekt eine annotationsgesteuerte Konfiguration mit der folgenden Zeile verwenden werden: #

Durch das Erstellen der Beans "velocityConfig" und "viewResolver" teilen wirVelocityConfigurer mit, wo nach Vorlagen gesucht werden soll, undVelocityLayoutViewResolver, wo Ansichten und Layouts zu finden sind.

4. Geschwindigkeitsvorlagen

Lassen Sie uns abschließend unsere Vorlagen erstellen - beginnend mit einem gemeinsamen Header:


    
        Our tutorials

und Fußzeile:


    @Copyright example.com

Definieren wir ein gemeinsames Layout für unsere Site, in dem die obigen Fragmente mitparse im folgenden Code verwendet werden:


    
        Spring & Velocity
    
    
        
            #parse("/WEB-INF/fragments/header.vm")
        
        
            
            $screen_content
        
        
            #parse("/WEB-INF/fragments/footer.vm")

Sie können überprüfen, ob die Variable$screen_contentden Inhalt der Seiten enthält.

Schließlich erstellen wir eine Vorlage für den Hauptinhalt:

Index

Tutorials list

    #foreach($tut in $tutorials)
    
    #end

    
        Tutorial Id
        Tutorial Title
        Tutorial Description
        Tutorial Author
    

        $tut.tutId
        $tut.title
        $tut.description
        $tut.author

Tutorial Id	Tutorial Title	Tutorial Description	Tutorial Author
$tut.tutId	$tut.title	$tut.description	$tut.author

5. Controller-Seite

Wir haben einen einfachen Controller erstellt, der eine Liste von Tutorials als Inhalt für unser Layout zurückgibt, mit denen Folgendes gefüllt werden soll:

@Controller
@RequestMapping("/")
public class MainController {

    @Autowired
    private ITutorialsService tutService;

    @RequestMapping(value ="/", method = RequestMethod.GET)
    public String defaultPage() {
        return "index";
    }

    @RequestMapping(value ="/list", method = RequestMethod.GET)
    public String listTutorialsPage(Model model) {
        List list = tutService.listTutorials();
        model.addAttribute("tutorials", list);
        return "index";
    }
}

Schließlich können wir lokal auf dieses einfache Beispiel zugreifen - zum Beispiel unter:localhost:8080/spring-mvc-velocity/

6. Fazit

In diesem einfachen Tutorial haben wir die Webanwendung vonSpring MVCmit der Template-Engine vonVelocitykonfiguriert.

Den vollständigen Beispielcode für dieses Tutorial finden Sie in unserenGitHub repository.

TOC