http client via java implement.[小糊涂的灵感]

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

// Make an HTTP 1.0 post
public class HTTPForm extends Properties {
    public boolean send(String page, OutputStream outstr) throws IOException {
 StringBuffer data=new StringBuffer();
 String headers;
 Enumeration i=keys();
 while (i.hasMoreElements()) {
     String key=(String)i.nextElement();
     data.append(URLEncoder.encode(key)
   + "=" +
   URLEncoder.encode((String)get(key))+
   "&");
 }
 data.deleteCharAt(data.length()-1);  // remove last &
 headers="POST " + page + " HTTP/1.0\r\n"+
     "Content-Type: application/x-www-form-urlencoded\r\n" +
     "Content-Length: " + data.length() + "\r\n\r\n";
        outstr.write(headers.getBytes());
 outstr.write(data.toString().getBytes());
 return true;
    }

    // Test main -- duplicates MailFind
    public static void main(String args[]) throws Exception {
        HTTPForm test=new HTTPForm();
 Socket sock=new Socket("new.usps.com",80);
 OutputStream output=sock.getOutputStream();
 InputStream input=sock.getInputStream();
 test.put("tracknbr",args[0]);
 test.send("/cgi-bin/cttgate/ontrack.cgi",output);
// For this example, just dump results
 int c;
 do {
     c=input.read();
     if (c!=-1) System.out.print((char)c);
 } while (c!=-1);
 sock.close();
    }
}

        Socket sock=new Socket("www.google.com",80);
        OutputStream str = sock.getOutputStream();
        InputStream istr=sock.getInputStream();
        String request;
        String data;
       data="";
        // Set up request
        request="GET /intl/zh-CN/ HTTP/1.0\r\n";
        request+="Content-Type: application/x-www-form-urlencoded\r\n";
        request+="Content-Length: " + (data.length())+"\r\n\r\n";
        request+=data;
        // Write it out
        str.write(request.getBytes());
        // For this example, just dump results
        int c;
        do {
            c=istr.read();
            if (c!=-1) System.out.print((char)c);
        } while (c!=-1);
        sock.close();
    }

//

Listing 34.1 Source Code for ReadThread.java

import java.net.*; import java.lang.*; import java.io.*;
   /** * A thread dedicated to reading data from a socket connection. */

public class ReadThread extends Thread { protected Socket
   connectionSocket; // the socket you are reading from protected DataInputStream inStream;
   // the input stream from the socket protected ReadCallback readCallback; /** * Creates
   an instance of a ReadThread on a Socket and identifies the callback * that will receive
   all data from the socket. * * @param callback the object to be notified when data
   is ready * @param connSock the socket this ReadThread will read data from * @exception
   IOException if there is an error getting an input stream * for the socket */ public
   ReadThread(ReadCallback callback, Socket connSock) throws IOException { connectionSocket
   = connSock; readCallback = callback; inStream = new DataInputStream(connSock.getInputStream());
   } /** * Closes down the socket connection using the socket's close method */ protected
   void closeConnection() { try { connectionSocket.close(); } catch (Exception oops)
   { } stop(); } /** * Continuously reads a string from the socket and then calls dataReady
   in the * read callback. If you want to read something other than a string, change
   * this method and the dataReady callback to handle the appropriate data. */ public
   void run() { while (true) { try { // readUTF reads in a string String str = inStream.readUTF();
   // Notify the callback that you have a string readCallback.dataReady(str); } catch
   (Exception oops) { // Tell the callback there was an error readCallback.dataReady(null);
   } } } } 

Listing 34.2 shows the ReadCallback interface, which must be implemented by a class to receive data from a ReadThread object.

Listing 34.2 Source Code for ReadCallback.java

/** * Implements a callback interface for the ReadConn
   class */ public interface ReadCallback { /** * Called when there is data ready on
   a ReadConn connection. * @param str the string read by the read thread, If null, the
   * connection closed or there was an error reading data */ public void dataReady(String
   str); } 

A Simple Socket Client

Using these two classes, you can implement a simple client that connects to a server and uses a read thread to read the data returned by the server. The corresponding server for this client is presented in the next section, "The ServerSocket Class." Listing 34.3 shows the SimpleClient class.

Listing 34.3 Source Code for SimpleClient.java

 import java.io.*; import java.net.*; /** * This class
   sets up a Socket connection to a server, spawns * a ReadThread object to read data
   coming back from the server, * and starts a thread that sends a string to the server
   every * 2 seconds. */ public class SimpleClient extends Object implements Runnable,
   ReadCallback { protected Socket serverSock; protected DataOutputStream outStream;
   protected Thread clientThread; protected ReadThread reader; public SimpleClient(String
   hostName, int portNumber) throws IOException { Socket serverSock = new Socket(hostName,
   portNumber); // The DataOutputStream has methods for sending different data types
   // in a machine-independent format. It is very useful for sending data // over a socket
   connection. outStream = new DataOutputStream(serverSock.getOutputStream()); // Create
   a reader thread reader = new ReadThread(this, serverSock); // Start the reader thread
   reader.start(); } // These are generic start and stop methods for a Runnable public
   void start() { clientThread = new Thread(this); clientThread.start(); } public void
   stop() { clientThread.stop(); clientThread = null; } // sendString sends a string
   to the server using writeUTF public synchronized void sendString(String str) throws
   IOException { System.out.println("Sending string: "+str); outStream.writeUTF(str);
   } // The run method for this object just sends a string to the server // and sleeps
   for 2 seconds before sending another string public void run() { while (true) { try
   { sendString("Hello There!"); Thread.sleep(2000); } catch (Exception oops) { // If
   there was an error, print info and disconnect oops.printStackTrace(); disconnect();
   stop(); } } } // The disconnect method closes down the connection to the server public
   void disconnect() { try { reader.closeConnection(); } catch (Exception badClose) {
   // should be able to ignore } } // dataReady is the callback from the read thread.
   It is called // whenever a string is received from the server. public synchronized
   void dataReady(String str) { System.out.println("Got incoming string: "+str); } public
   static void main(String[] args) { try { /* Change localhost to the host you are running
   the server on. If it is on the same machine, you can leave it as localhost. */ SimpleClient
   client = new SimpleClient("localhost", 4331); client.start(); } catch (Exception cantStart)
   { System.out.println("Got error"); cantStart.printStackTrace(); } } }