d15143231539
d15143231539

Tomcat源码学习--servlet请求处理

当前tomcat 8.5.20中已经不再使用bio模型，默认支持NIO实现的org.apache.coyote.http11.Http11NioProtocol，当前tomcat支持的io模型如下：

 Tomcat源码学习--servlet请求处理_第1张图片

在Tomcat启动时会启用一个端口来监听请求，并且会启动多个线程来处理相关的请求操作，如下图：

Tomcat源码学习--servlet请求处理_第2张图片

相关线程介绍：

（1）http-nio-8080-Acceptor为请求接收器，其只接收请求，不会对请求做任务业务处理操作，所以默认为单个线程。

（2）http-nio-8080-ClientPoller-0和http-nio-8080-ClientPoller-1为两个是作为轮询器或者转发器使用的，简单来说就是对获取到的SocketWrapper添加到一个线程池中进行处理，这种类型的线程数与CPU的核数有关。

（3）http-nio-8080-exec-1到10是tomcat的一个线程池产生的默认的10线程，这10个线程是用来执行具体的servlet请求操作，线程的数目可以跟随请求说的变化而变化。

以上3种类型的线程有点类似Reactor模式。

接下来我们看看tomcat是如何处理一个Servlet请求的。

1、tomcat启动时会初始化一个http-nio-8080-Acceptor线程来接收请求

[java]  view plain  copy
  1. protected class Acceptor extends AbstractEndpoint.Acceptor {  
  2.   
  3.         @Override  
  4.         public void run() {  
  5.   
  6.             int errorDelay = 0;  
  7.   
  8.             while (running) {  
  9.   
  10.                 // Loop if endpoint is paused  
  11.                 while (paused && running) {  
  12.                     state = AcceptorState.PAUSED;  
  13.                     try {  
  14.                         Thread.sleep(50);  
  15.                     } catch (InterruptedException e) {  
  16.                         // Ignore  
  17.                     }  
  18.                 }  
  19.   
  20.                 if (!running) {  
  21.                     break;  
  22.                 }  
  23.                 state = AcceptorState.RUNNING;  
  24.   
  25.                 try {  
  26.                     countUpOrAwaitConnection();  
  27.   
  28.                     SocketChannel socket = null;  
  29.                     try {  
  30.                         // Accept the next incoming connection from the server  
  31.                         // socket  
  32.             //阻塞方式等待请求  
  33.                         socket = serverSock.accept();  
  34.                     } catch (IOException ioe) {  
  35.                         // We didn't get a socket  
  36.                         countDownConnection();  
  37.                         if (running) {  
  38.                             // Introduce delay if necessary  
  39.                             errorDelay = handleExceptionWithDelay(errorDelay);  
  40.                             // re-throw  
  41.                             throw ioe;  
  42.                         } else {  
  43.                             break;  
  44.                         }  
  45.                     }  
  46.                     // Successful accept, reset the error delay  
  47.                     errorDelay = 0;  
  48.   
  49.                     // Configure the socket  
  50.                     if (running && !paused) {  
  51.                         // setSocketOptions() will hand the socket off to  
  52.                         // an appropriate processor if successful  
  53.             //对获取的请求进行处理操作  
  54.                         if (!setSocketOptions(socket)) {  
  55.                             closeSocket(socket);  
  56.                         }  
  57.                     } else {  
  58.                         closeSocket(socket);  
  59.                     }  
  60.                 } catch (Throwable t) {  
  61.                     ExceptionUtils.handleThrowable(t);  
  62.                     log.error(sm.getString("endpoint.accept.fail"), t);  
  63.                 }  
  64.             }  
  65.             state = AcceptorState.ENDED;  
  66.         }  
  67.   
  68.   
  69.         private void closeSocket(SocketChannel socket) {  
  70.             countDownConnection();  
  71.             try {  
  72.                 socket.socket().close();  
  73.             } catch (IOException ioe)  {  
  74.                 if (log.isDebugEnabled()) {  
  75.                     log.debug(sm.getString("endpoint.err.close"), ioe);  
  76.                 }  
  77.             }  
  78.             try {  
  79.                 socket.close();  
  80.             } catch (IOException ioe) {  
  81.                 if (log.isDebugEnabled()) {  
  82.                     log.debug(sm.getString("endpoint.err.close"), ioe);  
  83.                 }  
  84.             }  
  85.         }  
  86.     }  

在上面代码中， socket = serverSock.accept();与客户端建立连接，将连接的socket交给processSocket(socket)来处理，在processSocket会将socket进行包装成NioChannel交给Poller线程来进行处理。

[java]  view plain  copy
  1. protected boolean setSocketOptions(SocketChannel socket) {  
  2.         // Process the connection  
  3.         try {  
  4.             //disable blocking, APR style, we are gonna be polling it  
  5.             socket.configureBlocking(false);  
  6.             Socket sock = socket.socket();  
  7.             socketProperties.setProperties(sock);  
  8.   
  9.             NioChannel channel = nioChannels.pop();  
  10.             if (channel == null) {  
  11.                 SocketBufferHandler bufhandler = new SocketBufferHandler(  
  12.                         socketProperties.getAppReadBufSize(),  
  13.                         socketProperties.getAppWriteBufSize(),  
  14.                         socketProperties.getDirectBuffer());  
  15.                 if (isSSLEnabled()) {  
  16.                     channel = new SecureNioChannel(socket, bufhandler, selectorPool, this);  
  17.                 } else {  
  18.                     channel = new NioChannel(socket, bufhandler);  
  19.                 }  
  20.             } else {  
  21.                 channel.setIOChannel(socket);  
  22.                 channel.reset();  
  23.             }  
  24.             //交给Poller线程进行处理操作  
  25.             getPoller0().register(channel);  
  26.         } catch (Throwable t) {  
  27.             ExceptionUtils.handleThrowable(t);  
  28.             try {  
  29.                 log.error("",t);  
  30.             } catch (Throwable tt) {  
  31.                 ExceptionUtils.handleThrowable(tt);  
  32.             }  
  33.             // Tell to close the socket  
  34.             return false;  
  35.         }  
  36.         return true;  
  37.     }  

2、tomcat根据处理器核数创建http-nio-8080-ClientPoller-0和http-nio-8080-ClientPoller-1线程

Poller线程会通过while(true)不断从selector.selectdKeys获取是否有连接存在，如果有连接存在则从SelectionKey中获取NioSocketWrapper并通过processKey来进行处理

[java]  view plain  copy
  1. @Override  
  2.        public void run() {  
  3.            // Loop until destroy() is called  
  4.            while (true) {  
  5.   
  6.                boolean hasEvents = false;  
  7.   
  8.                try {  
  9.                    if (!close) {  
  10.                        hasEvents = events();  
  11.                        if (wakeupCounter.getAndSet(-1) > 0) {  
  12.                            //if we are here, means we have other stuff to do  
  13.                            //do a non blocking select  
  14.                            keyCount = selector.selectNow();  
  15.                        } else {  
  16.                            keyCount = selector.select(selectorTimeout);  
  17.                        }  
  18.                        wakeupCounter.set(0);  
  19.                    }  
  20.                    if (close) {  
  21.                        events();  
  22.                        timeout(0, false);  
  23.                        try {  
  24.                            selector.close();  
  25.                        } catch (IOException ioe) {  
  26.                            log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);  
  27.                        }  
  28.                        break;  
  29.                    }  
  30.                } catch (Throwable x) {  
  31.                    ExceptionUtils.handleThrowable(x);  
  32.                    log.error("",x);  
  33.                    continue;  
  34.                }  
  35.                //either we timed out or we woke up, process events first  
  36.                if ( keyCount == 0 ) hasEvents = (hasEvents | events());  
  37.   
  38.                Iterator iterator =  
  39.                    keyCount > 0 ? selector.selectedKeys().iterator() : null;  
  40.                // Walk through the collection of ready keys and dispatch  
  41.                // any active event.  
  42.                while (iterator != null && iterator.hasNext()) {  
  43.                    SelectionKey sk = iterator.next();  
  44.                    NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();  
  45.                    // Attachment may be null if another thread has called  
  46.                    // cancelledKey()  
  47.                    if (attachment == null) {  
  48.                        iterator.remove();  
  49.                    } else {  
  50.                        iterator.remove();  
  51.                     //获取到的请求NioSocketWrapper  
  52.                        processKey(sk, attachment);  
  53.                    }  
  54.                }//while  
  55.   
  56.                //process timeouts  
  57.                timeout(keyCount,hasEvents);  
  58.            }//while  
  59.   
  60.            getStopLatch().countDown();  
  61.        }  

在processKey中会判断一些SelectionKeyd 的状态，并将NioSocketWrapper提交给processSocket(SocketWrapperBase socketWrapper,

            SocketEvent event, boolean dispatch)来进行处理。

[java]  view plain  copy
  1. public boolean processSocket(SocketWrapperBase socketWrapper,  
  2.             SocketEvent event, boolean dispatch) {  
  3.         try {  
  4.             if (socketWrapper == null) {  
  5.                 return false;  
  6.             }  
  7.             SocketProcessorBase sc = processorCache.pop();  
  8.             if (sc == null) {  
  9.                 sc = createSocketProcessor(socketWrapper, event);  
  10.             } else {  
  11.                 sc.reset(socketWrapper, event);  
  12.             }  
  13.             //获取线程池，提交请求到线程池中进行处理  
  14.             Executor executor = getExecutor();  
  15.             if (dispatch && executor != null) {  
  16.                 executor.execute(sc);  
  17.             } else {  
  18.                 sc.run();  
  19.             }  
  20.         } catch (RejectedExecutionException ree) {  
  21.             getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);  
  22.             return false;  
  23.         } catch (Throwable t) {  
  24.             ExceptionUtils.handleThrowable(t);  
  25.             // This means we got an OOM or similar creating a thread, or that  
  26.             // the pool and its queue are full  
  27.             getLog().error(sm.getString("endpoint.process.fail"), t);  
  28.             return false;  
  29.         }  
  30.         return true;  
  31.     }  

在processSocket函数中会获取请求处理线程，将SocketProcessor提交到线程池中进行请求处理操作。

2、tomcat创建线程池来处理所有的servlet请求，线程池中线程名称为http-nio-8080-exec-1到10，用来对具体的请求进行处理操作，NIO对应的线程操作类为SocketProcessor。

在socketProcessor线程运行时会调用doRun()方法，在doRun()方法中调用getHandler().process(socketWrapper, SocketEvent.OPEN_READ)来处理socketWrapper请求

[java]  view plain  copy
  1. protected class SocketProcessor extends SocketProcessorBase {  
  2.   
  3.        public SocketProcessor(SocketWrapperBase socketWrapper, SocketEvent event) {  
  4.            super(socketWrapper, event);  
  5.        }  
  6.   
  7.        @Override  
  8.        protected void doRun() {  
  9.            NioChannel socket = socketWrapper.getSocket();  
  10.            SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());  
  11.   
  12.            try {  
  13.                int handshake = -1;  
  14.   
  15.                try {  
  16.                    if (key != null) {  
  17.                        if (socket.isHandshakeComplete()) {  
  18.                             
  19.                            handshake = 0;  
  20.                        } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||  
  21.                                event == SocketEvent.ERROR) {  
  22.                            handshake = -1;  
  23.                        } else {  
  24.                            handshake = socket.handshake(key.isReadable(), key.isWritable());  
  25.                             
  26.                            event = SocketEvent.OPEN_READ;  
  27.                        }  
  28.                    }  
  29.                } catch (IOException x) {  
  30.                    handshake = -1;  
  31.                    if (log.isDebugEnabled()) log.debug("Error during SSL handshake",x);  
  32.                } catch (CancelledKeyException ckx) {  
  33.                    handshake = -1;  
  34.                }  
  35.                if (handshake == 0) {  
  36.                    SocketState state = SocketState.OPEN;  
  37.                    // Process the request from this socket  
  38.                 //获取处理器调用process操作  
  39.                    if (event == null) {  
  40.                        state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);  
  41.                    } else {  
  42.                        state = getHandler().process(socketWrapper, event);  
  43.                    }  
  44.                    if (state == SocketState.CLOSED) {  
  45.                        close(socket, key);  
  46.                    }  
  47.                } else if (handshake == -1 ) {  
  48.                    close(socket, key);  
  49.                } else if (handshake == SelectionKey.OP_READ){  
  50.                    socketWrapper.registerReadInterest();  
  51.                } else if (handshake == SelectionKey.OP_WRITE){  
  52.                    socketWrapper.registerWriteInterest();  
  53.                }  
  54.            } catch (CancelledKeyException cx) {  
  55.                socket.getPoller().cancelledKey(key);  
  56.            } catch (VirtualMachineError vme) {  
  57.                ExceptionUtils.handleThrowable(vme);  
  58.            } catch (Throwable t) {  
  59.                log.error("", t);  
  60.                socket.getPoller().cancelledKey(key);  
  61.            } finally {  
  62.                socketWrapper = null;  
  63.                event = null;  
  64.                //return to cache  
  65.                if (running && !paused) {  
  66.                    processorCache.push(this);  
  67.                }  
  68.            }  
  69.        }  
  70.    }  

在父类AbstractProtocol的process方法中会获取处理器Processor，在处理器Processor.process(SocketWrapperBase socketWrapper, SocketEvent status)中调用service方法处理socketWrapper

[java]  view plain  copy
  1. @Override  
  2.    public SocketState process(SocketWrapperBase socketWrapper, SocketEvent status)  
  3.            throws IOException {  
  4.   
  5.        SocketState state = SocketState.CLOSED;  
  6.        Iterator dispatches = null;  
  7.        do {  
  8.            if (dispatches != null) {  
  9.                DispatchType nextDispatch = dispatches.next();  
  10.                state = dispatch(nextDispatch.getSocketStatus());  
  11.            } else if (status == SocketEvent.DISCONNECT) {  
  12.                // Do nothing here, just wait for it to get recycled  
  13.            } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {  
  14.                state = dispatch(status);  
  15.                if (state == SocketState.OPEN) {  
  16.                    // There may be pipe-lined data to read. If the data isn't  
  17.                    // processed now, execution will exit this loop and call  
  18.                    // release() which will recycle the processor (and input  
  19.                    // buffer) deleting any pipe-lined data. To avoid this,  
  20.                    // process it now.  
  21.                 //调用service方法处理SocketWrapper  
  22.                    state = service(socketWrapper);  
  23.                }  
  24.            } else if (status == SocketEvent.OPEN_WRITE) {  
  25.                // Extra write event likely after async, ignore  
  26.                state = SocketState.LONG;  
  27.            } else if (status == SocketEvent.OPEN_READ){  
  28.                state = service(socketWrapper);  
  29.            } else {  
  30.                // Default to closing the socket if the SocketEvent passed in  
  31.                // is not consistent with the current state of the Processor  
  32.                state = SocketState.CLOSED;  
  33.            }  
  34.   
  35.            if (state != SocketState.CLOSED && isAsync()) {  
  36.                state = asyncPostProcess();  
  37.            }  
  38.   
  39.            if (getLog().isDebugEnabled()) {  
  40.                getLog().debug("Socket: [" + socketWrapper +  
  41.                        "], Status in: [" + status +  
  42.                        "], State out: [" + state + "]");  
  43.            }  
  44.   
  45.            if (dispatches == null || !dispatches.hasNext()) {  
  46.                // Only returns non-null iterator if there are  
  47.                // dispatches to process.  
  48.                dispatches = getIteratorAndClearDispatches();  
  49.            }  
  50.        } while (state == SocketState.ASYNC_END ||  
  51.                dispatches != null && state != SocketState.CLOSED);  
  52.   
  53.        return state;  
  54.    }  

在http11Processor中调用service(socketWrapper)进行处理操作，调用CoyoteAdapter的service（request,response）方法进行请求操作。

[java]  view plain  copy
  1. @Override  
  2.     public SocketState service(SocketWrapperBase socketWrapper)  
  3.         throws IOException {  
  4.         RequestInfo rp = request.getRequestProcessor();  
  5.         rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);  
  6.   
  7.         // Setting up the I/O  
  8.         setSocketWrapper(socketWrapper);  
  9.         inputBuffer.init(socketWrapper);  
  10.         outputBuffer.init(socketWrapper);  
  11.   
  12.         // Flags  
  13.         keepAlive = true;  
  14.         openSocket = false;  
  15.         readComplete = true;  
  16.         boolean keptAlive = false;  
  17.         SendfileState sendfileState = SendfileState.DONE;  
  18.   
  19.         while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&  
  20.                 sendfileState == SendfileState.DONE && !endpoint.isPaused()) {  
  21.   
  22.             // Parsing the request header  
  23.             try {  
  24.                 if (!inputBuffer.parseRequestLine(keptAlive)) {  
  25.                     if (inputBuffer.getParsingRequestLinePhase() == -1) {  
  26.                         return SocketState.UPGRADING;  
  27.                     } else if (handleIncompleteRequestLineRead()) {  
  28.                         break;  
  29.                     }  
  30.                 }  
  31.   
  32.                 if (endpoint.isPaused()) {  
  33.                     // 503 - Service unavailable  
  34.                     response.setStatus(503);  
  35.                     setErrorState(ErrorState.CLOSE_CLEAN, null);  
  36.                 } else {  
  37.                     keptAlive = true;  
  38.                     // Set this every time in case limit has been changed via JMX  
  39.                     request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());  
  40.                     if (!inputBuffer.parseHeaders()) {  
  41.                         // We've read part of the request, don't recycle it  
  42.                         // instead associate it with the socket  
  43.                         openSocket = true;  
  44.                         readComplete = false;  
  45.                         break;  
  46.                     }  
  47.                     if (!disableUploadTimeout) {  
  48.                         socketWrapper.setReadTimeout(connectionUploadTimeout);  
  49.                     }  
  50.                 }  
  51.             } catch (IOException e) {  
  52.                 if (log.isDebugEnabled()) {  
  53.                     log.debug(sm.getString("http11processor.header.parse"), e);  
  54.                 }  
  55.                 setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);  
  56.                 break;  
  57.             } catch (Throwable t) {  
  58.                 ExceptionUtils.handleThrowable(t);  
  59.                 UserDataHelper.Mode logMode = userDataHelper.getNextMode();  
  60.                 if (logMode != null) {  
  61.                     String message = sm.getString("http11processor.header.parse");  
  62.                     switch (logMode) {  
  63.                         case INFO_THEN_DEBUG:  
  64.                             message += sm.getString("http11processor.fallToDebug");  
  65.                             //$FALL-THROUGH$  
  66.                         case INFO:  
  67.                             log.info(message, t);  
  68.                             break;  
  69.                         case DEBUG:  
  70.                             log.debug(message, t);  
  71.                     }  
  72.                 }  
  73.                 // 400 - Bad Request  
  74.                 response.setStatus(400);  
  75.                 setErrorState(ErrorState.CLOSE_CLEAN, t);  
  76.                 getAdapter().log(request, response, 0);  
  77.             }  
  78.   
  79.             // Has an upgrade been requested?  
  80.             Enumeration connectionValues = request.getMimeHeaders().values("Connection");  
  81.             boolean foundUpgrade = false;  
  82.             while (connectionValues.hasMoreElements() && !foundUpgrade) {  
  83.                 foundUpgrade = connectionValues.nextElement().toLowerCase(  
  84.                         Locale.ENGLISH).contains("upgrade");  
  85.             }  
  86.   
  87.             if (foundUpgrade) {  
  88.                 // Check the protocol  
  89.                 String requestedProtocol = request.getHeader("Upgrade");  
  90.   
  91.                 UpgradeProtocol upgradeProtocol = httpUpgradeProtocols.get(requestedProtocol);  
  92.                 if (upgradeProtocol != null) {  
  93.                     if (upgradeProtocol.accept(request)) {  
  94.                         // TODO Figure out how to handle request bodies at this  
  95.                         // point.  
  96.                         response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);  
  97.                         response.setHeader("Connection", "Upgrade");  
  98.                         response.setHeader("Upgrade", requestedProtocol);  
  99.                         action(ActionCode.CLOSE,  null);  
  100.                         getAdapter().log(request, response, 0);  
  101.   
  102.                         InternalHttpUpgradeHandler upgradeHandler =  
  103.                                 upgradeProtocol.getInternalUpgradeHandler(  
  104.                                         getAdapter(), cloneRequest(request));  
  105.                         UpgradeToken upgradeToken = new UpgradeToken(upgradeHandler, null, null);  
  106.                         action(ActionCode.UPGRADE, upgradeToken);  
  107.                         return SocketState.UPGRADING;  
  108.                     }  
  109.                 }  
  110.             }  
  111.   
  112.             if (!getErrorState().isError()) {  
  113.                 // Setting up filters, and parse some request headers  
  114.                 rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);  
  115.                 try {  
  116.                     prepareRequest();  
  117.                 } catch (Throwable t) {  
  118.                     ExceptionUtils.handleThrowable(t);  
  119.                     if (log.isDebugEnabled()) {  
  120.                         log.debug(sm.getString("http11processor.request.prepare"), t);  
  121.                     }  
  122.                     // 500 - Internal Server Error  
  123.                     response.setStatus(500);  
  124.                     setErrorState(ErrorState.CLOSE_CLEAN, t);  
  125.                     getAdapter().log(request, response, 0);  
  126.                 }  
  127.             }  
  128.   
  129.             if (maxKeepAliveRequests == 1) {  
  130.                 keepAlive = false;  
  131.             } else if (maxKeepAliveRequests > 0 &&  
  132.                     socketWrapper.decrementKeepAlive() <= 0) {  
  133.                 keepAlive = false;  
  134.             }  
  135.   
  136.             // Process the request in the adapter  
  137.             if (!getErrorState().isError()) {  
  138.                 try {  
  139.                     rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);  
  140.                     getAdapter().service(request, response);  
  141.                     // Handle when the response was committed before a serious  
  142.                     // error occurred.  Throwing a ServletException should both  
  143.                     // set the status to 500 and set the errorException.  
  144.                     // If we fail here, then the response is likely already  
  145.                     // committed, so we can't try and set headers.  
  146.                     if(keepAlive && !getErrorState().isError() && !isAsync() &&  
  147.                             statusDropsConnection(response.getStatus())) {  
  148.                         setErrorState(ErrorState.CLOSE_CLEAN, null);  
  149.                     }  
  150.                 } catch (InterruptedIOException e) {  
  151.                     setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);  
  152.                 } catch (HeadersTooLargeException e) {  
  153.                     log.error(sm.getString("http11processor.request.process"), e);  
  154.                     // The response should not have been committed but check it  
  155.                     // anyway to be safe  
  156.                     if (response.isCommitted()) {  
  157.                         setErrorState(ErrorState.CLOSE_NOW, e);  
  158.                     } else {  
  159.                         response.reset();  
  160.                         response.setStatus(500);  
  161.                         setErrorState(ErrorState.CLOSE_CLEAN, e);  
  162.                         response.setHeader("Connection", "close"); // TODO: Remove  
  163.                     }  
  164.                 } catch (Throwable t) {  
  165.                     ExceptionUtils.handleThrowable(t);  
  166.                     log.error(sm.getString("http11processor.request.process"), t);  
  167.                     // 500 - Internal Server Error  
  168.                     response.setStatus(500);  
  169.                     setErrorState(ErrorState.CLOSE_CLEAN, t);  
  170.                     getAdapter().log(request, response, 0);  
  171.                 }  
  172.             }  
  173.   
  174.             // Finish the handling of the request  
  175.             rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);  
  176.             if (!isAsync()) {  
  177.                 // If this is an async request then the request ends when it has  
  178.                 // been completed. The AsyncContext is responsible for calling  
  179.                 // endRequest() in that case.  
  180.                 endRequest();  
  181.             }  
  182.             rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);  
  183.   
  184.             // If there was an error, make sure the request is counted as  
  185.             // and error, and update the statistics counter  
  186.             if (getErrorState().isError()) {  
  187.                 response.setStatus(500);  
  188.             }  
  189.   
  190.             if (!isAsync() || getErrorState().isError()) {  
  191.                 request.updateCounters();  
  192.                 if (getErrorState().isIoAllowed()) {  
  193.                     inputBuffer.nextRequest();  
  194.                     outputBuffer.nextRequest();  
  195.                 }  
  196.             }  
  197.   
  198.             if (!disableUploadTimeout) {  
  199.                 int soTimeout = endpoint.getConnectionTimeout();  
  200.                 if(soTimeout > 0) {  
  201.                     socketWrapper.setReadTimeout(soTimeout);  
  202.                 } else {  
  203.                     socketWrapper.setReadTimeout(0);  
  204.                 }  
  205.             }  
  206.   
  207.             rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);  
  208.   
  209.             sendfileState = processSendfile(socketWrapper);  
  210.         }  
  211.   
  212.         rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);  
  213.   
  214.         if (getErrorState().isError() || endpoint.isPaused()) {  
  215.             return SocketState.CLOSED;  
  216.         } else if (isAsync()) {  
  217.             return SocketState.LONG;  
  218.         } else if (isUpgrade()) {  
  219.             return SocketState.UPGRADING;  
  220.         } else {  
  221.             if (sendfileState == SendfileState.PENDING) {  
  222.                 return SocketState.SENDFILE;  
  223.             } else {  
  224.                 if (openSocket) {  
  225.                     if (readComplete) {  
  226.                         return SocketState.OPEN;  
  227.                     } else {  
  228.                         return SocketState.LONG;  
  229.                     }  
  230.                 } else {  
  231.                     return SocketState.CLOSED;  
  232.                 }  
  233.             }  
  234.         }  
  235.     }  

你可能感兴趣的:(Tomcat源码学习--servlet请求处理)

  • 国内的AI大模型有可能超过ChatGPT吗？ AIWritePaper官方账号 PromptChatGPTAIWritePaperchatgpt人工智能深度学习AI写作AIGC
    这是一个非常有前瞻性和现实意义的问题。要回答国内AI是否有可能超过ChatGPT，我们需要从多个方面来分析，包括技术基础、数据资源、应用场景、政策支持以及人才储备等。以下是对这一问题的详细探讨：1.技术基础（1）现状国内AI技术：国内的AI技术发展迅速，尤其在深度学习、自然语言处理（NLP）和计算机视觉等领域已经取得了显著进展。例如，百度的文心一言、阿里的通义千问等大语言模型（LLM）已经在技术上
  • 【Mac】Python相关知识经验 水银嘻嘻 Pythonmacospython开发语言
    一、给Python3安装第三方库mac下给Python3安装第三方库pillow，处理图片【安装方式】：终端中输入命令：python3-mpipinstallpillow按回车，等待pillow下载安装NOTE:其他模块同理，如pytesseract二、Python版本升级1.终端执行命令：brewinstallpython32.安装Python3版本成功后，系统默认的仍旧是之前的版本，注意不要去
  • Oracle、PostgreSQL该学哪一个？ leegong23111 oraclepostgresql数据库
    从事数据库运维一线工作的老鸟，经常会有人来问我：“Oracle和PostgreSQL，我该学哪个？哪个更有职业发展前景？”今天就来和大家好好唠唠。先说说Oracle。它堪称数据库领域的“老牌贵族”，功能极其强大。在大型企业和金融机构中，Oracle有着深厚的根基。其具备高度的稳定性和可靠性，能支撑超大规模的数据处理和高并发业务。比如在银行的核心交易系统中，每天要处理海量的交易数据，Oracle就能
  • C# 调用 origin 批量作图 angliaokantang0683 c#runtime
    C#调用origin批量作图质谱数据处理软件中，需要批量粘贴Origin的矢量图到Word和PPT中，由于出图量大，需要用代码生成。代码参考了Origin9.2中自带的AutomationServer示例代码。本文涉及两部分内容，如何通过C#调用Origin.dll和interop.word对word的读写操作。目标：文件是一个.opj文件，内容如下。我们通过C#调用相关接口来修改数据和标签。并且
  • 【并发多个请求并失败重发】 CaraYQ 实践javascript开发语言ecmascript
    文章目录需求思路代码需求可以一次发任意多个请求，如果有失败，则重发失败的请求，知道所有的都成功，或者超出最大重试次数，才返回最终结果。封装成可复用的并发请求工具。实际的应用场景：数据太大，分批次传给后端，比如大文件分片上传思路使用循环、promise.all、promise.allSettled都可以用来发请求：循环能做到并发，各发各的，各回各的，如果要使用循环，需要自己写一个监听者监听请求都完成
  • 【C++基础】std::string详解 kucupung C++c++数据结构开发语言算法
    std::string是C++标准库提供的用于处理字符串的类。它在头文件中定义。std::string提供了一种灵活、高效的字符串表示方式，相比于C语言中的字符串表示（使用字符数组或指针），std::string更易于使用，更安全，并且提供了许多便捷的操作。一、底层实现std::string类的底层实现通常是一个动态分配的字符数组（即堆上的内存），并且该数组的长度可以动态地增长和收缩以适应字符串的
  • 使用 Intersection Observer 实现高效懒加载和滚动监听 桂月二二 macos前端框架前端
    在前端开发中，性能优化是提升用户体验的核心之一。随着网页内容的日益增多，如何高效地加载图片、视频等资源，以及如何监听用户的滚动行为，成为了前端开发者需要解决的难题。传统的滚动事件监听往往会带来性能瓶颈，尤其是在需要频繁触发的情况下。为此，IntersectionObserverAPI应运而生，它能让开发者更高效、灵活地处理懒加载和滚动监听等需求。本文将深入介绍如何使用IntersectionObs
  • Python设计模式 - 工厂方法模式 mofei12138 设计模式pythonpython设计模式工厂方法模式
    定义工厂方法模式是一种创建型设计模式，它定义一个创建对象的接口，让其子类来处理对象的创建，而不是直接实例化对象。结构抽象工厂（Factory）：声明工厂方法，返回一个产品对象。具体工厂类都必须实现该方法。具体工厂（ConcreteFactory）：实现工厂方法以创建具体的产品对象。抽象产品（Product）：定义产品对象的接口。具体产品（ConcreteProduct）：实现产品接口的具体产品对象
  • 【Lora微调】提高模型效率的创新方法 @fishv 人工智能大模型微调Lora
    前言在自然语言处理（NLP）和机器学习的研究和应用中，随着模型规模的不断扩大，模型训练的计算成本和存储需求也不断攀升。大型预训练模型，如GPT、BERT等，虽然在许多任务上表现出色，但它们的训练和微调通常需要巨大的计算资源，这使得许多研究者和开发者无法充分利用这些模型进行个性化或领域特定的调整。为了在保持模型性能的同时减少计算开销，**Lora（Low-RankAdaptation）**应运而生。
  • 正则表达式的艺术：轻松驾驭 Python 的 re 库 傻啦嘿哟 mysql数据库java
    目录一、正则表达式的基本概念二、Python的re库简介三、正则表达式的元字符四、正则表达式的贪婪与非贪婪模式五、实战案例六、总结正则表达式（RegularExpression）是文本处理中不可或缺的工具，它强大而灵活，能够帮助我们高效地匹配、查找、替换复杂的文本模式。Python的re库为我们提供了便捷的正则表达式操作接口。本文将带你领略正则表达式的艺术，通过简洁明了的代码和案例，轻松驾驭Pyt
  • 数字输出格式中的RAW与PCM有哪些区别 ~远在太平洋~ 测试pcmRAW
    数字输出格式中的RAW与PCM在音频和视频处理领域有着显著的区别。以下是对这两种格式的详细比较：一、定义与原理RAW定义：RAW通常指的是未经任何处理或压缩的原始数据格式。在音频领域，它表示音频文件中未经过编码或压缩的纯音频数据。原理：RAW音频数据直接从音频源（如麦克风、乐器等）获取，不经过任何形式的编码或压缩处理。PCM（PulseCodeModulation，脉冲编码调制）定义：PCM是一种
  • 数据项目相关的AWS云计算架构设计 weixin_30777913 云计算数据仓库awssparkpython
    电商数据平台架构高性能：使用AmazonEC2的计算优化实例处理业务逻辑和数据计算，搭配AmazonElastiCache内存缓存，加速数据读取。应用负载均衡器（ALB）在EC2实例间分发流量，实现负载均衡。高可用性：采用多可用区（Multi-AZ）部署，将EC2实例、数据库等资源分布在多个可用区。使用AmazonRDS并开启多AZ部署，实现数据库自动故障转移。利用AWSAutoScaling根据
  • CDH大数据平台 梦龙zmc 大数据大数据
    CDH概念CDH（ClouderaDistributionIncludingApacheHadoop)是由Cloudera公司提供的一个集成了ApacheHadoop以及相关生态系统的发行版本。CDH是一个大数据平台，简化和加速了大数据处理分析的部署和管理。CDH提供Hadoop的核心元素-可伸缩存储和分布式计算-以及基于web的用户界面和重要的企业功能。CDH是Apache许可的开放源码，是唯一
  • 解决并发问题的方法 梦龙zmc devops
    解决并发问题的方法常见有三种，它们分别是：‌使用缓存‌、‌使用异步处理‌、以及‌使用负载均衡‌。这些方法通过不同的方式提升系统的并发处理能力，减少等待时间，以及优化资源分配，从而提高系统的整体性能和稳定性。‌使用缓存‌：通过缓存机制来减少系统的数据库和文件系统等I/O操作，从而提升系统的响应速度和并发能力。缓存可以包括页面缓存、数据缓存、分布式缓存等，通过将热点数据存储在内存中，减轻数据库的访问压
  • 第二十二：Python接口自动化-token登录 平头哥-测试 python自动化
    一.简介1.为验证用户登录情况以及减轻服务器的压力，减少频繁的查询数据库，使服务器更加健壮2.有些登录不是用cookie来验证的，是用token参数来判断是否登录3.token传参有两种3.1.一种是放在请求头里，本质跟cookie是一样3.2.一种是在url请求参数里，这种更直观二.抓包登录返回token1.登录接口，就是没有cookies的登录接口。但是登录接口，登录成功后有返回tok
  • 电商平台架构设计与微服务部署 Go小鸟编程 微服务电商golang后端架构云原生
    电商业务模型分析电商业务是一个涵盖广泛、交互复杂的系统，涉及用户浏览商品、下单购物、支付、订单处理、物流配送等多个环节。从业务的角度进行拆解可以更好地理解和组织各个方面的功能。以下是对电商业务场景、业务模型和工作链路的拆解。买家视角电商系统的本质是促进商品和服务的在线买卖，面向买家用户的工作流是电商系统的核心卖家视角从商家的视角，电商系统的一般工作流程涉及商品管理、订单处理、售后服务等多个环节：平
  • 数据可视化期末复习-简答题 熊假猫威XStar 信息可视化数据分析数据挖掘计算机视觉数据可视化期末大学生
    数据可视化的标准实用性完整性真实性艺术性交互性数据可视化的目标通过数据可视化有效呈现数据中的重要特征通过数据可视化揭示事物内部的规律和数据之间的内在联系通过数据可视化辅助人们理解事物的概念和过程通过数据可视化对模拟和测量进行质量监控通过数据可视化提高科研开发效率数据可视化的过程1.通过仪器采样、调查记录、模拟计算等方法进行数据采集2.对采集来的数据进行处理和变换，提高数据的质量3.把不同数据之间的
  • 2023美赛数学建模C题思路复盘，备战24美赛！ 喜欢一个人_ 大数据人工智能数学建模
    目录2024美赛数学建模各题思路模型代码：开赛后第一时间更新，更新见文末一、2023题目重述拟解决的问题我们的工作：二、模型和计算1.数据预处理2.报告数量区间预测模型3.猜词结果分布预测模型3.词汇难度分类模型2024美赛数学建模各题思路模型代码：开赛后第一时间更新，更新见文末一、2023题目重述Homer是棒球运动中的术语，是非正式的美式英语单词。令人惊讶的是，Homer（本垒打）在剑桥词典网
  • 再分享API形式调用Dify项目应用 福安德信息科技 大模型python人工智能大模型llmdify
    大模型相关目录大模型，包括部署微调prompt/Agent应用开发、知识库增强、数据库增强、知识图谱增强、自然语言处理、多模态等大模型应用开发内容从0起步，扬帆起航。RAGOnMedicalKG：大模型结合知识图谱的RAG实现DSPy：变革式大模型应用开发最简明的Few-shotPrompt指南SemanticKernel：微软大模型开发框架——LangChain替代对话大模型Prompt是否需要
  • 16 分布式session和无状态的会话 40岁的系统架构师 分布式系统架构
    在我们传统的应用中session存储在服务端，减少服务端的查询压力。如果以集群的方式部署，用户登录的session存储在该次登录的服务器节点上，如果下次访问服务端的请求落到其他节点上就需要重新生成session，这样用户需要频繁的登录。nginx使用iphash的方式代理服务当nginx使用该方式代理请求转发时，相同ip的用户请求会落到相同的机器上，这样就可以避免了频繁的登录。该方式部署简单，在n
  • python处理excel的具体操作 若木胡 toolspython
    安装相关库openpyxl库：用于读取和写入Excel文件（.xlsx/.xlsm）。可以使用pipinstallopenpyxl命令进行安装。pandas库：提供了高效的数据结构和数据分析工具，它对openpyxl进行了封装，使操作Excel文件更加方便。安装命令是pipinstallpandas。使用openpyxl读取Excel文件打开工作簿：首先要导入openpyxl库，然后使用load_
  • uniapp 微信小程序 去除button默认样式 带着梦想扬帆启航 uniapp微信小程序LESSCSS微信小程序css前端
    一般情况下我们需要去掉的默认样式就是button按钮的背景和边框.btn{color:#333;text-align:center;border:none;border-radius:0;background-color:transparent;}此时你会发现按钮的边框并没有去掉，通过控制器定位到这个按钮的边框样式可以看到，这个边框线是通过伪元素实现的，我们只需要多加一个处理即可将这个边框线去除.
  • 免费AI大模型API汇总（非常详细），零基础入门到精通，看这一篇就够了 大模型扬叔 人工智能免费AI大模型API汇总大模型
    前言一、免费大模型API一览大模型免费版本免费限制控制台（api_key等）讯飞星火大模型spark-litetokens：总量无限；QPS：2；(每秒发送的请求数)有效期：不限访问链接百度千帆大模型平台ERNIE-Speed-8KRPM=300，TPM=300000（RPM是每分钟请求数（RequestsPerMinute），TPM是指每分钟处理的tokens数量）访问链接ERNIE-Speed
  • vite webpack原理和区别
    Vite和Webpack的工作原理有显著的不同，以下是对它们各自原理的简要说明：Vite原理原生ES模块：Vite利用浏览器对原生ES模块（ESM）的支持，实现按需加载和编译。开发服务器启动时，Vite只需解析入口文件，并将导入的模块路径记录下来。按需编译：当浏览器请求某个模块时，Vite会实时编译该模块及其依赖。使用esbuild或Vite自带的编译器快速处理JavaScript和CSS。热模块
  • pytorch-分类-检测-分割的dataset和dataloader创建 呆呆珝 基础pytorch分类人工智能
    1.前言在PyTorch中，Dataset和DataLoader是两个重要的工具，用于构建输入数据的管道。（1）Dataset是一个抽象类，表示数据集，需要实现__len__和__getitem__方法。（2）DataLoader是一个可迭代的数据加载器，它封装了数据集的加载、批处理、打乱和并行加载等功能。2.分类任务创建Dataset和DataLoader（1）对于分类任务，Dataset需要返
  • NCNN推理 呆呆珝 推理框架c++人工智能
    1.前言ncnn是一个高性能的神经网络前向计算框架，专门针对移动设备和嵌入式设备设计。它由腾讯优图实验室开发，旨在提供高效的神经网络推理能力，特别是在资源受限的环境中，如智能手机和嵌入式系统。ncnn被广泛应用于移动端和嵌入式设备上的各种深度学习应用，包括但不限于：图像分类/目标检测/语义分割/人脸识别/图像生成与处理2.NCNN的CMakeLists.txt编写ncnn的头文件，链接文件，静态链
  • wps2019数据分析加载项_怎样用Excel做数据分析（电商案例） weixin_39907939 wps2019数据分析加载项
    一、数据分析步骤明确问题：知道你要研究什么问题，从而有目地的查找数据理解数据：寻找与问题相关的数据；从数据中你能得出的信息；理解字段信息数据清洗（数据预处理）：选择子集；列名重命名；删除重复值；缺失值处理；一致化处理；数据排序；异常值处理数据分析或构建模型：数据透视表；在Excel安装数据分析功能（安装步骤：文件～选项～加载项～Excel加载项转到～分析工具库，注意！这是MicrosoftExce
  • double保留两位小数 IT-Lenjor Java基础java
    文章目录返回类型为double(四舍五入)返回类型是String【需要去除末尾多余0的，请看第4点】我们都知道double和float都是浮点型，在转型或者比较的时候可能出现问题，这里讲一下怎么针对double类型做精度处理返回类型为double(四舍五入)使用Math.round转成long再转回doubledoubledou=3.1487426;dou=(double)Math.round(d
  • Java中double保留2位小数(精度丢失)的两种方式 元正~Richarlie java开发语言
    在我们日常开发中，使用double数据类型进行计算，偶尔会出现精度丢失的情况，例如实际结果是0.75，就可能出现0.7500000000000001或0.7499999999999999。这边介绍两种方式（四舍五入）保留2位小数，可以满足开发中处理double精度丢失的大部分需求。方式一：使用round函数（同理：保留4位的话就是10000）Doubled=3.141592653589;doubl
  • 如何高效调用API：使用Python构建可靠的网络请求 qq_37836323 python开发语言
    #引言在当今的开发环境中，API的使用变得无处不在。无论是获取数据还是操作远程服务，API都是一个必不可少的工具。然而，由于网络限制和访问不稳定等问题，在某些地区开发者可能需要考虑使用API代理服务来提高API的访问成功率。本文将带您了解如何使用Python高效调用API，并提供实用的代码示例。#主要内容##API调用的基础API（应用程序编程接口）允许不同的软件程序通过API端点进行通信。对于P
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他