TOC

Guide rapide de Spring MVC avec Velocity

Guide rapide de Spring MVC avec Velocity

1. introduction

Velocity est un moteur de modèle d'Apache Software Foundation qui peut fonctionner avec des fichiers texte normaux, SQL, XML, du code Java et de nombreux autres types.

Dans cet article, nous allons nous concentrer sur l'utilisation de Velocity avec une application Web Spring MVC typique.

2. Dépendances Maven

Commençons par activer la prise en charge de Velocity - avec les dépendances suivantes: 


    org.apache.velocity
    velocity
    1.7



    org.apache.velocity
    velocity-tools
    2.0

Les versions les plus récentes des deux peuvent être trouvées ici:velocity etvelocity-tools.

3. Configuration

3.1. Configuration Web

Si nous ne voulons pas utiliser unweb.xml, configurons notre projet Web en utilisant Java et un initialiseur: 

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);
    }
}

Alternativement, on peut bien sûr utiliser les traditionnelsweb.xml: 


    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

Notez que nous avons mappé notre servlet sur le chemin «/ *».

3.2. Config printemps

Passons maintenant à une configuration Spring simple - encore une fois, en commençant par 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;
    }
}

Et jetons également un coup d'œil à la version XML de la configuration: 


    
    
    
        
            /

Ici, nous disons au printemps où chercher les définitions de haricots annotées:

[.s1] #Nous indiquons que nous allons utiliser la configuration basée sur les annotations dans notre projet avec la ligne suivante: #

En créant les beans «velocityConfig» et «viewResolver», nous indiquons àVelocityConfigurer où chercher les modèles et àVelocityLayoutViewResolver où trouver les vues et les mises en page.

4. Modèles de vélocité

Enfin, créons nos modèles - en commençant par un en-tête commun: 


    

        
Our tutorials

et pied de page: 


    @Copyright example.com

Et définissons une mise en page commune pour notre site où nous allons utiliser les fragments ci-dessus avecparse dans le code suivant: 


    
        Spring & Velocity
    
    
        

            #parse("/WEB-INF/fragments/header.vm")
        

        

            
            $screen_content
        

        

            #parse("/WEB-INF/fragments/footer.vm")

Vous pouvez vérifier que la variable$screen_content a le contenu des pages.

Enfin, nous allons créer un modèle pour le contenu principal: 

Index



Tutorials list


    #foreach($tut in $tutorials)
    
    #end


    

        Tutorial Id
        Tutorial Title
        Tutorial Description
        Tutorial Author
    

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

5. Côté contrôleur

Nous avons créé un contrôleur simple qui renvoie une liste de tutoriels sous forme de contenu pour que notre mise en page soit renseignée avec: 

@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";
    }
}

Enfin, nous pouvons accéder à cet exemple simple localement - par exemple à:localhost:8080/spring-mvc-velocity/

6. Conclusion

Dans ce didacticiel simple, nous avons configuré l'application WebSpring MVC avec le moteur de modèle deVelocity.

L'exemple de code complet de ce didacticiel se trouve dans nosGitHub repository.

Related