小木曾雪菜
小木曾雪菜

Play framework源码解析 Part2:Server与ServletWrapper

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

在上一篇中我们剖析了Play framework的启动原理，很容易就能发现Play framework的启动主入口在play.server.Server中，在本节，我们来一起看看Server类中主要发生了什么。

Server类

既然是程序运行的主入口，那么必然是由main方法进入的，Server类中的main方法十分简单。源码如下:

    public static void main(String[] args) throws Exception {
        File root = new File(System.getProperty("application.path"));
        //获取参数中的precompiled
        if (System.getProperty("precompiled", "false").equals("true")) {
            Play.usePrecompiled = true;
        }
        //获取参数中的writepid
        if (System.getProperty("writepid", "false").equals("true")) {
            //这个方法的作用是检查当前目录下是否存在server.pid文件，若存在表明当前已有程序在运行
            writePID(root);
        }
        //Play类的初始化
        Play.init(root, System.getProperty("play.id", ""));
        if (System.getProperty("precompile") == null) {
            //Server类初始化
            new Server(args);
        } else {
            Logger.info("Done.");
        }
    }

main方法执行的操作很简单:

  1. 获取程序路径
  2. 检查是否存在precompiled参数
  3. 检查是否存在writepid参数，若存在则检查是否存在server.pid文件，若存在则表明已有程序在运行，不存在则将当前程序pid写入server.pid
  4. play类初始化
  5. 检查是否存在precompile参数项，若存在表示是个预编译行为，结束运行，若没有则启动服务

这其中最重要的便是Play类的初始化以及Server类的初始化
这里我们先来看Server类的初始化过程，现在可以先简单的将Play类的初始化理解为Play框架中一些常量的初始化以及日志、配置文件、路由信息等配置的读取。
这里贴一下Server类的初始化过程：

    public Server(String[] args) {
        //设置文件编码为UTF-8
        System.setProperty("file.encoding", "utf-8");
        //p为Play类初始化过程中读取的配置文件信息
        final Properties p = Play.configuration;
        //获取参数中的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")));
        //若没有配置则设置默认端口为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 {
            //获取配置文件中的默认http地址，若不存在则在系统参数中查找
            //之前还是参数配置大于配置文件，这里不知道为什么又变成了配置文件的优先级高于参数配置，很迷
            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服务器启动类初始化，使用nio服务器，无限制线程池
        //这里的线程池是netty的主线程池与工作线程池，是处理连接的线程池，而Play实际执行业务操作的线程池在另一个地方配置
        ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
                Executors.newCachedThreadPool(), Executors.newCachedThreadPool())
        );
        try {
            //初始化http端口
            if (httpPort != -1) {
                //设置管道工厂类
                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端口服务器的启动过程，和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)
           //输出启动成功，以便进行自动化测试
           System.out.println("~ Server is up and running");
        }
    }

server类的初始化没什么好说的，重点就在于那2个管道工厂类，HttpServerPipelineFactory与SslHttpServerPipelineFactory

HttpServerPipelineFactory

HttpServerPipelineFactory类作用就是为netty服务器增加了各个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解码器，流区块聚合器，http response编码器，区块写入器，play处理器
flash处理器和流区块聚合器这里暂且不作详细解析，读者可以理解为这2者的作用分别为传输flash流和合并请求头中有Transfer-Encoding:chunked的请求数据。
PlayHandler类是Play将netty接收到的request转换为play的request并真正开始业务处理的入口类，我们先暂时放下PlayHandler，先来看看SslHttpServerPipelineFactory做了什么

SslHttpServerPipelineFactory

SslHttpServerPipelineFactory是https使用的管道工厂类，他除了添加了一下处理器外，最重要的是根据配置创建了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;
    }

在设置完SSLEngine后，SslHttpServerPipelineFactory在decoder处理器前加了一个SslHandler来处理连接，这里不是使用playHandler作为处理器，而是使用SslPlayHandler，SslPlayHandler是PlayHandler的一个子类，就是重写了连接和出错时的处理，这里不多做阐述。

PlayHandler

PlayHandler的作用是解析http request的类型，然后根据不同类型来进行不同的处理，由于PlayHandler内处理的东西较多，这里先附上一张大体流程图以供读者参考
Play framework源码解析 Part2:Server与ServletWrapper_第1张图片

messageReceived

messageReceived是一个Override方法，作用就是在netty消息传递至该handle时进行相应操作,方法代码如下

    @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的信息，不是则不进行处理
        if (msg instanceof HttpRequest) {

            final HttpRequest nettyRequest = (HttpRequest) msg;

            // 若为websocket的初次握手请求，则进行websocket握手过程
            if (HttpHeaders.Values.WEBSOCKET.equalsIgnoreCase(nettyRequest.getHeader(HttpHeaders.Names.UPGRADE))) {
                websocketHandshake(ctx, nettyRequest, messageEvent);
                return;
            }

            try {
                //将netty的request转为Play的request
                final Request request = parseRequest(ctx, nettyRequest, messageEvent);

                final Response response = new Response();
                //Response.current为ThreadLocal类型，保证每个线程拥有单独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() {

                    public void invoke(Object result) {
                        writeChunk(request, response, ctx, nettyRequest, result);
                    }
                });

                /*
                    查找Play插件(即继承了PlayPlugin抽象类的类)中是否有该request的实现方法，若存在，则用Play插件的实现
                    Play自带的插件实现有：
                        CorePlugin实现了/@kill和/@status路径的访问流程
                        DBPlugin实现了/@db路径的访问流程
                        Evolutions实现了/@evolutions路径的访问流程
                    这里将插件的访问与其他访问分开最主要原因应该是插件访问不需要启动Play，而其他命令必须先调用Play.start来启动
                */
                boolean raw = Play.pluginCollection.rawInvocation(request, response);
                if (raw) {
                    copyResponse(ctx, request, response, nettyRequest);
                } else {
                    /*
                        Invoker.invoke就是向Invoker类中的ScheduledThreadPoolExecutor提交任务并执行
                        使用ScheduledThreadPoolExecutor是因为可以定时，便于执行异步任务
                        Invoker类可以理解为是各个不同容器任务转向Play任务的一个转换类，他下面有2个静态内部类，分别为InvocationContext和Invocation
                        InvocationContext内存放了当前request映射的controller类的annotation
                        Invocation则为Play任务的基类，他的实现类有：
                            Job：Play的异步任务
                            NettyInvocation：netty请求的实现类
                            ServletInvocation：Servlet容器中的实现类
                            WebSocketInvocation：websocket的实现类
                    */
                    Invoker.invoke(new NettyInvocation(request, response, ctx, nettyRequest, messageEvent));
                }

            } catch (Exception ex) {
                //处理服务器错误
                serve500(ex, ctx, nettyRequest);
            }
        }

        // 如果msg是websocket，则进行websocket接收
        if (msg instanceof WebSocketFrame) {
            WebSocketFrame frame = (WebSocketFrame) msg;
            websocketFrameReceived(ctx, frame);
        }

        if (Logger.isTraceEnabled()) {
            Logger.trace("messageReceived: end");
        }
    } 
 
可以很清楚的发现PlayHandler处理请求就是依靠了各个不同的Invocation实现来完成，那我们就来看看Invocation他是如何一步步处理请求的。
 
 
Invocation
 
 
Invocation是一个抽象类，继承了Runnable接口，它的run方法是这个类的核心。
 
 
    public void run() {
        //waitInQueue是一个监视器，监视了这个invocation在队列中等待的时间
        if (waitInQueue != null) {
            waitInQueue.stop();
        }
        try {
            //预初始化，是对语言文件的清空
            preInit();
            //初始化
            if (init()) {
                //运行执行前插件任务
                before();
                //处理request
                execute();
                //运行执行后插件任务
                after();
                //成功执行后的处理
                onSuccess();
            }
        } catch (Suspend e) {
            //Suspend类让请求暂停
            suspend(e);
            after();
        } catch (Throwable e) {
            onException(e);
        } finally {
            _finally();
        }
    }
 
 
这里面的preInit()、before()、after()是没有实现类的，用的就是Invocation类中的方法。我们先来看看Invocation类中对这些方法的实现，然后再来看看他的实现类对这些方法的修改
 
 
     
  
  • init
    •  
 
 
 
    public boolean init() {
        //设置当前线程的classloader
        Thread.currentThread().setContextClassLoader(Play.classloader);
        //检查是否为dev模式，是则检查文件是否修改，以进行热加载
        Play.detectChanges();
        //若Play未启动，启动
        if (!Play.started) {
            if (Play.mode == Mode.PROD) {
                throw new UnexpectedException("Application is not started");
            }
            Play.start();
        }
        //InvocationContext中添加当前映射方法的annotation
        InvocationContext.current.set(getInvocationContext());
        return true;
    }
 
 
Play.start可以先理解为启动Play服务，具体展开将在之后mvc章节详解
 
 
     
  
  • execute
    •  
 
 
 
execute在Invocation类中是一个抽象方法，需要实现类完成自己的实现
 
 
     
  
  • onSuccess
    •  
 
 
 
    public void onSuccess() throws Exception {
        Play.pluginCollection.onInvocationSuccess();
    }
 
 
执行play插件中的执行成功方法
 
 
     
  
  • onException
    •  
 
 
 
    public void onException(Throwable e) {
        Play.pluginCollection.onInvocationException(e);
        if (e instanceof PlayException) {
            throw (PlayException) e;
        }
        throw new UnexpectedException(e);
    }
 
 
执行play插件中的执行异常方法，然后抛出异常
 
 
     
  
  • suspend
    •  
 
 
 
    public void suspend(Suspend suspendRequest) {
        if (suspendRequest.task != null) {
            WaitForTasksCompletion.waitFor(suspendRequest.task, this);
        } else {
            Invoker.invoke(this, suspendRequest.timeout);
        }
    }
 
 
若暂停的请求有任务，那么调用WaitForTasksCompletion.waitFor进行等待，直到任务完成再继续运行请求
若没有任务，那就将请求通过ScheduledThreadPoolExecutor.schedule延时一段时间后执行
 
 
     
  
  • _finally
    •  
 
 
 
    public void _finally() {
        Play.pluginCollection.invocationFinally();
        InvocationContext.current.remove();
    }
 
 
执行play插件中的invocationFinally方法
 
 
NettyInvocation
 
 
NettyInvocation是netty请求使用的实现类，我们来依次看看他对init,execute,onSuccess等方法的实现上相比Invocation改变了什么
 
 
     
  
  • run
    •  
 
 
 
    @Override
    public void run() {
        try {
            if (Logger.isTraceEnabled()) {
                Logger.trace("run: begin");
            }
            super.run();
        } catch (Exception e) {
            serve500(e, ctx, nettyRequest);
        }
        if (Logger.isTraceEnabled()) {
            Logger.trace("run: end");
        }
    }
 
 
NettyInvocation的run方法和基类唯一的差别就是包了一层try catch来处理服务器错误，这里有一点要注意，可以发现，NettyInvocation的run有一层try catch来处理500错误，PlayHandle中的messageReceived也有一层try catch来处理500错误，我的理解是前者是用来处理业务流程中的错误的，后者是为了防止意外错误引发整个服务器挂掉所以又套了一层做保险
 
 
     
  
  • init
    •  
 
 
 
    @Override
    public boolean init() {
        //设置当前线程的classloader
        Thread.currentThread().setContextClassLoader(Play.classloader);
        if (Logger.isTraceEnabled()) {
            Logger.trace("init: begin");
        }
        //设置当前线程的request和response
        Request.current.set(request);
        Response.current.set(response);
        try {
            //如果是dev模式检查路径更新
            if (Play.mode == Play.Mode.DEV) {
                Router.detectChanges(Play.ctxPath);
            }
            //如果是prod模式且静态路径缓存有当前请求信息，则从缓存中获取
            if (Play.mode == Play.Mode.PROD && staticPathsCache.containsKey(request.domain + " " + request.method + " " + request.path)) {
                RenderStatic rs = null;
                synchronized (staticPathsCache) {
                    rs = staticPathsCache.get(request.domain + " " + request.method + " " + request.path);
                }
                //使用静态资源
                serveStatic(rs, ctx, request, response, nettyRequest, event);
                if (Logger.isTraceEnabled()) {
                    Logger.trace("init: end false");
                }
                return false;
            }
            //检查是否为静态资源
            Router.routeOnlyStatic(request);
            super.init();
        } catch (NotFound nf) {
            //返回404
            serve404(nf, ctx, request, nettyRequest);
            if (Logger.isTraceEnabled()) {
                Logger.trace("init: end false");
            }
            return false;
        } catch (RenderStatic rs) {
            //使用静态资源
            if (Play.mode == Play.Mode.PROD) {
                synchronized (staticPathsCache) {
                    staticPathsCache.put(request.domain + " " + request.method + " " + request.path, rs);
                }
            }
            serveStatic(rs, ctx, request, response, nettyRequest, this.event);
            if (Logger.isTraceEnabled()) {
                Logger.trace("init: end false");
            }
            return false;
        }

        if (Logger.isTraceEnabled()) {
            Logger.trace("init: end true");
        }
        return true;
    }
 
 
可以看出，NettyInvocation的初始化就是在基类初始化之前判断request的路径，处理静态资源以及处理路径不存在的资源，这里也就说明了访问路由设置中的静态资源是不需要启动play服务的，是否意味着可以通过play搭建一个静态资源服务器？
 
 
     
  
  • execute
    •  
 
 
 
    @Override
    public void execute() throws Exception {
        //检查连接是否中断
        if (!ctx.getChannel().isConnected()) {
            try {
                ctx.getChannel().close();
            } catch (Throwable e) {
                // Ignore
            }
            return;
        }
        //渲染之前检查长度
        saveExceededSizeError(nettyRequest, request, response);
        //运行
        ActionInvoker.invoke(request, response);
    }
 
 
ActionInvoker.invoke是play mvc的执行入口方法，这个在之后会进行详解
 
 
     
  
  • success
    •  
 
 
 
    @Override
    public void onSuccess() throws Exception {
        super.onSuccess();
        if (response.chunked) {
            closeChunked(request, response, ctx, nettyRequest);
        } else {
            copyResponse(ctx, request, response, nettyRequest);
        }
        if (Logger.isTraceEnabled()) {
            Logger.trace("execute: end");
        }
    }
 
 
成功之后就判断是否是chunked类型的request，若是则关闭区块流并返回response，若不是则返回正常的response
 
 
Job
 
 
Job是Play任务的基类，用来处理异步任务，Job虽然继承了Invocation，但他并不会加入至Play的主线程池执行，Job有自己单独的线程池进行处理。因为Job可能需要一个返回值，所以它同时继承了Callable接口来提供返回值。
既然job能提供返回值，那真正起作用的方法就是call()而不是run(),我们来看一下他的call方法
 
 
    public V call() {
        Monitor monitor = null;
        try {
            if (init()) {
                before();
                V result = null;

                try {
                    lastException = null;
                    lastRun = System.currentTimeMillis();
                    monitor = MonitorFactory.start(getClass().getName()+".doJob()");
                    //执行任务并返回结果
                    result = doJobWithResult();
                    monitor.stop();
                    monitor = null;
                    wasError = false;
                } catch (PlayException e) {
                    throw e;
                } catch (Exception e) {
                    StackTraceElement element = PlayException.getInterestingStrackTraceElement(e);
                    if (element != null) {
                        throw new JavaExecutionException(Play.classes.getApplicationClass(element.getClassName()), element.getLineNumber(), e);
                    }
                    throw e;
                }
                after();
                return result;
            }
        } catch (Throwable e) {
            onException(e);
        } finally {
            if(monitor != null) {
                monitor.stop();
            }
            _finally();
        }
        return null;
    }
 
 
可以看出，job的call方法和Invocation的run方法其实差不多，中间执行job的代码其实就是execute方法的实现，但是有一点不同的是，job方法完成后不会调用onSuccess()方法。
这里只是提一下Job与Invocation类的关系，job任务的处理放在之后的插件篇再谈
 
 
WebSocketInvocation
 
 
WebSocketInvocation是websocket请求的实现类，我们来具体看下他对Invocation的方法做了怎么样的复写
 
 
     
  
  • init
    •  
 
 
 
    @Override
    public boolean init() {
        Http.Request.current.set(request);
        Http.Inbound.current.set(inbound);
        Http.Outbound.current.set(outbound);
        return super.init();
    }
 
 
没什么大的变动，就是在当前线程下添加了出入站的通道信息
 
 
     
  
  • execute
    •  
 
 
 
    @Override
    public void execute() throws Exception {
        WebSocketInvoker.invoke(request, inbound, outbound);
    }
 
 
execute方法就是将request请求，出入站通道传入WebSocketInvoker.invoke进行处理，WebSocketInvoker.invoke的代码如下，可以看出WebSocketInvoker.invoke方法也就是调用了ActionInvoker.invoke来对请求进行处理。
 
 
    public static void invoke(Http.Request request, Http.Inbound inbound, Http.Outbound outbound) {
        try {
            if (Play.mode == Play.Mode.DEV) {
                WebSocketController.class.getDeclaredField("inbound").set(null, Http.Inbound.current());
                WebSocketController.class.getDeclaredField("outbound").set(null, Http.Outbound.current());
                WebSocketController.class.getDeclaredField("params").set(null, Scope.Params.current());
                WebSocketController.class.getDeclaredField("request").set(null, Http.Request.current());
                WebSocketController.class.getDeclaredField("session").set(null, Scope.Session.current());
                WebSocketController.class.getDeclaredField("validation").set(null, Validation.current());
            }
            //websocket是没有response的
            ActionInvoker.invoke(request, null);
        }catch (PlayException e) {
            throw e;
        } catch (Exception e) {
            throw new UnexpectedException(e);
        }
    }
 
 
     
  
  • onSuccess
    •  
 
 
 
    @Override
    public void onSuccess() throws Exception {
        outbound.close();
        super.onSuccess();
    }
 
 
websocket只有当连接关闭时才会触发onSuccess方法，所以onSuccess相比Invocation也就多了一个关闭出站通道的操作
 
 
ServletInvocation
 
 
ServletInvocation是当使用Servlet容器时的实现类，也就是将程序用war打包后放在Servlet容器后运行的类，ServletInvocation不直接基础于Invocation，而且继承于DirectInvocation，DirectInvocation继承了Invocation，DirectInvocation类添加了一个Suspend字段，用来处理线程暂停或等待操作。
因为在Servlet规范中请求线程的管理交由Servlet容器处理，所以ServletInvocation不是使用Invoker的ScheduledThreadPoolExecutor来执行的，那么在配置文件中设置play.pool数量对于使用Servlet容器的程序是无效的。
既然ServletInvocation不是使用Invoker中的线程池运行的，那他是从什么地方初始化这个类并运行的呢，这点将在本篇的ServletWrapper中再详解
 
 
我们来看看ServletInvocation对Invocation中的方法进行了怎样的覆写
 
 
     
  
  • init
    •  
 
 
 
    @Override
    public boolean init() {
        try {
            return super.init();
        } catch (NotFound e) {
            serve404(httpServletRequest, httpServletResponse, e);
            return false;
        } catch (RenderStatic r) {
            try {
                serveStatic(httpServletResponse, httpServletRequest, r);
            } catch (IOException e) {
                throw new UnexpectedException(e);
            }
            return false;
        }
    }
 
 
很简单的初始化，和NettyInvocation相比就是静态资源的缓存交由Servlet容器处理
 
 
     
  
  • run
    •  
 
 
 
    @Override
    public void run() {
        try {
            super.run();
        } catch (Exception e) {
            serve500(e, httpServletRequest, httpServletResponse);
            return;
        }
    }
 
 
与NettyInvocation一样
 
 
     
  
  • execute
    •  
 
 
 
    @Override
    public void execute() throws Exception {
        ActionInvoker.invoke(request, response);
        copyResponse(request, response, httpServletRequest, httpServletResponse);
    }
 
 
ServletInvocation在execute结束后就将结果返回，这里不知道为什么不和NettyInvocation统一一下，都在execute阶段返回结果或者都在onSuccess阶段返回结果
 
 
使用netty的流程我们已经理清楚了，简单来说就是讲netty的请求处理后交由ActionInvoker.invoke来执行，ActionInvoker.invoke也是之后要研究的重点。
 
 
ServletWrapper
 
 
这篇的一开始我们以Server类为入口阐述了使用java命令直接运行时的运行过程，那么如果程序用war打包后放在Servlet容器中是如何运行的呢?
我们可以打开play程序包下resources/war的web.xml来看看默认的web.xml中是怎么配置的。
 
 
  
      play.server.ServletWrapper
  
  
  
    play
    play.server.ServletWrapper    
  
 
 
可以看出监听器和servlet入口都是ServletWrapper，那我们从程序的创建开始一点点剖析play的运行过程
 
 
contextInitialized
 
 
contextInitialized是在启动时自动加载，主要完成一些初始化的工作，代码如下
 
 
    public void contextInitialized(ServletContextEvent e) {
        //standalonePlayServer表示这是否是一个独立服务器
        Play.standalonePlayServer = false;

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        //这是程序根目录
        String appDir = e.getServletContext().getRealPath("/WEB-INF/application");
        File root = new File(appDir);

        //play id在web.xml中配置
        final String playId = System.getProperty("play.id", e.getServletContext().getInitParameter("play.id"));
        if (StringUtils.isEmpty(playId)) {
            throw new UnexpectedException("Please define a play.id parameter in your web.xml file. Without that parameter, play! cannot start your application. Please add a context-param into the WEB-INF/web.xml file.");
        }

        Play.frameworkPath = root.getParentFile();
        //使用预编译的文件
        Play.usePrecompiled = true;
        //初始化,初始化过程中会将运行模式强制改为prod
        Play.init(root, playId);
        //检查配置文件中模式是不是dev，是dev提示自动切换为prod
        Play.Mode mode = Play.Mode.valueOf(Play.configuration.getProperty("application.mode", "DEV").toUpperCase());
        if (mode.isDev()) {
            Logger.info("Forcing PROD mode because deploying as a war file.");
        }

        // Servlet 2.4手动加载路径
        // Servlet 2.4 does not allow you to get the context path from the servletcontext...
        if (isGreaterThan(e.getServletContext(), 2, 4)) {
            loadRouter(e.getServletContext().getContextPath());
        }

        Thread.currentThread().setContextClassLoader(oldClassLoader);
    }
 
 
初始化过程有2个地方需要注意
 
 
     
  
  1. 不管配置文件中使用的是什么模式，放在Servlet容器中会统一改为prod
    2.  
  
  2. 默认使用预编译模式加载
    3.  
 
 
 
service
 
 
service是servlet处理request的方法，我们先来看一下他的实现代码
 
 
    @Override
    protected void service(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
        //路由还没初始化时初始化路由
        if (!routerInitializedWithContext) {
            loadRouter(httpServletRequest.getContextPath());
        }

        if (Logger.isTraceEnabled()) {
            Logger.trace("ServletWrapper>service " + httpServletRequest.getRequestURI());
        }

        Request request = null;
        try {
            Response response = new Response();
            response.out = new ByteArrayOutputStream();
            Response.current.set(response);
            //httpServletRequest转为play的request
            request = parseRequest(httpServletRequest);

            if (Logger.isTraceEnabled()) {
                Logger.trace("ServletWrapper>service, request: " + request);
            }
            //检查插件中是否有实现
            boolean raw = Play.pluginCollection.rawInvocation(request, response);
            if (raw) {
                copyResponse(Request.current(), Response.current(), httpServletRequest, httpServletResponse);
            } else {
                //这里不是Invoker.invoke()方法，是invokeInThread
                Invoker.invokeInThread(new ServletInvocation(request, response, httpServletRequest, httpServletResponse));
            }
        } catch (NotFound e) {
            //处理404
            if (Logger.isTraceEnabled()) {
                Logger.trace("ServletWrapper>service, NotFound: " + e);
            }
            serve404(httpServletRequest, httpServletResponse, e);
            return;
        } catch (RenderStatic e) {
            //处理静态资源
            if (Logger.isTraceEnabled()) {
                Logger.trace("ServletWrapper>service, RenderStatic: " + e);
            }
            serveStatic(httpServletResponse, httpServletRequest, e);
            return;
        } catch(URISyntaxException e) {
            //处理404
            serve404(httpServletRequest, httpServletResponse, new NotFound(e.toString()));
            return;
        } catch (Throwable e) {
            throw new ServletException(e);
        } finally {
            //因为servlet的线程会复用，所以要手动删除当前线程内的值
            Request.current.remove();
            Response.current.remove();
            Scope.Session.current.remove();
            Scope.Params.current.remove();
            Scope.Flash.current.remove();
            Scope.RenderArgs.current.remove();
            Scope.RouteArgs.current.remove();
            CachedBoundActionMethodArgs.clear();
        }
    }
 
 
看的出和PlayHandle其实就是一个处理方式，先转为play的request再扔到Invoker类中进行处理，那么我们来看看Invoker.invokeInThread的具体实现过程
 
 
    public static void invokeInThread(DirectInvocation invocation) {
        boolean retry = true;
        while (retry) {
            invocation.run();
            if (invocation.retry == null) {
                retry = false;
            } else {
                try {
                    if (invocation.retry.task != null) {
                        invocation.retry.task.get();
                    } else {
                        Thread.sleep(invocation.retry.timeout);
                    }
                } catch (Exception e) {
                    throw new UnexpectedException(e);
                }
                retry = true;
            }
        }
    }
 
 
invokeInThread就是在当前线程下运行invocation，如果遇到暂停或者等待任务完成就循环直到完成。
要注意的一点是，Play 1.2.6未完成servlet模式下的websocket实现，所以如果要用websocket请用netty模式
 
 
总结
 
 
至此，play的2种正常运行的启动逻辑已经分析完毕，play的启动过程还是在与不同的服务器运行容器打交道，如何将转化后的请求交由ActionInvoker来处理。
下一篇，我们先不看ActionInvoker的具体实现，先看看play对配置文件及路由的分析处理过程。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,playframework,play框架,源码分析)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
    
                    
    • 
                    
  • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 自我意识
                        徐立华

                        
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                                
  • 关于旗正规则引擎规则中的上传和下载问题
                                    何必如此
文件下载压缩jsp文件上传
                                    
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 
一、文件打包下载 
1.文件写入压缩包 
string mainPath="D:\upload\";     下载路径 
 
string tmpfileName=jar.zip;        &n
    
                                
    • 
                                
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析
                                    bit1129
Stream
                                    
      
以如下代码为例（SocketInputDStream）： 
Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
    
                                
    • 
                                
  • spark master web ui 端口8080被占用解决方法
                                    daizj
8080端口占用sparkmaster web ui
                                    
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 
  
1、cd SPARK_HOME/sbin 
  
2、vi start-master.sh 
  
  
3、定位到下面部分
    
                                
    • 
                                
  • oracle_执行计划_谓词信息和数据获取
                                    周凡杨
oracle执行计划
                                    
      
oracle_执行计划_谓词信息和数据获取(上) 
一：简要说明  
在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 
简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
    
                                
    • 
                                
  • spring中datasource配置
                                    g21121
dataSource
                                    
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： 
http://baike.baidu.com/view/920062.htm 
  
	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.b
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三）
                                    老A不折腾
finereportFAQ报表软件
                                    
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
1、repeated column width is largerthan paper width： 
这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
    
                                
    • 
                                
  • mysql 用户管理
                                    墙头上一根草
linuxmysqluser
                                    
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
    
                                
    • 
                                
  • 关于使用Spring导致c3p0数据库死锁问题
                                    aijuans
springSpring 入门Spring 实例Spring3Spring 教程
                                    
    这个问题我实在是为整个 springsource 的员工蒙羞  
如果大家使用 spring 控制事务，使用 Open Session In View 模式，  
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
    
                                
    • 
                                
  • 百度词库联想
                                    annan211
百度
                                    
    

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>RunJS</title&g
    
                                
    • 
                                
  • int数据与byte之间的相互转换实现代码
                                    百合不是茶
位移int转bytebyte转int基本数据类型的实现
                                    
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 
  
主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 
  
int转byte; 
  
byte转int; 
  
/**
 * 字节转成int,int转成字节
 * @author Administrator
 *

    
                                
    • 
                                
  • 简单模拟实现数据库连接池
                                    bijian1013
javathreadjava多线程简单模拟实现数据库连接池
                                    
    简单模拟实现数据库连接池 
实例1： 
package com.bijian.thread;

public class DB {

	//private static final int MAX_COUNT = 10;
	private static final DB instance = new DB();

	private int count = 0;
	private i
    
                                
    • 
                                
  • 一种基于Weblogic容器的鉴权设计
                                    bijian1013
javaweblogic
                                    
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： 
String  vuser_id = "weblogic";
String  vuse
    
                                
    • 
                                
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化
                                    bit1129
hessian
                                    
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 
  1. 定义三个POJO 
   Person类 
package com.tom.hes
    
                                
    • 
                                
  • 【Hadoop十四】Hadoop提供的脚本的功能
                                    bit1129
hadoop
                                    
    1. hadoop-daemon.sh 
1.1 启动HDFS 
./hadoop-daemon.sh start namenode
./hadoop-daemon.sh start datanode 
 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
    
                                
    • 
                                
  • 中国互联网走在“灰度”上
                                    ronin47
管理 灰度
                                    
    中国互联网走在“灰度”上（转） 
文/孕峰 
  
第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。 
  
灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
    
                                
    • 
                                
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
                                    bylijinnan
java
                                    
    

public class PrintMatrixClockwisely {

	/**
	 * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2             3            4
5              6             7            8
9 
    
                                
    • 
                                
  • mongoDB 用户管理
                                    开窍的石头
mongoDB用户管理
                                    
      1:添加用户 
   第一次设置用户需要进入admin数据库下设置超级用户（use admin） 
  
   db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 
   第一个参数用户的名字 
   第二个参数
    
                                
    • 
                                
  • [游戏与生活]玩暗黑破坏神3的一些问题
                                    comsci
生活
                                    
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意 
 
 
     玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天 
 
     结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 
 
  &nb
    
                                
    • 
                                
  • java 二维数组如何存入数据库
                                    cuiyadll
java
                                    
    using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
 
namespace WindowsFormsApplication1
{
    
    
                                
    • 
                                
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA)
                                    darrenzhu
javaspringlocalglobaltransaction
                                    
    Configuring Spring and JTA without full Java EE 
 
http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ 
 
Spring doc -Transaction Management 
 
http://docs.spring.io/spri
    
                                
    • 
                                
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练
                                    dcj3sjt126com
linuxalias
                                    
    用途说明 
设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。 
  常用参数 
格式：alias 
格式：ali
    
                                
    • 
                                
  • yii2 restful web服务[格式响应]
                                    dcj3sjt126com
PHPyii2
                                    
    响应格式 
当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 
 
 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 
 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
    
                                
    • 
                                
  • MongoDB索引调优（2）——[十]
                                    eksliang
mongodbMongoDB索引优化
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述 
      上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档 
    可以在嵌套文档的键上建立索引，方式与正常
    
                                
    • 
                                
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView
                                    gundumw100
android
                                    
    拉动ListView，Item之间的间距会变大，释放后恢复原样； 
 

package cn.tangdada.tangbang.widget;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import andr
    
                                
    • 
                                
  • 程序员用HTML5制作的爱心树表白动画
                                    ini
JavaScriptjqueryWebhtml5css
                                    
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" >
<ti
    
                                
    • 
                                
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版
                                    kakajw
ThinkPad预装改装windows 7windows 8
                                    
      
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 
该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！ 
  
缘由 
小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
    
                                
    • 
                                
  • Nginx学习笔记
                                    mcj8089
nginx
                                    
    一、安装nginx                      1、在nginx官方网站下载一个包，下载地址是：  
http://nginx.org/download/nginx-1.4.2.tar.gz  
     2、WinSCP(ftp上传工
    
                                
    • 
                                
  • mongodb 聚合查询每天论坛链接点击次数
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 18 */
{
    "_id" : ObjectId("5596414cbe4d73a327e50274"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
    
                                
    • 
                                
  • java术语（PO/POJO/VO/BO/DAO/DTO）
                                    Luob.
DAOPOJODTOpoVO BO
                                    
    
PO(persistant object) 持久对象
在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作.

VO(value object) 值对象
通
    
                                
    • 
                                
  • 算法复杂度
                                    Wuaner
Algorithm
                                    
    Time Complexity & Big-O： 
 
http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o 
 
http://bigocheatsheet.com/ 
 
http://www.sitepoint.com/time-complexity-algorithms/ 
 
 

    
                                
    •