java中网络编程

TCP/IP协议的四层模型，从底层到高层分别是:网络接口层、网络层、传输层、应用层。IP属于网络层，TCP/UDP属于传输层。IP定位对方的主机名，端口号对应接受数据的应用程序。

本地回环地址：127.0.0.1 主机名：localhost 有效端口：0~65535， 其中0~1024为系统保留端口。

IP地址由InetAddress类表示。没有构造函数，通过静态方法得到实例。

UDP：将数据及源和目的封装成数据包，不需要建立连接；每个数据包的大小限制在64k内；因无连接，是不可靠协议；速度快。

TCP：建立连接，形成传输数据的通道；在连接中进行大量数据传输；通过三次握手完成连接，是可靠协议；必须建立连接，效率稍低。

Socket：网络之间的通信其实就是Socket之间的通信，Socket之间通过IO进行传输。

DatagramSocket：UDP使用的Socket接口，是本地的接口；发送、接受的单位为DatagramPacket。注意：这里DatagramPacket里面有get/setPort的操作，其中set为设置此包的目的端口号，而get有两种情况，一种是未发送的时候得到刚才set的端口号，一种是在接收端得到发送端的Socket的端口号（发送端DatagramePacket的设置的端口号）。所以getPort是Packet的得到Port的方法，而getLocalPort是Socket得到Port的方法。

测试UDP传输简单的数据：

package net;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
//主线程为server端接受，子线程为client发送
public class TestUDP {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UDPClient udpClient = new UDPClient();
        Thread t1 = new Thread(udpClient);
        t1.start();
        UDPServerFunc();
    }
    static void UDPServerFunc(){
        try {
            DatagramSocket dsServer = new DatagramSocket(7777);
            System.out.println("Server DatagramSocket Port"+dsServer.getLocalPort());
            byte[] buf = new byte[1024];
            DatagramPacket dpServer = new DatagramPacket(buf, 0, buf.length);
            dsServer.receive(dpServer);
            System.out.println(dpServer.getAddress().getHostAddress() + " :: "
                    + new String(dpServer.getData(),0,dpServer.getLength()));
            System.out.println("Server DatagramPacket Port"+dpServer.getPort());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class UDPClient implements Runnable{
    @Override
    public void run() {
        try {
            DatagramSocket dsClient = new DatagramSocket(6666);
            System.out.println("Client DatagramSocket Port"+dsClient.getLocalPort());
            byte[] buf = "hello this is UDPTest".getBytes();
            DatagramPacket dpClient =
                    new DatagramPacket(buf, buf.length,InetAddress.getByName("localhost"), 7777);
            Thread.sleep(1000);
            System.out.println("Client : "+"wakeup");
            System.out.println("Client DatagramPacket Port"+dpClient.getPort());
            dsClient.send(dpClient);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}

UDP是没有“方向”的，所以用DatagramePacket既发送数据，又接收数据。但是TCP是有“方向”的连接，因此用两个类Socket 、ServerSocket分别表示客户端和服务器端， TCP先形成Socket的“通路”，然后再通过IO流在这条通路上进行数据的传输。即ServerSocket先接收到客户端的Socket，然后调用此Socket中的IO流实现数据的流传输。

package net;
//主进程中为server 子进程中为client
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class TestTCP {
    public static void main(String[] args){
        try {
            ServerSocket ssever = new ServerSocket(7777);
            System.out.println("ServerSocket Port:" + ssever.getLocalPort());
            Thread tclient = new Thread(new TCPClient());
            tclient.start();
        
            Socket s1 = ssever.accept();
            InputStream serverIn = s1.getInputStream();
            OutputStream serverOut = s1.getOutputStream();
            System.out.println("Server : "+"connected host : "+"addr --"+s1.getInetAddress().getHostAddress()
                                    +";port --"+s1.getPort());
            BufferedReader serverBR = new BufferedReader(new InputStreamReader(serverIn));
            BufferedWriter serverBW = new BufferedWriter(new OutputStreamWriter(serverOut));
            System.out.println("ready");
//            String serverStr ="aaaaaaaa";//测试数据用
            String serverStr = serverBR.readLine();
            while (true) {
                if (serverStr.equalsIgnoreCase("over")) {
                    s1.close();
                    break;
                }
                System.out.println("Server receive string : " +serverStr);
                Thread.sleep(500);
                serverBW.write(serverStr.toUpperCase());
                serverBW.newLine();
                serverBW.flush();
                serverStr = serverBR.readLine();
            }
            
        } catch (Exception e) {
            System.out.println("main problem");
        }
    }
}
class TCPClient implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            Socket sclient = new Socket("localhost", 7777);
            System.out.println("Client Socket Port"+sclient.getLocalPort());
            BufferedReader consleBR = new BufferedReader(new InputStreamReader(System.in));
            BufferedWriter clientBW = new BufferedWriter(new OutputStreamWriter(sclient.getOutputStream()));
            BufferedReader clientBR = new BufferedReader(new InputStreamReader(sclient.getInputStream()));
            
            String consoleStr = consleBR.readLine();
            String receiveStr = null;
            while(true){
                if (consoleStr.equalsIgnoreCase("Over")) {
                    clientBW.write("over");
                    clientBW.newLine();
                    clientBW.flush();
                    break;
                }
                clientBW.write(consoleStr);
                clientBW.newLine();
                clientBW.flush();
//                SOP.sop("console : "+consoleStr);
                receiveStr = clientBR.readLine();
                System.out.println("Client receive string : "+receiveStr);
                consoleStr = consleBR.readLine();
            }
            clientBR.close();
            clientBW.close();
            consleBR.close();
            
        } catch (UnknownHostException e) {
            System.out.println("UnknownHostException ...");
        } catch (InterruptedException e1) {
            System.out.println("InterruptedException ...");
        }catch (BindException e2) {
            System.out.println("BindException ...");
        }catch (IOException e) {
            System.out.println("IOEcxeption ... ");
        }
    }

}