Verwenden Sie Federmvc Xml-Projekt im Frühjahr-Boot-Projekt

Question

Ich habe dieses Testprojekt ich erstellt, aus 2 Projekten komponiert: eines mit Spring-Boot und eines mit Feder-Mvc. Jeder von ihnen funktioniert eigenständig. Ich möchte den Spring-Boot starten und auf die Webseiten des Spring-Mvc-Projekts zugreifen, indem ich seinen Kontext lade. Das Projekt ist ziemlich einfach, da ich nur testen möchte, wie man den Mix macht.

Das Problem ist, dass, wenn ich die Spring-Boot-Anwendung ausführen, die Seite von Spring-Mvc nicht zugänglich ist, da es nicht den Webbapp-Ordner (mit WEB-INF) im Build hinzufügen. Ich kann den Service von spring-mvc innerhalb der Spring-Boot-Anwendung autowire.

Der Baum sieht wie folgt aus:

Die Application.java Klasse für das Frühjahr-boot ist die folgende:

package hello; 

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

import java.util.Arrays; 

@SpringBootApplication 
@ComponentScan({"org.burdu", "hello"}) 
//@ImportResource({"classpath:WEB-INF/spring-core-config.xml", "classpath:WEB-INF/spring-mvc-config.xml"}) 
public class Application { 

public static void main(String[] args) { 
    ApplicationContext ctx = SpringApplication.run(Application.class, 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); 
    } 
} 
} 

Die Wurzel build.gradle

group 'net.burdu' 
version '1.0-SNAPSHOT' 

apply plugin: 'java' 
apply plugin: 'idea' 

sourceCompatibility = 1.8 

repositories { 
mavenCentral() 
mavenLocal() 
} 

dependencies { 
testCompile group: 'junit', name: 'junit', version: '4.11' 
} 

root settings.gradle

rootProject.name = 'testSpringXMLAndBoot' 
include 'spring-mvc' 
include 'spring-boot' 

Feder-boot build.gradle

apply plugin: 'java' 
apply plugin: 'idea' 
apply plugin: 'war' 
apply plugin: 'spring-boot' 

sourceCompatibility = 1.8 

repositories { 
jcenter() 
mavenCentral() 
} 

buildscript { 
repositories { 
    mavenCentral() 
} 

dependencies { 
    classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.3.RELEASE") 
} 
} 

dependencies { 
compile("org.springframework.boot:spring-boot-starter-web") 
compile project(':spring-mvc') 
} 

feder mvc build.gradle

apply plugin: 'java' 
apply plugin: 'idea' 
apply plugin: 'war' 
apply plugin: 'jetty' 

sourceCompatibility = 1.8 

repositories { 
mavenCentral() 
mavenLocal() 
} 

dependencies { 
compile 'ch.qos.logback:logback-classic:1.1.3' 
compile 'org.springframework:spring-webmvc:4.1.6.RELEASE' 
compile 'javax.servlet:jstl:1.2' 
} 

jettyRun{ 
contextPath = "" 
httpPort = 8080 
} 

jettyRunWar{ 
contextPath = "" 
httpPort = 8080 
} 

Federkern-config.xml

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/mvc 
    http://www.springframework.org/schema/mvc/spring-mvc.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd "> 

<context:component-scan base-package="org.burdu.web" /> 

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> 
    <property name="prefix" value="/WEB-INF/view/" /> 
    <property name="suffix" value=".jsp" /> 
</bean> 

<mvc:resources mapping="/resources/**" location="/resources/" /> 

<mvc:annotation-driven /> 

</beans> 

feder MVC config.xml

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd "> 

<context:component-scan base-package="org.burdu.service" /> 

</beans> 

web.xml innen feder mvc Projekt

<web-app xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    version="2.5"> 

<display-name>Gradle + Spring MVC Hello World + XML</display-name> 
<description>Spring MVC web application</description> 

<!-- For web context --> 
<servlet> 
    <servlet-name>hello-dispatcher</servlet-name> 
    <servlet-class> 
    org.springframework.web.servlet.DispatcherServlet 
    </servlet-class> 
    <init-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/spring-mvc-config.xml</param-value> 
    </init-param> 
    <load-on-startup>1</load-on-startup> 
</servlet> 

<servlet-mapping> 
    <servlet-name>hello-dispatcher</servlet-name> 
    <url-pattern>/</url-pattern> 
</servlet-mapping> 

<!-- For root context --> 
<listener> 
    <listener-class> 
    org.springframework.web.context.ContextLoaderListener 
    </listener-class> 
</listener> 

<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/spring-core-config.xml</param-value> 
</context-param> 

</web-app> 

The Hello innen feder Boot, und Helloworld WelcomeController sind einfache Bohnen. Ich gebe hier ihren Inhalt nicht an, da die Frage schon zu lange war, aber wenn nötig, kann ich sie hinzufügen.

Answer 1

Ich habe die kombinierten Projekte in meine IDE importiert und ich fand es schwierig, zwei Projekte in einem zu integrieren und sie original zu erhalten. Die eigentliche Schwierigkeit ist der Frühling konnte nicht die Ressourcen in Glas des Unterprojekts spring-mvc in lib/spring-mvc.jar bekannt. Wenn ich es in Unterprojekt spring-boot extrahiere, funktioniert es immer noch nicht.

Danach fand ich diese Dokumentation über JSP limitations im Frühjahr-Boot, das sagt:

Eine ausführbare jar wegen eines hartcodierte Dateimuster nicht in Tomcat

Was mehr funktionieren wird, meine vorschlagen, ist Ihre Anwendung in modernen feder Boot-Form wie folgt zu konvertieren:

Convert an existing application to Spring Boot

In diesem Fall müssen Sie nur die in web.xml definierten Servlets und Filter in Spring Beans konvertieren, wie es in der Dokumentation heißt. Darüber hinaus können spring-core-config.xml und spring-mvc-config.xml keine Änderung beibehalten, da sie direkt importiert werden können, obwohl sie sich in embedded jar befinden. Es sollte einfach sein.

Nachdem Sie Ihre Anwendung in Spring-Boot konvertiert haben, können Sie auch die Kontrolle über den Web-Container übernehmen.

Am Ende, wenn Sie möchten, sind sie wirklich zusammen verwenden, Dokumentation folgende könnte nützlich sein:

Deploying a WAR in an Old (Servlet 2.5) Container

Diesmal Sie SpringBootContextLoaderListener als Zuhörer an Ihrem web.xml angeben . Es könnte helfen, Ihre Anwendung zu konfigurieren. Wie der Frühling sagt, ist es jedoch nur nützlich, wenn Sie Ihre Anwendung in einem alten Container bereitstellen.

Aber wenn ich Sie wäre, würde ich es in Spring-Boot-Format konvertieren. Weil es die Wartungsarbeiten vereinfachen kann.

standardmäßig Feder Boot nur Verzeichnisse erlaubt /, META-INF/resources, resources, public, static als Ressourcen Ladepfad. Wenn alle Ressourcen unter diesen Verzeichnissen liegen, sollte das funktionieren. Natürlich wäre specifying document root erforderlich. Wenn Sie tolerant extrahieren können spring-mvc, ich denke, das wäre die Lösung.

Wenn Feder Kontext in eingebetteten jar definiert ist, was Sie wollen, können Sie einfach einen Stern nach classpath wie classpath*:WEB-INF/applicationContext.xml hinzufügen. Dies wird alle WEB-INF/applicationContext.xml in jedem lib jar hinzufügen. Mit anderen Worten, Sie brauchen nur einen Stern nach classpath unter Ihrem @ImportResource Ausdruck hinzufügen. Wenn alles gut läuft, bist du da.

Answer 2

habe ich versucht, diese kleinen Änderungen an Ihrem github project:

feder boot/build.gradle:

// This will include files and settings from spring-mvc 
war { 
    baseName = 'testSpringXMLAndBoot' 
    version = '0.1.0' 
    from '../spring-mvc/src/main/webapp' 
} 

// tomcat-embed-jasper is for jsp support 
dependencies { 
    .. 
    compile("org.apache.tomcat.embed:tomcat-embed-jasper") 
    .. 
} 

feder boot/src/main/java/hallo/Anwendung.java:

@SpringBootApplication 
@ComponentScan({"org.burdu", "hello"}) 
@ImportResource({"classpath:WEB-INF/spring-mvc-config.xml"}) // added this resource back 
public class Application { 

    public static void main(String[] args) { 
     ApplicationContext ctx = SpringApplication.run(Application.class, args); 
     .. 
    } 
} 

Jetzt läuft:

• feder mvc/gradle jettyRun

noch eigenständige spring-mvc Modul auf Jetty Server

Und läuft Läuft:

• feder boot/java -jar build/libs/testSpringXMLAndBoot-0.1.0.war

Wird spring-mvc Kontext spring-boot sind und sie auf einem eingebetteten Tomcat laufen.