Jetty源码分析之AbstractHandler

jetty可以说是一个基于Handler设计的Web服务器,其通过组合各种Handler实现对请求的处理。所以源码阅读部分先从Handler部分开始,而AbstractHandler是大部分Handler都继承了的父类,因此先了解它的源码。下面先来看下AbstractHandler的类图,了解下它的继承关系。

从类图上就可以看到AbstractHandler实现了LifeCycle和Handler两个接口,所以同时具备这两个类的特性。
对于Handler接口,其实里面主要定义了一个处理请求的handle()方法。

public interface Handler extends LifeCycle, Destroyable
{
   //target 请求的目标,一般是个url
   //baseRequest 还未包装过的请求
   //request 包装之后得到的HttpServletRequest
   //response 保证之后得到的HttpServletResponse
   //Handler负责对请求进行处理,对外提供的处理请求的就是handle()方法.
    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException;

    public void setServer(Server server);
    public Server getServer();

    public void destroy();

}

对于LifeCycle接口这里继承的是其一个子类AggregateLifeCycle,这个类是定义用来管理集合类的生命周期的,它里面持有一个List<Bean> _beans,可以将一些组件加入到这个list中,如果这些组件实现了LifeCycle接口,则AggregateLifeCycle统一负责管理它们的生命周期—在AggregateLifeCycle启动的时候启动这些组件,在AggregateLifeCycle停止的时候停止这些组件。下面是其部分源码:

 private final List<Bean> _beans=new CopyOnWriteArrayList<Bean>();
    private boolean _started=false;

   //定义的一个内部类
    private class Bean
    {
        Bean(Object b)
        {
            _bean=b;
        }
        final Object _bean;
        volatile boolean _managed=true;

        public String toString()
        {
            return "{"+_bean+","+_managed+"}";
        }
    }


   //会依次启动管理的所有未启动的LifeCycle组件
    @Override
    protected void doStart() throws Exception
    {
        for (Bean b:_beans)
        {
            if (b._managed && b._bean instanceof LifeCycle)
            {
                LifeCycle l=(LifeCycle)b._bean;
                if (!l.isRunning())
                    l.start();
            }
        }
        // indicate that we are started, so that addBean will start other beans added.
        _started=true;
        super.doStart();
    }

    //添加一个组件,并且指定是否被管理,如果不指定为被管理组件,
    //则AggregateLifeCycle不复杂管理它们的生命周期
    public boolean addBean(Object o, boolean managed)
    {
        if (contains(o))
            return false;

        Bean b = new Bean(o);
        b._managed=managed;
        _beans.add(b);

        if (o instanceof LifeCycle)
        {
            LifeCycle l=(LifeCycle)o;

            // Start the bean if we are started
            if (managed && _started)
            {
                try
                {
                    l.start();
                }
                catch(Exception e)
                {
                    throw new RuntimeException (e);
                }
            }
        }
        return true;
    }

其实分析了上面两个继承的父类之后, AbstractHandler中基本就分析完了,因为AbstractHandler本身没有对父类的关键方法,比如doStart()和doStop()进行重写,也没有实现handle()方法(留给具体的子类去实现了),唯一重写的一个方法就是setServer()方法。AbstractHandler的全部源码如下:

public abstract class AbstractHandler extends AggregateLifeCycle implements Handler
{
    private static final Logger LOG = Log.getLogger(AbstractHandler.class);

    private Server _server;


    public AbstractHandler()
    {
    }

    //仅仅是简单的调用父类的doStart(),没有加任何新逻辑
    @Override
    protected void doStart() throws Exception
    {
        LOG.debug("starting {}",this);
        super.doStart();
    }

    @Override
    protected void doStop() throws Exception
    {
        LOG.debug("stopping {}",this);
        super.doStop();
    }


   //重写了Handler接口中的setServer()方法
    public void setServer(Server server)
    {
        Server old_server=_server;
        //server中持有其管理的所有组件的引用,所以下面会有remove和add操作
        if (old_server!=null && old_server!=server)
            old_server.getContainer().removeBean(this);
        _server=server;
        if (_server!=null && _server!=old_server)
            _server.getContainer().addBean(this);
    }

    public Server getServer()
    {
        return _server;
    }

    public void destroy()
    {
        if (!isStopped())
            throw new IllegalStateException("!STOPPED");
        super.destroy();
        if (_server!=null)
            _server.getContainer().removeBean(this);
    }


    public void dumpThis(Appendable out) throws IOException
    {
        out.append(toString()).append(" - ").append(getState()).append('\n');
    }

}