Comment servir.fichiers html avec le Printemps

j'ajouterais simplement que vous n'avez pas besoin d'implémenter une méthode de controller pour cela car vous pouvez utiliser la balise view-controller (Spring 3) dans le fichier de configuration servlet:

<mvc:view-controller path="/" view-name="/WEB-INF/jsp/index.html"/>

Fond du problème

la première chose à comprendre est la suivante: ce n'est pas le ressort qui rend les fichiers jsp. Il s'agit de JspServlet (org.Apache.Jasper.servlet.JspServlet) qui le fait. Ce servlet est livré avec Tomcat (jasper compiler) pas avec spring. Ce JspServlet sait comment compiler la page jsp et comment la retourner sous forme de texte html au client. Par défaut, le JspServlet de tomcat ne traite que les requêtes correspondant à deux patterns.: *.jsp et *.jspx.

maintenant que le printemps rend la vue avec InternalResourceView (ou JstlView ), trois choses ont vraiment lieu:

1. récupérez tous les paramètres du modèle (retournés par votre méthode de gestionnaire de contrôleur i.e. "public ModelAndView doSomething() { return new ModelAndView("home") }" )
2. exposer ces paramètres de modèle comme attributs de requête (de sorte qu'il peut être lu par JspServlet)
3. envoyer la demande à JspServlet. RequestDispatcher sait que chacun.* la requête jsp doit être transmise à JspServlet (parce que c'est la configuration par défaut de tomcat)

quand vous changez simplement le nom de la vue à la maison.html tomcat va et non savoir comment traiter la demande. C'est parce qu'il n'y a pas de servlet de manutention *.html demandes.

Solution

comment résoudre ceci. Il y a trois solutions les plus évidentes:

1. exposer le html comme un fichier de ressource
2. donner instruction au JspServlet de manipuler aussi *.html les demandes
3. écrivez votre propre servlet (ou passez à une autre demande de servlet existante à *.HTML.)

pour des exemples de codes complets comment y parvenir s'il vous plaît réserver à ma réponse dans un autre post: Comment faire la correspondance des demandes au fichier HTML dans MVC printemps?

vous pouvez toujours continuer à utiliser le même résolveur de vue mais régler le suffixe à empty.

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
    p:prefix="/WEB-INF/jsp/" p:suffix="" />

maintenant votre code peut choisir de retourner l'un ou l'autre des index.html ou d'un index.jsp comme indiqué ci - dessous échantillon -

@RequestMapping(value="jsp", method = RequestMethod.GET )
public String startJsp(){
    return "/test.jsp";
}

@RequestMapping(value="html", method = RequestMethod.GET )
public String startHtml(){
    return "/test.html";
}   

j'ai fait face à la même question et essayé diverses solutions pour charger le html page de printemps MVC, la solution suivante a fonctionné pour moi

Step-1 dans le Web du serveur.commentaire xml ces deux lignes

<!--     <mime-mapping>
        <extension>htm</extension>
        <mime-type>text/html</mime-type>
    </mime-mapping>--> 
<!--     <mime-mapping>
        <extension>html</extension>
        <mime-type>text/html</mime-type>
    </mime-mapping>
 -->

Étape-2 Entrer le code suivant dans le xml web de l'application

  <servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.htm</url-pattern>
</servlet-mapping>

Étape-3 Créer une classe de contrôleur statique

@Controller 
public class FrontController {
     @RequestMapping("/landingPage") 
    public String getIndexPage() { 
    return "CompanyInfo"; 

    }

}

Étape-4 au printemps fichier de configuration changez le suffixe en .htm .htm

Étape-5 renommer la page en .HTM le fichier et le stocker dans WEB-INF et construire / démarrer le serveur

localhost:8080/.../landingPage

modifier p: suffix=".jsp" valeur acordingly sinon, nous pouvons développer une vue personnalisée de résolution

http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/view/UrlBasedViewResolver.html

on dirait que vous essayez de faire quelque chose comme ça:

• vues HTML statiques
• contrôleurs à ressort desservant AJAX

si tel est le cas, comme mentionné précédemment, le moyen le plus efficace est de laisser le serveur web(et non le ressort) traiter les requêtes HTML comme des ressources statiques. Vous voulez donc ce qui suit:

1. Avant tout .HTML. ,CSS. ,js, .png, etc demande à le serveur de ressources gestionnaire
2. Map toutes les autres requêtes aux contrôleurs à ressort

Voici une façon d'y parvenir...

web.xml - Carte servlet pour la racine (/)

<servlet>
            <servlet-name>sprung</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            ...
<servlet>

<servlet-mapping>
            <servlet-name>sprung</servlet-name>
            <url-pattern>/</url-pattern>
</servlet-mapping>

Printemps JavaConfig

public class SpringSprungConfig extends DelegatingWebMvcConfiguration {

    // Delegate resource requests to default servlet
    @Bean
    protected DefaultServletHttpRequestHandler defaultServletHttpRequestHandler() {
        DefaultServletHttpRequestHandler dsrh = new DefaultServletHttpRequestHandler();
        return dsrh;
    }

    //map static resources by extension
    @Bean
    public SimpleUrlHandlerMapping resourceServletMapping() {
        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();

        //make sure static resources are mapped first since we are using
        //a slightly different approach
        mapping.setOrder(0);
        Properties urlProperties = new Properties();
        urlProperties.put("/**/*.css", "defaultServletHttpRequestHandler");
        urlProperties.put("/**/*.js", "defaultServletHttpRequestHandler");
        urlProperties.put("/**/*.png", "defaultServletHttpRequestHandler");
        urlProperties.put("/**/*.html", "defaultServletHttpRequestHandler");
        urlProperties.put("/**/*.woff", "defaultServletHttpRequestHandler");
        urlProperties.put("/**/*.ico", "defaultServletHttpRequestHandler");
        mapping.setMappings(urlProperties);
        return mapping;
    }

    @Override
    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
        RequestMappingHandlerMapping handlerMapping = super.requestMappingHandlerMapping();

        //controller mappings must be evaluated after the static resource requests
        handlerMapping.setOrder(1);
        handlerMapping.setInterceptors(this.getInterceptors());
        handlerMapping.setPathMatcher(this.getPathMatchConfigurer().getPathMatcher());
        handlerMapping.setRemoveSemicolonContent(false);
        handlerMapping.setUseSuffixPatternMatch(false);
        //set other options here
        return handlerMapping;
    }
}

Considérations Supplémentaires

• Cacher. extension html - ceci est en dehors de la portée de Spring si vous déléguez les requêtes de ressources statiques. Regardez dans un filtre de réécriture D'URL.
• Templier-vous ne voulez pas dupliquer le markup dans chaque page HTML pour les éléments communs. Cela ne peut probablement pas être fait sur le serveur si vous servez de HTML comme une ressource statique. Examinez un cadre de VC côté client*. Je suis fan de YUI qui a de nombreux mécanismes de modelage, y compris le guidon.

Java configuration pour les fichiers html (dans ce cas-index.html):

@Configuration
@EnableWebMvc
public class DispatcherConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {

        registry.addResourceHandler("/index.html").addResourceLocations("/index.html");
    }

}