IDEA内嵌Jetty启动SpringMvc项目

　　这段时间本意是想要研究一下Netty的多线程异步NIO通讯框架，看完原理想要做下源码分析。查找资料发现Jetty框架底层支持用Netty做web请求的多线程分发处理，于是就筹备着将Jetty框架内嵌到手头的一个测试项目中，调试源码分析实现原理。结果这集成一搞就是两天，有些细节部分还是要真正接触之后才会了解，为此特意整理博客一篇，就集成过程中的问题做一下总结。

　　项目说明：Maven多模块，springmvc，spring-security；

　　参考项目：JFinal（国产优秀的mvc开发框架）;

　　问题说明：1、设置webapp根目录后，项目根本无法启动；2、解决项目根路径问题后，spring-security过滤器链不执行；

一、内嵌的Jetty服务最终实现

　　1.1、Jetty服务的站点根目录与监听端口号设置代码实现

package com.train.simulate.web.server;

public class JettyServerRun {
    public static final int DEFAULT_PORT = 8898;
    public static final String DEFAULT_CONTEXT_PATH = "/train";
    private static final String DEFAULT_APP_CONTEXT_PATH = "src/main/webapp";


    public static void main(String[] args) {

        runJettyServer(DEFAULT_PORT, DEFAULT_CONTEXT_PATH);

    }

    public static void runJettyServer(int port, String contextPath) {

        new JettyServerForIDEA(DEFAULT_APP_CONTEXT_PATH,port,contextPath).start();

    }
}

/**
 * Copyright (c) 2011-2017, James Zhan 詹波 (jfinal@126.com).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.train.simulate.web.server;

import java.io.File;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.ServerSocket;
import java.util.EnumSet;

import com.train.simulate.common.utils.*;
import org.eclipse.jetty.server.DispatcherType;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.SessionManager;
import org.eclipse.jetty.server.nio.SelectChannelConnector;
import org.eclipse.jetty.server.session.HashSessionManager;
import org.eclipse.jetty.server.session.SessionHandler;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.webapp.WebAppContext;
import org.springframework.web.filter.DelegatingFilterProxy;

/**
 * IDEA 专用于在 IDEA 之下用 main 方法启动，原启动方式在 IDEA 下会报异常
 * 注意：用此方法启动对热加载支持不完全，只支持方法内部修改的热加载，不支持添加、删除方法
 *      不支持添加类文件热加载，建议开发者在 IDEA 下使用 jrebel 或者 maven 下的 jetty
 *      插件支持列为完全的热加载
 */
public class JettyServerForIDEA implements IServer {
    
    private String webAppDir;
    private int port;
    private String context;
    // private int scanIntervalSeconds;
    private boolean running = false;
    private Server server;
    private WebAppContext webApp;
    
    public JettyServerForIDEA(String webAppDir, int port, String context) {
        if (webAppDir == null) {
            throw new IllegalStateException("Invalid webAppDir of web server: " + webAppDir);
        }
        if (port < 0 || port > 65535) {
            throw new IllegalArgumentException("Invalid port of web server: " + port);
        }
        if (StrKit.isBlank(context)) {
            throw new IllegalStateException("Invalid context of web server: " + context);
        }
        
        this.webAppDir = webAppDir;
        this.port = port;
        this.context = context;
        // this.scanIntervalSeconds = scanIntervalSeconds;
    }
    
    public void start() {
        if (!running) {
            try {
                running = true;
                doStart();
            } catch (Exception e) {
                System.err.println(e.getMessage());
                //LogKit.error(e.getMessage(), e);
            }
        }
    }
    
    public void stop() {
        if (running) {
            try {server.stop();} catch (Exception e) {
                //LogKit.error(e.getMessage(), e);
                System.err.println(e.getMessage());
            }
            running = false;
        }
    }
    
    private void doStart() {
        if (!available(port)) {
            throw new IllegalStateException("port: " + port + " already in use!");
        }
        deleteSessionData();
        System.out.println("Starting Jetty ...... ");
        server = new Server();
        SelectChannelConnector connector = new SelectChannelConnector();
        connector.setPort(port);
        server.addConnector(connector);
        webApp = new WebAppContext();
        webApp.setThrowUnavailableOnStartupException(true);    // 在启动过程中允许抛出异常终止启动并退出 JVM
        webApp.setContextPath(context);
        String rootPath = PathKit.getWebRootPath();
        System.out.println(rootPath);
        String webDir = rootPath + "/" + webAppDir;
        //webApp.setDescriptor(webDir + "/WEB-INF/web.xml");
        webApp.setResourceBase(webDir);    // webApp.setWar(webAppDir);
        //postStart(webApp);
        webApp.setWelcomeFiles(new String[]{"/index.do"});
        webApp.setInitParameter("org.eclipse.jetty.servlet.Default.dirAllowed", "false");
        webApp.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false");    // webApp.setInitParams(Collections.singletonMap("org.mortbay.jetty.servlet.Default.useFileMappedBuffer", "false"));
        persistSession(webApp);

        server.setHandler(webApp);
        try {
            System.out.println("Starting web server on port: " + port);
            server.start();
            System.out.println("Starting Complete. Welcome To The Jetty :)");
            server.join();
        } catch (Exception e) {
            //LogKit.error(e.getMessage(), e);
            System.err.println(e.getMessage());
            System.exit(100);
        }
        return;
    }
    private void postStart(WebAppContext root){
        /**spring内部过滤器代理 里面包含了默认的11个过滤器 这里的初始化参数可以直接些spring的bean名称*/
        FilterHolder filterHolder=new FilterHolder(DelegatingFilterProxy.class);
        filterHolder.setName("springSecurityFilterChain");
        root.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.REQUEST));
    }
    
    private void deleteSessionData() {
        try {
            FileKit.delete(new File(getStoreDir()));
        }
        catch (Exception e) {
            //LogKit.logNothing(e);
            System.err.println(e.getMessage());
        }
    }
    
    private String getStoreDir() {
        String storeDir = PathKit.getWebRootPath() + "/../../session_data" + context;
        if ("\".equals(File.separator)) {
            storeDir = storeDir.replaceAll("/", "\\");
        }
        return storeDir;
    }
    
    private void persistSession(WebAppContext webApp) {
        String storeDir = getStoreDir();
        
        SessionManager sm = webApp.getSessionHandler().getSessionManager();
        if (sm instanceof HashSessionManager) {
            try {
                ((HashSessionManager)sm).setStoreDirectory(new File(storeDir));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return ;
        }
        
        HashSessionManager hsm = new HashSessionManager();
        try {
            hsm.setStoreDirectory(new File(storeDir));
        } catch (Exception e) {
            e.printStackTrace();
        }
        SessionHandler sh = new SessionHandler();
        sh.setSessionManager(hsm);
        webApp.setSessionHandler(sh);
    }
    
    private static boolean available(int port) {
        if (port <= 0) {
            throw new IllegalArgumentException("Invalid start port: " + port);
        }
        
        ServerSocket ss = null;
        DatagramSocket ds = null;
        try {
            ss = new ServerSocket(port);
            ss.setReuseAddress(true);
            ds = new DatagramSocket(port);
            ds.setReuseAddress(true);
            return true;
        } catch (IOException e) {
            //LogKit.logNothing(e);
            System.err.println(e.getMessage());
        } finally {
            if (ds != null) {
                ds.close();
            }
            
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    // should not be thrown, just detect port available.
                    // LogKit.logNothing(e);
                    System.err.println(e.getMessage());
                }
            }
        }
        return false;
    }
}

package com.train.simulate.web.server;

public interface IServer {
    void start();
    void stop();
}

　　1.2、Jetty架包的maven配置

<dependency>
            <groupId>org.eclipse.jetty.aggregate</groupId>
            <artifactId>jetty-all</artifactId>
            <version>7.6.0.v20120127</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

二、关于站点根目录设置后，站点无法启动的问题处理

　　2.1、在Jfinal中调用org.eclipse.jetty.webapp.WebAppContext.setResourceBase("src/main/webapp") 这样的相对路径方式。结果站点无法启动后，我去跟踪源码，发现setResourceBase方法底层使用File.getCanonicalFile方法来获取站点的绝对根路径，而这个方法最终调用System.getProperty("user.dir")来获取项目路径。具体这个系统变量是如何赋的值，这块我还没有具体搞明白，但是跟踪结果告诉我这个路径指向的是我的Maven多模块项目的顶级项目目录，而不是我想要的web子级项目。因为路径错误，所以无法启动。

　　

　　2.2、既然问题已经定位，接下来就有两种处理方案。一是设置资源根路径时从web项目名称开始设置；二是直接读取web站点的绝对根路径，将绝对路径设置到org.eclipse.jetty.webapp.WebAppContext.setResourceBase方法中。我上面的源码使用的就是直接指明绝对路径的方式。

　　

三、启用Spring-Security组件，过滤链却不生效的问题

　　

　　3.1、因为我在登录页面启用了crsf功能，需要crsfFilter为登录请求输出crsf-token码。结果站点启动执行登录时，发现这个值始终为null。异常日志显示请求也仅仅是进入了servlet的处理器，未执行Filter代码。经过一番的跟踪分析，最终确定 Tomcat模式下请求由org.springframework.web.filter.DelegatingFilterProxy进行拦截。从结果推断apache应该是直接内置了该过滤功能，不需要手动设置，但是jetty没有这个实现。

　　3.2、识别这个问题后，相应的也有两种处理方案（两种方案二选一）

• 第一种，在web.xml中显示指明这个Filter（推荐做法）

<filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

• 第二种，在代码中org.eclipse.jetty.webapp.WebAppContext中添加这个Filter，示例代码如下

private void postStart(WebAppContext root){
        /**spring内部过滤器代理 里面包含了默认的11个过滤器 这里的初始化参数可以直接些spring的bean名称*/
        FilterHolder filterHolder=new FilterHolder(DelegatingFilterProxy.class);
        filterHolder.setName("springSecurityFilterChain");
        root.addFilter(filterHolder, "/*", EnumSet.of(DispatcherType.REQUEST));
    }

小结：

　　纸上得来终觉浅，绝知此事要躬行。折腾之后好在出了结果，得到了一点安慰。接下来就准备从jetty切入分析Netty的nio工作原理啦！