摘要：是一個(gè)抽象類，繼承了接口，它的方法是這個(gè)類的核心。因?yàn)榭赡苄枰粋€(gè)返回值，所以它同時(shí)繼承了接口來提供返回值。

注：本系列文章所用play版本為1.2.6

在上一篇中我們剖析了Play framework的啟動(dòng)原理，很容易就能發(fā)現(xiàn)Play framework的啟動(dòng)主入口在play.server.Server中，在本節(jié)，我們來一起看看Server類中主要發(fā)生了什么。

既然是程序運(yùn)行的主入口，那么必然是由main方法進(jìn)入的，Server類中的main方法十分簡單。源碼如下:

    public static void main(String[] args) throws Exception {
        File root = new File(System.getProperty("application.path"));
        //獲取參數(shù)中的precompiled
        if (System.getProperty("precompiled", "false").equals("true")) {
            Play.usePrecompiled = true;
        }
        //獲取參數(shù)中的writepid
        if (System.getProperty("writepid", "false").equals("true")) {
            //這個(gè)方法的作用是檢查當(dāng)前目錄下是否存在server.pid文件，若存在表明當(dāng)前已有程序在運(yùn)行
            writePID(root);
        }
        //Play類的初始化
        Play.init(root, System.getProperty("play.id", ""));
        if (System.getProperty("precompile") == null) {
            //Server類初始化
            new Server(args);
        } else {
            Logger.info("Done.");
        }
    }

main方法執(zhí)行的操作很簡單:

獲取程序路徑

檢查是否存在precompiled參數(shù)

檢查是否存在writepid參數(shù)，若存在則檢查是否存在server.pid文件，若存在則表明已有程序在運(yùn)行，不存在則將當(dāng)前程序pid寫入server.pid

play類初始化

檢查是否存在precompile參數(shù)項(xiàng)，若存在表示是個(gè)預(yù)編譯行為，結(jié)束運(yùn)行，若沒有則啟動(dòng)服務(wù)

這其中最重要的便是Play類的初始化以及Server類的初始化
這里我們先來看Server類的初始化過程，現(xiàn)在可以先簡單的將Play類的初始化理解為Play框架中一些常量的初始化以及日志、配置文件、路由信息等配置的讀取。
這里貼一下Server類的初始化過程：

    public Server(String[] args) {
        //設(shè)置文件編碼為UTF-8
        System.setProperty("file.encoding", "utf-8");
        //p為Play類初始化過程中讀取的配置文件信息
        final Properties p = Play.configuration;
        //獲取參數(shù)中的http與https端口信息，若不存在則用配置文件中的http與https端口信息
        httpPort = Integer.parseInt(getOpt(args, "http.port", p.getProperty("http.port", "-1")));
        httpsPort = Integer.parseInt(getOpt(args, "https.port", p.getProperty("https.port", "-1")));
        //若沒有配置則設(shè)置默認(rèn)端口為9000
        if (httpPort == -1 && httpsPort == -1) {
            httpPort = 9000;
        }
        //http與https端口不能相同
        if (httpPort == httpsPort) {
            Logger.error("Could not bind on https and http on the same port " + httpPort);
            Play.fatalServerErrorOccurred();
        }

        InetAddress address = null;
        InetAddress secureAddress = null;
        try {
            //獲取配置文件中的默認(rèn)http地址，若不存在則在系統(tǒng)參數(shù)中查找
            //之前還是參數(shù)配置大于配置文件，這里不知道為什么又變成了配置文件的優(yōu)先級(jí)高于參數(shù)配置，很迷
            if (p.getProperty("http.address") != null) {
                address = InetAddress.getByName(p.getProperty("http.address"));
            } else if (System.getProperties().containsKey("http.address")) {
                address = InetAddress.getByName(System.getProperty("http.address"));
            }

        } catch (Exception e) {
            Logger.error(e, "Could not understand http.address");
            Play.fatalServerErrorOccurred();
        }
        try {
            //同上，獲取https地址
            if (p.getProperty("https.address") != null) {
                secureAddress = InetAddress.getByName(p.getProperty("https.address"));
            } else if (System.getProperties().containsKey("https.address")) {
                secureAddress = InetAddress.getByName(System.getProperty("https.address"));
            }
        } catch (Exception e) {
            Logger.error(e, "Could not understand https.address");
            Play.fatalServerErrorOccurred();
        }
        //netty服務(wù)器啟動(dòng)類初始化，使用nio服務(wù)器，無限制線程池
        //這里的線程池是netty的主線程池與工作線程池，是處理連接的線程池，而Play實(shí)際執(zhí)行業(yè)務(wù)操作的線程池在另一個(gè)地方配置
        ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
                Executors.newCachedThreadPool(), Executors.newCachedThreadPool())
        );
        try {
            //初始化http端口
            if (httpPort != -1) {
                //設(shè)置管道工廠類
                bootstrap.setPipelineFactory(new HttpServerPipelineFactory());
                //綁定端口
                bootstrap.bind(new InetSocketAddress(address, httpPort));
                bootstrap.setOption("child.tcpNoDelay", true);

                if (Play.mode == Mode.DEV) {
                    if (address == null) {
                        Logger.info("Listening for HTTP on port %s (Waiting a first request to start) ...", httpPort);
                    } else {
                        Logger.info("Listening for HTTP at %2$s:%1$s (Waiting a first request to start) ...", httpPort, address);
                    }
                } else {
                    if (address == null) {
                        Logger.info("Listening for HTTP on port %s ...", httpPort);
                    } else {
                        Logger.info("Listening for HTTP at %2$s:%1$s  ...", httpPort, address);
                    }
                }

            }

        } catch (ChannelException e) {
            Logger.error("Could not bind on port " + httpPort, e);
            Play.fatalServerErrorOccurred();
        }
        //下面是https端口服務(wù)器的啟動(dòng)過程，和http一致
        bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
                Executors.newCachedThreadPool(), Executors.newCachedThreadPool())
        );

        try {
            if (httpsPort != -1) {
                //這里的管道工廠類變成了SslHttpServerPipelineFactory
                bootstrap.setPipelineFactory(new SslHttpServerPipelineFactory());
                bootstrap.bind(new InetSocketAddress(secureAddress, httpsPort));
                bootstrap.setOption("child.tcpNoDelay", true);

                if (Play.mode == Mode.DEV) {
                    if (secureAddress == null) {
                        Logger.info("Listening for HTTPS on port %s (Waiting a first request to start) ...", httpsPort);
                    } else {
                        Logger.info("Listening for HTTPS at %2$s:%1$s (Waiting a first request to start) ...", httpsPort, secureAddress);
                    }
                } else {
                    if (secureAddress == null) {
                        Logger.info("Listening for HTTPS on port %s ...", httpsPort);
                    } else {
                        Logger.info("Listening for HTTPS at %2$s:%1$s  ...", httpsPort, secureAddress);
                    }
                }

            }

        } catch (ChannelException e) {
            Logger.error("Could not bind on port " + httpsPort, e);
            Play.fatalServerErrorOccurred();
        }
        if (Play.mode == Mode.DEV) {
           // print this line to STDOUT - not using logger, so auto test runner will not block if logger is misconfigured (see #1222)
           //輸出啟動(dòng)成功，以便進(jìn)行自動(dòng)化測試
           System.out.println("~ Server is up and running");
        }
    }

server類的初始化沒什么好說的，重點(diǎn)就在于那2個(gè)管道工廠類，HttpServerPipelineFactory與SslHttpServerPipelineFactory

HttpServerPipelineFactory類作用就是為netty服務(wù)器增加了各個(gè)ChannelHandler。

public class HttpServerPipelineFactory implements ChannelPipelineFactory {

    public ChannelPipeline getPipeline() throws Exception {

        Integer max = Integer.valueOf(Play.configuration.getProperty("play.netty.maxContentLength", "-1"));

        ChannelPipeline pipeline = pipeline();
        PlayHandler playHandler = new PlayHandler();

        pipeline.addLast("flashPolicy", new FlashPolicyHandler()); 
        pipeline.addLast("decoder", new HttpRequestDecoder());
        pipeline.addLast("aggregator", new StreamChunkAggregator(max));
        pipeline.addLast("encoder", new HttpResponseEncoder());
        pipeline.addLast("chunkedWriter", playHandler.chunkedWriteHandler);
        pipeline.addLast("handler", playHandler);

        return pipeline;
    }
}

pipeline依次添加了flash處理器，http request解碼器，流區(qū)塊聚合器，http response編碼器，區(qū)塊寫入器，play處理器
flash處理器和流區(qū)塊聚合器這里暫且不作詳細(xì)解析，讀者可以理解為這2者的作用分別為傳輸flash流和合并請求頭中有Transfer-Encoding:chunked的請求數(shù)據(jù)。
PlayHandler類是Play將netty接收到的request轉(zhuǎn)換為play的request并真正開始業(yè)務(wù)處理的入口類，我們先暫時(shí)放下PlayHandler，先來看看SslHttpServerPipelineFactory做了什么

SslHttpServerPipelineFactory是https使用的管道工廠類，他除了添加了一下處理器外，最重要的是根據(jù)配置創(chuàng)建了https的連接方式。

    public ChannelPipeline getPipeline() throws Exception {

        Integer max = Integer.valueOf(Play.configuration.getProperty("play.netty.maxContentLength", "-1"));
        String mode = Play.configuration.getProperty("play.netty.clientAuth", "none");

        ChannelPipeline pipeline = pipeline();

        // Add SSL handler first to encrypt and decrypt everything.
        SSLEngine engine = SslHttpServerContextFactory.getServerContext().createSSLEngine();
        engine.setUseClientMode(false);

        if ("want".equalsIgnoreCase(mode)) {
            engine.setWantClientAuth(true);
        } else if ("need".equalsIgnoreCase(mode)) {
            engine.setNeedClientAuth(true);
        }

        engine.setEnableSessionCreation(true);

        pipeline.addLast("flashPolicy", new FlashPolicyHandler());
        pipeline.addLast("ssl", new SslHandler(engine));
        pipeline.addLast("decoder", new HttpRequestDecoder());
        pipeline.addLast("aggregator", new StreamChunkAggregator(max));
        pipeline.addLast("encoder", new HttpResponseEncoder());
        pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());

        pipeline.addLast("handler", new SslPlayHandler());

        return pipeline;
    }

在設(shè)置完SSLEngine后，SslHttpServerPipelineFactory在decoder處理器前加了一個(gè)SslHandler來處理連接，這里不是使用playHandler作為處理器，而是使用SslPlayHandler，SslPlayHandler是PlayHandler的一個(gè)子類，就是重寫了連接和出錯(cuò)時(shí)的處理，這里不多做闡述。

PlayHandler的作用是解析http request的類型，然后根據(jù)不同類型來進(jìn)行不同的處理，由于PlayHandler內(nèi)處理的東西較多，這里先附上一張大體流程圖以供讀者參考

messageReceived是一個(gè)Override方法，作用就是在netty消息傳遞至該handle時(shí)進(jìn)行相應(yīng)操作,方法代碼如下

    @Override
    public void messageReceived(final ChannelHandlerContext ctx, final MessageEvent messageEvent) throws Exception {
        if (Logger.isTraceEnabled()) {
            Logger.trace("messageReceived: begin");
        }

        final Object msg = messageEvent.getMessage();

        //判斷是否為HttpRequest的信息，不是則不進(jìn)行處理
        if (msg instanceof HttpRequest) {

            final HttpRequest nettyRequest = (HttpRequest) msg;

            // 若為websocket的初次握手請求，則進(jìn)行websocket握手過程
            if (HttpHeaders.Values.WEBSOCKET.equalsIgnoreCase(nettyRequest.getHeader(HttpHeaders.Names.UPGRADE))) {
                websocketHandshake(ctx, nettyRequest, messageEvent);
                return;
            }

            try {
                //將netty的request轉(zhuǎn)為Play的request
                final Request request = parseRequest(ctx, nettyRequest, messageEvent);

                final Response response = new Response();
                //Response.current為ThreadLocal類型，保證每個(gè)線程擁有多帶帶Response
                Http.Response.current.set(response);

                // Buffered in memory output
                response.out = new ByteArrayOutputStream();

                // Direct output (will be set later)
                response.direct = null;

                // Streamed output (using response.writeChunk)
                response.onWriteChunk(new Action