Questa applicazione non ha una mappatura esplicita per / error

Ho usato Maven per fare il tutorial https://spring.io/guides/gs/uploading-files/
Tutti i codici che ho usato sono stati copiati.

L'applicazione può essere eseguita, ma ottengo l'errore:

Pagina di errore Whitelabel Questa applicazione non ha una mappatura esplicita per / error, quindi stai vedendo questo come ripiego. Tue Jun 30 17:24:02 CST 2015 Si è verificato un errore imprevisto (tipo = Non trovato, stato = 404). Nessun messaggio disponibile

Come posso risolverlo?

Assicurati che la tua classe principale sia in un pacchetto root sopra le altre classi.

Quando esegui un'applicazione Spring Boot, (cioè una classe annotata con @SpringBootApplication), Spring scansionerà solo le classi sotto il pacchetto della classe principale.

com
   +- APP
         +- Application.java  <--- your main class should be here, above your controller classes
         |
         +- model
         |   +- user.java
         +- controller
             +- UserController.java

Quando creiamo un'applicazione Spring boot, la annotiamo con @SpringBootApplicationannotation. Questa annotazione "racchiude" molte altre annotazioni necessarie affinché l'applicazione funzioni. Una di queste annotazioni è l' @ComponentScanannotazione. Questa annotazione dice a Spring di cercare i componenti di Spring e di configurare l'applicazione per l'esecuzione.

La classe dell'applicazione deve essere in cima alla gerarchia dei pacchetti, in modo che Spring possa eseguire la scansione dei sotto-pacchetti e trovare gli altri componenti richiesti.

package com.test.spring.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Lo snippet di codice riportato di seguito funziona poiché il pacchetto del controller è in com.test.spring.bootpackage

package com.test.spring.boot.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HomeController {

    @RequestMapping("/")
    public String home(){
        return "Hello World!";
    }
}

Il frammento di codice riportato di seguito NON funziona poiché il pacchetto del controller NON è incluso nel com.test.spring.bootpacchetto

package com.test.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HomeController {

     @RequestMapping("/")
     public String home(){
         return "Hello World!";
     }
 }

Dalla documentazione di Spring Boot:

Molti sviluppatori Spring Boot hanno sempre la loro classe principale annotata con @Configuration, @EnableAutoConfiguratione @ComponentScan. Poiché queste annotazioni sono così spesso utilizzate insieme (soprattutto se segui le migliori pratiche sopra), Spring Boot fornisce una comoda @SpringBootApplicationalternativa.

L' @SpringBootApplicationannotazione è equivalente ad usare @Configuration, @EnableAutoConfiguratione @ComponentScancon i loro attributi di default

Puoi risolvere questo problema aggiungendo un ErrorControllernella tua applicazione. Puoi fare in modo che il controller degli errori restituisca una vista di cui hai bisogno.

Il controller degli errori nella mia applicazione ha il seguente aspetto:

import org.springframework.boot.autoconfigure.web.ErrorAttributes;
import org.springframework.boot.autoconfigure.web.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * Basic Controller which is called for unhandled errors
 */
@Controller
public class AppErrorController implements ErrorController{

    /**
     * Error Attributes in the Application
     */
    private ErrorAttributes errorAttributes;

    private final static String ERROR_PATH = "/error";

    /**
     * Controller for the Error Controller
     * @param errorAttributes
     */
    public AppErrorController(ErrorAttributes errorAttributes) {
        this.errorAttributes = errorAttributes;
    }

    /**
     * Supports the HTML Error View
     * @param request
     * @return
     */
    @RequestMapping(value = ERROR_PATH, produces = "text/html")
    public ModelAndView errorHtml(HttpServletRequest request) {
        return new ModelAndView("/errors/error", getErrorAttributes(request, false));
    }

    /**
     * Supports other formats like JSON, XML
     * @param request
     * @return
     */
    @RequestMapping(value = ERROR_PATH)
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request, getTraceParameter(request));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }

    /**
     * Returns the path of the error page.
     *
     * @return the error path
     */
    @Override
    public String getErrorPath() {
        return ERROR_PATH;
    }


    private boolean getTraceParameter(HttpServletRequest request) {
        String parameter = request.getParameter("trace");
        if (parameter == null) {
            return false;
        }
        return !"false".equals(parameter.toLowerCase());
    }

    private Map<String, Object> getErrorAttributes(HttpServletRequest request,
                                                   boolean includeStackTrace) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(request);
        return this.errorAttributes.getErrorAttributes(requestAttributes,
                includeStackTrace);
    }

    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request
                .getAttribute("javax.servlet.error.status_code");
        if (statusCode != null) {
            try {
                return HttpStatus.valueOf(statusCode);
            }
            catch (Exception ex) {
            }
        }
        return HttpStatus.INTERNAL_SERVER_ERROR;
    }
}

La classe precedente è basata sulla classe Springs BasicErrorController .

Puoi istanziare quanto sopra in ErrorControllerquesto modo in un @Configurationfile:

 @Autowired
 private ErrorAttributes errorAttributes;

 @Bean
 public AppErrorController appErrorController(){return new AppErrorController(errorAttributes);}

Puoi scegliere di ignorare il valore predefinito ErrorAttributesimplementando ErrorAttributes . Ma nella maggior parte dei casi DefaultErrorAttributes dovrebbe essere sufficiente.

Nel mio caso la classe controller è stata annotata con @Controller. Cambiarlo per @RestControllerrisolvere il problema. Fondamentalmente @RestControllerè @Controller + @ResponseBody così o usa @RestControllero @Controllercon @ResponseBodyannotazioni con ogni metodo.

Alcune note utili qui: https://www.genuitec.com/spring-frameworkrestcontroller-vs-controller/

nel mio caso è a causa della posizione del pacchetto, il che significa che il pacchetto del controller deve essere sopra il pacchetto della classe principale

se il mio pacchetto di classe principale è package co.companyname.spring.tutorial;qualsiasi pacchetto di controller dovrebbepackage co.companyname.spring.tutorial.WHAT_EVER_HERE;

package co.companyname.spring.tutorial; // package for main class
@SpringBootApplication
public class FirstProjectApplication {

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


package co.companyname.spring.tutorial.controllers; // package for controllers 

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController 
public class HelloController { 

@RequestMapping("/hello")  
public String hello() {   
 return "Hello, world"; 
 }}

dopo aver terminato la codifica premere il cruscotto di avvio

un'ultima cosa per assicurarti che il tuo controller stia mappando o non solo la console dovresti vedere qualcosa di simpatico

Mapped "{[/hello]}" onto public java.lang.String co.companyname.spring.tutorial.controllers.HelloController.hello()

codifica felice

Prova ad aggiungere la dipendenza.

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

Ciò accade quando non è definita una pagina di errore esplicita. Per definire una pagina di errore, creare una mappatura di / error con una vista. ad esempio, il codice seguente viene mappato a un valore stringa restituito in caso di errore.

package com.rumango.controller;

import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class IndexController implements ErrorController{
    private final static String PATH = "/error";
    @Override
    @RequestMapping(PATH)
    @ResponseBody
    public String getErrorPath() {
        // TODO Auto-generated method stub
        return "No Mapping Found";
    }

}

Ho aggiunto questa dipendenza e ha risolto il mio problema.

<dependency>
    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Sto sviluppando l'applicazione Spring Boot per alcune settimane .. E stavo ricevendo lo stesso errore come di seguito;

Pagina di errore Whitelabel Questa applicazione non ha una mappatura esplicita per / error, quindi stai vedendo questo come ripiego. Thu Jan 18 14:12:11 AST 2018 Si è verificato un errore imprevisto (tipo = Non trovato, stato = 404). Nessun messaggio disponibile

Quando ricevo questo messaggio di errore, mi sono reso conto che la mia classe controller o controller di riposo è definita come nota nel mio progetto. Voglio dire che tutti i nostri pacchetti controller non sono lo stesso pacchetto con la classe principale che include l'annotazione @SpringBootApplication .. Voglio dire che devi aggiungere il nome del tuo pacchetto controller all'annotazione @ComponentScan alla tua classe principale che è inclusa l'annotazione @SpringBootApplication. Se scrivi codici di seguito risolverà il tuo problema ... La cosa più importante è che devi aggiungere il pacchetto di tutti i controller all'annotazione @ComponentScan come ho fatto sotto

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan({ "com.controller.package1, com.controller.package2, com.controller.package3, com.controller.packageN", "controller", "service" } // If our Controller class or Service class is not in the same packages we have //to add packages's name like this...directory(package) with main class
public class MainApp {
    public static void main(String[] args) {
        SpringApplication.run(MainApp.class, args);
    }
}

Spero che questi codici aiuteranno qualcuno ...

Se trovi un altro modo per risolvere questo errore o hai qualche suggerimento per me, scrivi ai commenti ... grazie ...

Nella classe principale, dopo la configurazione "@SpringBootApplication", l'aggiunta di "@ComponentScan" senza argomenti, ha funzionato per me !!!

Classe principale:

@SpringBootApplication
@ComponentScan
public class CommentStoreApplication {

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

    }
}

Classe RestController:

@RestController
public class CommentStoreApp {

    @RequestMapping("/") 
    public String hello() {
        return "Hello World!";
    }
}

PS: non perdere i comandi mvn clean e mvn install, prima di avviare l'applicazione

Piuttosto tardi alla festa. Come da documentazione ufficiale di primavera "Spring Boot installa una pagina di errore whitelabel che viene visualizzata in un client del browser se si verifica un errore del server". https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-customize-the-whitelabel-error-page

1. È possibile disabilitare la funzione impostando server.error.whitelabel.enabled=falsenel file application.yml o application.properties .

2. Il modo consigliato è impostare la pagina di errore in modo che l'utente finale possa capire. Sotto risorse / templates cartella creano un error.html di file e la dipendenza aggiuntivo in pom.xml di file

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

Spring sceglierà automaticamente la pagina error.html come modello di errore predefinito. Nota: - Non dimenticare di aggiornare il progetto Maven dopo aver aggiunto la dipendenza.

Potresti ricevere l'errore, ad es

"Questa applicazione non ha una mappatura esplicita per / error, quindi lo vedi come un fallback."

Questo perché non sta scansionando le tue classi Controller & Service che devi specificare nella tua classe main () in questo modo,

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableAutoConfiguration
**@ComponentScan({"com.example.demo", "controller", "service"})**
public class SpringBootMvcExample1Application {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootMvcExample1Application.class, args);
    }
}

Nota: qui, ho specificato varie classi come demo, controller e servizio da scansionare, solo che funzionerà correttamente.

Devi organizzare i pacchetti in modo che il pacchetto contenente public static main (o dove hai scritto @SpringBootApplication), il padre di tutti gli altri tuoi pacchetti.

Per impostazione predefinita, l'avvio primaverile analizzerà il pacchetto corrente per la definizione del bean. Pertanto, se il pacchetto corrente in cui è definita la classe principale e il pacchetto del controller non è lo stesso o il pacchetto del controller non è un pacchetto figlio del pacchetto dell'app principale, non eseguirà la scansione del controller. Per risolvere questo problema, è possibile includere un elenco di pacchetti per la definizione del bean nel pacchetto principale

@SpringBootApplication(scanBasePackages = {"com.module.restapi1.controller"})

oppure creare una gerarchia di pacchetto in cui il pacchetto figlio è derivato dal pacchetto principale

package com.module.restapi;
package com.module.restapi.controller

Il problema è che stai navigando su localhost: 8080 / invece di localhost: 8080 / carica come prescritto nella guida. Spring Boot ha una pagina di errore predefinita utilizzata quando si naviga in un percorso non definito per evitare di fornire dettagli specifici del server (che possono essere visualizzati come un rischio per la sicurezza).

Le tue opzioni sono: visitare la pagina giusta, aggiungere la tua pagina di destinazione o ignorare la pagina di errore bianca .

Per semplificare questa situazione particolare, ho aggiornato la guida in modo che utilizzi / invece di / upload.

So che non è esattamente la risposta alla domanda, ma questa è la prima domanda che appare su Google :)

Il problema ("Questa applicazione non ha una mappatura esplicita per / errore") viene visualizzato quando si tenta di accedere all'interfaccia utente di Swagger.

Nel mio caso i problemi sono stati causati da @RestController ("/ endpoint"), che non è gestito correttamente dalla spavalderia.

Quindi, questo ha provocato errori:

@RestController("/endpoint")
public class EndpointController {

E questo andava bene

@RestController
@RequestMapping("/endpoint")
public class EndpointController {

questo può accadere se dimentichi l'annotazione @RestController sopra la classe del controller import import org.springframework.web.bind.annotation.RestController;

e aggiungi l'annotazione come sotto

fare riferimento al semplice esempio di seguito

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;


@RestController
public class HelloController {
@RequestMapping("/")
    public String index() {
        return "Greetings from Spring Boot!";
    }

}

Cambia @Controller in @RestController nella tua classe controller e tutto dovrebbe andare liscio.

Anch'io ho ricevuto lo stesso errore e sono stato in grado di risolvere l'errore aggiungendo la seguente dipendenza al mio pom.xml.

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

Il motivo è che stiamo usando JSP come vista. Il contenitore servlet incorporato predefinito per Spring Boot Starter Web è tomcat. Per abilitare il supporto per JSP, dovremmo aggiungere una dipendenza da tomcat-embed-jasper.

Nel mio caso stavo restituendo un JSP come vista dal controller. Spero che questa risposta aiuti qualcuno che sta lottando con lo stesso problema.

Stavo affrontando lo stesso problema, usando gradle e si è risolto aggiungendo le seguenti dipendenze-

compile('org.springframework.boot:spring-boot-starter-data-jpa')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
compile('org.apache.tomcat.embed:tomcat-embed-jasper')

prima mi mancava l'ultimo che causava lo stesso errore.

Stavo affrontando questo problema e in seguito mi sono reso conto che mi mancava l' @Configurationannotazione nella MvcConfigclasse che fondamentalmente fa la mappatura per ViewControllerse setViewNames.

Ecco il contenuto del file:

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
**@Configuration**
public class MvcConfig implements WebMvcConfigurer{
   public void addViewControllers(ViewControllerRegistry registry)
   {
      registry.addViewController("/").setViewName("login");
      registry.addViewController("/login").setViewName("login");
      registry.addViewController("/dashboard").setViewName("dashboard");
   }
}

Spero che questo aiuti qualcuno !!

Assicurati di avere jasper e jstl nell'elenco 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>

Ecco un progetto iniziale funzionante: https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-web-jsp

Autore: Biju Kunjummen

Devo menzionare in questo modo e dare il riferimento ai pacchetti e ha funzionato. Puoi escludere @EnableAutoConfigurationquesta annotazione, ma è necessario che io ignori eventuali dipendenze correlate al database.

@SpringBootApplication
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
@ComponentScan(basePackages = {"your package 1", "your package2"})

public class CommentStoreApplication {

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

    }
}

La classe principale deve essere al di fuori della struttura ad albero dei pacchetti dell'app. Per esempio:

Tutto quello che ho fatto per risolvere questo tipo di problema è menzionare un'annotazione @Configuration nella classe MVCConfig.

Come questo :

package com.example;

/**
 * Created by sartika.s.hasibuan on 1/10/2017.
 */
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@EnableAutoConfiguration
@Configuration
@ComponentScan
public class MvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/home").setViewName("home");
        registry.addViewController("/").setViewName("home");
        registry.addViewController("/hello").setViewName("hello");
        registry.addViewController("/login").setViewName("login");
    }

}

Ho avuto un errore simile, uso lo spring boot e la velocità, la mia soluzione è controllare il file application.properties, spring.velocity.toolbox-config-location ha scoperto che questa proprietà è sbagliata

Nel mio caso, questo problema si verifica quando si esegue SpringApplication da IntelliJ dopo averlo eseguito prima con Maven.

Per risolvere il problema, corro prima mvn clean. Quindi eseguo SpringApplication da IntelliJ.

Assicurati che il tuo Main. la classe dovrebbe essere in cima ai tuoi controller. Nel caso del seguente esempio:

Main.class contenente:

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

EmployeeController. classe contenente:

@RestController
public class EmployeeController {
    @InitBinder
    public void setAllowedFields(WebDataBinder dataBinder) {
        dataBinder.setDisallowedFields("id");
    }

    @RequestMapping(value = "/employee/save", method = RequestMethod.GET)
    public String save(){
        Employee newEmp = new Employee();
        newEmp.setAge(25);
        newEmp.setFirstName("Pikachu");
        newEmp.setId(100);
        return "Name: " + newEmp.getFirstName() + ", Age: " + newEmp.getAge() + ", Id = " + newEmp.getId();
    }
}

Se la tua classe principale è nella cartella principale, proprio come questo percorso: {nomeprogetto} / src / main / java / main, assicurati che i tuoi controller siano sotto la tua classe principale. Ad esempio {projectname} / src / main / java / main / controllers .

Nel tuo file java (ad esempio: Viper.java) con la classe principale aggiungi: "@RestController" e @RequestMapping ("/")

@SpringBootApplication
@RestController
public class Viper {

  @RequestMapping("/")

   public String home(){
          return "This is what i was looking for";                      
     }

public static void main( String[] args){

   SpringApplication.run(Viper.class , args);
}

}

Controlla se hai contrassegnato la classe controller con l' annotazione @RestController .