TCP和UDP的一些简单应用

public class  Clients
{
 public static void main(String[] args)  throws Exception
 {
  InetAddress addr = InetAddress.getByName(null);
  Socket socket = new Socket(addr,2000);
  PrintWriter out =
        new PrintWriter(
          new BufferedWriter(
            new OutputStreamWriter(
              socket.getOutputStream())),true);
  byte[] b = new byte[2048];
  String msg = new String(b,0,System.in.read(b));
  out.println(msg);
  socket.close();
 }
}

//Servers.java

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

public class  Servers
{
 public static void main(String[] args) throws Exception
 {
  ServerSocket s = new ServerSocket(2000);
 try{
  while(true){
  Socket socket = s.accept();
  try{
  BufferedReader in =
          new BufferedReader(
            new InputStreamReader(
              socket.getInputStream()));
  StringBuffer sb = new StringBuffer();
  int c;
  while( (c = in.read()) != -1 ){
   char ch = (char)c;
   sb.append(ch);
  }
  System.out.println(sb.toString());

  }catch(IOException e){
   socket.close();
  }finally{
   socket.close();
  }
  }//while
 }finally{
  s.close();
 }//try
 }//main
}

此程式主要用Servers来进行无限监听，而Clients是客户机发送程式，他们的端口全采用2000。

eg2:

//UDPsend.java
import java.io.*;
import java.net.*;

/**
 * This class sends the specified text or file as a datagram to the
 * specified port of the specified host.
 **/
public class UDPSend {
    public static final String usage =
 "Usage: java UDPSend   ...\n" +
 "   or: java UDPSend   -f ";

    public static void main(String args[]) {
        try {
            // Check the number of arguments
            if (args.length < 3)
                throw new IllegalArgumentException("Wrong number of args");
           
            // Parse the arguments
            String host = args[0];
            int port = Integer.parseInt(args[1]);
    
            // Figure out the message to send. 
            // If the third argument is -f, then send the contents of the file
            // specified as the fourth argument.  Otherwise, concatenate the
            // third and all remaining arguments and send that.
            byte[] message;
            if (args[2].equals("-f")) {
                File f = new File(args[3]);
                int len = (int)f.length();    // figure out how big the file is
                message = new byte[len];      // create a buffer big enough
                FileInputStream in = new FileInputStream(f);
                int bytes_read = 0, n;
                do {                          // loop until we've read it all
                    n = in.read(message, bytes_read, len-bytes_read);
                    bytes_read += n;
                } while((bytes_read < len)&& (n != -1));
            }
            else { // Otherwise, just combine all the remaining arguments.
                String msg = args[2]; 
                for (int i = 3; i < args.length; i++) msg += " " + args[i];
                message = msg.getBytes();
            }
           
            // Get the internet address of the specified host
            InetAddress address = InetAddress.getByName(host);
    
            // Initialize a datagram packet with data and address
            DatagramPacket packet = new DatagramPacket(message, message.length,
             address, port);
    
            // Create a datagram socket, send the packet through it, close it.
            DatagramSocket dsocket = new DatagramSocket();
            dsocket.send(packet);
            dsocket.close();
        }
        catch (Exception e) {
            System.err.println(e);
     System.err.println(usage);
        }
    }
}

//UDPreceive.java
import java.io.*;
import java.net.*;

/**
 * This program waits to receive datagrams sent the specified port.
 * When it receives one, it displays the sending host and prints the
 * contents of the datagram as a string.  Then it loops and waits again.
 **/
public class UDPReceive {
    public static final String usage = "Usage: java UDPReceive ";
    public static void main(String args[]) {
        try {
            if (args.length != 1)
                throw new IllegalArgumentException("Wrong number of args");
    
            // Get the port from the command line
            int port = Integer.parseInt(args[0]);
    
            // Create a socket to listen on the port.
            DatagramSocket dsocket = new DatagramSocket(port);
    
            // Create a buffer to read datagrams into.  If anyone sends us a
            // packet containing more than will fit into this buffer, the
            // excess will simply be discarded!
            byte[] buffer = new byte[2048];
    
     // Create a packet to receive data into the buffer
     DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

            // Now loop forever, waiting to receive packets and printing them.
            for(;;) {
                // Wait to receive a datagram
                dsocket.receive(packet);

                // Convert the contents to a string, and display them
                String msg = new String(buffer, 0, packet.getLength());
                System.out.println(packet.getAddress().getHostName() +
       ": " + msg);

  // Reset the length of the packet before reusing it.
  // Prior to Java 1.1, we'd just create a new packet each time.
  packet.setLength(buffer.length);
            }
        }
        catch (Exception e) {
            System.err.println(e);
            System.err.println(usage);
        }
    }
}

在UDP中主要的类是DatagramSocket()和DatagramPacket()，而在UDPreceive中，被接受的字节是受限制，这些感觉不是太好，既然buf是一个字节数组，我们实在是很奇怪为什么构建器自己不能调查出数组的长度呢？唯一能猜测的原因就是C风格的编程使然，那里的数组不能自己告诉我们它有多大。