Jetty

　　Jetty作为Servlet服务器，和Tomcat一样也是成名已久，但是和tomcat不同的是它的体量较小，作为大型企业的服务器资格不足，但是作为分布式服务器和小型企业服务器还是很不错的选择，与作为补丁服务器的tomcat自然有些差距，介绍下jetty。

这里是Jetty和Tomcat的比较：https://blog.51cto.com/825272560/2058729

Jetty的架构：

　　Jetty和Tomcat都采用了观察者模式，定义的接口都是LifeCycle，但是Jetty的较简单，注意Jetty中所有的组件都是有生命周期的，包括Server，也就是说Jetty的起点是LifeCycle接口，所以下面就不再提这个接口了。

　　Jetty定义了两个接口，分别是Handler，HandlerContainer；这两个接口代表了Jetty的两个重要的功能，同时Jetty提供了抽象实现类AbstractHandler和AbstractHandlerContainer，注意AbstractHandlerContainer继承了AbstractHandler，他们是Jetty的默认实现。还有AbstractHandlerContainer抽象类，这个抽象类又继承了AbstractHandlerContainer，至此，Jetty的功能抽象类都已经完成。

 HandlerWrapper

　　这是个包装类，人如其名，看下它的结构和属性：

　　HandlerWrapper包装了一个Handler，这个Handler需要你自己决定你需要什么样的handler，这个Handler与后面讲的Jetty的两种实现方式有关。同时Server也继承了HandlerWrapepr，Server继承它的原因是因为Server是Jetty的启动类，所以这个Handler需要被Sever引用，并通过生命周期管理这个handler，仅此而已。

下面是Jetty的Handler的两种实现方式：

1. ScopedHandler

　　这个Handler继承自HandlerWrapper，这是个抽象类无关紧要，但是jetty为我们提供了这个抽象类的实现子类，这些是我们需要考虑的选择。

如ServletHandler：

public class ServletHandler extends ScopedHandler {
    private static final Logger LOG = Log.getLogger(ServletHandler.class);
    public static final String __DEFAULT_SERVLET = "default";
    private ServletContextHandler _contextHandler;
    private ServletContext _servletContext;
    private FilterHolder[] _filters = new FilterHolder[0];
    private FilterMapping[] _filterMappings;
    private int _matchBeforeIndex = -1;
    private int _matchAfterIndex = -1;
    private boolean _filterChainsCached = true;
    private int _maxFilterChainsCacheSize = 512;
    private boolean _startWithUnavailable = false;
    private boolean _ensureDefaultServlet = true;
    private IdentityService _identityService;
    private boolean _allowDuplicateMappings = false;
    private ServletHolder[] _servlets = new ServletHolder[0];
    private ServletMapping[] _servletMappings;
    private final Map<String, FilterHolder> _filterNameMap = new HashMap();
    private List<FilterMapping> _filterPathMappings;
    private MultiMap<FilterMapping> _filterNameMappings;
    private final Map<String, ServletHolder> _servletNameMap = new HashMap();
    private PathMappings<ServletHolder> _servletPathMap;
    private ListenerHolder[] _listeners = new ListenerHolder[0];
    private boolean _initialized = false;
    protected final ConcurrentMap<String, FilterChain>[] _chainCache = new ConcurrentMap[31];
    protected final Queue<String>[] _chainLRU = new Queue[31];

这个类允许你实现自己的filter，它会在调用Servlet之前执行这些filter。

如ContextHandler：

public class ContextHandler extends ScopedHandler implements Attributes, Graceful {
    public static final int SERVLET_MAJOR_VERSION = 3;
    public static final int SERVLET_MINOR_VERSION = 1;
    public static final Class<?>[] SERVLET_LISTENER_TYPES = new Class[]{ServletContextListener.class, ServletContextAttributeListener.class, ServletRequestListener.class, ServletRequestAttributeListener.class, HttpSessionIdListener.class, HttpSessionListener.class, HttpSessionAttributeListener.class};
    public static final int DEFAULT_LISTENER_TYPE_INDEX = 1;
    public static final int EXTENDED_LISTENER_TYPE_INDEX = 0;
    private static final String UNIMPLEMENTED_USE_SERVLET_CONTEXT_HANDLER = "Unimplemented {} - use org.eclipse.jetty.servlet.ServletContextHandler";
    private static final Logger LOG = Log.getLogger(ContextHandler.class);
    private static final ThreadLocal<ContextHandler.Context> __context = new ThreadLocal();
    private static String __serverInfo = "jetty/" + Server.getVersion();
    public static final String MANAGED_ATTRIBUTES = "org.eclipse.jetty.server.context.ManagedAttributes";
    public static final String MAX_FORM_KEYS_KEY = "org.eclipse.jetty.server.Request.maxFormKeys";
    public static final String MAX_FORM_CONTENT_SIZE_KEY = "org.eclipse.jetty.server.Request.maxFormContentSize";
    public static final int DEFAULT_MAX_FORM_KEYS = 1000;
    public static final int DEFAULT_MAX_FORM_CONTENT_SIZE = 200000;
    protected ContextHandler.Context _scontext;
    private final AttributesMap _attributes;
    private final Map<String, String> _initParams;
    private ClassLoader _classLoader;
    private String _contextPath;
    private String _contextPathEncoded;
    private String _displayName;
    private Resource _baseResource;
    private MimeTypes _mimeTypes;
    private Map<String, String> _localeEncodingMap;
    private String[] _welcomeFiles;
    private ErrorHandler _errorHandler;
    private String[] _vhosts;
    private boolean[] _vhostswildcard;
    private String[] _vconnectors;
    private Logger _logger;
    private boolean _allowNullPathInfo;
    private int _maxFormKeys;
    private int _maxFormContentSize;
    private boolean _compactPath;
    private boolean _usingSecurityManager;
    private final List<EventListener> _eventListeners;
    private final List<EventListener> _programmaticListeners;
    private final List<ServletContextListener> _servletContextListeners;
    private final List<ServletContextListener> _destroySerletContextListeners;
    private final List<ServletContextAttributeListener> _servletContextAttributeListeners;
    private final List<ServletRequestListener> _servletRequestListeners;
    private final List<ServletRequestAttributeListener> _servletRequestAttributeListeners;
    private final List<ContextHandler.ContextScopeListener> _contextListeners;
    private final List<EventListener> _durableListeners;
    private String[] _protectedTargets;
    private final CopyOnWriteArrayList<ContextHandler.AliasCheck> _aliasChecks;
    private volatile ContextHandler.Availability _availability;

这个类看起来才像正儿八经的容器类，它允许你接触到容器上下文，web容器的handler一般都会继承自这个类。

还有ServletContextHandler：

public class ServletContextHandler extends ContextHandler {
    private static final Logger LOG = Log.getLogger(ServletContextHandler.class);
    public static final int SESSIONS = 1;
    public static final int SECURITY = 2;
    public static final int GZIP = 4;
    public static final int NO_SESSIONS = 0;
    public static final int NO_SECURITY = 0;
    protected final DecoratedObjectFactory _objFactory;
    protected Class<? extends SecurityHandler> _defaultSecurityHandlerClass;
    protected SessionHandler _sessionHandler;
    protected SecurityHandler _securityHandler;
    protected ServletHandler _servletHandler;
    protected GzipHandler _gzipHandler;
    protected int _options;
    protected JspConfigDescriptor _jspConfig;
    private boolean _startListeners;

这个类继承自ContextHandler，同时它又允许你加入Jetty实现的一些特定Handler，如SessionHandler等。

后面还有一些其他的继承自ScopedHandler的Handler，原理是一样的，这些Handler最后都会执行Servlet的Service方法。

2. HandlerCollection

　　这个类继承自AbstractHandlerContainer，这个类属于暴力类，举个例子：

public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        if (this.isStarted()) {
            HandlerCollection.Handlers handlers = (HandlerCollection.Handlers)this._handlers.get();
            if (handlers == null) {
                return;
            }

            MultiException mex = null;
            Handler[] var7 = handlers._handlers;
            int var8 = var7.length;

            for(int var9 = 0; var9 < var8; ++var9) {
                Handler handler = var7[var9];

                try {
                    handler.handle(target, baseRequest, request, response);
                } catch (RuntimeException | IOException var12) {
                    throw var12;
                } catch (Exception var13) {
                    if (mex == null) {
                        mex = new MultiException();
                    }

                    mex.add(var13);
                }
            }

            if (mex != null) {
                if (mex.size() == 1) {
                    throw new ServletException(mex.getThrowable(0));
                }

                throw new ServletException(mex);
            }
        }

    }

　　这个类的作用很简单，将需要处理的handler加到这个集合类中，并把这个集合类注入到Server中的Handler中，这个类就会循环处理其中的Handler。

Connector和Tomcat中的Connector一样，负责接受请求，将请求交给Server，由Server交给Handler.hande处理：

public void handle(HttpChannel channel) throws IOException, ServletException {
        String target = channel.getRequest().getPathInfo();
        Request request = channel.getRequest();
        Response response = channel.getResponse();
        if (LOG.isDebugEnabled()) {
            LOG.debug("{} {} {} on {}", new Object[]{request.getDispatcherType(), request.getMethod(), target, channel});
        }

        if (!HttpMethod.OPTIONS.is(request.getMethod()) && !"*".equals(target)) {
            this.handle(target, request, request, response);
        } else if (!HttpMethod.OPTIONS.is(request.getMethod())) {
            request.setHandled(true);
            response.sendError(400);
        } else {
            this.handleOptions(request, response);
            if (!request.isHandled()) {
                this.handle(target, request, request, response);
            }
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("handled={} async={} committed={} on {}", new Object[]{request.isHandled(), request.isAsyncStarted(), response.isCommitted(), channel});
        }

    }

　　这个Connector实现了LifeCycle和Container以及Graceful接口，LifeCycle和Container接口方便设置一些属性和将自己注册到Server上等功能。

至此Jetty的大体流程搞清楚了，自己的学习，可能有错误，后续持续修正。