So vermeiden Sie die Ausnahme „Kreisansichtspfad“ beim Spring MVC-Test

Ich habe den folgenden Code in einem meiner Controller:

@Controller
@RequestMapping("/preference")
public class PreferenceController {

    @RequestMapping(method = RequestMethod.GET, produces = "text/html")
    public String preference() {
        return "preference";
    }
}

Ich versuche einfach, es mit dem Spring MVC-Test wie folgt zu testen :

@ContextConfiguration
@WebAppConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
public class PreferenceControllerTest {

    @Autowired
    private WebApplicationContext ctx;

    private MockMvc mockMvc;
    @Before
    public void setup() {
        mockMvc = webAppContextSetup(ctx).build();
    }

    @Test
    public void circularViewPathIssue() throws Exception {
        mockMvc.perform(get("/preference"))
               .andDo(print());
    }
}

Ich erhalte die folgende Ausnahme:

Kreisansichtspfad [Präferenz]: würde erneut an die aktuelle Handler-URL [/ Präferenz] zurücksenden. Überprüfen Sie Ihr ViewResolver-Setup! (Hinweis: Dies kann das Ergebnis einer nicht angegebenen Ansicht sein, da der Name der Standardansicht generiert wurde.)

Was ich seltsam finde, ist, dass es gut funktioniert, wenn ich die "vollständige" Kontextkonfiguration lade , die die Vorlage und die Ansichtsauflöser enthält, wie unten gezeigt:

<bean class="org.thymeleaf.templateresolver.ServletContextTemplateResolver" id="webTemplateResolver">
    <property name="prefix" value="WEB-INF/web-templates/" />
    <property name="suffix" value=".html" />
    <property name="templateMode" value="HTML5" />
    <property name="characterEncoding" value="UTF-8" />
    <property name="order" value="2" />
    <property name="cacheable" value="false" />
</bean>

Mir ist klar, dass das vom Vorlagen-Resolver hinzugefügte Präfix sicherstellt, dass es keinen "kreisförmigen Ansichtspfad" gibt, wenn die App diesen Vorlagen-Resolver verwendet.

Aber wie soll ich dann meine App mit dem Spring MVC-Test testen?

Dies hat nichts mit Spring MVC-Tests zu tun.

Wenn Sie a nicht deklarieren ViewResolver, registriert Spring einen Standardwert, InternalResourceViewResolverder Instanzen JstlViewfür das Rendern von erstellt View.

Die JstlViewKlasse erweitert InternalResourceViewsich

Wrapper für eine JSP oder eine andere Ressource in derselben Webanwendung. Macht Modellobjekte als Anforderungsattribute verfügbar und leitet die Anforderung mithilfe eines javax.servlet.RequestDispatcher an die angegebene Ressourcen-URL weiter.

Eine URL für diese Ansicht soll eine Ressource in der Webanwendung angeben, die für die Weiterleitungs- oder Include-Methode von RequestDispatcher geeignet ist.

Mutig ist meins. Mit anderen Worten, die Ansicht wird vor dem Rendern versuchen, eine RequestDispatcherzu bekommen, zu der forward(). Zuvor wird Folgendes überprüft

if (path.startsWith("/") ? uri.equals(path) : uri.equals(StringUtils.applyRelativePath(uri, path))) {
    throw new ServletException("Circular view path [" + path + "]: would dispatch back " +
                        "to the current handler URL [" + uri + "] again. Check your ViewResolver setup! " +
                        "(Hint: This may be the result of an unspecified view, due to default view name generation.)");
}

Wo pathist der Ansichtsname, was Sie von der zurückgegeben haben @Controller. In diesem Beispiel also preference. Die Variable urienthält die URL der zu bearbeitenden Anforderung /context/preference.

Der obige Code erkennt, dass bei einer Weiterleitung /context/preferencedasselbe Servlet (da dasselbe das vorherige behandelt hat) die Anforderung verarbeiten würde und Sie in eine Endlosschleife geraten würden.

Wenn Sie a ThymeleafViewResolverund a ServletContextTemplateResolvermit einem bestimmten prefixund deklarieren suffix, baut es das Viewanders auf und gibt ihm einen Pfad wie

WEB-INF/web-templates/preference.html

ThymeleafViewInstanzen suchen die Datei relativ zum ServletContextPfad mithilfe von a ServletContextResourceResolver

templateInputStream = resourceResolver.getResourceAsStream(templateProcessingParameters, resourceName);`

was schließlich

return servletContext.getResourceAsStream(resourceName);

Dadurch wird eine Ressource abgerufen, die relativ zum ServletContextPfad ist. Es kann dann das verwenden TemplateEngine, um den HTML-Code zu generieren. Hier kann keine Endlosschleife passieren.

Ich habe dieses Problem mit @ResponseBody wie folgt gelöst:

@RequestMapping(value = "/resturl", method = RequestMethod.GET, produces = {"application/json"})
    @ResponseStatus(HttpStatus.OK)
    @Transactional(value = "jpaTransactionManager")
    public @ResponseBody List<DomainObject> findByResourceID(@PathParam("resourceID") String resourceID) {

@Controller → @RestController

Ich hatte das gleiche Problem und bemerkte, dass mein Controller auch mit Anmerkungen versehen war @Controller. Das Ersetzen durch hat @RestControllerdas Problem behoben. Hier ist die Erklärung von Spring Web MVC :

@RestController ist eine zusammengesetzte Annotation, die selbst mit @Controller und @ResponseBody meta-annotiert ist und einen Controller angibt, dessen jede Methode die Annotation @ResponseBody auf Typebene erbt und daher direkt in den Antworttext im Vergleich zur Ansichtsauflösung und zum Rendern mit einer HTML-Vorlage schreibt.

So habe ich dieses Problem gelöst:

@Before
    public void setup() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/jsp/view/");
        viewResolver.setSuffix(".jsp");

        mockMvc = MockMvcBuilders.standaloneSetup(new HelpController())
                                 .setViewResolvers(viewResolver)
                                 .build();
    }

Ich verwende Spring Boot, um eine Webseite zu laden, nicht zu testen, und hatte dieses Problem. Meine Lösung war etwas anders als die oben genannten, wenn man die etwas anderen Umstände berücksichtigt. (obwohl diese Antworten mir geholfen haben zu verstehen.)

Ich musste einfach meine Spring Boot-Starter-Abhängigkeit in Maven ändern von:

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

zu:

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

Nur das 'Web' in 'Thymeleaf' zu ändern, hat das Problem für mich behoben.

Hier ist eine einfache Lösung, wenn Sie das Rendern der Ansicht nicht wirklich interessieren.

Erstellen Sie eine Unterklasse von InternalResourceViewResolver, die nicht nach kreisförmigen Ansichtspfaden sucht:

public class StandaloneMvcTestViewResolver extends InternalResourceViewResolver {

    public StandaloneMvcTestViewResolver() {
        super();
    }

    @Override
    protected AbstractUrlBasedView buildView(final String viewName) throws Exception {
        final InternalResourceView view = (InternalResourceView) super.buildView(viewName);
        // prevent checking for circular view paths
        view.setPreventDispatchLoop(false);
        return view;
    }
}

Dann richten Sie Ihren Test damit ein:

MockMvc mockMvc;

@Before
public void setUp() {
    final MyController controller = new MyController();

    mockMvc =
            MockMvcBuilders.standaloneSetup(controller)
                    .setViewResolvers(new StandaloneMvcTestViewResolver())
                    .build();
}

Wenn Sie Spring Boot verwenden, fügen Sie Ihrer pom.xml die Abhängigkeit von Thymeleaf hinzu:

    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring4</artifactId>
        <version>2.1.6.RELEASE</version>
    </dependency>

Hinzufügen /nach /preferencegelöst das Problem für mich:

@Test
public void circularViewPathIssue() throws Exception {
    mockMvc.perform(get("/preference/"))
           .andDo(print());
}

In meinem Fall habe ich Kotlin + Spring Boot ausprobiert und bin zum Thema Circular View Path gekommen. Alle Vorschläge, die ich online bekam, konnten nicht helfen, bis ich Folgendes versuchte:

Ursprünglich hatte ich meinen Controller mit kommentiert @Controller

import org.springframework.stereotype.Controller

Ich habe dann ersetzt @Controllermit@RestController

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

Und es hat funktioniert.

Wenn Sie keinen @RequestBody verwendet haben und nur verwenden @Controller, ist die einfachste Möglichkeit, dies zu beheben, die Verwendung von @RestControlleranstelle von@Controller

Fügen Sie die Anmerkung @ResponseBodyIhrer Methodenrückgabe hinzu.

Ich benutze Spring Boot mit Thymeleaf. Das hat bei mir funktioniert. Es gibt ähnliche Antworten mit JSP, aber beachten Sie, dass ich HTML verwende, nicht JSP, und diese befinden sich im Ordner src/main/resources/templateswie in einem Standard-Spring Boot-Projekt, wie hier erläutert . Dies könnte auch Ihr Fall sein.

@InjectMocks
private MyController myController;

@Before
public void setup()
{
    MockitoAnnotations.initMocks(this);

    this.mockMvc = MockMvcBuilders.standaloneSetup(myController)
                    .setViewResolvers(viewResolver())
                    .build();
}

private ViewResolver viewResolver()
{
    InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

    viewResolver.setPrefix("classpath:templates/");
    viewResolver.setSuffix(".html");

    return viewResolver;
}

Hoffe das hilft.

Wenn Sie Spring Boot + Freemarker ausführen, wird folgende Seite angezeigt:

Whitelabel-Fehlerseite Diese Anwendung hat keine explizite Zuordnung für / error, daher sehen Sie dies als Fallback.

In der Version Spring-Boot-Starter-Parent 2.2.1.RELEASE funktioniert Freemarker nicht:

1. Benennen Sie Freemarker-Dateien von .ftl in .ftlh um
2. Zu application.properties hinzufügen: spring.freemarker.expose-request-attribute = true

spring.freemarker.suffix = .ftl

Für Thymeleaf:

Ich habe gerade angefangen, Spring 4 und Thymeleaf zu verwenden. Als ich auf diesen Fehler stieß, wurde er durch Hinzufügen von:

<bean class="org.thymeleaf.spring4.view.ThymeleafViewResolver">
  <property name="templateEngine" ref="templateEngine" />
  <property name="order" value="0" />
</bean> 

Wenn Sie @ControllerAnmerkungen verwenden, benötigen Sie @RequestMappingund @ResponseBodyAnmerkungen. Versuchen Sie es erneut, nachdem Sie eine Anmerkung hinzugefügt haben@ResponseBody

Ich verwende die Anmerkung, um die Spring Web App InternalResourceViewResolverzu konfigurieren. Das Problem wurde durch Hinzufügen einer Bean zur Konfiguration gelöst . Hoffe es wäre hilfreich.

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "com.example.springmvc" })
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    @Bean
    public InternalResourceViewResolver internalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/jsp/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

Dies geschieht, weil Spring "Präferenz" entfernt und die "Präferenz" erneut anfügt, wobei derselbe Pfad wie bei der Anforderung Uri verwendet wird.

So passiert: Anfrage Uri: "/ Präferenz"

"Präferenz" entfernen: "/"

Pfad anhängen: "/" + "Voreinstellung"

Endzeichenfolge: "/ Präferenz"

Dies gerät in eine Schleife, die der Frühling durch Auslösen einer Ausnahme benachrichtigt.

Es ist am besten in Ihrem Interesse, einen anderen Ansichtsnamen wie "PreferenceView" oder etwas anderes anzugeben, das Sie mögen.

Versuchen Sie, Ihrer Gradle-Datei eine Kompilierungsabhängigkeit ("org.springframework.boot: spring-boot-Starter-thymeleaf") hinzuzufügen. Thymeleaf hilft beim Zuordnen von Ansichten.

In meinem Fall hatte ich dieses Problem beim Versuch, JSP-Seiten mit der Spring-Boot-Anwendung bereitzustellen.

Folgendes hat bei mir funktioniert:

application.properties

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

pom.xml

Um die Unterstützung für JSPs zu aktivieren, müssten wir eine Abhängigkeit von Tomcat-Embed-Jasper hinzufügen.

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

Ein weiterer einfacher Ansatz:

package org.yourpackagename;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.web.SpringBootServletInitializer;

@SpringBootApplication
public class Application extends SpringBootServletInitializer {

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


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