pseudoserver.java

这是远程web服务调用的一个包,可以将JSP直接作为服务

        outputStream.close();
        socket.close();
    }


    private boolean respondToRequest( HttpRequest request, HttpResponseStream response ) {
        if (_debug) System.out.println( "** Server thread " + hashCode() + " handling request: " + request );
        boolean keepAlive = isKeepAlive( request );
        WebResource resource = null;
        try {
            response.restart();
            response.setProtocol( getResponseProtocol( request ) );
            resource = getResource( request );
            if (resource == null) {
                response.setResponse( HttpURLConnection.HTTP_NOT_FOUND, "unable to find " + request.getURI() );
            } else {
                if (resource.closesConnection()) keepAlive = false;
                if (resource.getResponseCode() != HttpURLConnection.HTTP_OK) {
                    response.setResponse( resource.getResponseCode(), "" );
                }
                String[] headers = resource.getHeaders();
                for (int i = 0; i < headers.length; i++) {
                    if (_debug) System.out.println( "** Server thread " + hashCode() + " sending header: " + headers[i] );
                    response.addHeader( headers[i] );
                }
            }
        } catch (UnknownMethodException e) {
            response.setResponse( HttpURLConnection.HTTP_BAD_METHOD, "unsupported method: " + e.getMethod() );
        } catch (Throwable t) {
            t.printStackTrace();
            response.setResponse( HttpURLConnection.HTTP_INTERNAL_ERROR, t.toString() );
        }
        try { response.write( resource ); } catch (IOException e) { System.out.println( "*** Failed to send reply: " + e ); }
        return keepAlive;
    }


    private boolean isKeepAlive( HttpRequest request ) {
        return request.wantsKeepAlive() && _maxProtocolLevel.equals( "1.1" );
    }


    private String getResponseProtocol( HttpRequest request ) {
        return _maxProtocolLevel.equalsIgnoreCase( "1.1" ) ? request.getProtocol() : "HTTP/1.0";
    }


    private WebResource getResource( HttpRequest request ) throws IOException {
        Object resource = _resources.get( request.getURI() );
        if (resource == null) resource = _resources.get( withoutParameters( request.getURI() ) );

        if (request.getCommand().equals( "GET" ) && resource instanceof WebResource) {
            return (WebResource) resource;
        } else if (resource instanceof PseudoServlet) {
            return getResource( (PseudoServlet) resource, request );
        } else if (request.getURI().endsWith( ".class" )) {
            for (Iterator iterator = _classpathDirs.iterator(); iterator.hasNext();) {
                String directory = (String) iterator.next();
                if (request.getURI().startsWith( directory )) {
                    String resourceName = request.getURI().substring( directory.length()+1 );
                    return new WebResource( getClass().getClassLoader().getResourceAsStream( resourceName ), "application/class", 200 );
                }
            }
            return null;
        } else if (request.getURI().endsWith( ".zip" ) || request.getURI().endsWith( ".jar" )) {
            for (Iterator iterator = _classpathDirs.iterator(); iterator.hasNext();) {
                String directory = (String) iterator.next();
                if (request.getURI().startsWith( directory )) {
                    String resourceName = request.getURI().substring( directory.length()+1 );
                    String classPath = System.getProperty( "java.class.path" );
                    StringTokenizer st = new StringTokenizer( classPath, ":;," );
                    while (st.hasMoreTokens()) {
                        String file = st.nextToken();
                        if (file.endsWith( resourceName )) {
                            File f = new File( file );
                            return new WebResource( new FileInputStream( f ), "application/zip", 200 );
                        }
                    }
                }
            }
            return null;
        } else {
            return null;
        }
    }


    private String withoutParameters( String uri ) {
        return uri.indexOf( '?' ) < 0 ? uri : uri.substring( 0, uri.indexOf( '?' ) );
    }


    private WebResource getResource( PseudoServlet servlet, HttpRequest request ) throws IOException {
        servlet.init( request );
        return servlet.getResponse( request.getCommand() );
    }


    private ServerSocket getServerSocket() throws IOException {
        synchronized (this) {
            if (_serverSocket == null) _serverSocket = ServerSocketFactory.newServerSocket();
        }
        return _serverSocket;
    }


    private ServerSocket _serverSocket;

}




class HttpResponseStream {

    final private static String CRLF = "\r\n";

    void restart() {
        _headersWritten = false;
        _headers.clear();
        _responseCode = HttpURLConnection.HTTP_OK;
        _responseText = "OK";
    }


    void close() throws IOException {
        flushHeaders();
        _pw.close();
    }


    HttpResponseStream( OutputStream stream ) {
        _stream = stream;
        try {
            setCharacterSet( "us-ascii" );
        } catch (UnsupportedEncodingException e) {
            _pw = new PrintWriter( new OutputStreamWriter( _stream ) );
        }
    }


    void setProtocol( String protocol ) {
        _protocol = protocol;
    }


    void setResponse( int responseCode, String responseText ) {
        _responseCode = responseCode;
        _responseText = responseText;
    }


    void addHeader( String header ) {
        _headers.addElement( header );
    }


    void write( String contents, String charset ) throws IOException {
        flushHeaders();
        setCharacterSet( charset );
        sendText( contents );
    }


    void write( WebResource resource ) throws IOException {
        flushHeaders();
        if (resource != null) resource.writeTo( _stream );
        _stream.flush();
    }


    private void setCharacterSet( String characterSet ) throws UnsupportedEncodingException {
        if (_pw != null) _pw.flush();
        _pw = new PrintWriter( new OutputStreamWriter( _stream, characterSet ) );
    }


    private void flushHeaders() {
        if (!_headersWritten) {
            sendResponse( _responseCode, _responseText );
            for (Enumeration e = _headers.elements(); e.hasMoreElements();) {
                sendLine( (String) e.nextElement() );
            }
            sendText( CRLF );
            _headersWritten = true;
            _pw.flush();
        }
    }


    private void sendResponse( int responseCode, String responseText ) {
        sendLine( _protocol + ' ' + responseCode + ' ' + responseText );
    }


    private void sendLine( String text ) {
        sendText( text );
        sendText( CRLF );
    }


    private void sendText( String text ) {
        _pw.write( text );
    }


    private OutputStream _stream;
    private PrintWriter _pw;

    private Vector    _headers = new Vector();
    private String    _protocol = "HTTP/1.0";
    private int       _responseCode = HttpURLConnection.HTTP_OK;
    private String    _responseText = "OK";

    private boolean   _headersWritten;

}



class ServerSocketFactory {

    static private ArrayList _sockets = new ArrayList();

    static private int _outstandingSockets;

    static private Object _releaseSemaphore = new Object();

    static synchronized ServerSocket newServerSocket() throws IOException {
        if (_sockets.isEmpty() && _outstandingSockets > PseudoServer.getWaitThreshhold()) {
            try { synchronized( _releaseSemaphore) {_releaseSemaphore.wait( PseudoServer.getSocketReleaseWaitTime() ); } } catch (InterruptedException e) {};
        }
        _outstandingSockets++;
        if (!_sockets.isEmpty()) {
            return (ServerSocket) _sockets.remove(0);
        } else {
            ServerSocket serverSocket = new ServerSocket(0);
            serverSocket.setSoTimeout( 1000 );
            return serverSocket;
        }
    }

    static synchronized void release( ServerSocket serverSocket ) throws IOException {
        if (_sockets.size() >= 2 * PseudoServer.getWaitThreshhold()) {
            serverSocket.close();
        } else {
            _sockets.add( serverSocket );
            _outstandingSockets--;
            synchronized (_releaseSemaphore) { _releaseSemaphore.notify(); }
        }
    }
}


class RecordingOutputStream extends OutputStream {

    private OutputStream _nestedStream;
    private PrintStream _log;


    public RecordingOutputStream( OutputStream nestedStream, PrintStream log ) {
        _nestedStream = nestedStream;
        _log = log;
    }


    public void write( int b ) throws IOException {
        _nestedStream.write( b );
        _log.println( "sending " + Integer.toHexString( b ) );
    }


    public void write( byte b[], int offset, int len ) throws IOException {
        _nestedStream.write( b, offset, len );
        _log.print( "sending" );
        for (int i = offset; i < offset+len; i++) {
            _log.print( ' ' + Integer.toHexString( b[i] ) );
        }
        _log.println();
    }
}


class RecordingInputStream extends InputStream {

    private InputStream _nestedStream;
    private PrintStream _log;


    public RecordingInputStream( InputStream nestedStream, PrintStream log ) {
        _nestedStream = nestedStream;
        _log = log;
    }


    public int read() throws IOException {
        int value = _nestedStream.read();
        if (value != -1) _log.print( ' ' + Integer.toHexString( value ) );
        return value;
    }
}