2015-04-21 19 views
18

Sto cercando di aggiungere una pagina jsp nel mio servizio Spring Boot. Il mio problema è che ogni volta che cerco di andare a quella pagina ho questo:Spring Boot JSP 404

Whitelabel errore Pagina

Questa applicazione non ha alcuna mappatura esplicita per/errore, in modo che state vedendo questo come un ripiego.

Mar 21 Apr 23:16:00 EEST 2015 Si è verificato un errore imprevisto (tipo = non Trovato, stato = 404). Nessuna informazione disponibile

Ho aggiunto il prefisso e Sufix nelle mie application.properties:

spring.view.prefix: /WEB-INF/jsp/ 
spring.view.suffix: .jsp 

Questa è la mia classe controller:

@Controller 
public class MarkerController { 
    @RequestMapping(value="/map") 
    public String trafficSpy() { 
     return "index"; 
    } 
} 

La mia classe di applicazione:

@SpringBootApplication 
public class Application extends SpringBootServletInitializer { 
    private static Logger logger = Logger.getLogger(Application.class.getName()); 

    public static void main(String[] args) { 
      logger.info("SPRING VERSION: " + SpringVersion.getVersion()); 
      SpringApplication.run(Application.class, args); 
     } 
} 

E index.jsp:

<!DOCTYPE html> 
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 
<html lang="en"> 

<body> 
    <h1>Hello, World!!!</h1> 


    <p>JSTL URL: ${url}</p> 
</body> 

</html> 

e questa è la struttura del file src:

├── src 
│   ├── main 
│   │   ├── java 
│   │   │   └── com 
│   │   │    └── example 
│   │   │     └── internetprogramming 
│   │   │      └── myserver 
│   │   │       └── server 
│   │   │        ├── Application.java 
│   │   │        ├── config 
│   │   │        │   └── DatabaseConfig.java 
│   │   │        ├── controller 
│   │   │        │   └── MarkerController.java 
│   │   │        ├── dao 
│   │   │        │   ├── MarkerDaoImplementation.java 
│   │   │        │   └── MarkerDaoInterface.java 
│   │   │        ├── Marker.java 
│   │   │        └── service 
│   │   │         ├── MarkerServiceImplementation.java 
│   │   │         └── MarkerServiceInterface.java 
│   │   ├── resources 
│   │   │   └── application.properties 
│   │   └── webapp 
│   │    └── WEB-INF 
│   │     └── jsp 
│   │      └── index.jsp 
+0

Qual è l'URL che si sta tentando di accedere? – Andy

+1

localhost: 8080/map Ho aggiunto una stampa di debug nel metodo e stampa il messaggio in modo che venga chiamato il metodo. – definera

risposta

20

Assicurarsi di disporre di diaspro e JSTL nella lista delle dipendenze:

<dependency> 
     <groupId>org.apache.tomcat.embed</groupId> 
     <artifactId>tomcat-embed-jasper</artifactId> 
     <scope>provided</scope> 
    </dependency> 
    <dependency> 
     <groupId>javax.servlet</groupId> 
     <artifactId>jstl</artifactId> 
    </dependency> 

Qui è un progetto di avviamento di lavoro - https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-web-jsp

+1

E 'stato! Ho avuto la dipendenza da jstl, ma non il diaspro. Ha funzionato dopo averlo aggiunto. Grazie! – definera

+2

Inoltre! Per gli altri con problemi simili quando si utilizza Spring Boot 1.3.0 è probabile che le proprietà 'spring.view.prefix' e' spring.view.suffix' abbiano cambiato il nome in 'spring.mvc.view.prefix' e' spring. mvc.view.prefisso »rispettivamente. [Maggiori informazioni qui] (https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-1.3.0-M2-Release-Notes#property-renames). – worldsayshi

+4

Ho avuto lo stesso problema. Nel mio caso, ho anche dovuto rimuovere lo scope fornito dalla dipendenza di javper tomcat-embed prima che funzionasse! – NickGreen

0

Spring MVC non offre (fall-back) pagina di errore predefinita out-of-the-box. Il modo più comune per impostare una pagina di errore predefinita è sempre stato il SimpleMappingExceptionResolver (poiché Spring V1 in effetti). Tuttavia Spring Boot fornisce anche una pagina di gestione degli errori di fallback.

All'avvio, Spring Boot tenta di trovare una mappatura per /error. Per convenzione, un URL che termina con /error esegue il mapping ad una vista logica con lo stesso nome: error. Generalmente questa vista mappa a sua volta nel modello error.html Thymeleaf. (Se si utilizza JSP, si assocerebbe a error.jsp in base all'impostazione del proprio InternalResourceViewResolver ).


Primavera Boot utilizzerà automaticamente e configurare Thymeleaf come il motore di visualizzazione di rendering, a patto che si trova sul classpath.

Thymeleaf con Maven:

Assicurarsi di avere Maven 3 installato con il seguente comando: mvn --version. Passare alla directory che si desidera creare il progetto in ed eseguire Maven archtetype:

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=pl.codeleak.demos.sbt -DartifactId=spring-boot-thymeleaf -interactiveMode=false 

Il comando precedente creerà una nuova directory primavera-boot-thymeleaf. Ora puoi importarlo sul tuo IDE. Il prossimo passo è configurare l'applicazione. Aprire pom.xml e aggiungere un progetto principale:

<parent> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-parent</artifactId> 
    <version>1.1.8.RELEASE</version> 
</parent> 

valori del progetto genitore sarà il valore predefinito per questo progetto se lasciati non specificato. Il prossimo passo è aggiungere dipendenze web. Per fare ciò, ho prima rimosso tutte le dipendenze precedenti (junit 3.8.1 in realtà) e ha aggiunto le dipendenze di seguito:

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

Ora, aspetta un secondo fino a Maven scarica le dipendenze e la dipendenza eseguire mvn: Albero di vedere ciò che le dipendenze sono inclusi. La prossima cosa è una configurazione di imballaggio. Aggiungiamo primavera Boot Maven Plugin:

<build> 
    <plugins> 
     <plugin> 
      <groupId>org.springframework.boot</groupId> 
      <artifactId>spring-boot-maven-plugin</artifactId> 
     </plugin> 
    </plugins> 
</build> 

Thymeleaf con Gradle:

Per mettere Thymeleaf nel classpath utilizzare

compile("org.springframework.boot:spring-boot-starter-thymeleaf") 

nel file di configurazione Gradle (usando la dipendenza rilevante Maven è semplice).

Nel vostro caso per visualizzare la vista index.jsp (in base al controller in uso), è necessario posizionarlo sotto src/main/resources/templates/.


Se il mapping non da/di errore per una visualizzazione può essere trovato, Primavera di avvio definisce una propria pagina di errore di ripiego - il cosiddetto Whitelabel Error Page (una pagina minimo con solo le informazioni di stato HTTP e gli eventuali dettagli di errore , ad esempio il messaggio di un'eccezione non rilevata).

+1

Grazie per la tua risposta dettagliata ma non voglio mappare da/errore. Voglio index.jsp per essere restituito e renderizzato quando vai a /map – definera

3

Il mio problema era che stavo usando @RestController invece di @Controller come l'annotazione nella mia classe controller. Spero che questo possa aiutare qualcuno.

4

Nelle versioni più recenti di primavera, seguito deve essere messo in application.properties File:

spring.mvc.view.prefix =/WEB-INF/jsp/
spring.mvc.view.suffix = .jsp

Inoltre, i file JSP devono essere messi sotto src/main/risorse/META-INF/risorse/WEB-INF/jsp

+0

Questo lo ha risolto per me –

+0

sicuro, tuttavia questa è solo una configurazione e, sebbene sia efficace negli scenari più comuni, riflette solo la posizione desiderata dei jsps. Potrei impostare questi a 'spring.mvc.view.prefix =/WEB-INF/foo/bar/jsp' e mettere tutti i miei jsps lì se volessi. – coderatchet

1

mio problema è stato Primavera vesrion: ho trovato che dalla versione 1.4.3 e sopra s top che supportano le JSP integrate. Quindi cambio la versione in 1.4.1, ha funzionato per me.

un'altra cosa decollare:

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

non funzionerà con esso.

1

Oltre alle risposte di cui sopra l'applicazione deve essere distribuito come guerra invece barattolo

<groupId>com.igt</groupId> 
<artifactId>customer</artifactId> 
<version>0.0.1-SNAPSHOT</version> 
<packaging>war</packaging> 

per eseguire

java -jar customer-0.0.1-SNAPSHOT.war 

Anche Se avete intenzione di avviare l'applicazione come una guerra o come un'applicazione eseguibile, è necessario condividere le personalizzazioni del builder in un metodo disponibile sia per il callback SpringBootServletInitializer che per il metodo main, ad esempio

package com.igt.customer; 

import java.util.Arrays; 

import org.springframework.boot.CommandLineRunner; 
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
import org.springframework.boot.builder.SpringApplicationBuilder; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.annotation.Bean; 



@SpringBootApplication 
public class CustomerApplication extends org.springframework.boot.web.support.SpringBootServletInitializer { 


    @Override 
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { 
     return application.sources(CustomerApplication.class); 
    } 

    public static void main(String[] args) { 
     SpringApplication.run(CustomerApplication.class, args); 
    } 



    @Bean 
     public CommandLineRunner commandLineRunner(ApplicationContext ctx) { 
      return args -> { 

       System.out.println("Let's inspect the beans provided by Spring Boot:"); 

       String[] beanNames = ctx.getBeanDefinitionNames(); 
       Arrays.sort(beanNames); 
       for (String beanName : beanNames) { 
        System.out.println(beanName); 
       } 

      }; 
     } 


} 

Vedere

this

-1

Cercare di aggiungere i file vostro errore jsp nella cartella di errore.

application.properties 
spring.mvc.view.prefix=/views/jsp/ 
spring.mvc.view.suffix=.jsp 

jsp files : 
/views/jsp/error/401.jsp 
/views/jsp/error/404.jsp - to display 404 instead of default whitelabel page 
+0

E dov'è la risposta per il problema sopra riportato? – Aditzu

0

È possibile utilizzare thymeleaf con jsp, ma si deve scrivere:

spring.thymeleaf.excluded-view-names=#jsp file without extension 

nel file di application.properties

0

Per avere questa in pom.xml

<!-- JSP --> 
<dependency> 
    <groupId>org.apache.tomcat.embed</groupId> 
    <artifactId>tomcat-embed-jasper</artifactId> 
    <scope>provided</scope> 
</dependency> 
<!-- jstl for jsp --> 
<dependency> 
    <groupId>javax.servlet</groupId> 
    <artifactId>jstl</artifactId> 
</dependency> 

E ' potrebbe non essere abbastanza

Da non perdere.

<packaging>war</packaging> 

In caso contrario quando si genera il pacchetto, si otterrà un file jar e che non hanno né la JSP Tomcat incorporato.

vedi esempio runable e la sua spiegazione qui https://www.surasint.com/spring-boot-jsp/

0

Si potrebbe ottenere questo errore in 2 casi:

O si dimentica di aggiungere jsp compilare le dipendenze:

<dependency> 
    <groupId>org.apache.tomcat.embed</groupId> 
    <artifactId>tomcat-embed-jasper</artifactId> 
    <scope>provided</scope> 
</dependency> 

o siete imballaggio la tua domanda come jar invece di war, attualmente esistono limitazioni in Spring Boot per supportare JSP all'interno del file jar (th e vista resolver non sarebbe mappato correttamente).

È possibile controllare questo esempio completo per ulteriori spiegazioni: Spring Boot + JSP