post方式发送数据

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><BR>
// <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 );
 }

    }