Spring 3.1 WebApplicationInitializer & amp; Embedded Jetty 8 AnnotationConfiguration

Das problem ist, dass jettys AnnotationConfiguration Klasse nicht Scannen nicht-jar-Ressourcen in den Klassenpfad (außer unter WEB-INF/classes).

Er findet meine WebApplicationInitializer's wenn ich eine Unterklasse von AnnotationConfiguration überschrieben configure(WebAppContext) zu Scannen Sie den host-classpath neben die container und web-inf Standorten.

Meisten sub-class ist (leider) copy-paste von den Eltern. Es beinhaltet:

• eine zusätzliche parse-Aufruf (parseHostClassPath) am Ende des configure-Methode;
• die parseHostClassPath - Methode, die weitgehend copy-paste von
  AnnotationConfiguration's parseWebInfClasses;
• die getHostClassPathResource Methode, die schnappt sich der erste nicht-jar-URL
  von den classloader, der die, für mich zumindest, ist die Datei-url zu meinem
  classpath in eclipse).

Ich bin mit leicht verschiedenen Versionen von Jetty (8.1.7.v20120910) und der Feder (3.1.2_RELEASE), aber ich Stelle mir die gleiche Lösung funktioniert.

Edit: ich erstellte ein funktionierendes Beispiel-Projekt in github mit einigen änderungen (der code unten funktioniert von Eclipse aber nicht, wenn die Ausführung in einem schattierten Glas) - https://github.com/steveliles/jetty-embedded-spring-mvc-noxml

In den OP ' s JettyServer Klasse, die nötigen änderungen würden ersetzen Sie die Zeile 15 mit:

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;                    
            }
        },
    });

Update: Jetty 8.1.8 führt interne Veränderungen, die nicht mit dem code oben. Für 8.1.8 Folgendes scheint zu funktionieren:

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();                 
            }
        }
    });

InformationsquelleAutor der Antwort Stevie

Steg 9.0.1 enthält eine Erweiterung die es ermöglicht das Scannen von Anmerkungen von nicht-jar-Ressourcen (ie-Klassen) auf den container classpath. Siehe Kommentar #5 auf dem folgenden Problem, wie es zu benutzen:

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

Jan

InformationsquelleAutor der Antwort Jan

Basierend auf meinen Tests und dieser thread http://forum.springsource.org/showthread.php?127152-WebApplicationInitializer-not-loaded-with-embedded-Jetty ich glaube nicht, dass es im moment arbeitet. Wenn man sich in AnnotationConfiguration.konfigurieren:

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

scheint es gekoppelt ist, um einen Krieg wie Bereitstellung, anstatt eingebettet.

Hier ist ein Beispiel mit Spring MVC und embedded Jetty, die vielleicht nützlicher sein:

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

Schafft es der Spring-servlet direkt anstatt sich auf Anmerkungen.

InformationsquelleAutor der Antwort artbristol

Das es auf den Steg 9 set-Attribut AnnotationConfiguration.CLASS_INHERITANCE_MAP auf WebAppContext

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

Und hier ist, wie man dieser Karte:

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;
}

Legte ich, dass die Lösung auf gitHub

InformationsquelleAutor der Antwort marians27

In unserem Fall haben diese Zeilen geholfen, in der Jetty-Start-code:

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

InformationsquelleAutor der Antwort ssasa

Für Jetty 9, wenn Sie webjars, die Lösung funktioniert nicht sofort wie diese Gläser müssen im classpath und JAR-Inhalte verfügbar sein müssen als Ressourcen für Ihre webapp. So, für die, die arbeiten zusammen mit webjars, die config müsste:

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);
            }
        } });

Hier die Reihenfolge wichtig ist (WebInfConfiguration hat zu kommen, bevor MetaInf).

InformationsquelleAutor der Antwort dontForgetTheJoker

haben ein einfaches maven Projekt zu zeigen, wie es getan werden kann, sauber.

    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;
    }
}

und das ist alles - der Frühling WebApplicationInitializer, die Sie verwenden, wird erkannt werden, ohne explizit zu lassen jetty-server wissen, über die Existenz von solch eine app Initialisierung.

InformationsquelleAutor der Antwort maggu