jetty9内嵌到应用，并在启动后加载WebApplicationInitializer，可运行jsp

nainai1

　　声明：本文所介绍的两功能都已经测试通过。
　　第一步先确保你用的是java 8,并依赖需要的相关jar包，以下是用gradle进行依赖的信息：


　　ext {
taglibsStandardVersion     = "1.2.5"
ecjVersion       = "4.4.2"
apacheJspVersion        = "6.9.10"
asmVersion        = "5.0.1"
tomcatVersion        = "8.0.30"
annotationApiVersion         = "1.2"
jettySchemasVersion        = "3.1"
jettyVersion         = "9.3.7.v20160115"
servletApiVersion      = "3.1.0"
hamcrestCoreVersion      = "5.0.1"
commonsLoggingVersion       = "1.2"
springVersion       = "4.2.3.RELEASE"
　　}
　　dependencies {

  compile("spring-web:spring-web:${springVersion}")
compile("spring-aop:spring-aop:${springVersion}")
compile("spring-beans:spring-beans:${springVersion}")
compile("spring-context:spring-context:${springVersion}")
compile("spring-expression:spring-expression:${springVersion}")
compile("spring-core:spring-core:${springVersion}")
compile("commons-logging:commons-logging:${commonsLoggingVersion}")
compile("javax.servlet-api:javax.servlet-api:${servletApiVersion}")
compile("hamcrest-core:hamcrest-core:${hamcrestCoreVersion}")
compile("jetty-annotations:jetty-annotations:${jettyVersion}")
compile("jetty-plus:jetty-plus:${jettyVersion}")
compile("jetty-jndi:jetty-jndi:${jettyVersion}")
compile("jetty-webapp:jetty-webapp:${jettyVersion}")
compile("jetty-xml:jetty-xml:${jettyVersion}")
compile("jetty-servlet:jetty-servlet:${jettyVersion}")
compile("jetty-servlet:jetty-security:${jettyVersion}")
compile("jetty-servlet:jetty-util:${jettyVersion}")
compile("jetty-servlet:jetty-server:${jettyVersion}")
compile("jetty-servlet:jetty-http:${jettyVersion}")
compile("jetty-servlet:jetty-io:${jettyVersion}")
compile("jetty-servlet:jetty-schemas:${jettySchemasVersion}")
compile("apache-jsp:apache-jsp:${jettyVersion}")
compile("aopalliance:aopalliance:1.0")
compile("javax.annotation-api:javax.annotation-api:${annotationApiVersion}")
compile("asm:asm:${asmVersion}")
compile("asm-tree:asm-tree:${asmVersion}")
compile("asm-commons:asm-commons:${asmVersion}")   
compile("jasper-apache-jsp:apache-jsp:${apacheJspVersion}")
compile("apache-el:apache-el:${apacheJspVersion}")
compile("ecj:ecj:${ecjVersion}")
compile("taglibs-standard-spec:taglibs-standard-spec:${taglibsStandardVersion}")
compile("taglibs-standard-impl:taglibs-standard-impl:${taglibsStandardVersion}")
}

　　1、jetty9内嵌到应用
　　核心类代码如下：



import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import org.apache.tomcat.InstanceManager;
import org.apache.tomcat.SimpleInstanceManager;
import org.eclipse.jetty.annotations.AnnotationConfiguration;
import org.eclipse.jetty.annotations.ClassInheritanceHandler;
import org.eclipse.jetty.annotations.ServletContainerInitializersStarter;
import org.eclipse.jetty.apache.jsp.JettyJasperInitializer;
import org.eclipse.jetty.jsp.JettyJspServlet;
import org.eclipse.jetty.plus.annotation.ContainerInitializer;
import org.eclipse.jetty.server.ConnectionFactory;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.NCSARequestLog;
import org.eclipse.jetty.server.NetworkConnector;
import org.eclipse.jetty.server.RequestLog;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.RequestLogHandler;
import org.eclipse.jetty.server.handler.gzip.GzipHandler;
import org.eclipse.jetty.servlet.DefaultServlet;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.util.ConcurrentHashSet;
import org.eclipse.jetty.util.log.JavaUtilLog;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.eclipse.jetty.util.thread.ThreadPool;
import org.eclipse.jetty.webapp.Configuration;
import org.eclipse.jetty.webapp.MetaData;
import org.eclipse.jetty.webapp.WebAppContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.WebApplicationInitializer;
import com.wangzhe.autojoin.wangfw.init.WebAppStrarUpInitializer;
import com.wangzhe.autojoin.wangfw.server.Common;
import com.wangzhe.autojoin.wangfw.server.ServerParam;
import com.wangzhe.autojoin.wangfw.server.jetty9.test.DateServlet;
import com.wangzhe.autojoin.wangfw.util.DateUtil;
import com.wangzhe.autojoin.wangfw.util.ObjectUtil;
import com.wangzhe.autojoin.wangfw.util.Pic2Char;
/**
* Example of using JSP's with embedded jetty and not requiring all of the
* overhead of a WebAppContext
*/
public class JettyRunner {
private static final Logger LOG = LoggerFactory.getLogger(JettyRunner.class);
// web容器相关参数
private static final ServerParam param = new ServerParam();
public static void main(String[] args) throws Exception {
printFrameWorkLog();
Common.initServerParam(args, param);
LoggingUtil.config();
Log.setLog(new JavaUtilLog());
JettyRunner main = new JettyRunner();
main.start();
printStartSuccess();
main.waitForInterrupt();
}
private static void printFrameWorkLog() throws IOException {
String fileStr = new File("").getAbsolutePath()+"\\src\\main\\webapp\\pc\\aj.wangfw\\img\\wang_font.png";
        Pic2Char.startPic2Char(fileStr);
}
private static void printStartSuccess() throws IOException {
String fileStr = new File("").getAbsolutePath()+"\\src\\main\\webapp\\pc\\aj.wangfw\\img\\startSuccess.png";
System.out.println();
Pic2Char.startPic2Char(fileStr);
}
private Server server;
private URI serverURI;
public JettyRunner() {
}
public URI getServerURI() {
return serverURI;
}
public void start() throws Exception {
server = new Server(createThreadPool());
NetworkConnector connector = createConnector();
server.addConnector(connector);
URI baseUri = getWebRootResourceUri();
// Set JSP to use Standard JavaC always
System.setProperty("org.apache.jasper.compiler.disablejsr199", "false");
server.setHandler(getWebAppContext(baseUri, getScratchDir()));
server.addConnector(connector);
server.setStopAtShutdown(true);
// Start Server
        server.start();
// Show server state
// if (LOG.isDebugEnabled())
String dump = server.dump();// 输出jetty部分dump信息
LOG.info(dump.substring(dump.indexOf("> sun.misc.Launcher$AppClassLoader")));
// }
this.serverURI = getServerUri(connector);
}
private NetworkConnector createConnector() {
ServerConnector connector = new ServerConnector(server);
connector.setPort(param.getPort());
connector.setHost(param.getHost());
return connector;
}
private URI getWebRootResourceUri() throws FileNotFoundException, URISyntaxException {
URL indexUri = this.getClass().getResource("" + param.getWebDir());
if (indexUri == null) {
return null;
}
// Points to wherever /webroot/ (the resource) is
return indexUri.toURI();
}
/**
* Establish Scratch directory for the servlet context (used by JSP
* compilation)
*/
private File getScratchDir() throws IOException {
File tempDir = new File(System.getProperty("java.io.tmpdir"));
File scratchDir = new File(tempDir.toString(), "embedded-jetty-jsp");
if (!scratchDir.exists()) {
if (!scratchDir.mkdirs()) {
throw new IOException("Unable to create scratch directory: " + scratchDir);
}
}
return scratchDir;
}
/**
* Setup the basic application "context" for this application at "/" This is
* also known as the handler tree (in jetty speak)
*/
private HandlerCollection getWebAppContext(URI baseUri, File scratchDir) {
WebAppContext webappCtx = new WebAppContext();
webappCtx.setContextPath("/");
// webappCtx.setDescriptor(param.getWebDir()+"\\WEB-INF\\web.xml");
// webappCtx.setWar(param.getWebDir());//for war
webappCtx.setDisplayName("auto join");
webappCtx.setTempDirectory(new File(param.getTempDir()));
webappCtx.setWelcomeFiles(new String[] { param.getWebDir() + "\\index.html" });// 欢迎页面
webappCtx.setConfigurationDiscovered(true);
webappCtx.setParentLoaderPriority(true);
RequestLogHandler logHandler = new RequestLogHandler();
logHandler.setRequestLog(createRequestLog());
webappCtx.setAttribute("javax.servlet.context.tempdir", scratchDir);
webappCtx.setAttribute("org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern",
".*/[^/]*servlet-api-[^/]*\\.jar$|.*/javax.servlet.jsp.jstl-.*\\.jar$|.*/.*taglibs.*\\.jar$");
if (ObjectUtil.isNotEmpty(baseUri)) {
webappCtx.setResourceBase(baseUri.toASCIIString());// for dir
} else {
webappCtx.setResourceBase(param.getWebDir());
}
webappCtx.setAttribute("org.eclipse.jetty.containerInitializers", jspInitializers());
webappCtx.setAttribute(InstanceManager.class.getName(), new SimpleInstanceManager());
webappCtx.addBean(new ServletContainerInitializersStarter(webappCtx), true);
webappCtx.setClassLoader(getUrlClassLoader());
webappCtx.addServlet(jspServletHolder(), "*.jsp");
// Add Application Servlets
webappCtx.addServlet(DateServlet.class, "/date/");
webappCtx.addServlet(exampleJspFileMappedServletHolder(), "/test/foo/");
webappCtx.addServlet(defaultServletHolder(baseUri), "/");
setConfigurations(webappCtx);
MetaData metaData = webappCtx.getMetaData();
Resource webappInitializer = Resource.newResource(WebAppStrarUpInitializer.class.getProtectionDomain().getCodeSource().getLocation());
metaData.addContainerResource(webappInitializer);
HandlerCollection handlerCollection = new HandlerCollection();
GzipHandler gzipHandler = new GzipHandler();
handlerCollection.setHandlers(new Handler[] { webappCtx, logHandler, gzipHandler });
return handlerCollection;
}
private void setConfigurations(WebAppContext webappCtx) {
webappCtx.setConfigurations(new Configuration[] {
new AnnotationConfiguration() {
@Override
public void preConfigure(WebAppContext context) throws Exception {
ClassInheritanceMap map = new ClassInheritanceMap();
ConcurrentHashSet<String> hashSet = new  ConcurrentHashSet<String>();
hashSet.add(WebAppStrarUpInitializer.class.getName());
map.put(WebApplicationInitializer.class.getName(), hashSet);
context.setAttribute(CLASS_INHERITANCE_MAP, map);
_classInheritanceHandler = new ClassInheritanceHandler(map);
}
}
});
}
/**
* Ensure the jsp engine is initialized correctly
*/
private List<ContainerInitializer> jspInitializers() {
JettyJasperInitializer sci = new JettyJasperInitializer();
ContainerInitializer initializer = new ContainerInitializer(sci, null);
List<ContainerInitializer> initializers = new ArrayList<ContainerInitializer>();
initializers.add(initializer);
return initializers;
}
/**
* Set Classloader of Context to be sane (needed for JSTL) JSP requires a
* non-System classloader, this simply wraps the embedded System classloader
* in a way that makes it suitable for JSP to use
*/
private ClassLoader getUrlClassLoader() {
ClassLoader jspClassLoader = new URLClassLoader(new URL[0], this.getClass().getClassLoader());
// jspClassLoader=Thread.currentThread().getContextClassLoader();
// //也可以用这种方式
return jspClassLoader;
}
/**
* Create JSP Servlet (must be named "jsp")
*/
private ServletHolder jspServletHolder() {
ServletHolder holderJsp = new ServletHolder("jsp", JettyJspServlet.class);
holderJsp.setInitOrder(0);
holderJsp.setInitParameter("logVerbosityLevel", "DEBUG");
holderJsp.setInitParameter("fork", "false");
holderJsp.setInitParameter("xpoweredBy", "false");
holderJsp.setInitParameter("compilerTargetVM", "1.7");
holderJsp.setInitParameter("compilerSourceVM", "1.7");
holderJsp.setInitParameter("keepgenerated", "true");
return holderJsp;
}
/**
* Create Example of mapping jsp to path spec
*/
private ServletHolder exampleJspFileMappedServletHolder() {
ServletHolder holderAltMapping = new ServletHolder();
holderAltMapping.setName("foo.jsp");
holderAltMapping.setForcedPath("/test/foo/foo.jsp");
return holderAltMapping;
}
/**
* Create Default Servlet (must be named "default")
*/
private ServletHolder defaultServletHolder(URI baseUri) {
ServletHolder holderDefault = new ServletHolder("default", DefaultServlet.class);
if (ObjectUtil.isNotEmpty(baseUri)) {
LOG.info("Base URI: " + baseUri);
holderDefault.setInitParameter("resourceBase", baseUri.toASCIIString());
} else {
holderDefault.setInitParameter("resourceBase", param.getWebDir());
}
holderDefault.setInitParameter("dirAllowed", "true");
return holderDefault;
}
/**
* Establish the Server URI
*/
private URI getServerUri(NetworkConnector connector) throws URISyntaxException {
String scheme = "http";
for (ConnectionFactory connectFactory : connector.getConnectionFactories()) {
if (connectFactory.getProtocol().equals("SSL-http")) {
scheme = "https";
}
}
String host = connector.getHost();
if (host == null) {
host = "localhost";
}
int port = connector.getLocalPort();
serverURI = new URI(String.format("%s://%s:%d/", scheme, host, port));
LOG.info("start sucess on Server URI: " + serverURI);
return serverURI;
}
public void stop() throws Exception {
server.stop();
}
/**
* Cause server to keep running until it receives a Interrupt.
* <p>
* Interrupt Signal, or SIGINT (Unix Signal), is typically seen as a result
* of a kill -TERM {pid} or Ctrl+C
*
* @throws InterruptedException
*             if interrupted
*/
public void waitForInterrupt() throws InterruptedException {
server.join();
}
public static ServerParam getParam() {
return param;
}
private RequestLog createRequestLog() {
// 记录访问日志的处理
NCSARequestLog requestLog = new NCSARequestLog();
requestLog.setFilename(param.getLogDir() + "/jetty_log" + DateUtil.formatDate(DateUtil.YYYYMMDD) + ".log");
requestLog.setRetainDays(90);
requestLog.setExtended(false);
requestLog.setAppend(true);
// requestLog.setLogTimeZone("GMT");
requestLog.setLogTimeZone("Asia/beijing");
requestLog.setLogDateFormat("yyyy-MM-dd HH:mm:ss");
requestLog.setLogLatency(true);
return requestLog;
}
/**
* 设置线程池
*
* @return
*/
private ThreadPool createThreadPool() {
QueuedThreadPool threadPool = new QueuedThreadPool();
threadPool.setMinThreads(10);
threadPool.setMaxThreads(500);
return threadPool;
}
}
　　2、jetty9服务器启动时加载WebApplicationInitializer
　　下面代码是WebApplicationInitializer的一个实现类



@Order(Integer.MIN_VALUE) // 较低的值有更高的优先级 所以这个类的优先级是最高的
public class WebAppStrarUpInitializer implements WebApplicationInitializer{
public WebAppStrarUpInitializer() {
}
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
System.out.println("hello WebAppStrarUpInitializer");
}
}
　　下面代码是从上面第一部分的JettyRunner类中抽取的部分代码，即注册WebApplicationInitializer的地方



private void setConfigurations(WebAppContext webappCtx) {
webappCtx.setConfigurations(new Configuration[] {
new AnnotationConfiguration() {
@Override
public void preConfigure(WebAppContext context) throws Exception {
ClassInheritanceMap map = new ClassInheritanceMap();
ConcurrentHashSet<String> hashSet = new  ConcurrentHashSet<String>();
hashSet.add(WebAppStrarUpInitializer.class.getName());//注册WebApplicationInitializer
map.put(WebApplicationInitializer.class.getName(), hashSet);
context.setAttribute(CLASS_INHERITANCE_MAP, map);
_classInheritanceHandler = new ClassInheritanceHandler(map);
}
}
});
}
　　完成代码编写后，请运行JettyRunner类的main方法，运行后请在浏览器输入localhost/index.jsp即可看到效果。如图：

　　参考：
　　https://github.com/orb15/embeddedjetty9-spring4
　　https://github.com/langtianya/embedded-jetty-jsp
　　https://github.com/yjmyzz/jetty-embed-demo
　　本文代码托管：https://github.com/langtianya/autojion/tree/master/module_project