数据package Acme;

import java.net.*;
import java.io.*;
import java.util.*;
import java.text.*;

/// A URLConnection that implements POST.
// <P>
// Some implementations of URLConnection, e.g. the one in Navigator 3.0,
// do not support POST.  This is a stripped-down version that does.
// <P>
// Note that it can't inherit from java.net.URLConnection because that
// class has no public constructors.  Not all the standard URLConnection
// methods are re-implemented here, just the ones necessary for posting.
// <P>
// This class is not needed in current browsers.
// <P>
// <A HREF="/resources/classes/Acme/PostURLConnection.java">Fetch the software.</A>

// <A HREF="/resources/classes/Acme.tar.gz">Fetch the entire Acme package.</A>

public class PostURLConnection
    {

    private URL url;
    private boolean doInput = false;
    private boolean doOutput = true;
    private boolean useCaches = false;

    private Vector reqHeaderNames = new Vector();
    private Vector reqHeaderValues = new Vector();
    private Vector resHeaderNames = null;
    private Vector resHeaderValues = null;
    private Socket socket;
    private OutputStream out;
    private InputStream in;


    /// Constructs a POST URL connection to the specified URL.
    // param url the specified URL
    public PostURLConnection( URL url )
    {
    this.url = url;
    }


    private boolean connected = false;

    public void connect() throws IOException
    {
    if ( connected )
        return;
    if ( ! useCaches )
        setRequestProperty( "Pragma", "no-cache" );
    String protocol = url.getProtocol();
    if ( ! protocol.equals( "http" ) )
        throw new UnknownServiceException( "unknown protocol" );
    String host = url.getHost();
    int port = url.getPort();
    if ( port == -1 )
        port = 80;
    String file = url.getFile();
    socket = new Socket( host, port );
    out = socket.getOutputStream();
    PrintStream pout = new PrintStream( out );
    String method;
    if ( doOutput )
        method = "POST";
    else
        method = "GET";
    pout.println( method + " " + file + " HTTP/1.0" );
    for ( int i = 0; i < reqHeaderNames.size(); ++i )
        {
        String name = (String) reqHeaderNames.elementAt( i );
        String value = (String) reqHeaderValues.elementAt( i );
        pout.println( name + ": " + value );
        }
    pout.println( "" );
    pout.flush();
    connected = true;
    }
    

    private boolean inputStarted = false;

    private void startInput() throws IOException
    {
    connect();
    if ( inputStarted )
        return;
    in = socket.getInputStream();
    resHeaderNames = new Vector();
    resHeaderValues = new Vector();
    DataInputStream din = new DataInputStream( in );
    String line;
    // Read and ignore the status line.
    line = din.readLine();
    // Read and save the header lines.
    while ( true )
        {
        line = din.readLine();
        if ( line == null || line.length() == 0 )
        break;
        int colonBlank = line.indexOf( ": " );
        if ( colonBlank != -1 )
        {
        String name = line.substring( 0, colonBlank );
        String value = line.substring( colonBlank + 2 );
        resHeaderNames.addElement( name.toLowerCase() );
        resHeaderValues.addElement( value );
        }
        }
    inputStarted = true;
    }
    

    public void close() throws IOException
    {
    if ( ! connected )
        return;
    out.close();
    if ( inputStarted )
        in.close();
    socket.close();
    }


    /// Gets the URL for this connection.
    public URL getURL()
    {
    return url;
    }

    // Gets the content length.  Returns -1 if not known.
    public int getContentLength() throws IOException
        {
        return getHeaderFieldInt( "content-length", -1 );
    }

    /// Gets the content type.  Returns null if not known.
    public String getContentType() throws IOException
    {
    return getHeaderField( "content-type" );
    }

    /// Gets a header field by name.  Returns null if not known.
    // param name the name of the header field
    public String getHeaderField( String name ) throws IOException
    {
    if ( resHeaderNames == null )
        startInput();
    int i = resHeaderNames.indexOf( name.toLowerCase() );
    if ( i == -1 )
        return null;
    return (String) resHeaderValues.elementAt( i );
    }

    /// Gets a header field by name.  Returns null if not known.
    // The field is parsed as an integer.
    // param name the name of the header field
    // param def the value to return if the field is missing or malformed.
    public int getHeaderFieldInt( String name, int def ) throws IOException
    {
    try
        {
        return Integer.parseInt( getHeaderField( name ) );
        }
    catch ( NumberFormatException t )
        {
        return def;
        }
    }


    /// Gets a header field by name.  Returns null if not known.
    // The field is parsed as a date.
    // param name the name of the header field
    // param def the value to return if the field is missing or malformed.
    public long getHeaderFieldDate( String name, long def ) throws IOException
    {
    try
        {
        return DateFormat.getDateInstance().parse( getHeaderField( name ) ).getTime();
        }
    catch ( ParseException e )
        {
        throw new IOException( e.toString() );
        }
    }

    /// Call this routine to get an InputStream that reads from the object.
    // exception UnknownServiceException If the protocol does not support input.
    public InputStream getInputStream() throws IOException
    {
    if ( ! doInput )
        throw new UnknownServiceException(
        "connection doesn't support input" );
    startInput();
    return in;
    }

    /// Call this routine to get an OutputStream that writes to the object.
    // exception UnknownServiceException If the protocol does not support output.
    public OutputStream getOutputStream() throws IOException
    {
    if ( ! doOutput )
        throw new UnknownServiceException(
        "connection doesn't support output" );
    connect();
    return out;
    }


    /// Returns the String representation of the URL connection.
    public String toString()
    {
    return this.getClass().getName() + ":" + url;
    }


    /// A URL connection can be used for input and/or output.  Set the DoInput
    // flag to true if you intend to use the URL connection for input,
    // false if not.  The default for PostURLConnections is false.
    public void setDoInput( boolean doInput )
    {
    if ( connected )
        throw new IllegalAccessError( "already connected" );
    this.doInput = doInput;
    }

    public boolean getDoInput()
    {
    return doInput;
    }


    /// A URL connection can be used for input and/or output.  Set the DoOutput
    // flag to true if you intend to use the URL connection for output,
    // false if not.  The default for PostURLConnections is true.
    public void setDoOutput( boolean doOutput )
    {
    if ( connected )
        throw new IllegalAccessError( "already connected" );
    this.doOutput = doOutput;
    }

    public boolean getDoOutput()
    {
    return doOutput;
    }


    /// Some protocols do caching of documents.  Occasionally, it is important
    // to be able to "tunnel through" and ignore the caches (e.g. the "reload"
    // button in a browser).  If the UseCaches flag on a connection is true,
    // the connection is allowed to use whatever caches it can.  If false,
    // caches are to be ignored.  The default for PostURLConnections is false.
    public void setUseCaches( boolean useCaches )
    {
    if ( connected )
        throw new IllegalAccessError( "already connected" );
    this.useCaches = useCaches;
    }

    public boolean getUseCaches()
    {
    return useCaches;
    }


    // Sets/gets a general request property.
    // param name The keyword by which the request is known (eg "accept")
    // param value The value associated with it.
    public void setRequestProperty( String name, String value )
    {
    if ( connected )
        throw new IllegalAccessError("already connected");
    reqHeaderNames.addElement( name );
    reqHeaderValues.addElement( value );
    }

    public String getRequestProperty( String name )
    {
    if ( connected )
        throw new IllegalAccessError( "already connected" );
    int i = reqHeaderNames.indexOf( name );
    if ( i == -1 )
        return null;
    return (String) reqHeaderValues.elementAt( i );
    }

    }