Spring Boot no sirve contenido estático

No puedo hacer que mi proyecto Spring-boot sirva contenido estático.

He colocado una carpeta nombrada staticdebajo src/main/resources. En su interior tengo una carpeta llamada images. Cuando empaque la aplicación y la ejecute, no puede encontrar las imágenes que he puesto en esa carpeta.

He tratado de poner los archivos estáticos en public, resourcesy META-INF/resourcespero nada funciona.

Si jar -tvf app.jar puedo ver que los archivos están dentro del jar en la carpeta correcta: /static/images/head.pngpor ejemplo, pero llamando:, http://localhost:8080/images/head.pngtodo lo que obtengo es un404

¿Alguna idea de por qué spring-boot no encuentra esto? (Estoy usando 1.1.4 BTW)

No para resucitar a los muertos después de más de un año, pero todas las respuestas anteriores pierden algunos puntos cruciales:

1. @EnableWebMvcen su clase se deshabilitará org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration. Eso está bien si quieres un control completo, pero de lo contrario, es un problema.

2. No es necesario escribir ningún código para agregar otra ubicación para recursos estáticos además de lo que ya se proporciona. Mirando org.springframework.boot.autoconfigure.web.ResourcePropertiesdesde v1.3.0.RELEASE, veo un campo staticLocationsque se puede configurar en application.properties. Aquí hay un fragmento de la fuente:

   /**
    * 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 se mencionó anteriormente, la URL de solicitud se resolverá en relación con estas ubicaciones. Por src/main/resources/static/index.htmllo tanto , se servirá cuando la URL de solicitud sea /index.html. La clase responsable de resolver la ruta, a partir de Spring 4.1, es org.springframework.web.servlet.resource.PathResourceResolver.

4. La coincidencia de patrones de sufijo está habilitada de manera predeterminada, lo que significa que para una URL de solicitud /index.html, Spring buscará los controladores correspondientes /index.html. Este es un problema si la intención es servir contenido estático. Para deshabilitar eso, extienda WebMvcConfigurerAdapter(pero no use @EnableWebMvc) y anule configurePathMatchcomo se muestra a continuación:

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

En mi humilde opinión, la única forma de tener menos errores en su código es no escribir código siempre que sea posible. Utilice lo que ya se proporciona, incluso si eso requiere un poco de investigación, el rendimiento lo vale.

A diferencia de lo que dice el arranque de primavera, para que mi jarra de arranque de primavera sirva el contenido: tuve que agregar registrar específicamente mi contenido src / main / resources / static a través de esta clase de configuración:

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

Tuve un problema similar, y resultó que la solución simple era extender mi clase de configuración WebMvcAutoConfiguration:

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

No necesitaba ningún otro código para permitir que se sirviera mi contenido estático, sin embargo, puse un directorio llamado publicdebajo src/main/webappy configuré a maven para que señalara src/main/webappcomo un directorio de recursos. Esto significa que publicse copia target/classesy, por lo tanto, está en el classpath en tiempo de ejecución para que spring-boot / tomcat lo encuentre.

Busque los Controladores asignados a "/" o sin ruta asignada.

Tuve un problema como este, obtuve 405 errores y me golpeé la cabeza con fuerza durante días. El problema resultó ser un @RestControllercontrolador anotado que olvidé anotar con una @RequestMappinganotación. Supongo que esta ruta asignada por defecto fue "/" y bloqueó la asignación de recursos de contenido estático.

La configuración se puede hacer de la siguiente manera:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcAutoConfigurationAdapter {

// specific project configuration

}

Importante aquí es que WebMvcConfig puede anular el addResourceHandlersmétodo y, por lo tanto, debe invocar explícitamente super.addResourceHandlers(registry)(es cierto que si está satisfecho con las ubicaciones de recursos predeterminadas, no necesita anular ningún método).

Otra cosa que necesita ser comentado aquí es que esos lugares de recursos por defecto ( /static, /public, /resourcesy /META-INF/resources) se registrarán sólo si no hay ya un controlador de recursos asignada a /**.

A partir de este momento, si tiene una imagen con src/main/resources/static/imagesnombre, image.jpgpor ejemplo, puede acceder a ella utilizando la siguiente URL: http://localhost:8080/images/image.jpg(el servidor se inició en el puerto 8080 y la aplicación se implementó en el contexto raíz).

¿Revisaste los documentos de referencia de Spring Boot ?

Por defecto, Spring Boot servirá contenido estático desde una carpeta llamada /static(o /publico /resourceso /META-INF/resources) en el classpath o desde la raíz del ServletContext.

También puede comparar su proyecto con la guía Servir contenido web con Spring MVC , o consultar el código fuente del proyecto spring-boot-sample-web-ui .

Estaba teniendo este problema exacto, luego me di cuenta de que lo había definido en mi aplicación.

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

Lo cual estaba anulando todo lo demás que había intentado. En mi caso, quería conservar ambos, así que solo guardé la propiedad y agregué:

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

Que sirvió archivos de src / main / resources / static como localhost: {port} /file.html.

Nada de lo anterior funcionó para mí porque nadie mencionó esta pequeña propiedad que podría haberse copiado fácilmente en línea para servir a un propósito diferente;)

¡Espero eso ayude! Pensé que encajaría bien en esta larga publicación de respuestas para personas con este problema.

Creo que las respuestas anteriores abordan el tema muy bien. Sin embargo, agregaría que en un caso cuando tiene Spring Security habilitado en su aplicación, es posible que tenga que decirle específicamente a Spring que permita solicitudes a otros directorios de recursos estáticos como, por ejemplo, "/ static / fonts" .

En mi caso, tenía "/ static / css", "/ static / js", "/ static / images" permitido por defecto, pero / static / fonts / ** fue bloqueado por mi implementación de Spring Security.

A continuación se muestra un ejemplo de cómo arreglé esto.

@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
    }
.....
}

Solo para agregar otra respuesta a una pregunta anterior ... La gente ha mencionado @EnableWebMvcque evitará que se WebMvcAutoConfigurationcargue, que es el código responsable de crear los manejadores de recursos estáticos. Hay otras condiciones que evitarán que se WebMvcAutoConfigurationcargue también. La forma más clara de ver esto es mirar la fuente:

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

En mi caso, estaba incluyendo una biblioteca que tenía una clase que se extendía desde la WebMvcConfigurationSupportcual es una condición que evitará la autoconfiguración:

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

Es importante no extenderse nuncaWebMvcConfigurationSupport . En cambio, extienda desde WebMvcConfigurerAdapter.

ACTUALIZACIÓN: La forma correcta de hacer esto en 5.x es implementar WebMvcConfigurer

Esta solución me funciona:

Primero, coloque una carpeta de recursos debajo de webapp / WEB-INF, como sigue la estructura

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

En segundo lugar, en el archivo de configuración de 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/");
    }
}

Luego, puede acceder al contenido de sus recursos, como http: // localhost: 8080 / resource / image / yourimage.jpg

Hay 2 cosas a considerar (Spring Boot v1.5.2.RELEASE) - 1) Verifique todas las clases de Controlador para la anotación @EnableWebMvc, elimínela si hay alguna 2) Verifique las clases de Controlador para las que se usa la anotación: @RestController o @Controller . No mezcle el comportamiento Rest API y MVC en una clase. Para MVC use @Controller y para API REST use @RestController

Hacer más de 2 cosas resolvió mi problema. Ahora mi arranque de primavera está cargando recursos estáticos sin ningún problema. @Controller => load index.html => carga archivos 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>

Ponga recursos estáticos bajo el directorio:

/src/main/resources/static

agregue esta propiedad en el archivo application.properties

server.servlet.context-path=/pdx

Puede acceder desde http: // localhost: 8080 / pdx / images / image.jpg

En caso de que surja el problema al iniciar la aplicación desde un IDE (es decir, a partir de Eclipse o IntelliJ Idea), y utilizando Maven, la clave de la solución está en la documentación de Inicio de Spring-boot :

Si está utilizando Maven, ejecute:

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

La parte importante es agregar el packageobjetivo que se ejecutará antes de que la aplicación se inicie realmente. (Idea: RunMenú, Edit Configrations..., Add, y seleccionar Run Maven Goaly especificar el packageobjetivo en el campo)

Estoy usando 1.3.5 y alojo un montón de servicios REST a través de la implementación de Jersey. Eso funcionó bien hasta que decidí agregar un par de archivos HTML + js. Ninguna de las respuestas dadas en este foro me ayudó. Sin embargo, cuando agregué la siguiente dependencia en mi pom.xml, todo el contenido en src / main / resources / static finalmente se mostró a través del navegador:

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

Parece que spring-web / spring-webmvc es la dependencia transitiva importante que hace que la configuración automática de inicio de Spring se active.

FYI: También noté que puedo estropear una aplicación de arranque de resorte que funciona perfectamente y evitar que sirva contenido de la carpeta estática, si agrego un controlador de reposo incorrecto así

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

En este ejemplo, después de agregar el controlador incorrecto al proyecto, cuando el navegador solicita un archivo disponible en la carpeta estática, la respuesta de error es ' Método 405 no permitido '.

Observe que las rutas no están asignadas en el ejemplo de controlador incorrecto.

Estaba enfrentando el mismo problema en el arranque de primavera 2.1.3 diciendo que no se encontró el recurso 404. Quité a continuación de application.properties .

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

Se eliminó @enableWebMVC y se eliminó cualquier anulación de WebMvcConfigurer

// @ EnableWebMvc

También asegúrese de tener @EnableAutoConfiguration en su configuración.

Y ponga todos los recursos estáticos en src / main / resources / static y finalmente funcionó como magia ...

usando spring boot 2. *, tengo un controlador que se asigna a las rutas GetMapping({"/{var}", "/{var1}/{var2}", "/{var1}/{var2}/{var3}"})y mi aplicación deja de servir recursos.

Sé que no es aconsejable tener tales rutas, pero todo depende de la aplicación que esté creando (en mi caso, no tengo más remedio que tener tales rutas)

así que aquí está mi truco para asegurarme de que mi aplicación sirva recursos nuevamente. Simplemente tengo un controlador que se asigna a mis recursos. Dado que la primavera coincidirá primero con una ruta directa antes que cualquiera que tenga variable, decidí agregar un método de controlador que se asigna /imgaes/{name}y se repite para otros 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;
    }

y esto resolvió mi problema

Tuve el mismo problema, usando gradle y eclipse y pasé horas tratando de resolverlo.

No se requiere codificación, el truco es que debe usar la opción de menú Nuevo-> Carpeta de origen (NO Nuevo -> Carpeta) para crear la carpeta estática en src / main / resources. No sé por qué esto funciona, pero hice una nueva -> carpeta de origen y luego llamé a la carpeta estática (luego el cuadro de diálogo de la carpeta de origen da un error que debe verificar: Actualice los filtros de exclusión en otras carpetas de origen para resolver el anidamiento). La nueva carpeta estática agregué index.html y ahora funciona.

Bueno, a veces vale la pena verificar si anuló las asignaciones globales por algún controlador de descanso. Ejemplo de error simple (kotlin):

@RestController("/foo")
class TrainingController {

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

}

En el caso anterior, obtendrá cuando solicite recursos estáticos:

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

La razón podría ser que deseaba asignar @PostMappingun mapa /foopero olvidarse de la @RequestMappinganotación en el @RestControllernivel. En este caso, todas las solicitudes se asignan POSTy no recibirá contenido estático en este caso.

Dados recursos en src / main / resources / static, si agrega este código, todo el contenido estático de src / main / resources / static estará disponible en "/":

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

En mi caso, algunos archivos estáticos no fueron servidos, como las fuentes .woff y algunas imágenes. Pero css y js funcionaron bien.

Actualización: una solución mucho mejor para hacer que Spring Boot sirva las fuentes de woff correctamente es configurar el filtrado de recursos mencionado en esta respuesta, por ejemplo (tenga en cuenta que necesita incluir y excluir):

<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>

----- Solución anterior (funciona pero dañará algunas fuentes) -----

Otra solución fue deshabilitar la coincidencia de patrón de sufijo con 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 señaló con 4. en la dirección correcta!

Las solicitudes a / ** se evalúan en ubicaciones estáticas configuradas en resourceProperties .

agregar lo siguiente en application.properties, podría ser lo único que debe hacer ...

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

esto sobrescribirá las ubicaciones estáticas predeterminadas, que es:

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

Es posible que no desee hacer eso y solo asegúrese de que sus recursos terminen en una de esas carpetas predeterminadas.

Realización de una solicitud: si tuviera el archivo example.html almacenado en /public/example.html, entonces puedo acceder de esta manera:

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

Si quisiera otra uri como <host>/<context-path>/magico/*para los archivos en classpath: / magicofiles / * necesitas un poco más de configuración

@Configuration
class MyConfigClass implements WebMvcConfigurer

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

Como se dijo anteriormente, el archivo debe estar en $ClassPath/static/images/name.png(/ static o / public o / resources o / META-INF / resources). Este $ ClassPath significa main/resourceso main/javadir.

Si sus archivos no están en directorios estándar, puede agregar la siguiente configuración:

@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.
}
...

}