स्प्रिंग 3.1 वेब ऐप्लिकेशंसइनाइज़र और एंबेडेड जेटी 8 एनोटेशन कॉन्फ़िगरेशन

Question

मैं स्प्रिंग 3.1 और एम्बेडेड जेट्टी 8 सर्वर का उपयोग कर किसी भी XML कॉन्फ़िगरेशन के बिना एक सरल वेबपैप बनाने की कोशिश कर रहा हूं।

हालांकि, मैं जेटी को स्प्रिंग वेबएप्लिकेशंसइनाइज़र इंटरफ़ेस के मेरे कार्यान्वयन को पहचानने के लिए संघर्ष कर रहा हूं।

परियोजना संरचना:

src 
+- main 
    +- java 
    | +- JettyServer.java 
    | +- Initializer.java 
    | 
    +- webapp 
     +- web.xml (objective is to remove this - see below). 

प्रारंभकर्ता ऊपर वर्ग का एक सरल कार्यान्वयन है WebApplicationInitializer:

import javax.servlet.ServletContext; 
import javax.servlet.ServletException; 

import org.springframework.web.WebApplicationInitializer; 

public class Initializer implements WebApplicationInitializer { 

    @Override 
    public void onStartup(ServletContext servletContext) throws ServletException { 
     System.out.println("onStartup"); 
    } 
} 

इसी तरह JettyServer एक एम्बेडेड जेट्टी सर्वर का एक सरल दिया गया है:

import org.eclipse.jetty.annotations.AnnotationConfiguration; 
import org.eclipse.jetty.server.Server; 
import org.eclipse.jetty.webapp.Configuration; 
import org.eclipse.jetty.webapp.WebAppContext; 

public class JettyServer { 

    public static void main(String[] args) throws Exception { 

     Server server = new Server(8080); 

     WebAppContext webAppContext = new WebAppContext(); 
     webAppContext.setResourceBase("src/main/webapp"); 
     webAppContext.setContextPath("/"); 
     webAppContext.setConfigurations(new Configuration[] { new AnnotationConfiguration() }); 
     webAppContext.setParentLoaderPriority(true); 

     server.setHandler(webAppContext); 
     server.start(); 
     server.join(); 
    } 
} 

मेरे समझ है कि स्टार्टअप पर जेट्टी ServletContainerInitializer की एनोटेट कार्यान्वयन के लिए स्कैन करने AnnotationConfiguration प्रयोग करेंगे; यह प्रारंभकर्ता और उस में तार ...

हालांकि, खोजना चाहिए जब मैं जेट्टी सर्वर (ग्रहण के भीतर से) शुरू मैं कमांड लाइन पर निम्न देखें:

2012-11-04 16:59:04.552:INFO:oejs.Server:jetty-8.1.7.v20120910 
2012-11-04 16:59:05.046:INFO:/:No Spring WebApplicationInitializer types detected on classpath 
2012-11-04 16:59:05.046:INFO:oejsh.ContextHandler:started o.e.j.w.WebAppContext{/,file:/Users/duncan/Coding/spring-mvc-embedded-jetty-test/src/main/webapp/} 
2012-11-04 16:59:05.117:INFO:oejs.AbstractConnector:Started SelectChannelConnector@0.0.0.0:8080 

महत्वपूर्ण बिट यह है:

No Spring WebApplicationInitializer types detected on classpath 

ध्यान दें कि src/मुख्य/जावा ग्रहण में एक स्रोत फ़ोल्डर के रूप में परिभाषित किया गया है, इसलिए classpath पर होना चाहिए। यह भी ध्यान रखें कि डायनामिक वेब मॉड्यूल फ़ैसैट 3.0 पर सेट है।

मुझे यकीन है कि एक साधारण स्पष्टीकरण है, लेकिन मैं पेड़ के लिए लकड़ी को देखने के लिए संघर्ष कर रहा हूं! मुझे लगता है कुंजी निम्न पंक्ति के साथ है:

... 
webAppContext.setResourceBase("src/main/webapp"); 
... 

यह web.xml (देखें नीचे) का उपयोग कर एक 2.5 सर्वलेट के साथ समझ में आता है, लेकिन जब AnnotationConfiguration का उपयोग कर यह क्या किया जाना चाहिए?

एनबी: सब कुछ सही ढंग से करता है, तो मैं निम्नलिखित करने के लिए विन्यास बदलने के ऊपर आग:

... 
webAppContext.setConfigurations(new Configuration[] { new WebXmlConfiguration() }); 
... 

इस मामले में यह src/मुख्य/webapp तहत web.xml पाता है और तार करने के लिए इसे इस्तेमाल करता है का उपयोग कर सर्वलेट सामान्य रूप से DispatcherServlet और एनोटेशन कॉनफिग वेब ऐप्लिकेशंस कॉन्टेक्स्ट (पूरी तरह से वेब एप्प्लिकेशनइनेनाइज़र उपरोक्त कार्यान्वयन) को छोड़कर।

यह एक classpath समस्या की तरह बहुत ज्यादा लगता है, लेकिन मैं समझने के लिए काफी है कि कैसे जेट्टी WebApplicationInitializer के कार्यान्वयन के साथ सहयोगियों ही संघर्ष कर रहा हूँ - किसी भी सुझाव सबसे की सराहना की होगी!

वसंत 3.1.1 जेट्टी 8.1.7 एसटीएस 3.1.0

Answer 1

समस्या यह है कि जेटी की AnnotationConfiguration कक्षा वर्गपैथ पर गैर-जार संसाधन स्कैन नहीं करती है (वेब-आईएनएफ/कक्षाओं के तहत छोड़कर)।

यह मेरी WebApplicationInitializer की यह पता लगता है मैं जो configure(WebAppContext) ओवरराइड करता है कंटेनर और वेब inf स्थानों के अलावा मेजबान classpath स्कैन करने के लिए AnnotationConfiguration का एक उपवर्ग रजिस्टर।

अधिकांश उप-वर्ग माता-पिता से (दुख की बात है) कॉपी-पेस्ट है। इसमें शामिल हैं:

• कॉन्फ़िगरेशन विधि के अंत में एक अतिरिक्त पार्स कॉल (parseHostClassPath);
• parseHostClassPath विधि जो AnnotationConfigurationparseWebInfClasses से बड़े पैमाने पर कॉपी-पेस्ट है;
• getHostClassPathResource विधि जो क्लासलोडर से पहले गैर-जार यूआरएल को पकड़ती है (जो मेरे लिए कम से कम है, ग्रहण में मेरे क्लासपाथ में फ़ाइल यूआरएल है)।

मैं जेटी (8.1.7.v20120910) और वसंत (3.1.2_RELEASE) के कुछ अलग संस्करणों का उपयोग कर रहा हूं, लेकिन मुझे लगता है कि एक ही समाधान काम करेगा।

संपादित करें: मैं कुछ संशोधनों के साथ GitHub में एक काम नमूना प्रोजेक्ट बनाया (नीचे दिए गए कोड ग्रहण से ठीक काम करता है, लेकिन नहीं है जब एक छायांकित जार में चल रहा है) - ओ पी के JettyServer वर्ग आवश्यक परिवर्तन में https://github.com/steveliles/jetty-embedded-spring-mvc-noxml

webAppContext.setConfigurations (new Configuration [] 
{ 
     new AnnotationConfiguration() 
     { 
      @Override 
      public void configure(WebAppContext context) throws Exception 
      { 
       boolean metadataComplete = context.getMetaData().isMetaDataComplete(); 
       context.addDecorator(new AnnotationDecorator(context)); 

       AnnotationParser parser = null; 
       if (!metadataComplete) 
       { 
        if (context.getServletContext().getEffectiveMajorVersion() >= 3 || context.isConfigurationDiscovered()) 
        { 
         parser = createAnnotationParser(); 
         parser.registerAnnotationHandler("javax.servlet.annotation.WebServlet", new WebServletAnnotationHandler(context)); 
         parser.registerAnnotationHandler("javax.servlet.annotation.WebFilter", new WebFilterAnnotationHandler(context)); 
         parser.registerAnnotationHandler("javax.servlet.annotation.WebListener", new WebListenerAnnotationHandler(context)); 
        } 
       } 

       List<ServletContainerInitializer> nonExcludedInitializers = getNonExcludedInitializers(context); 
       parser = registerServletContainerInitializerAnnotationHandlers(context, parser, nonExcludedInitializers); 

       if (parser != null) 
       { 
        parseContainerPath(context, parser); 
        parseWebInfClasses(context, parser); 
        parseWebInfLib (context, parser); 
        parseHostClassPath(context, parser); 
       }     
      } 

      private void parseHostClassPath(final WebAppContext context, AnnotationParser parser) throws Exception 
      { 
       clearAnnotationList(parser.getAnnotationHandlers()); 
       Resource resource = getHostClassPathResource(getClass().getClassLoader());     
       if (resource == null) 
        return; 

       parser.parse(resource, new ClassNameResolver() 
       { 
        public boolean isExcluded (String name) 
        {   
         if (context.isSystemClass(name)) return true;       
         if (context.isServerClass(name)) return false; 
         return false; 
        } 

        public boolean shouldOverride (String name) 
        { 
         //looking at webapp classpath, found already-parsed class of same name - did it come from system or duplicate in webapp? 
         if (context.isParentLoaderPriority()) 
          return false; 
         return true; 
        } 
       }); 

       //TODO - where to set the annotations discovered from WEB-INF/classes?  
       List<DiscoveredAnnotation> annotations = new ArrayList<DiscoveredAnnotation>(); 
       gatherAnnotations(annotations, parser.getAnnotationHandlers());     
       context.getMetaData().addDiscoveredAnnotations (annotations); 
      } 

      private Resource getHostClassPathResource(ClassLoader loader) throws IOException 
      { 
       if (loader instanceof URLClassLoader) 
       { 
        URL[] urls = ((URLClassLoader)loader).getURLs(); 
        for (URL url : urls) 
         if (url.getProtocol().startsWith("file")) 
          return Resource.newResource(url); 
       } 
       return null;      
      } 
     }, 
    }); 

अद्यतन: के साथ कतार में 15 की जगह लेंगे जेट्टी 8.1.8 आंतरिक परिवर्तन है कि इसके बाद के संस्करण कोड के साथ असंगत हैं परिचय देता है। 8.1 के लिए।8 निम्नलिखित काम करने के लिए लगता है:

webAppContext.setConfigurations (new Configuration [] 
    { 
     // This is necessary because Jetty out-of-the-box does not scan 
     // the classpath of your project in Eclipse, so it doesn't find 
     // your WebAppInitializer. 
     new AnnotationConfiguration() 
     { 
      @Override 
      public void configure(WebAppContext context) throws Exception { 
        boolean metadataComplete = context.getMetaData().isMetaDataComplete(); 
        context.addDecorator(new AnnotationDecorator(context)); 


        //Even if metadata is complete, we still need to scan for ServletContainerInitializers - if there are any 
        AnnotationParser parser = null; 
        if (!metadataComplete) 
        { 
         //If metadata isn't complete, if this is a servlet 3 webapp or isConfigDiscovered is true, we need to search for annotations 
         if (context.getServletContext().getEffectiveMajorVersion() >= 3 || context.isConfigurationDiscovered()) 
         { 
          _discoverableAnnotationHandlers.add(new WebServletAnnotationHandler(context)); 
          _discoverableAnnotationHandlers.add(new WebFilterAnnotationHandler(context)); 
          _discoverableAnnotationHandlers.add(new WebListenerAnnotationHandler(context)); 
         } 
        } 

        //Regardless of metadata, if there are any ServletContainerInitializers with @HandlesTypes, then we need to scan all the 
        //classes so we can call their onStartup() methods correctly 
        createServletContainerInitializerAnnotationHandlers(context, getNonExcludedInitializers(context)); 

        if (!_discoverableAnnotationHandlers.isEmpty() || _classInheritanceHandler != null || !_containerInitializerAnnotationHandlers.isEmpty()) 
        {   
         parser = createAnnotationParser(); 

         parse(context, parser); 

         for (DiscoverableAnnotationHandler h:_discoverableAnnotationHandlers) 
          context.getMetaData().addDiscoveredAnnotations(((AbstractDiscoverableAnnotationHandler)h).getAnnotationList());  
        } 

      } 

      private void parse(final WebAppContext context, AnnotationParser parser) throws Exception 
      {     
       List<Resource> _resources = getResources(getClass().getClassLoader()); 

       for (Resource _resource : _resources) 
       { 
        if (_resource == null) 
         return; 

        parser.clearHandlers(); 
        for (DiscoverableAnnotationHandler h:_discoverableAnnotationHandlers) 
        { 
         if (h instanceof AbstractDiscoverableAnnotationHandler) 
          ((AbstractDiscoverableAnnotationHandler)h).setResource(null); // 
        } 
        parser.registerHandlers(_discoverableAnnotationHandlers); 
        parser.registerHandler(_classInheritanceHandler); 
        parser.registerHandlers(_containerInitializerAnnotationHandlers); 

        parser.parse(_resource, 
           new ClassNameResolver() 
        { 
         public boolean isExcluded (String name) 
         { 
          if (context.isSystemClass(name)) return true; 
          if (context.isServerClass(name)) return false; 
          return false; 
         } 

         public boolean shouldOverride (String name) 
         { 
          //looking at webapp classpath, found already-parsed class of same name - did it come from system or duplicate in webapp? 
          if (context.isParentLoaderPriority()) 
           return false; 
          return true; 
         } 
        }); 
       } 
      } 

      private List<Resource> getResources(ClassLoader aLoader) throws IOException 
      { 
       if (aLoader instanceof URLClassLoader) 
       { 
        List<Resource> _result = new ArrayList<Resource>(); 
        URL[] _urls = ((URLClassLoader)aLoader).getURLs();      
        for (URL _url : _urls) 
         _result.add(Resource.newResource(_url)); 

        return _result; 
       } 
       return Collections.emptyList();     
      } 
     } 
    }); 

Answer 2

मेरी परीक्षण के आधार पर और इस थ्रेड http://forum.springsource.org/showthread.php?127152-WebApplicationInitializer-not-loaded-with-embedded-Jetty मैं इसे नहीं लगता कि:

जानकारी के लिए, मैं निम्नलिखित का उपयोग कर रहा इस समय काम करता है। आप AnnotationConfiguration.configure में देखें, तो:

parseContainerPath(context, parser); 
    // snip comment 
    parseWebInfClasses(context, parser); 
    parseWebInfLib (context, parser); 

यह बजाय एक युद्ध की तरह तैनाती के लिए युग्मित लगता है एम्बेडेड।

http://www.jamesward.com/2012/08/13/containerless-spring-mvc

यह वसंत सर्वलेट सीधे बल्कि तो एनोटेशन पर निर्भर बनाता है:

यहाँ एक उदाहरण वसंत MVC का उपयोग कर और एम्बेडेड जेट्टी कि और अधिक उपयोगी हो सकता है।

Answer 3

क्या सिर्फ संदर्भ विशेषता है कि स्कैनर जो बातें कंटेनर classpath को स्कैन करने की जरूरत है कि पर हैं बताता है की स्थापना के बारे में?

संदर्भ विशेषता: org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern । /servlet-api - [^ /] .jar $

इसे जार नामों के साथ उपयोग करने के लिए डिज़ाइन किया गया है, लेकिन आप बस सबकुछ मिलान कर सकते हैं।

आपको WebInfConfiguration के साथ-साथ एनोटेशन कॉन्फ़िगरेशन कक्षाओं का उपयोग करने की आवश्यकता होगी।

चियर्स जनवरी

Answer 4

मैं सिर्फ स्पष्ट रूप AnnotationConfiguration के कार्यान्वयन वर्ग (इस उदाहरण में MyWebApplicationInitializerImpl) है कि मैं इस तरह से लोड करना चाहते हैं प्रदान करके एक आसान है लेकिन अधिक सीमित रास्ते में हल करने में सक्षम था:

webAppContext.setConfigurations(new Configuration[] { 
    new WebXmlConfiguration(), 
    new AnnotationConfiguration() { 
     @Override 
     public void preConfigure(WebAppContext context) throws Exception { 
      MultiMap<String> map = new MultiMap<String>(); 
      map.add(WebApplicationInitializer.class.getName(), MyWebApplicationInitializerImpl.class.getName()); 
      context.setAttribute(CLASS_INHERITANCE_MAP, map); 
      _classInheritanceHandler = new ClassInheritanceHandler(map); 
     } 
    } 
}); 

Answer 5

जेट्टी 9.0.1 में एक वृद्धि शामिल है जो कंटेनर क्लासपाथ पर गैर-जार संसाधनों (यानी कक्षाओं) की टिप्पणियों की स्कैनिंग की अनुमति देता है। इसे उपयोग करने के लिए निम्नलिखित मुद्दे पर टिप्पणी # 5 देखें:

https://bugs.eclipse.org/bugs/show_bug.cgi?id=404176#c5

जनवरी

Answer 6

कोड के नीचे किया मेरी Maven परियोजना में चाल:

public static void main(String[] args) throws Exception { 
    Server server = new Server(); 
    ServerConnector scc = new ServerConnector(server); 
    scc.setPort(Integer.parseInt(System.getProperty("jetty.port", "8080"))); 
    server.setConnectors(new Connector[] { scc }); 

    WebAppContext context = new WebAppContext(); 
    context.setServer(server); 
    context.setContextPath("/"); 
    context.setWar("src/main/webapp"); 
    context.getMetaData().addContainerResource(new FileResource(new File("./target/classes").toURI())); 
    context.setConfigurations(new Configuration[]{ 
      new WebXmlConfiguration(), 
      new AnnotationConfiguration() 
    }); 

    server.setHandler(context); 

    try { 
     System.out.println(">>> STARTING EMBEDDED JETTY SERVER, PRESS ANY KEY TO STOP"); 
     System.out.println(String.format(">>> open http://localhost:%s/", scc.getPort())); 
     server.start(); 
     while (System.in.available() == 0) { 
      Thread.sleep(5000); 
     } 
     server.stop(); 
     server.join(); 
    } catch (Throwable t) { 
     t.printStackTrace(); 
     System.exit(100); 
    } 

} 

Answer 7

हमारे मामले इन में जेटी स्टार्टअप कोड में लाइनों की मदद मिली:

ClassList cl = Configuration.ClassList.setServerDefault(server); 
    cl.addBefore("org.eclipse.jetty.webapp.JettyWebXmlConfiguration", "org.eclipse.jetty.annotations.AnnotationConfiguration"); 

Answer 8

उन तकनीकों के लिए

@Component 
public class Initializer implements WebApplicationInitializer { 

    private ServletContext servletContext; 

    @Autowired 
    public WebInitializer(ServletContext servletContext) { 
     this.servletContext = servletContext; 
    } 

    @PostConstruct 
    public void onStartup() throws ServletException { 
     onStartup(servletContext); 
    } 

    public void onStartup(ServletContext servletContext) throws ServletException { 
     System.out.println("onStartup"); 
    } 
} 

Answer 9

घाट "magomarcelo" जवाब के 9 संस्करण: इस हाल ही में ncing, यह इस समस्या के समाधान हो जाता है प्रकट होता है

 context.setConfigurations(
      new org.eclipse.jetty.webapp.Configuration[] { new WebXmlConfiguration(), new AnnotationConfiguration() { 
       @Override 
       public void preConfigure(WebAppContext context) throws Exception { 
        final ClassInheritanceMap map = new ClassInheritanceMap(); 
        final ConcurrentHashSet<String> set = new ConcurrentHashSet<>(); 
        set.add(MyWebAppInitializer.class.getName()); 
        map.put(WebApplicationInitializer.class.getName(), set); 
        context.setAttribute(CLASS_INHERITANCE_MAP, map); 
        _classInheritanceHandler = new ClassInheritanceHandler(map); 
       } 
      } }); 

Answer 10

जेट्टी 9 के लिए, यदि आप webjars है, बशर्ते समाधान काम नहीं करता है सीधे उन जारों को कक्षापथ पर होना जरूरी है और जेएआर सामग्री को आपके वेबएप के संसाधनों के रूप में उपलब्ध होना चाहिए। तो, कि webjars के साथ मिलकर काम करने के लिए, config होना चाहिए था:

context.setExtraClasspath(pathsToWebJarsCommaSeparated); 
context.setAttribute(WebInfConfiguration.WEBINF_JAR_PATTERN, ".*\\.jar$"); 
context.setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, ".*\\.jar$"); 
context.setConfigurations(
     new org.eclipse.jetty.webapp.Configuration[] { 
     new WebInfConfiguration(), new MetaInfConfiguration(), 
     new AnnotationConfiguration() { 
      @Override 
      public void preConfigure(WebAppContext context) throws Exception { 
       final ClassInheritanceMap map = new ClassInheritanceMap(); 
       final ConcurrentHashSet<String> set = new ConcurrentHashSet<>(); 
       set.add(MyWebAppInitializer.class.getName()); 
       map.put(WebApplicationInitializer.class.getName(), set); 
       context.setAttribute(CLASS_INHERITANCE_MAP, map); 
       _classInheritanceHandler = new ClassInheritanceHandler(map); 
      } 
     } }); 

यहाँ क्रम महत्वपूर्ण है (WebInfConfiguration MetaInf से पहले आने के लिए है)।

Answer 11

जेटी 9 सेट विशेषता एनोटेशन कॉन्फ़िगरेशन पर काम करने के लिए।

webAppContext.setAttribute(AnnotationConfiguration.CLASS_INHERITANCE_MAP, createClassMap()); 

और यहाँ WebAppContext

पर CLASS_INHERITANCE_MAP यह मानचित्र बनाने के लिए कैसे है:

private ClassInheritanceMap createClassMap() { 
    ClassInheritanceMap classMap = new ClassInheritanceMap(); 
    ConcurrentHashSet<String> impl = new ConcurrentHashSet<>(); 
    impl.add(MyWebAppInitializer.class.getName()); 
    classMap.put(WebApplicationInitializer.class.getName(), impl); 
    return classMap; 
} 

मैं पर gitHub

Answer 12

समाधान है कि मेरे लिए काम किया है और स्कैनिंग को शामिल नहीं करता है कि समाधान रखा है, लेकिन WebApplicationInitializer का उपयोग करता है कक्षा जो आप प्रदान करते हैं। जेट्टी संस्करण: 9.2.20

public class Main { 

public static void main(String... args) throws Exception { 
    Properties properties = new Properties(); 
    InputStream stream = Main.class.getResourceAsStream("/WEB-INF/application.properties"); 
    properties.load(stream); 
    stream.close(); 
    PropertyConfigurator.configure(properties); 

    WebAppContext webAppContext = new WebAppContext(); 
    webAppContext.setResourceBase("resource"); 
    webAppContext.setContextPath(properties.getProperty("base.url")); 
    webAppContext.setConfigurations(new Configuration[] { 
     new WebXmlConfiguration(), 
     new AnnotationConfiguration() { 
      @Override 
      public void preConfigure(WebAppContext context) { 
       ClassInheritanceMap map = new ClassInheritanceMap(); 
       map.put(WebApplicationInitializer.class.getName(), new ConcurrentHashSet<String>() {{ 
        add(WebInitializer.class.getName()); 
        add(SecurityWebInitializer.class.getName()); 
       }}); 
       context.setAttribute(CLASS_INHERITANCE_MAP, map); 
       _classInheritanceHandler = new ClassInheritanceHandler(map); 
      } 
     } 
    }); 

    Server server = new Server(Integer.parseInt(properties.getProperty("base.port"))); 
    server.setHandler(webAppContext); 
    server.start(); 
    server.join(); 
} 
} 

स्रोत (में रूसी) इस कोड स्निपेट के यहाँ है: https://habrahabr.ru/post/255773/

Answer 13

प्रदर्शित करने के लिए कि यह कैसे सफाई से किया जा सकता है एक सरल Maven परियोजना किया था।

public class Console { 
    public static void main(String[] args) { 
     try { 
      Server server = new Server(8080); 

      //Set a handler to handle requests. 
      server.setHandler(getWebAppContext()); 

      //starts to listen at 0.0.0.0:8080 
      server.start(); 
      server.join(); 
     } catch (Exception e) { 
      log.error("server exited with exception", e); 
     } 
    } 

    private static WebAppContext getWebAppContext() { 
     final WebAppContext webAppContext = new WebAppContext(); 

     //route all requests via this web-app. 
     webAppContext.setContextPath("/"); 

     /* 
     * point to location where the jar into which this class gets packaged into resides. 
     * this could very well be the target directory in a maven development build. 
     */ 
     webAppContext.setResourceBase("directory_where_the_application_jar_exists"); 

     //no web inf for us - so let the scanning know about location of our libraries/classes. 
     webAppContext.getMetaData().setWebInfClassesDirs(Arrays.asList(webAppContext.getBaseResource())); 

     //Scan for annotations (servlet 3+) 
     final AnnotationConfiguration configuration = new AnnotationConfiguration(); 
     webAppContext.setConfigurations(new Configuration[]{configuration}); 

     return webAppContext; 
    } 
} 

और बस इतना ही है - वसंत WebApplicationInitializer जिसका उपयोग आप स्पष्ट रूप से घाट सर्वर दे बिना पता लगाया जाएगा, जैसे किसी एप्लिकेशन प्रारंभकर्ता के अस्तित्व के बारे में पता है।