理解TCP/IP协议与Socket编程：实例解析-优快云博客

一、IP地址：

计算机在网络中一定要有一个IP地址，IP地址是计算机自网络中的唯一标识。IP地址v4是由四段组成的，每一段的范围是0~225

二、端口号（port）：

代表了计算机中的一个服务，服务和服务的端口号不能重复，一个端口号被占用后，另一个服务就不能使用这个端口号了，除非占用这个端口的服务关闭了

三、TCP和UDP协议

TCP协议：是面向连接的协议，在传输数据前先要保证两台计算机已经建立好了连接。是可靠的协议，在建立连接时采用三次握手，在断开连接时采用四次挥手，能保证数据能安全可靠的传输。在网络环境不好的情况，一般使用 TCP协议。

UDP协议：是面向数据报的协议，不可靠的协议，在网络环境好的情况，使用UDP协议，效率高。

四、TCP编程

使用Socket进行TCP编程，Socket叫套接字，是由IP+端口号组成的；Socket编程分为客户端和服务器端。客户端连接服务器端，建立连接后，客户端和服务器端可以进行数据传输。

TCP编程步骤：

1. 服务器端创建一个Socket服务，使用ServerSocket类实现

2.客户端向服务器发送一个连接请求，使用Socket类实现

3.传输数据

4.关闭连接

第一步：服务器端

public static void main(String[] args) {
    try {
        ServerSocket serverSocket = new ServerSocket(7001);
        //准备接收客户端发来的连接请求，也就是启动了服务器端的Socket服务，程序进入到阻塞状态
        serverSocket.accept();
        System.out.println("客户端连接了服务器");
    } catch (IOException e) {

        e.printStackTrace();
    }
}

第二步：客户端

public static void main(String[] args) {
    //连接那台机器？本机
    try {
        //写本机的IP地址
        //Socket socket = new Socket("192.168.1.3",7001);
        //localhost字符串 代表本机的域名,会通过网络层解析为本机的IP
        //Socket socket = new Socket("localhost",7001);
        //无论IP是什么，127.0.0.1就代表了本机的IP，不需要解析
        //Socket socket = new Socket("127.0.0.1",7001);
        //InetAddress对象就是一个封装了IP地址的对象
        Socket socket = new Socket(InetAddress.getByName("192.168.1.3"),7001);
    } catch (UnknownHostException e) {

        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

第三步：传数据，Socket中封装了OutputStream和InputStream，如果要发送数据，就向OutputStream中写；如果要收数据，就从InputStream中读。

public static void main(String[] args) {
    Socket socket = null;
    //连接那台机器？本机
    try {
        //写本机的IP地址
        //Socket socket = new Socket("192.168.1.3",7001);
        //localhost字符串 代表本机的域名,会通过网络层解析为本机的IP
        //Socket socket = new Socket("localhost",7001);
        //无论IP是什么，127.0.0.1就代表了本机的IP，不需要解析
        //Socket socket = new Socket("127.0.0.1",7001);
        //InetAddress对象就是一个封装了IP地址的对象
        socket = new Socket(InetAddress.getByName("192.168.1.3"),7001);
        //客户端向服务器传数据
        OutputStream os = socket.getOutputStream();
        PrintWriter pw = new PrintWriter(os,true);
        pw.println("你好，我是客户端！");
        BufferedReader br = new BufferedReader(new
        InputStreamReader(socket.getInputStream()));
        System.out.println("客户端收到的信息："+br.readLine());
    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
    try {
        ServerSocket serverSocket = new ServerSocket(7001);
        //准备接收客户端发来的连接请求，也就是启动了服务器端的Socket服务，程序进入到阻塞状态
        Socket socket = serverSocket.accept();
        System.out.println("客户端连接了服务器");
        InputStream is = socket.getInputStream();
        InputStreamReader reader = new InputStreamReader(is);
        BufferedReader br = new BufferedReader(reader);
        System.out.println("服务器端接收的数据："+br.readLine());
        //服务器向客户端发送数据
        PrintWriter pw = new PrintWriter(socket.getOutputStream(),true);
        pw.println("我是服务器，我收到你的消息了！");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

五、示例：用TCP协议实现一个点对点的聊天程序

编写两个类，两个main方法，各自都是服务器端和客户端

public class ChatA {
    public ChatA() {
        try {
            ServerSocket server = new ServerSocket(7001);
            new Thread(new ARunnable()).start();
            Socket socket = null;
            while(true) {
                socket = server.accept();
                BufferedReader br = new BufferedReader(new
                        InputStreamReader(socket.getInputStream()));
                System.out.println(br.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    class ARunnable implements Runnable{
        @Override
        public void run() {
            Scanner scanner = new Scanner(System.in);
            while(true) {
                String msg = scanner.next();
                Socket socket = null;
                msg = "杨过："+msg;
                //连接B
                try {
                    socket = new Socket("localhost",7002);
                    new PrintWriter(socket.getOutputStream(),true).println(msg);
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        new ChatA();
    }
}

public class ChatB {
    public ChatB() {
        try {
            ServerSocket server = new ServerSocket(7002);
            new Thread(new ARunnable()).start();
            Socket socket = null;
            while(true) {
                socket = server.accept();
                BufferedReader br = new BufferedReader(new
                        InputStreamReader(socket.getInputStream()));
                System.out.println(br.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    class ARunnable implements Runnable{
        @Override
        public void run() {
            Scanner scanner = new Scanner(System.in);
            while(true) {
                String msg = scanner.next();
                Socket socket = null;
                msg = "小龙女："+msg;
                //连接B
                try {
                    socket = new Socket("localhost",7001);
                    new PrintWriter(socket.getOutputStream(),true).println(msg);
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args) {
        new ChatB();
    }
}

六、UDP协议编程

public class UDPA {
    public static void main(String[] args) {
        try {
            DatagramSocket datagramSocket = new DatagramSocket(7002);
            byte[] bytes = "你好，我是A。".getBytes();
            DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length,
                    InetAddress.getLocalHost(), 7001);
            datagramSocket.send(datagramPacket);
            bytes = new byte[1024];
            DatagramPacket p = new DatagramPacket(bytes, bytes.length);
            datagramSocket.receive(p);
            System.out.println("A收到的消息："+new String(p.getData()));
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class UDPB {
    public static void main(String[] args) {
        try {
            DatagramSocket datagramSocket = new DatagramSocket(7001);
            byte[] bytes = new byte[1024];
            DatagramPacket p = new DatagramPacket(bytes, bytes.length);
            datagramSocket.receive(p);
            System.out.println("B收到的消息："+new String(p.getData()));
            bytes = "我收到你的消息了".getBytes();
            p = new DatagramPacket(bytes,bytes.length,InetAddress.getLocalHost(),7002);
            datagramSocket.send(p);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

七、URL（统一资源定位符）

统一资源定位符，表示一个地址，在网络上通过这个地址访问对应的唯一资源，即网址。

URL组成：传输协议://IP:端口号/目录/文件?参数名=值&参数名=值

通过URLConnection对象，通过编程实现向服务器发送连接请求及数据

public class TestURLConnection {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.baidu.com");
            URLConnection conn = url.openConnection();
            conn.connect();
            InputStream is = conn.getInputStream();
            byte[] bytes = new byte[1024];
            int temp = 0;
            while ((temp = is.read(bytes)) != -1) {
                System.out.print(new String(bytes, 0, temp));
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}