Spring Boot ne sert pas de contenu statique

Je ne parviens pas à faire en sorte que mon projet Spring-boot diffuse du contenu statique.

J'ai placé un dossier nommé staticsous src/main/resources. À l'intérieur, j'ai un dossier nommé images. Lorsque j'emballe l'application et que je l'exécute, elle ne trouve pas les images que j'ai placées dans ce dossier.

J'ai essayé de mettre les fichiers statiques public, resourceset , META-INF/resourcesmais rien ne fonctionne.

Si je jar -tvf app.jar, je peux voir que les fichiers sont à l'intérieur du fichier jar dans le bon dossier: /static/images/head.pngpar exemple, mais en appelant :, http://localhost:8080/images/head.pngtout ce que j'obtiens est un404

Des idées pourquoi Spring-Boot ne trouve pas cela? (J'utilise 1.1.4 BTW)

Ne pas ressusciter les morts après plus d'un an, mais toutes les réponses précédentes passent à côté de quelques points cruciaux:

1. @EnableWebMvcsur votre classe sera désactivé org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration. C'est bien si vous voulez un contrôle complet mais sinon, c'est un problème.

2. Il n'est pas nécessaire d'écrire du code pour ajouter un autre emplacement pour les ressources statiques en plus de ce qui est déjà fourni. En regardant à org.springframework.boot.autoconfigure.web.ResourcePropertiespartir de la v1.3.0.RELEASE, je vois un champ staticLocationsqui peut être configuré dans le application.properties. Voici un extrait de la source:

   /**
    * 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. Comme mentionné précédemment, l'URL de la demande sera résolue par rapport à ces emplacements. Ainsi src/main/resources/static/index.htmlsera servi lorsque l'URL de la demande est /index.html. La classe qui est responsable de la résolution du chemin, à partir du printemps 4.1, est org.springframework.web.servlet.resource.PathResourceResolver.

4. La correspondance de modèle de suffixe est activée par défaut, ce qui signifie que pour une URL de requête /index.html, Spring va rechercher les gestionnaires correspondant à /index.html. C'est un problème si l'intention est de diffuser du contenu statique. Pour désactiver cela, étendez WebMvcConfigurerAdapter(mais ne l'utilisez pas @EnableWebMvc) et remplacez configurePathMatchcomme indiqué ci-dessous:

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

À mon humble avis, la seule façon d'avoir moins de bogues dans votre code est de ne pas écrire de code autant que possible. Utilisez ce qui est déjà fourni, même si cela demande des recherches, le retour en vaut la peine.

Contrairement à ce qu'indique le spring-boot, pour que mon jar spring-boot serve le contenu: j'ai dû ajouter spécifiquement enregistrer mon contenu src / main / resources / static via cette classe de configuration:

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

J'ai eu un problème similaire, et il s'est avéré que la solution simple était d'étendre ma classe de configuration WebMvcAutoConfiguration:

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

Je n'avais besoin d'aucun autre code pour permettre à mon contenu statique d'être diffusé, cependant, j'ai mis un répertoire appelé publicsous src/main/webappet configuré maven pour qu'il pointe en src/main/webapptant que répertoire de ressources. Cela signifie qu'il publicest copié dans target/classes, et est donc sur le chemin de classe au moment de l'exécution pour que spring-boot / tomcat le trouve.

Recherchez les contrôleurs mappés à "/" ou sans chemin mappé.

J'ai eu un problème comme celui-ci, obtenir des erreurs 405 et me suis cogné la tête pendant des jours. Le problème s'est avéré être un @RestControllercontrôleur annoté que j'avais oublié d'annoter avec une @RequestMappingannotation. Je suppose que ce chemin mappé par défaut est "/" et bloque le mappage des ressources de contenu statique.

La configuration pourrait être faite comme suit:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcAutoConfigurationAdapter {

// specific project configuration

}

Il est important ici que votre méthode WebMvcConfig peut surcharger addResourceHandlerset que vous devez donc l'invoquer explicitement super.addResourceHandlers(registry)(il est vrai que si vous êtes satisfait des emplacements de ressources par défaut, vous n'avez pas besoin de remplacer une méthode).

Une autre chose qui doit être commenté ici est que ces emplacements de ressources par défaut ( /static, /public, /resourceset /META-INF/resources) seront enregistrées que s'il n'y a pas déjà un gestionnaire de ressources mis en correspondance /**.

À partir de ce moment, si vous avez une image sur src/main/resources/static/imagesnamed image.jpgpar exemple, vous pouvez y accéder en utilisant l'URL suivante: http://localhost:8080/images/image.jpg(étant le serveur démarré sur le port 8080 et l'application déployée en contexte racine).

Avez-vous consulté la documentation de référence de Spring Boot ?

Par défaut, Spring Boot servira le contenu statique à partir d'un dossier appelé /static(ou /publicou /resourcesou /META-INF/resources) dans le chemin de classe ou à partir de la racine de ServletContext.

Vous pouvez également comparer votre projet avec le guide Servir du contenu Web avec Spring MVC , ou consulter le code source du projet spring-boot-sample-web-ui .

J'avais exactement ce problème, puis j'ai réalisé que j'avais défini dans mon application.properties:

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

Ce qui l'emportait sur tout ce que j'avais essayé. Dans mon cas, je voulais garder les deux, alors j'ai juste gardé la propriété et ajouté:

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

Quels fichiers ont servi de src / main / resources / static en tant qu'hôte local: {port} /file.html.

Rien de ce qui précède n'a fonctionné pour moi car personne n'a mentionné cette petite propriété qui aurait pu facilement être copiée en ligne pour servir un objectif différent;)

J'espère que ça aide! Je pensais que cela s'intégrerait bien dans ce long post de réponses pour les personnes ayant ce problème.

Je pense que les réponses précédentes abordent très bien le sujet. Cependant, j'ajouterais que dans un cas, lorsque Spring Security est activé dans votre application, vous devrez peut-être spécifiquement indiquer à Spring d'autoriser les demandes à d'autres répertoires de ressources statiques comme par exemple "/ static / fonts" .

Dans mon cas, j'avais "/ static / css", "/ static / js", "/ static / images" permis par défaut, mais / static / fonts / ** était bloqué par mon implémentation Spring Security.

Voici un exemple de la façon dont j'ai résolu ce problème.

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

Juste pour ajouter encore une autre réponse à une vieille question ... Les gens ont mentionné l' @EnableWebMvcempêcher WebMvcAutoConfigurationde se charger, qui est le code responsable de la création des gestionnaires de ressources statiques. Il existe d'autres conditions qui empêcheront également le WebMvcAutoConfigurationchargement. La façon la plus claire de voir cela est de regarder la source:

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

Dans mon cas, j'incluais une bibliothèque qui avait une classe qui s'étendait à partir de WebMvcConfigurationSupportlaquelle est une condition qui empêchera l'autoconfiguration:

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

Il est important de ne jamais dépasser WebMvcConfigurationSupport. Au lieu de cela, étendez à partir de WebMvcConfigurerAdapter.

MISE À JOUR: La bonne façon de faire cela dans 5.x est d'implémenter WebMvcConfigurer

Cette solution fonctionne pour moi:

Tout d'abord, placez un dossier de ressources sous webapp / WEB-INF, comme suit la structure

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

Deuxièmement, dans le fichier de configuration du printemps

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

Ensuite, vous pouvez accéder au contenu de votre ressource, tel que http: // localhost: 8080 / resource / image / yourimage.jpg

Il y a 2 choses à considérer (Spring Boot v1.5.2.RELEASE) - 1) Vérifiez toutes les classes de contrôleur pour l'annotation @EnableWebMvc, supprimez-la s'il y en a 2) Vérifiez les classes de contrôleur pour lesquelles l'annotation est utilisée - @RestController ou @Controller . Ne mélangez pas l'API Rest et le comportement MVC dans une seule classe. Pour MVC, utilisez @Controller et pour l'API REST, utilisez @RestController

Faire ci-dessus 2 choses a résolu mon problème. Maintenant, mon démarrage de printemps charge des ressources statiques sans aucun problème. @Controller => load index.html => charge les fichiers statiques.

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

Mettez les ressources statiques sous le répertoire:

/src/main/resources/static

ajouter cette propriété dans le fichier application.properties

server.servlet.context-path=/pdx

Vous pouvez accéder à partir de http: // localhost: 8080 / pdx / images / image.jpg

Si le problème survient lors du lancement de l'application à partir d'un IDE (c'est-à-dire à partir d'Eclipse ou d'IntelliJ Idea) et à l'aide de Maven, la clé de la solution se trouve dans la documentation de démarrage de Spring-boot :

Si vous utilisez Maven, exécutez:

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

L'important est d'ajouter l' packageobjectif à exécuter avant que l'application ne soit réellement lancée. (Idée: Runmenu, Edit Configrations..., Addet il sélectionner Run Maven Goalet spécifier le packagebut sur le terrain)

J'utilise 1.3.5 et j'héberge un tas de services REST via l'implémentation Jersey. Cela a bien fonctionné jusqu'à ce que je décide d'ajouter quelques fichiers HTML + js. Aucune des réponses données sur ce forum ne m'a aidé. Cependant, lorsque j'ai ajouté la dépendance suivante dans mon pom.xml, tout le contenu de src / main / resources / static était finalement affiché via le navigateur:

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

Il semble que spring-web / spring-webmvc soit la dépendance transitive importante qui active la configuration automatique de spring boot.

FYI: J'ai également remarqué que je peux gâcher une application de démarrage à ressort parfaitement fonctionnelle et l'empêcher de servir le contenu du dossier statique, si j'ajoute un contrôleur de repos défectueux comme ça

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

Dans cet exemple, après avoir ajouté le contrôleur défectueux au projet, lorsque le navigateur demande un fichier disponible dans le dossier statique, la réponse d'erreur est « Méthode 405 non autorisée ».

Remarquez que les chemins ne sont pas mappés dans l'exemple de contrôleur défectueux.

J'étais confronté au même problème dans Spring Boot 2.1.3 en disant que la ressource n'a pas été trouvée 404. J'ai supprimé ci-dessous de applicatiion.properties .

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

Suppression de @enableWebMVC et suppression de tout remplacement de WebMvcConfigurer

// @ EnableWebMvc

Assurez-vous également d'avoir @EnableAutoConfiguration dans votre configuration.

Et mettez toutes les ressources statiques dans src / main / resources / static et cela a finalement fonctionné comme par magie.

en utilisant Spring Boot 2. *, j'ai un contrôleur qui mappe sur les routes GetMapping({"/{var}", "/{var1}/{var2}", "/{var1}/{var2}/{var3}"})et que mon application arrête de servir des ressources.

Je sais qu'il n'est pas conseillé d'avoir de tels itinéraires mais tout dépend de l'application que vous construisez (dans mon cas, je n'ai pas d'autre choix que d'avoir de tels itinéraires)

voici donc mon hack pour m'assurer que mon application sert à nouveau les ressources. J'ai simplement un contrôleur qui correspond à mes ressources. puisque le printemps correspondra à une route directe avant tout ce qui a une variable, j'ai décidé d'ajouter une méthode de contrôleur qui mappe /imgaes/{name}et répétée pour d'autres ressources

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

et cela a résolu mon problème

J'ai eu le même problème, en utilisant gradle et éclipse et j'ai passé des heures à essayer de le comprendre.

Aucun codage requis, l'astuce est que vous devez utiliser l'option de menu Nouveau-> Dossier source (PAS Nouveau -> Dossier) pour créer le dossier statique sous src / main / resources. Je ne sais pas pourquoi cela fonctionne, mais j'ai fait nouveau -> dossier source, puis j'ai nommé le dossier statique (la boîte de dialogue du dossier source donne une erreur pour laquelle vous devez vérifier: Mettre à jour les filtres d'exclusion dans d'autres dossiers source pour résoudre l'imbrication). Le mon nouveau dossier statique, j'ai ajouté index.html et maintenant cela fonctionne.

Il vaut parfois la peine de vérifier si vous avez remplacé les mappages globaux par un contrôleur de repos. Exemple d'erreur simple (kotlin):

@RestController("/foo")
class TrainingController {

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

}

Dans le cas ci-dessus, vous obtiendrez lorsque vous demanderez des ressources statiques:

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

La raison de cela pourrait être que vous vouliez carte @PostMappingà /foomais oublier une @RequestMappingannotation sur le @RestControllerniveau. Dans ce cas, toutes les demandes sont mappées POSTet vous ne recevrez pas de contenu statique dans ce cas.

Étant donné les ressources sous src / main / resources / static, si vous ajoutez ce code, alors tout le contenu statique de src / main / resources / static sera disponible sous "/":

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

Dans mon cas, certains fichiers statiques n'étaient pas servis, comme les polices .woff et certaines images. Mais css et js fonctionnaient très bien.

Mise à jour: Une bien meilleure solution pour que Spring Boot serve correctement les polices woff consiste à configurer le filtrage des ressources mentionné dans cette réponse, par exemple (notez que vous avez besoin à la fois d'inclusions et d'exclusions):

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

----- Ancienne solution (fonctionne mais corrompra certaines polices) -----

Une autre solution consistait à désactiver la correspondance de modèle de suffixe avec 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édits: @Abhiji m'a pointé avec 4. dans la bonne direction!

Les demandes adressées à / ** sont évaluées vers des emplacements statiques configurés dans resourceProperties .

l'ajout de ce qui suit sur application.properties, peut être la seule chose à faire ...

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

cela écrasera les emplacements statiques par défaut, à savoir:

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

Vous pourriez ne pas vouloir faire cela et vous assurer simplement que vos ressources se retrouvent dans l'un de ces dossiers par défaut.

Exécution d'une requête: Si j'aurais example.html stocké sur /public/example.html alors je peux y accéder comme ceci:

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

Si je veux un autre uri comme <host>/<context-path>/magico/*pour les fichiers dans classpath: / magicofiles / * vous avez besoin d'un peu plus de configuration

@Configuration
class MyConfigClass implements WebMvcConfigurer

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

Comme indiqué ci-dessus, le fichier doit être dans $ClassPath/static/images/name.png, (/ static ou / public ou / resources ou / META-INF / resources). Ce $ ClassPath signifie main/resourcesou main/javadir.

Si vos fichiers ne sont pas dans des répertoires standard, vous pouvez ajouter la configuration suivante:

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

}