一、目的

　　1、了解jetty组成架构；

　　2、学习jetty启动过程；

　　3、学习请求访问过程；

　　4、学习jetty内各模块作用，学习各模块内部代码；

二、jetty版本

　　本文所学习的jetty版本为：9.2.19.v20160908

 

三、正文

　　第一节，Server的架构图及相关类分析。

　　在jetty中，Server类是最核心的类，系统启动始于Server类，启动的同时注册了ShutdownHuk事件。Server架构图如下：

　　

从开源社区下载jetty 镜像 jetty源码分析_系统启动

　　由上图可见，在Jetty中，和Server关系最为紧密的类有Handler，LifeCycle和Container三个接口。

　　1、LifeCycle：是一个通用的组件。实现这个接口的类必须实现这个接口定义的有关生命周期的方法。主要包含以下几个和生命周期相关的方法，及由相关时间出发的监听器：

　　

public void start() throws Exception;
public void stop() throws Exception;
public boolean isRunning();
public boolean isStarted();
public boolean isStarting();
public boolean isStopping();
public boolean isStopped();
public boolean isFailed();

public void addLifeCycleListener(LifeCycle.Listener listener);
public void removeLifeCycleListener(LifeCycle.Listener listener);
    

/* ------------------------------------------------------------ */
/** Listener.
 * A listener for Lifecycle events.
 */
public interface Listener extends EventListener
{
    public void lifeCycleStarting(LifeCycle event);
    public void lifeCycleStarted(LifeCycle event);
    public void lifeCycleFailure(LifeCycle event,Throwable cause);
    public void lifeCycleStopping(LifeCycle event);
    public void lifeCycleStopped(LifeCycle event);
}

　　2、Handler：Server的处理器，也是包含生命周期的逻辑，因此继承了LifeCycle接口。Server需要handler的实现类来处理Http请求。一般Handler做如下几个工作

　　　　A：产生Http的响应；

　　　　B：检验/修改请求或调用另外一个Handler(HandlerWapper)；

　　　　C：传递请求到一个或更多个Handler(HandlerCollection)；

　　Handler被用来传递Servlet的请求或响应对象API，但不是Servet本身。servlet容器由上下文，安全性，会话和servlet的处理程序实现，在将请求对象传递到下一个处理阶段之前修改请求对象。主要包含以下4各方法：

　　

public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException;

    public void setServer(Server server);

    @ManagedAttribute(value="the jetty server for this handler", readonly=true)
    public Server getServer();

    @ManagedOperation(value="destroy associated resources", impact="ACTION")
    public void destroy();

　　其中最主要的是handle方法，Handler的所有功能都是有handle方法来实现的。

　　3、Container：Jetty的类容器(是否所有对象都由此容器保存？)

　　4、其它类分析：

　　　　A：AbstractLifeCycle，LifeCycle的抽象类实现。定义了生命周期的几个阶段，实现了LifeCycle的所有方法，并且新建了两个protected方法doStart()和doStop()；在设置生命周期状态时通知响应的listener。

　　　　B: ContainerLifeCycle，实现了LifeCycle接口(继承自AbstractLifeCycle)，并保存bean的集合。有两种类型的Bean可以加入到ContainerLifeCycle中，一种是managed Bean，此种Bean是被启动，停止和消除的集合；另外一种是unmanaged Bean，此种Bean是和dump相关联的集合，但是它的生命周期必须在外部被管理。

　　当一个没有携带managed状态的LifeBean bean被加入到容器中时，是通过启发式决定的。

　　　　如果被加入的Bean正在运行，将会被作为unmanaged Bean加入；

　　　　如果被加入的Bean没有运行，容器也没有正在运行(!running)，将会被作为AUTO bean加入；

　　　　如果被加入的Bean没有运行，容器是正在启动的(starting)，将会被作为managed bean加入容器集合，并且会被启动；

　　　　如果被加入的Bean没有运行，容器是启动好的(started)，将会被作为unmanaged bean加入容器集合；

　　当容器被启动时，所有被包含的managed bean也会被启动。任何被包含的Auto类型的bean将会检测它们的状态，如果已经启动了(started)就会转向unmanaged bean，其它的就会被启动并且转向managed bean。在容器启动后加入的没有启动的Bean，它们的状态需要被显示的管理。

　　当正在停止容器时，被集合包含并且已经启动的bean会被停止。

　　addBean(Object, boolean)方法，第一个参数的Object(可为managed，unmanaged)可以用来显式控制生命周期关系。

　　这个类提供了一些实用的方法深度保存类的结构。在存储中，下列符号用来标明包含对象的类型；

　　　　一些ContainerLifeCycle实例

　　　　　　包含POJO实例

　　　　　　包含可在本实例内启动、停止的managed对象

　　　　　　引用带单独生命周期的unmanaged对象

　　　　　　引用可变为managed和unmanaged的auto对象

protected void doStart() throws Exception
protected void doStop() throws Exception
public void destroy()
public boolean addBean(Object o)
public void addEventListener(Container.Listener listener)
public Collection<Object> getBeans()
public <T> Collection<T> getBeans(Class<T> clazz)
public <T> T getBean(Class<T> clazz)
public boolean removeBean(Object o)
public void removeEventListener(Container.Listener listener)
public void setStopTimeout(long stopTimeout)
public String dump()
public void dump(Appendable out, String indent) throws IOException

-------------------------------------------------

protected void start(LifeCycle l) throws Exception
protected void stop(LifeCycle l) throws Exception
public boolean contains(Object bean)
public boolean isManaged(Object bean)
public boolean addBean(Object o, boolean managed)
public boolean addBean(Object o, Managed managed)
public void addManaged(LifeCycle lifecycle)
public void manage(Object bean)
private void manage(Bean bean)
public void unmanage(Object bean)
private void unmanage(Bean bean)
public void setBeans(Collection<Object> beans)
public void removeBeans()
private Bean getBean(Object o)
private boolean remove(Bean bean)
public void dumpStdErr()
public static String dump(Dumpable dumpable)
public void dump(Appendable out) throws IOException
protected void dumpThis(Appendable out) throws IOException
public static void dumpObject(Appendable out, Object o) throws IOException
protected void dumpBeans(Appendable out, String indent, Collection<?>... collections) throws IOException
public static void dump(Appendable out, String indent, Collection<?>... collections) throws IOException
public void updateBean(Object oldBean, final Object newBean)
public void updateBeans(Object[] oldBeans, final Object[] newBeans)

　　分割线以上实现的是超类的方法，分割线以下是ContainerLifeCycle自身为实现超类或其它功能的方法。

　　C：AbstractHandler，Handler的抽象实现类，同时继承了ContainerLifeCycle类。内部无特重要的逻辑处理，主要是实现了ContainerLifeCycle类中的doStart和doStop方法，及Handdler接口的setServer和getServer方法。

　　D：HandlerWrapper，AbstractHandlerContainer的装饰类，设置和获取handler，为handler设置server，同时执行handler方法。

　　5、Server，系统最重要的一个类，系统启动的入口。此类由ThreadPool和Connector组合而成。类中的主要方法包括设置ThreadPool和Connector，容器启动和停止，处理请求的handler方法，以及处理session的方法等。