Spring Boot non offre contenuto statico

Non riesco a far sì che il mio progetto Spring-boot offra contenuti statici.

Ho inserito una cartella staticsotto src/main/resources. Al suo interno ho una cartella chiamata images. Quando impacco l'app e la eseguo, non riesce a trovare le immagini che ho inserito in quella cartella.

Ho cercato di mettere i file statici in public, resourcese META-INF/resourcesma non funziona niente.

Se io jar -tvf app.jar posso vedere che i file sono all'interno del jar nella cartella giusta: /static/images/head.pngper esempio, ma chiamando :, http://localhost:8080/images/head.pngtutto ciò che ottengo è un404

Qualche idea sul perché lo stivale a molla non lo trovi? (Sto usando 1.1.4 BTW)

Non risuscitare i morti dopo più di un anno, ma tutte le risposte precedenti mancano alcuni punti cruciali:

1. @EnableWebMvcsulla tua classe verrà disattivato org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration. Va bene se vuoi il controllo completo, ma per il resto, è un problema.

2. Non è necessario scrivere alcun codice per aggiungere un'altra posizione per le risorse statiche oltre a quanto già fornito. Guardando org.springframework.boot.autoconfigure.web.ResourcePropertiesda v1.3.0.RELEASE, vedo un campo staticLocationsche può essere configurato in application.properties. Ecco uno snippet dalla 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. Come accennato in precedenza, l'URL della richiesta verrà risolto rispetto a queste posizioni. Pertanto src/main/resources/static/index.htmlverrà pubblicato quando l'URL della richiesta è /index.html. La classe responsabile della risoluzione del percorso, a partire dalla primavera 4.1, è org.springframework.web.servlet.resource.PathResourceResolver.

4. La corrispondenza del suffisso è abilitata per impostazione predefinita, il che significa che per un URL di richiesta /index.html, Spring cercherà i gestori corrispondenti /index.html. Questo è un problema se l'intenzione è quella di servire contenuto statico. Per disabilitarlo, estendi WebMvcConfigurerAdapter(ma non usa @EnableWebMvc) e sovrascrivi configurePathMatchcome mostrato di seguito:

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

IMHO, l'unico modo per avere meno bug nel tuo codice è non scrivere il codice ogni volta che è possibile. Usa ciò che è già fornito, anche se richiede un po 'di ricerca, ne vale la pena.

A differenza di quanto afferma Spring-Boot, per ottenere il mio vaso Spring-Boot per servire il contenuto: ho dovuto aggiungere in modo specifico registrare il mio contenuto src / main / resources / static attraverso questa classe di configurazione:

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

Ho avuto un problema simile e si è scoperto che la soluzione semplice era estendere la mia classe di configurazione WebMvcAutoConfiguration:

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

Non avevo bisogno di nessun altro codice per consentire la pubblicazione del mio contenuto statico, tuttavia, ho inserito una directory chiamata publicsotto src/main/webappe ho configurato maven in modo da indicare src/main/webappuna directory di risorse. Ciò significa che publicviene copiato in target/classes, ed è quindi sul percorso di classe in fase di esecuzione per essere trovato da Spring-Boot / Tomcat.

Cerca i controller mappati su "/" o senza percorso mappato.

Ho avuto un problema del genere, con 405 errori e mi sono sbattuto la testa per giorni. Il problema si è rivelato essere un @RestControllercontroller con annotazioni che avevo dimenticato di annotare con @RequestMappingun'annotazione. Immagino che questo percorso mappato sia predefinito su "/" e abbia bloccato la mappatura delle risorse di contenuto statico.

La configurazione potrebbe essere effettuata come segue:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcAutoConfigurationAdapter {

// specific project configuration

}

È importante qui che il tuo metodo di override WebMvcConfig possa essere annullato addResourceHandlerse pertanto devi invocare esplicitamentesuper.addResourceHandlers(registry) (è vero che se sei soddisfatto delle posizioni delle risorse predefinite non hai bisogno di sovrascrivere alcun metodo).

Un'altra cosa che ha bisogno di essere commentate qui è che quei luoghi di risorse di default ( /static, /public, /resourcese /META-INF/resources) saranno registrate solo se non v'è già un gestore di risorse mappata/** .

Da questo momento in poi, se si dispone di un'immagine con un src/main/resources/static/imagesnome, image.jpgad esempio, è possibile accedervi utilizzando il seguente URL: http://localhost:8080/images/image.jpg(essendo il server avviato sulla porta 8080 e l'applicazione distribuita nel contesto principale).

Hai controllato i documenti di riferimento di Spring Boot ?

Per impostazione predefinita, Spring Boot servirà contenuto statico da una cartella chiamata /static(o /publico /resourceso /META-INF/resources) nel percorso di classe o dalla radice di ServletContext.

Puoi anche confrontare il tuo progetto con la guida Serving Content Web con Spring MVC o consultare il codice sorgente del progetto spring-boot-sample-web-ui .

Stavo avendo questo esatto problema, poi ho capito che avevo definito nella mia application.properties:

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

Il che stava scavalcando tutto il resto che avevo provato. Nel mio caso, volevo mantenere entrambi, quindi ho semplicemente mantenuto la proprietà e aggiunto:

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

Che ha servito file da src / main / resources / static come localhost: {port} /file.html.

Nessuna delle precedenti ha funzionato per me perché nessuno ha menzionato questa piccola proprietà che avrebbe potuto essere facilmente copiata dall'online per servire a uno scopo diverso;)

Spero che sia d'aiuto! Ho pensato che si adattava bene a questo lungo post di risposte per le persone con questo problema.

Penso che le risposte precedenti affrontino molto bene l'argomento. Tuttavia, aggiungerei che in un caso quando Spring Security è abilitato nella tua applicazione, potresti dover dire espressamente a Spring di consentire richieste ad altre directory di risorse statiche come ad esempio "/ static / fonts" .

Nel mio caso avevo "/ static / css", "/ static / js", "/ static / images" consentito per impostazione predefinita, ma / static / fonts / ** è stato bloccato dalla mia implementazione di Spring Security.

Di seguito è riportato un esempio di come ho risolto questo problema.

@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 per aggiungere l'ennesima risposta a una vecchia domanda ... Le persone hanno menzionato @EnableWebMvcche impedirà il WebMvcAutoConfigurationcaricamento, che è il codice responsabile della creazione dei gestori di risorse statiche. Esistono anche altre condizioni che impediranno il WebMvcAutoConfigurationcaricamento. Il modo più chiaro per vedere questo è guardare la 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

Nel mio caso, stavo includendo una libreria che aveva una classe che si stava estendendo da WebMvcConfigurationSupportcui è una condizione che impedirà l'autoconfigurazione:

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

È importante non estendersi maiWebMvcConfigurationSupport . Invece, estendi da WebMvcConfigurerAdapter.

AGGIORNAMENTO: Il modo corretto per farlo in 5.x è implementare WebMvcConfigurer

Questa soluzione funziona per me:

Innanzitutto, inserisci una cartella di risorse in webapp / WEB-INF, come segue struttura

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

In secondo luogo, nel file di configurazione di 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/");
    }
}

Quindi, è possibile accedere al contenuto delle risorse, ad esempio http: // localhost: 8080 / resource / image / yourimage.jpg

Ci sono 2 cose da considerare (Spring Boot v1.5.2.RELEASE) - 1) Controlla tutte le classi Controller per l'annotazione @EnableWebMvc, rimuovila se ce ne sono 2) Controlla le classi Controller per cui viene usata l'annotazione - @RestController o @Controller . Non mescolare il comportamento API Rest e MVC in una classe. Per MVC utilizzare @Controller e per l'API REST utilizzare @RestController

Fare sopra 2 cose ha risolto il mio problema. Ora il mio avvio a molla sta caricando risorse statiche senza problemi. @Controller => load index.html => carica i file statici.

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

Inserisci le risorse statiche nella directory:

/src/main/resources/static

aggiungi questa proprietà nel file application.properties

server.servlet.context-path=/pdx

È possibile accedere da http: // localhost: 8080 / pdx / images / image.jpg

Nel caso in cui il problema si presenti quando si avvia l'applicazione dall'interno di un IDE (ovvero a partire da Eclipse o IntelliJ Idea) e si utilizza Maven, la chiave della soluzione è nella documentazione di avvio di Spring-boot :

Se stai usando Maven, esegui:

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

La parte importante della quale è l'aggiunta packagedell'obiettivo da eseguire prima dell'avvio dell'applicazione. (Idea: Runmenù, Edit Configrations..., Add, e ci selezionare Run Maven Goal, e specificare l' packageobiettivo nel campo)

Sto usando 1.3.5 e ospito un sacco di servizi REST tramite l'implementazione di Jersey. Ha funzionato bene fino a quando ho deciso di aggiungere un paio di file HTML + js. Nessuna delle risposte fornite in questo forum mi ha aiutato. Tuttavia, quando ho aggiunto la seguente dipendenza nel mio pom.xml, tutto il contenuto in src / main / resources / static veniva finalmente mostrato tramite browser:

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

Sembra che spring-web / spring-webmvc sia l'importante dipendenza transitiva che attiva la configurazione automatica dell'avvio a molla.

Cordiali saluti: Ho anche notato che posso rovinare un'app di avvio a molla perfettamente funzionante e impedirle di pubblicare contenuti dalla cartella statica, se aggiungo un controller di resto difettoso in questo modo

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

In questo esempio, dopo aver aggiunto il controller errato al progetto, quando il browser richiede un file disponibile nella cartella statica, la risposta di errore è " Metodo 405 non consentito ".

I percorsi di avviso non sono mappati nell'esempio di controller errato.

Stavo affrontando lo stesso problema in Spring Boot 2.1.3 dicendo che la risorsa non è stata trovata 404. Ho rimosso di seguito da applicion.properties .

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

Rimosso @enableWebMVC e rimosso qualsiasi override di WebMvcConfigurer

// @ EnableWebMvc

Assicurati anche di avere @EnableAutoConfiguration nella tua configurazione.

E metti tutte le risorse statiche in src / main / resources / static e alla fine ha funzionato come per magia ..

utilizzando Spring Boot 2. *, ho un controller che esegue il mapping alle rotte GetMapping({"/{var}", "/{var1}/{var2}", "/{var1}/{var2}/{var3}"})e che la mia app smette di servire risorse.

so che non è consigliabile avere tali percorsi, ma tutto dipende dall'app che stai costruendo (nel mio caso, non ho altra scelta che avere tali percorsi)

quindi ecco il mio trucco per assicurarsi che la mia app serva nuovamente le risorse. Ho semplicemente un controller che mappa le mie risorse. dato che la primavera corrisponderà a un percorso diretto prima di qualsiasi variabile che abbia, ho deciso di aggiungere un metodo controller che mappasse /imgaes/{name}e ripetuto lo stesso per altre risorse

@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 questo ha risolto il mio problema

Ho avuto lo stesso problema, usando Gradle ed Eclissi e ho passato ore a cercare di capirlo.

Non è richiesta alcuna codifica, il trucco è che è necessario utilizzare l'opzione di menu Nuovo-> Cartella di origine (NON nuovo -> Cartella) per creare la cartella statica in src / main / resources. Non so perché funzioni, ma ho fatto la nuova -> cartella di origine, quindi ho chiamato la cartella statica (quindi la finestra di dialogo della cartella di origine fornisce un errore per il quale è necessario verificare: Aggiorna i filtri di esclusione in altre cartelle di origine per risolvere l'annidamento). La mia nuova cartella statica ho aggiunto index.html e ora funziona.

Beh, a volte vale la pena controllare se hai sovrascritto le mappature globali da alcuni controller di riposo. Semplice errore di esempio (kotlin):

@RestController("/foo")
class TrainingController {

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

}

Nel caso precedente otterrai quando richiedi risorse statiche:

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

La ragione per questo potrebbe essere che si voleva mappare @PostMappinga /fooma dimenticare @RequestMappingl'annotazione sul @RestControllerpiano. In questo caso, tutte le richieste sono mappate POSTe in questo caso non riceverai contenuti statici.

Date le risorse in src / main / resources / static, se aggiungi questo codice, tutto il contenuto statico di src / main / resources / static sarà disponibile in "/":

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

Nel mio caso, alcuni file statici non sono stati serviti, come i caratteri .woff e alcune immagini. Ma css e js hanno funzionato bene.

Aggiornamento: una soluzione molto migliore per fare in modo che Spring Boot serva correttamente i caratteri woff consiste nel configurare il filtro delle risorse menzionato in questa risposta, ad esempio (si noti che è necessario includere sia ed escludere):

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

----- Vecchia soluzione (funzionante ma corromperà alcuni caratteri) -----

Un'altra soluzione era disabilitare la corrispondenza del modello di suffisso 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);
    }
}

Crediti: @Abhiji mi ha indicato 4. nella giusta direzione!

Le richieste a / ** vengono valutate in posizioni statiche configurate in resourceProperties .

aggiungendo quanto segue su application.properties, potrebbe essere l'unica cosa che devi fare ...

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

questo sovrascriverà le posizioni statiche predefinite, che è:

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

Potresti non volerlo fare e assicurati solo che le tue risorse finiscano in una di quelle cartelle predefinite.

Esecuzione di una richiesta: se dovessi avere example.html archiviato su /public/example.html, allora posso accedervi in ​​questo modo:

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

Se volessi un altro uri come <host>/<context-path>/magico/*per i file in classpath: / magicofiles / * hai bisogno di un po 'più di configurazione

@Configuration
class MyConfigClass implements WebMvcConfigurer

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

Come detto sopra, il file dovrebbe essere in $ClassPath/static/images/name.png(/ static o / public o / resources o / META-INF / resources). Questo $ ClassPath significa main/resourceso main/javadir.

Se i tuoi file non sono in dir standard, puoi aggiungere la seguente configurazione:

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

}