Spring Boot não exibe conteúdo estático

Não consigo que meu projeto de inicialização Spring sirva conteúdo estático.

Coloquei uma pasta chamada staticsob src/main/resources. Dentro dela, tenho uma pasta chamada images. Quando empacoto o aplicativo e o executo, ele não consegue encontrar as imagens que coloquei nessa pasta.

Eu tentei colocar os arquivos estáticos em public, resourcese META-INF/resources, mas nada funciona.

Se eu jar -tvf app.jar, posso ver que os arquivos estão dentro do jar na pasta correta: /static/images/head.pngpor exemplo, mas chamando :, http://localhost:8080/images/head.pngtudo o que recebo é um404

Alguma idéia de por que o boot-spring não está encontrando isso? (Estou usando 1.1.4 BTW)

Não para ressuscitar os mortos depois de mais de um ano, mas todas as respostas anteriores perdem alguns pontos cruciais:

1. @EnableWebMvcna sua turma será desativado org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration. Tudo bem se você deseja controle completo, mas, caso contrário, é um problema.

2. Não é necessário escrever nenhum código para adicionar outro local para recursos estáticos, além do que já é fornecido. Observando a org.springframework.boot.autoconfigure.web.ResourcePropertiespartir da v1.3.0.RELEASE, vejo um campo staticLocationsque pode ser configurado no application.properties. Aqui está um trecho da fonte:

   /**
    * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
    * /resources/, /static/, /public/] plus context:/ (the root of the servlet context).
    */
   private String[] staticLocations = RESOURCE_LOCATIONS;
   

3. Como mencionado anteriormente, o URL da solicitação será resolvido em relação a esses locais. Assim src/main/resources/static/index.html, será veiculado quando o URL da solicitação for /index.html. A classe responsável pela resolução do caminho, a partir da Primavera 4.1, é org.springframework.web.servlet.resource.PathResourceResolver.

4. A correspondência de padrão de sufixo é ativada por padrão, o que significa que para uma URL de solicitação /index.html, o Spring procurará manipuladores correspondentes /index.html. Esse é um problema se a intenção é veicular conteúdo estático. Para desabilitar isso, estenda WebMvcConfigurerAdapter(mas não use @EnableWebMvc) e substitua configurePathMatchcomo mostrado abaixo:

   @Override
   public void configurePathMatch(PathMatchConfigurer configurer) {
       super.configurePathMatch(configurer);
   
       configurer.setUseSuffixPatternMatch(false);
   }
   

IMHO, a única maneira de ter menos erros no seu código é não escrever código sempre que possível. Use o que já é fornecido, mesmo que isso exija alguma pesquisa, o retorno vale a pena.

Diferentemente do que afirma o spring-boot, para obter meu jar de spring-boot para servir o conteúdo: eu tive que adicionar especificamente registrar meu src / main / resources / static content através desta classe de configuração:

@Configuration
public class StaticResourceConfiguration implements WebMvcConfigurer {

    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
            "classpath:/META-INF/resources/", "classpath:/resources/",
            "classpath:/static/", "classpath:/public/" };

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

Eu tive um problema semelhante, e a solução simples era ter minha classe de configuração estendida WebMvcAutoConfiguration:

@Configuration
@EnableWebMvc
@ComponentScan
public class ServerConfiguration extends WebMvcAutoConfiguration{
}

Eu não precisava de nenhum outro código para permitir que meu conteúdo estático fosse veiculado; no entanto, coloquei um diretório chamado publicunder src/main/webappe configurei o maven para apontar src/main/webappcomo um diretório de recursos. Isso significa que ele publicé copiado target/classese, portanto, está no caminho de classe no tempo de execução para o spring-boot / tomcat encontrar.

Procure Controladores mapeados para "/" ou sem nenhum caminho mapeado.

Eu tive um problema como esse, obtendo 405 erros, e bati minha cabeça com força por dias. O problema acabou sendo um @RestControllercontrolador anotado que eu esqueci de anotar com uma @RequestMappinganotação. Eu acho que esse caminho mapeado assumiu o padrão "/" e bloqueou o mapeamento estático de recursos de conteúdo.

A configuração pode ser feita da seguinte maneira:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcAutoConfigurationAdapter {

// specific project configuration

}

Importante aqui é que você WebMvcConfig pode substituir o addResourceHandlersmétodo e, portanto, é necessário invocar explicitamente super.addResourceHandlers(registry)(é verdade que, se você estiver satisfeito com os locais de recursos padrão, não precisará substituir nenhum método).

Outra coisa que precisa ser comentado aqui é que esses locais de recursos padrão ( /static, /public, /resourcese /META-INF/resources) serão registradas somente se não houver já um manipulador de recursos mapeados para /**.

A partir deste momento, se você tiver uma imagem src/main/resources/static/imagesnomeada, image.jpgpor exemplo, poderá acessá-la usando o seguinte URL: http://localhost:8080/images/image.jpg(sendo o servidor iniciado na porta 8080 e o aplicativo implantado no contexto raiz).

Você verificou os documentos de referência do Spring Boot ?

Por padrão, o Spring Boot servirá conteúdo estático de uma pasta chamada /static(ou /publicou /resourcesou /META-INF/resources) no caminho de classe ou na raiz do ServletContext.

Você também pode comparar seu projeto com o guia Serving Web Content with Spring MVC ou verificar o código-fonte do projeto spring-boot-sample-web-ui .

Eu estava tendo esse problema exato e percebi que havia definido em meu application.properties:

spring.resources.static-locations=file:/var/www/static

O que estava substituindo tudo o que eu havia tentado. No meu caso, eu queria manter os dois, então apenas mantive a propriedade e adicionei:

spring.resources.static-locations=file:/var/www/static,classpath:static

Que serviu os arquivos de src / main / resources / static como localhost: {port} /file.html.

Nenhuma das opções acima funcionou para mim porque ninguém mencionou essa pequena propriedade que poderia ser facilmente copiada da online para servir a um propósito diferente;)

Espero que ajude! Imaginei que caberia bem neste longo post de respostas para pessoas com esse problema.

Eu acho que as respostas anteriores abordam o tópico muito bem. No entanto, eu acrescentaria que, em um caso, quando você tiver o Spring Security ativado no seu aplicativo, poderá ser necessário informar especificamente o Spring para permitir solicitações para outros diretórios de recursos estáticos, como por exemplo "/ static / fonts" .

No meu caso, eu tinha "/ static / css", "/ static / js", "/ static / images" permitido por padrão, mas / static / fonts / ** foi bloqueado pela minha implementação do Spring Security.

Abaixo está um exemplo de como eu consertei isso.

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
.....
    @Override
    protected void configure(final HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/", "/fonts/**").permitAll().
        //other security configuration rules
    }
.....
}

Apenas para adicionar mais uma resposta a uma pergunta antiga ... As pessoas mencionaram o @EnableWebMvcimpedimento WebMvcAutoConfigurationde carregar, que é o código responsável pela criação dos manipuladores de recursos estáticos. Existem outras condições que impedirão o WebMvcAutoConfigurationcarregamento também. A maneira mais clara de ver isso é olhar para a fonte:

https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/ WebMvcAutoConfiguration.java # L139-L141

No meu caso, eu estava incluindo uma biblioteca que tinha uma classe que estava se estendendo, da WebMvcConfigurationSupportqual é uma condição que impedirá a configuração automática:

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

É importante nunca se estender WebMvcConfigurationSupport. Em vez disso, estenda de WebMvcConfigurerAdapter.

ATUALIZAÇÃO: A maneira correta de fazer isso no 5.x é implementar o WebMvcConfigurer

Esta solução funciona para mim:

Primeiro, coloque uma pasta de recursos em webapp / WEB-INF, como segue a estrutura

-- src
  -- main
    -- webapp
      -- WEB-INF
        -- resources
          -- css
          -- image
          -- js
          -- ...

Segundo, no arquivo de configuração da primavera

@Configuration
@EnableWebMvc
public class MvcConfig extends WebMvcConfigurerAdapter{

    @Bean
    public ViewResolver getViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".html");
        return resolver;
    }

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

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

Em seguida, você pode acessar o conteúdo do recurso, como http: // localhost: 8080 / resource / image / yourimage.jpg

Há duas coisas a considerar (Spring Boot v1.5.2.RELEASE) - 1) Verifique todas as classes Controller quanto à anotação @EnableWebMvc, remova-a se houver 2) Verifique as classes Controller para as quais a anotação é usada - @RestController ou @Controller . Não misture o comportamento da API Rest e MVC em uma classe. Para MVC, use @Controller e, para API REST, use @RestController

Fazer acima de duas coisas resolveu meu problema. Agora minha bota primavera está carregando recursos estáticos sem problemas. @Controller => load index.html => carrega arquivos estáticos.

@Controller
public class WelcomeController {

    // inject via application.properties
    @Value("${welcome.message:Hello}")
    private String message = "Hello World";

    @RequestMapping("/")
    public String home(Map<String, Object> model) {
        model.put("message", this.message);
        return "index";
    }

}

index.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>index</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />


    <link rel="stylesheet/less" th:href="@{/webapp/assets/theme.siberia.less}"/>

    <!-- The app's logic -->
    <script type="text/javascript" data-main="/webapp/app" th:src="@{/webapp/libs/require.js}"></script>
    <script type="text/javascript">
        require.config({
            paths: { text:"/webapp/libs/text" }
        });
    </script>



   <!-- Development only -->
     <script type="text/javascript" th:src="@{/webapp/libs/less.min.js}"></script>


</head>
<body>

</body>
</html>

Coloque os recursos estáticos no diretório:

/src/main/resources/static

inclua esta propriedade no arquivo application.properties

server.servlet.context-path=/pdx

Você pode acessar a partir de http: // localhost: 8080 / pdx / images / image.jpg

Caso o problema ocorra ao iniciar o aplicativo a partir de um IDE (por exemplo, iniciando no Eclipse ou no IntelliJ Idea) e usando o Maven, a chave da solução está na documentação de Inicialização do Spring-boot :

Se você estiver usando o Maven, execute:

mvn package && java -jar target/gs-spring-boot-0.1.0.jar

A parte importante disso é adicionar o packageobjetivo a ser executado antes que o aplicativo seja realmente iniciado. (Idea: Runmenu Edit Configrations..., Adde há escolha Run Maven Goal, e especifique o packageobjetivo no campo)

Estou usando o 1.3.5 e hospedo vários serviços REST por meio da implementação de Jersey. Isso funcionou bem até que eu decidi adicionar alguns arquivos HTMLs + js. Nenhuma das respostas dadas neste fórum me ajudou. No entanto, quando adicionei a seguinte dependência no meu pom.xml, todo o conteúdo em src / main / resources / static finalmente foi exibido via navegador:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<dependency>

Parece que spring-web / spring-webmvc é a importante dependência transitiva que ativa a configuração automática da inicialização por primavera.

FYI: Eu também notei que posso atrapalhar um aplicativo de inicialização de primavera que funciona perfeitamente e impedir que ele sirva conteúdo da pasta estática, se eu adicionar um controlador de descanso incorreto como esse

 @RestController
public class BadController {
    @RequestMapping(method= RequestMethod.POST)
    public String someMethod(@RequestParam(value="date", required=false)String dateString, Model model){
        return "foo";
    }
}

Neste exemplo, depois de adicionar o controlador incorreto ao projeto, quando o navegador solicita um arquivo disponível na pasta estática, a resposta do erro é ' 405 Método Não Permitido '.

Os caminhos de aviso não são mapeados no exemplo de controlador incorreto.

Eu estava enfrentando o mesmo problema no boot da primavera 2.1.3 dizendo que o recurso não foi encontrado 404. Eu removi abaixo do applicatiion.properties .

#spring.resources.add-mappings=true
#spring.resources.static-locations=classpath:static
#spring.mvc.static-path-pattern=/**,

Removeu @enableWebMVC e removeu qualquer substituição do WebMvcConfigurer

// @ EnableWebMvc

Verifique também se você tem @EnableAutoConfiguration em sua configuração.

E coloque todos os recursos estáticos em src / main / resources / static e funcionou como mágica finalmente.

usando o boot de primavera 2. *, eu tenho um controlador que mapeia para rotas GetMapping({"/{var}", "/{var1}/{var2}", "/{var1}/{var2}/{var3}"})e lança meu aplicativo para de servir recursos.

eu sei que não é aconselhável ter essas rotas, mas tudo depende do aplicativo que você está construindo (no meu caso, não tenho escolha a não ser ter essas rotas)

então aqui está o meu truque para garantir que meu aplicativo sirva recursos novamente. Eu simplesmente tenho um controlador que mapeia meus recursos. Como a primavera corresponderá a uma rota direta antes de qualquer variável, decidi adicionar um método de controlador que mapeia /imgaes/{name}e repete o mesmo para outros recursos

@GetMapping(value = "/images/{image}", produces = {MediaType.IMAGE_GIF_VALUE, MediaType.IMAGE_JPEG_VALUE, MediaType.IMAGE_PNG_VALUE})
    public @ResponseBody
    byte[] getImage(@PathVariable String image) {
        ClassPathResource file = new ClassPathResource("static/images/" + image);
        byte[] bytes;
        try {
            bytes = StreamUtils.copyToByteArray(file.getInputStream());
        } catch (IOException e) {
            throw new ResourceNotFoundException("file not found: " + image);
        }
        return bytes;
    }

e isso resolveu meu problema

Teve o mesmo problema, usando gradle e eclipse e passou horas tentando descobrir.

Sem necessidade de codificação, o truque é que você deve usar a opção de menu Novo-> Pasta de Origem (NÃO Nova -> Pasta) para criar a pasta estática em src / main / resources. Não sei por que isso funciona, mas fiz o novo -> pasta de origem e nomeei a pasta estática (a caixa de diálogo da pasta de origem fornece um erro para o qual você deve verificar: Atualize os filtros de exclusão em outras pastas de origem para resolver o aninhamento). A minha nova pasta estática adicionei index.html e agora funciona.

Bem, às vezes vale a pena verificar se você substituiu os mapeamentos globais por algum controlador restante. Erro de exemplo simples (kotlin):

@RestController("/foo")
class TrainingController {

    @PostMapping
    fun bazz(@RequestBody newBody: CommandDto): CommandDto = return commandDto

}

No caso acima, você receberá quando solicitar recursos estáticos:

{
    title: "Method Not Allowed",
    status: 405,
    detail: "Request method 'GET' not supported",
    path: "/index.html"
}

A razão para isso poderia ser que você queria para mapear @PostMappinga /foomas esquecer @RequestMappinganotação no @RestControllernível. Nesse caso, todas as solicitações são mapeadas POSTe você não receberá conteúdo estático nesse caso.

Dados os recursos em src / main / resources / static, se você adicionar esse código, todo o conteúdo estático de src / main / resources / static estará disponível em "/":

@Configuration
public class StaticResourcesConfigurer implements WebMvcConfigurer {
    public void addResourceHandlers(final ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**").addResourceLocations("classpath:/resources/static/");
    }
}

No meu caso, alguns arquivos estáticos não foram servidos, como fontes .woff e algumas imagens. Mas css e js funcionaram muito bem.

Atualização: Uma solução muito melhor para fazer com que o Spring Boot atenda corretamente as fontes woff é configurar a filtragem de recursos mencionada nesta resposta, por exemplo (observe que você precisa de inclusão e exclusão):

<resources>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
        <excludes>
            <exclude>static/aui/fonts/**</exclude>
        </excludes>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <includes>
            <include>static/aui/fonts/**</include>
        </includes>
    </resource>
</resources>

----- Solução antiga (funcionando, mas irá corromper algumas fontes) -----

Outra solução foi desativar a correspondência de padrão de sufixo com setUseSuffixPatternMatch(false)

@Configuration
public class StaticResourceConfig implements WebMvcConfigurer {
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        // disable suffix matching to serve .woff, images, etc.
        configurer.setUseSuffixPatternMatch(false);
    }
}

Créditos: @Abhiji me apontou com 4. na direção certa!

Solicitações para / ** são avaliadas para locais estáticos configurados em resourceProperties .

adicionar o seguinte em application.properties, pode ser a única coisa que você precisa fazer ...

spring.resources.static-locations=classpath:/myresources/

isso substituirá os locais estáticos padrão, que são:

ResourceProperties.CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
        "classpath:/resources/", "classpath:/static/", "classpath:/public/" };

Você pode não querer fazer isso e verifique se os recursos acabam em uma dessas pastas padrão.

Executando uma solicitação: se eu tivesse o example.html armazenado em /public/example.html, posso acessá-lo assim:

<host>/<context-path?if you have one>/example.html

Se eu quiser outra uri como <host>/<context-path>/magico/*para arquivos no classpath: / magicofiles / * você precisa de um pouco mais de configuração

@Configuration
class MyConfigClass implements WebMvcConfigurer

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

Como dito acima, o arquivo deve estar em $ClassPath/static/images/name.png(/ static ou / public ou / resources ou / META-INF / resources). Esse $ ClassPath significa main/resourcesou main/javadir.

Se seus arquivos não estiverem em diretórios padrão, você poderá adicionar a seguinte configuração:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Override
public void configure(WebSecurity web) throws Exception {
    web.ignoring().antMatchers("/lib/**"); // like this
}

@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        // ... etc.
}
...

}