Como servir arquivos .html com o Spring

Estou desenvolvendo um site com o Spring e estou tentando fornecer resources que não são arquivos .jsp (.html por exemplo)

agora eu comentei esta parte da minha configuração de servlet

 

E tentou retornar do controlador o caminho completo para o recurso.

 @Controller public class LandingPageController { protected static Logger logger = Logger.getLogger(LandingPageController.class); @RequestMapping({"/","/home"}) public String showHomePage(Map model) { return "/WEB-INF/jsp/index.html"; } } 

o arquivo index.html existe nessa pasta.

NOTA: quando eu altero o index.html para index.jsp, meu servidor agora exibe a página corretamente.

Obrigado.

O problema inicial é que a configuração especifica uma propriedade suffix=".jsp" Jsp suffix=".jsp" para que a class de implementação ViewResolver adicione .jsp ao final do nome da visão que está sendo retornada de seu método.

No entanto, desde que você comentou o InternalResourceViewResolver , dependendo do resto da configuração do aplicativo, pode não haver nenhum outro ViewResolver registrado. Você pode achar que nada está funcionando agora.

Como os arquivos .html são estáticos e não requerem processamento por um servlet, é mais eficiente e mais simples usar um mapeamento . Isso requer o Spring 3.0.4+.

Por exemplo:

  

que passaria por todas as solicitações iniciando com /static/ para o diretório webapp/static/ .

Então, colocando index.html no webapp/static/ e usando o return "static/index.html"; do seu método, o Spring deve encontrar a visualização.

Gostaria apenas de acrescentar que você não precisa implementar um método controlador para isso, pois você pode usar a tag do controlador de visualização (Spring 3) no arquivo de configuração de servlet:

  

Antecedentes do problema

A primeira coisa a entender é a seguinte: NÃO é a primavera que renderiza os arquivos jsp. É JspServlet (org.apache.jasper.servlet.JspServlet) que faz isso. Este servlet vem com o Tomcat (compilador de jasper) não com a mola. Esse JspServlet está ciente de como compilar a página jsp e como retorná-la como texto html para o cliente. O JspServlet no tomcat, por padrão, manipula apenas solicitações que correspondem a dois padrões: * .jsp e * .jspx.

Agora, quando a primavera processa a visualização com InternalResourceView (ou JstlView ), três coisas realmente ocorrem:

  1. obter todos os parâmetros do modelo do modelo (retornado pelo método do manipulador do controlador, isto é, "public ModelAndView doSomething() { return new ModelAndView("home") }" )
  2. expor esses parâmetros do modelo como atributos de solicitação (para que ele possa ser lido por JspServlet)
  3. encaminhar pedido para JspServlet. RequestDispatcher sabe que cada solicitação * .jsp deve ser encaminhada para JspServlet (porque essa é a configuração padrão do tomcat)

Quando você simplesmente altera o nome da visualização para home.html, o tomcat não saberá como lidar com a solicitação. Isso ocorre porque não há nenhum servlet que manipule solicitações * .html.

Solução

Como resolver isso Existem três soluções mais óbvias:

  1. expor o html como um arquivo de recurso
  2. instruir o JspServlet para também manipular solicitações * .html
  3. escreva seu próprio servlet (ou passe para outros pedidos de servlet existentes para * .html).

Para obter exemplos de código completos, por favor, refira-se à minha resposta em outro post: Como mapear solicitações para o arquivo HTML no Spring MVC?

Você ainda pode continuar a usar o mesmo resolvedor View, mas defina o sufixo para esvaziar.

  

Agora, seu código pode optar por retornar index.html ou index.jsp, conforme mostrado na amostra a seguir.

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

Eu enfrentei o mesmo problema e tentei várias soluções para carregar a página html do Spring MVC, seguindo a solução trabalhada para mim

Passo-1 no web.xml do servidor comente estas duas linhas

   

Passo 2 – digite o seguinte código no xml da web do aplicativo

   jsp *.htm  

Etapa 3 criar uma class de controlador estático

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

Passo-4 no arquivo de configuração Spring altere o sufixo para .htm .htm

Passo-5 Renomeie a página como arquivo .htm e armazene-o no WEB-INF e construa / inicie o servidor

 localhost:8080/.../landingPage 

alterar p: sufixo = “. jsp” valor de acordo com o contrário, podemos desenvolver resolvedor de visão personalizada

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

Parece que você está tentando fazer algo assim:

  • Visualizações de HTML estático
  • Controladores de mola servindo AJAX

Se esse for o caso, como mencionado anteriormente, a maneira mais eficiente é permitir que o servidor da Web (e não o Spring) manipule solicitações de HTML como resources estáticos. Então você quer o seguinte:

  1. Encaminhar todas as solicitações de .html, .css, .js, .png, etc para o manipulador de resources do servidor da web
  2. Mapeie todos os outros pedidos para controladores de mola

Aqui está uma maneira de conseguir isso …

web.xml – Servlet de mapa para raiz (/)

  sprung org.springframework.web.servlet.DispatcherServlet ...   sprung /  

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

Considerações adicionais

  • Ocultar extensão .html – está fora do escopo do Spring, se você estiver delegando as solicitações de resources estáticos. Olhe para um filtro de reescrita de URL.
  • Templating – Você não quer duplicar a marcação em cada página HTML para elementos comuns. Isso provavelmente não pode ser feito no servidor se estiver servindo HTML como um recurso estático. Olhe para um framework VC do lado do cliente. Sou fã da YUI, que possui vários mecanismos de templates, incluindo o Handlebars.

Configuração Java para arquivos html (neste caso, index.html):

 @Configuration @EnableWebMvc public class DispatcherConfig extends WebMvcConfigurerAdapter { @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/index.html").addResourceLocations("/index.html"); } }