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(); } } }