前言

最近要学习一些Java网络编程的内容，本篇文章是对网络编程的准备工作。

一、网络编程概念

1、网络

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件以及网络通信协议的管理和协调之下，实现资源共享和信息传递的计算机系统。

2、网络编程的目的

通信：交流信息，数据交换。

3、想要达到这个效果需要什么

如何准确定位网络上的一台主机 ip:端口，定位到这个计算机上的某个资源。
找到这个主机如何传输数据。

4、网络分层

TCP/IP四层架构：应用层、传输层、网络层、数据链路层。
网络编程主要是在传输层，使用TCP和UDP协议。
网络编程不同于网站编程的B/S架构，它是C/S架构。
网络编程中的要素：1、IP和端口号（IP）。2、网络通信协议（TCP，UDP）。

二、网络编程Java类

1、IP地址：InetAddress

唯一定位一台网络上的计算机。
127.0.0.1：本机localhost
ip地址分类：IPV4（4个字节组成，0-255，42亿个ip地址，30亿在北美，亚洲4亿，2011年用尽）和IPV6（128位，8个无符号整数）
网络类型分类：公网（互联网）-私网（局域网）
ABCD类网络
域名：不用记忆IP，使用域名之后，会进行DNS域名转换为地址。

2、端口

端口对应计算机上的一个程序的进程。可以打个比方：一栋楼是一个IP，每个住户是一个端口。
不同的进程有不同的端口号，端口号的范围是0-65535，单个协议下端口号不能冲突。
端口号0-1023是公有端口，尽量不要使用。
默认端口：HTTP：80， HTTPS：443， FTP：21，远程连接：22。
分配给用户或者程序的端口：1024-29151 例如Tomcat：8080， MySQL：3306，Oracle：1512等
动态和私有端口：49512-65535 这些端口尽量不要使用。

在java中，可以使用InetAddress和InetSocketAddress来获得Ip和端口号，两者的使用情况很相似，使用示例如下：

   // InetAddress
   InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
   System.out.println(inetAddress1);
   InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
   System.out.println(inetAddress2);
   System.out.println(inetAddress2.getHostAddress());
   System.out.println(inetAddress2.getHostName());
   // InetSocketAddress
   InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
   System.out.println(socketAddress.toString());
   System.out.println(socketAddress.getAddress());
   System.out.println(socketAddress.getPort());

3、TCP连接

TCP是一种面向有连接的传输层协议，适用于要求可靠传输的应用，每条TCP连接只能有两个端点，只能是一对一通信。适用于文件传输等应用场景。
TCP建立连接需要进行三次握手：（1）客户端向服务器端发送syn包，进入SYN_SENT状态，等待服务器确认。（2）服务器收到syn包，必须确认客户端的SYN，同时自己发送一个SYN包（SYN+ACK），此时服务器进入SYN_RECV状态。（3）客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK，此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。
TCP释放连接需要进行四次挥手：（1）当主机A的应用程序通知TCP数据已经发送完毕时，TCP向主机B发送一个带有FIN（finish）附加标记的报文段。（2）主机B收到这个FIN报文段之后，并不立即用FIN回复主机A，而是先向主机A发送一个确认序号ACK，同时通知自己相应的应用程序，对方要求关闭连接（先发送ACK目的是防止这段时间对方重传FIN报文段）。（3）主机B应用程序告诉TCP：我要彻底关闭连接，TCP向主机A发送一个FIN报文段。（4）主机A收到这个FIN报文段之后，向主机B发送一个ACK表示连接彻底释放。

Java实现TCP连接的代码：
服务器端：

package network0428;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/*
* 1、建立服务的端口ServerSocket
* 2、等待用户的连接 accept
* 3、接收消息
* */
public class TcpServer {
    public static void main(String[] args) throws Exception {
        fileServer();
    }
    public static void fileServer() throws Exception{
//        1、创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
//        2、监听客户端的连接
        Socket socket = serverSocket.accept();
//        3、获取输入流
        InputStream is = socket.getInputStream();
//        4、文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.txt"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
//        5、通知客户端我接收完了
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕了，你可以断开了".getBytes());
//        6、关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

客户端：

package network0428;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

/*
* 1、通过Socket连接服务器
* 2、发送消息
* */
public class TcpClient {
    public static void main(String[] args) throws Exception{
        fileClient();
    }
    public static void fileClient() throws Exception{
//        1、创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
//        2、创建一个输出流
        OutputStream os = socket.getOutputStream();
//        3、读文件
        FileInputStream fis = new FileInputStream(new File("aaa.txt"));
//        4、写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
//        5、通知服务器，我已经传输完了
        socket.shutdownOutput();

//        6、确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

//        7、关闭资源
        fis.close();
        os.close();
        socket.close();
    }
}

3、UDP连接

UDP是一种无连接的传输层协议，是不可靠传输，适用于实时应用，例如视频会议等。
UDP实际上不分客户端和服务端，使用发送端和接收端。

Java实现UDP：
接收端：

package network0429;


import java.net.DatagramPacket;
import java.net.DatagramSocket;

//等待发送端的链接
public class UdpServer {
    public static void main(String[] args) throws Exception {
        learnUdpServer();
    }
    public static void learnUdpServer() throws Exception{
//        开放端口
        DatagramSocket socket = new DatagramSocket(9090);
//        接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));
//        关闭连接
        socket.close();
    }
}

发送端：

package network0429;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
* 不需要连接服务器
* UDP没有服务器客户端的概念，任何机器都可以互相发送消息，被称为“发送端”和“接收端”。
* */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        learnUdpClient();
    }
    public static void learnUdpClient () throws Exception{
//        1、建立一个Socket，DatagramSocket数据报。
        DatagramSocket socket = new DatagramSocket();
//        2、建个包
        String msg = "你好啊 服务器";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        DatagramPacket pack = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
//        3、发送包
        socket.send(pack);
//        4、关闭连接
        socket.close();
    }
}

使用UDP实现在线聊天室（使用多线程）：
发送端代码：

package network0429;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class TalkSend implements Runnable {

    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort;
    private String toIp;
    private int toPort;

    public TalkSend(int fromPort, String toIp, int toPort) {
        this.fromPort = fromPort;
        this.toIp = toIp;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIp, this.toPort));
                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收端：

package network0429;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        while (true){
            try {
                byte[] contains = new byte[1024];
                DatagramPacket packet = new DatagramPacket(contains, 0, contains.length);
                socket.receive(packet);
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, packet.getLength());
                System.out.println(msgFrom+": "+receiveData);
                if (receiveData.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

模拟老师和学生交流：
老师端启动发送消息和接收消息线程：

package network0429;

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

学生端启动发送消息和接收消息线程：

package network0429;

public class TalkStudent {
    public static void main(String[] args) {
        new Thread(new TalkSend(777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}