如何让嵌入式 Jetty 9 成功解析 JSTL URI？

Question

我正在打包一个 Web 应用程序存档 (.war)，以便可以在 shell 中通过 java -jar webapp.war 启动它，方法是在主类中使用此代码启动 Jetty 9 的嵌入式副本：

int port = Integer.parseInt(System.getProperty("port", "80")); // I know this has implications :)
String contextPath = System.getProperty("contextPath", "");
Server server = new Server(port);
ProtectionDomain domain = Deployer.class.getProtectionDomain();
URL location = domain.getCodeSource().getLocation();
WebAppContext webapp = new WebAppContext();
webapp.setContextPath("/" + contextPath);
webapp.setWar(location.toExternalForm());
server.setHandler(webapp);
server.start();
server.join();

但是，当第一个包含 JSTL taglib 声明的 JSP 被编译时，我遇到了这个错误：

org.apache.jasper.JasperException: /WEB-INF/html/user/login.jsp(2,62) PWC6188: The absolute uri: http://java.sun.com/jsp/jstl/core cannot be resolved in either web.xml or the jar files deployed with this application
at org.apache.jasper.compiler.DefaultErrorHandler.jspError(DefaultErrorHandler.java:92)
at org.apache.jasper.compiler.ErrorDispatcher.dispatch(ErrorDispatcher.java:378)
at org.apache.jasper.compiler.ErrorDispatcher.jspError(ErrorDispatcher.java:172)
at org.apache.jasper.compiler.TagLibraryInfoImpl.generateTLDLocation(TagLibraryInfoImpl.java:431)
at org.apache.jasper.compiler.TagLibraryInfoImpl.<init>(TagLibraryInfoImpl.java:240)
at org.apache.jasper.compiler.Parser.parseTaglibDirective(Parser.java:502)
at org.apache.jasper.compiler.Parser.parseDirective(Parser.java:582)
at org.apache.jasper.compiler.Parser.parseElements(Parser.java:1652)
at org.apache.jasper.compiler.Parser.parse(Parser.java:185)
at org.apache.jasper.compiler.ParserController.doParse(ParserController.java:244)
at org.apache.jasper.compiler.ParserController.parse(ParserController.java:145)
at org.apache.jasper.compiler.Compiler.generateJava(Compiler.java:212)
at org.apache.jasper.compiler.Compiler.compile(Compiler.java:451)
at org.apache.jasper.JspCompilationContext.compile(JspCompilationContext.java:625)
at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:374)
at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:492)
at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:378)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:848)
at org.eclipse.jetty.servlet.ServletHolder.handle(ServletHolder.java:698)
etc...

该 JSP 的前几行如下：

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" isELIgnored="false" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

我环顾四周（这似乎不是一个新问题）并尝试了以下解决方案：

• 精简我的依赖并寻找冲突（目前我只依赖jetty-server、jetty-webapp和jetty-jsp，所有版本9.0.4.v20130625）
• 在 webapp 的 web.xml 文件中指定一个显式的 <taglib> 映射，直接指向 JSTL（从阅读 JSP 规范中得到这个想法）
• 根据this answer修改服务器类路径
• 利用addServerClass和setParentLoaderPriority等WebAppContext方法

根据Jetty's documentation，使用 JSTL 应该可以正常工作，但我认为嵌入式上下文可能会改变 JSTL 的加载方式并导致其失败。

如果有任何想法或建议，我们将不胜感激。此设置将替换旧设置，该设置在 Windows 上成功执行相同操作，但由于包含引入 this bug 的旧依赖项，因此无法在 Linux 上运行。不幸的是，我无法找到一个不引入上述 JSTL URI 堆栈跟踪的依赖项（groupId org.mortbay.jetty artifactId jsp-2.1-glassfish version 2.1.v20100127）的快速替代品。

更新：我找到了一个次优的解决方案。受this thread 启发，降级到 Jetty 7 现在让我启动并运行。这是个好消息，但令人沮丧的是，如果我以后需要 Jetty 8 或 Jetty 9 独有的任何功能，我将不得不放弃这个部署基础设施。对 Jetty 9 中 JSTL taglib 问题的任何见解仍将不胜感激。

Answer 1

所以这里还有另一种解决方案。我正在为非常相似的问题苦苦挣扎，只是我有一个单独的战争文件和一个简单的嵌入器类，它为我创建了一个 Jetty 服务器并启动它指向可能的任何战争文件。以下是这一切的工作原理。

1. war 文件在WEB-INF/lib 中没有任何 tld 库，并且与加载程序小应用程序完全分离。

2. 启动服务器并将其指向任何war文件的Loader应用程序主类具有以下依赖项（maven）：

       <!-- Jetty webapp -->
       <dependency>
           <groupId>org.eclipse.jetty</groupId>
           <artifactId>jetty-webapp</artifactId>
           <version>${jettyVersion}</version>
       </dependency>
   
       <!-- With JSP support -->
       <dependency>
           <groupId>org.eclipse.jetty</groupId>
           <artifactId>jetty-jsp</artifactId>
           <version>${jettyVersion}</version>
       </dependency>
   

3. 加载类本身如下所示：

   Server server = new Server(cncPort);
   
   WebAppContext webApp = new WebAppContext();
   
   webApp.setContextPath(applicationContext);
   webApp.setWar(jettyHome + "/" + warFile);
   server.setHandler(webApp);
   
   try {
       server.start();
       server.join();
   } catch (Exception ex) {
       System.out.println("Failed to start server.");
       ex.printStackTrace();
   } 
   

4. 在我的案例中生成的包如下所示：

   + EmbedderApp
   |
   +-- lib
     - EmbeddedApp.jar <-- JAR with the embedder class
     - com.sun.el-2.2.0.v201303151357.jar
     - javax.el-2.2.0.v201303151357.jar
     - javax.servlet-3.0.0.v201112011016.jar
     - javax.servlet.jsp-2.2.0.v201112011158.jar
     - javax.servlet.jsp.jstl-1.2.0.v201105211821.jar
     - jetty-http-9.0.6.v20130930.jar
     - jetty-io-9.0.6.v20130930.jar
     - jetty-jsp-9.0.6.v20130930.jar
     - jetty-security-9.0.6.v20130930.jar
     - jetty-server-9.0.6.v20130930.jar
     - jetty-servlet-9.0.6.v20130930.jar
     - jetty-util-9.0.6.v20130930.jar
     - jetty-webapp-9.0.6.v20130930.jar
     - jetty-xml-9.0.6.v20130930.jar
     - org.apache.jasper.glassfish-2.2.2.v201112011158.jar
     - org.apache.taglibs.standard.glassfish-1.2.0.v201112081803.jar
     - org.eclipse.jdt.core-3.8.2.v20130121.jar
   

5. 我的依赖只是通过程序集插件添加为

   <dependencySet>
       <outputDirectory>lib</outputDirectory>
       <scope>runtime</scope>
   </dependencySet>
   

6. 我有一个启动嵌入类的 shell 启动脚本，这就是我花了很长时间才弄清楚的问题。

   我使用了一个嵌入在 jar 中的类路径的清单，并设置了我的 CLASSPATH=<PATH_TO_APP>\lib\EmbeddedApp.jar，假设依赖项的重置是我通过清单的类路径的一部分。我得到了同样的无法解决的 URI 错误.

   一旦我添加了更改脚本中的CLASSPATH 变量以明确包含所有罐子，它就开始工作了。

   for jar in ${APP_ROOT}/lib/*.jar; do CLASSPATH=$jar:${CLASSPATH}; done 
   

希望这可以节省别人的时间:-)

Answer 2

我在 Surefire 测试中启动 Jetty 时遇到了同样的问题；问题是 Jetty 9 不查看除 WEB-INF 之外的任何 jar 文件的清单，这与我编写测试的方式不兼容。

为了解决这个问题，我写了一点代码来从清单中找到 jar 文件，并将它们放入一个新的中间 URLClassLoader。

这就是我的功能测试设置功能最终让它与 Jetty 9 一起工作的样子：

@Before @SuppressWarnings("unchecked")
public void setUp() throws Exception {

    WebAppContext ctx = new WebAppContext("src/main/webapp", "/");

    Server server = new Server(9000);

    ctx.setServer(server);
    server.setHandler(ctx);

    ctx.preConfigure();

    ctx.addOverrideDescriptor("src/main/webapp/WEB-INF/tests-web.xml");      

    // Replace classloader with a new classloader with all URLs in manifests 
    // from the parent loader bubbled up so Jasper looks at them.
    ClassLoader contextClassLoader = ctx.getClassLoader();
    ClassLoader parentLoader = contextClassLoader.getParent();
    if (contextClassLoader instanceof WebAppClassLoader &&
        parentLoader instanceof URLClassLoader) {
      LinkedList<URL> allURLs =
          new LinkedList<URL>(Arrays.asList(((URLClassLoader)parentLoader).getURLs()));
      for (URL url : ((LinkedList<URL>)allURLs.clone())) {
        try {
          URLConnection conn = new URL("jar:" + url.toString() + "!/").openConnection();
          if (!(conn instanceof JarURLConnection))
            continue;
          JarURLConnection jconn = (JarURLConnection)conn;
          Manifest jarManifest = jconn.getManifest();
          String[] classPath = ((String)jarManifest.getMainAttributes().getValue("Class-Path")).split(" ");

          for (String cpurl : classPath)
            allURLs.add(new URL(url, cpurl));
        } catch (IOException e) {} catch (NullPointerException e) {}
      }

      ctx.setClassLoader(
          new WebAppClassLoader(
              new URLClassLoader(allURLs.toArray(new URL[]{}), parentLoader),
              ((WebAppClassLoader)contextClassLoader).getContext()));
    }

    server.start();
}

我的代码示例位于公共领域 - 您可以在自己的代码中使用它（感谢注明出处，但不是必需的）。

Answer 3

在摆弄 a1kmm 的解决方案并最终使用 NullPointers 之后，我注意到我没有在 WebAppContext 上设置类加载器。使用以下行，我不再需要自定义类加载/清单扫描设置。

webAppContext.setClassLoader(new WebAppClassLoader(getClass().getClassLoader(), webAppContext));

Answer 4

我遇到了这个确切的问题。我用最不寻常的方式解决了它。

我使用 Maven 作为构建工具，但这是我构建自我执行 WAR 的方式。

<profile>
        <id>Jetty_9</id>
        <properties>
            <jetty9.version>9.0.4.v20130625</jetty9.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-access</artifactId>
                <version>${logback.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
                <scope>provided</scope>
            </dependency>

            <dependency>
                <groupId>org.eclipse.jetty.orbit</groupId>
                <artifactId>javax.servlet</artifactId>
                <version>3.0.0.v201112011016</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-webapp</artifactId>
                <version>${jetty9.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-plus</artifactId>
                <version>${jetty9.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-jsp</artifactId>
                <version>${jetty9.version}</version>
            </dependency>            
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>${compileSource}</source>
                        <target>${compileSource}</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-antrun-plugin</artifactId>
                    <version>1.7</version>
                    <executions>
                        <execution>
                            <id>main-class-placement</id>
                            <phase>prepare-package</phase>
                            <configuration>
                                <target>
                                    <move todir="${project.build.directory}/${project.build.finalName}/">
                                        <fileset dir="${project.build.directory}/classes/">
                                            <include name="Main.class"/>
                                        </fileset>
                                    </move>
                                </target>
                            </configuration>
                            <goals>
                                <goal>run</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>2.6</version>
                    <executions>
                        <execution>
                            <id>jetty-classpath</id>
                            <phase>prepare-package</phase>
                            <goals>
                                <goal>unpack-dependencies</goal>
                            </goals>
                            <configuration>
                                <includeGroupIds>
                                    org.eclipse.jetty,org.slf4j,ch.qos
                                </includeGroupIds>                                    
                                <includeScope>provided</includeScope>
                                <excludes>META-INF/*.SF,META-INF/*.RSA,about.html, about_files/**, readme.txt,
                                    plugin.properties, jetty-dir.css
                                </excludes>
                                <outputDirectory>
                                    ${project.build.directory}/${project.build.finalName}
                                </outputDirectory>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>2.3</version>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>Main</mainClass>
                            </manifest>
                        </archive>
                    </configuration>
                    <executions>
                        <execution>
                            <id>default-war</id>
                            <phase>package</phase>
                            <goals>
                                <goal>war</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>

但和你一样，我也遇到了这个错误。在 2 天后谷歌搜索死亡后，我发现了这个 - http://internna.blogspot.co.uk/2011/08/step-by-step-executable-war-files.html

通过切换这个的 jetty-jsp 依赖：

 <dependency>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>jsp-2.1-glassfish</artifactId>
            <version>2.1.v20100127</version>
 </dependency>

一切都开始神奇地工作了！

到目前为止，我无法解释它为什么会起作用。但我很想知道

Answer 5

我刚刚使用 ta taglib 创建了简单的 jsp。然后创建了服务器应用程序，它可以工作。 所以，我认为导致问题的不是标签库。

public static void main(String[] args) throws Exception {
    Server server = new Server(8680);
    HandlerCollection handlers = new HandlerCollection();
    server.setHandler(handlers);
    ContextHandlerCollection chc = new ContextHandlerCollection();
    handlers.addHandler(chc);
    WebAppContext webapp = new WebAppContext();
    webapp.getInitParams().put("org.eclipse.jetty.servlet.Default.useFileMappedBuffer",    
    "false");
    webapp.setContextPath("/WebAppMng01");
    //URL url = ManagedServer.class.getResource("/WebAppMng01/build/web");
    URL url = ManagedServer.class.getResource("/WebAppMng01/dist/WebAppMng01.war");
    if (url != null) {
        webapp.setWar(url.toExternalForm());
        chc.addHandler(webapp);
    }
    server.start();
    server.join();
}   

Answer 6

遗憾的是，到目前为止，没有一个答案对我有用。但我终于找到了解决我的问题的方法。这听起来像是一种 hack，而且感觉绝对是一种。

但是，如果我按照我在问题中描述的那样设置好所有东西，直到 JSTL 无法解决，我就可以采取一个步骤，让一切正常，就像魔术一样。

这个令人畏缩的步骤是将.war 文件的扩展名更改为.jar。一旦我这样做了，JSTL 就会很好地解析，并且一切正常。

所以现在我生成了一个 .war，您可以将其粘贴到 servlet 容器中，或者您可以重命名为 .jar 并独立运行。它适用于 Unix 和 Windows，而我之前这样做的方式在 Unix 上不起作用，因为 James Cook 提到的 jsp-2.1-glassfish 库中存在一个错误。

我的 pom 中的相关位：

<properties>
    <jetty.version>9.0.5.v20130815</jetty.version>
    <war.class>com.domain.package.DeployWebapp</war.class>
    <war.class.path>com/domain/package</war.class.path>
</properties>    

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>${jetty.version}</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-webapp</artifactId>
    <version>${jetty.version}</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-jsp</artifactId>
    <version>${jetty.version}</version>
    <scope>provided</scope>
</dependency>

<plugin>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>1.7</version>
    <executions>
        <execution>
            <id>main-class-placement</id>
            <phase>prepare-package</phase>
            <configuration>
                <tasks>
                    <move todir="${project.build.directory}/${project.artifactId}-${project.version}/${war.class.path}">
                    <fileset dir="${project.build.directory}/classes/${war.class.path}">
                        <include name="DeployWebapp.class" />
                    </fileset>
                </move>
                        </tasks>
                </configuration>
                <goals>
                    <goal>run</goal>
                </goals>
            </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.3</version>
    <executions>
        <execution>
            <id>jetty-classpath</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>unpack-dependencies</goal>
            </goals>
            <configuration>
                <includeGroupIds>org.eclipse.jetty,javax.servlet,javax.el,org.glassfish.web,org.eclipse.jetty.orbit,org.ow2.asm,javax.annotation</includeGroupIds>
                <outputDirectory>
                    ${project.build.directory}/${project.artifactId}-${project.version}
                </outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <attachClasses>true</attachClasses>
        <archiveClasses>true</archiveClasses>
        <archive>
            <manifest>
                <mainClass>${war.class}</mainClass>
            </manifest>
        </archive>
        <packagingExcludes>META-INF/*.SF</packagingExcludes>
        <packagingExcludes>META-INF/*.DSA</packagingExcludes>
        <packagingExcludes>META-INF/*.RSA</packagingExcludes>
    </configuration>
</plugin>

Answer 7

嵌入式 jetty 9 似乎不喜欢自动使用主可执行 jar 文件中的任何类路径条目。这包括 taglib 库。将类路径条目直接添加到 webappclassloader 似乎也不起作用。无论出于何种原因，类路径条目都必须添加到 webappclassloader 的父级。

简单的解决方案对我不起作用：

    webAppContext.setClassLoader(new WebAppClassLoader(getClass().getClassLoader(), webAppContext));

但是手动扫描清单确实如此。我重写了上面的扫描示例，只是我可以看到发生了什么，并尝试了我将在此处包含的不同内容。

//========== create WebAppClassloader with a new parent classloader with all URLs in manifests=================== 
    //search for any secondary class path entries
    Vector<URL> secondayClassPathURLVector = new Vector<>();
    ClassLoader parentClassLoader = this.getClass().getClassLoader();
    if(parentClassLoader instanceof URLClassLoader)
    {
        URL[] existingURLs = ((URLClassLoader)parentClassLoader).getURLs(); 
        for (URL parentURL : existingURLs)
        {
            //if it doesn't end in .jar, then it's probably not going to have Manifest with a Class-Path entry 
            if(parentURL.toString().endsWith(".jar"))
            {
                JarURLConnection jarURLConnection = (JarURLConnection) new URL("jar:" + parentURL.toString() + "!/").openConnection();
                Manifest jarManifest = jarURLConnection.getManifest();
                String classPath = jarManifest.getMainAttributes().getValue("Class-Path");
                if(classPath != null)
                {
                    //Iterate through all of the class path entries and create URLs out of them                                                
                    for (String part : classPath.split(" "))
                    {
                        //add our full path to the jar file to our classpath list
                        secondayClassPathURLVector.add(new URL(parentURL,part));                     
                    }
                }
            }                
        }
    }
    //use our class path entries to create a parent for the webappclassloader that knows how to use or referenced class paths
    URLClassLoader internalClassPathUrlClassLoader = new URLClassLoader(secondayClassPathURLVector.toArray(new URL[secondayClassPathURLVector.size()]), parentClassLoader);
    //create a new webapp class loader as a child of our  internalClassPathUrlClassLoader. For whatever reason Jetty needs to have a WebAppClassLoader be it's main class loader,
    //while all of our classpath entries need to be added to the parent class loader   
    WebAppClassLoader webAppClassLoader = new WebAppClassLoader(internalClassPathUrlClassLoader,context);
    context.setClassLoader(webAppClassLoader);

这应该替换 Embedded-jetty-jsp 示例，该示例由于任何原因都不起作用，但是应该，因为任何类路径条目都应该自动包含在类路径中。然而，它确实说 JSP 需要一个非系统类加载器。所以我只能假设 JSP 一旦到达系统类路径加载器就会停止扫描类路径。这就是为什么我们必须有效地更换它。

Answer 8

WebAppContext context = new WebAppContext();      
final URL url = getClass().getProtectionDomain().getCodeSource().getLocation();
if (url != null) {
    context.getMetaData().addWebInfJar(JarResource.newResource(url));
}

将 fat-jar 添加为 WEB-INF jar，让MetaInfConfiguration 找到 *.tld 文件。

参考：

• https://eclipse.googlesource.com/jetty/org.eclipse.jetty.project/+/b3be24742353f7b5880fa8229a20ed0b19058cac/jetty-webapp/src/main/java/org/eclipse/jetty/webapp/MetaInfConfiguration.java#123
• https://github.com/wacai/json-template-renderer