TCP 和 UDP：

TCP协议：传输控制协议

1. 使用TCP协议前，必须先建立TCP链接，形成传输数据通道
2. 传输前，采用”三次握手”方式，是可靠的
3. TCP协议进行通信的两个应用进程：客户端、服务端
4. 在连接中可进行大数据量的传输
5. 传输完毕，需释放已建立的链接，效率低

UDP协议：

1. 将数据、源、目的封装成数据包，不需要建立链接
2. 每个数据报的大小限制在64k内
3. 因无需链接，故是不可靠的
4. 发送数据结束时无需释放资源(因为不是面向连接的)，速度快
5. 举例：厕所通知：发短信

InetAddress类：

相关方法：

1. getLocalHost 获取本机InetAddress对象
2. geyByName 根据指定主机名/域名获取ip地址对象
3. getHostName 获取InetAddress对象的主机名
4. getHostAddress 获取InetAddress对象的地址

   public static void main(String[] args) {
   
       //1、获取本机的InetAddress对象
       InetAddress localHost = InetAddress.getLocalHost();
       System.out.print(localHost);    //会输出ip地址和主机名
   
       //2、根据指定主机名，获取InetAddress对象
       InetAddress Host1 = InetAddress.getByName("电脑名称");
       System.out.print(Host1);        //输出ip地址
   
       //3、根据域名返回InetAddress对象，比如获取 www.baidu.com 对应
       InetAddress Host2 = InetAddress.getByName("www.baidu.com");、
       System.out.print("host2 = " + host2);
       //输出 host2 = www.baidu.com/110.242.68.4
   
       //4、通过InetAddress对象，获取对应的地址
       String HostAddress = host2.getHostAddress();    //IP 110.242.68.4
       System.out.print("host2 对应的ip = " + HostAddress);
   
       //5、通过InetAddress对象，获取对应的主机名/或者域名
       String hostName = host2.getHostName();
       System.out.print("host2对应的主机名/域名 = " + hostName);       //www.baidu.com
   }
   

Socket:

基本介绍：

1. 嵌套字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
2. 通信的两端都要有Socket，是两台机器间通信的端点
3. 网络通信其实就是Socket间的通信。
4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

TCP网络通信编程：

基本介绍：

1. 基于 客户端——服务端 的网络通信
2. 底层使用的是TCP/IP协议
3. 应用场景举例：客户端发送数据，服务端接受并显示控制台
4. 基于Socket的TCP编程

案例1(使用字节流)：

​ 1、编写一个服务器端和一个客户端

​ 2、服务器端在9999端口监听

​ 3、客户端连接到服务器端，发送”hello sever”，然后退出

​ 4、服务器端接受到 客户端发送的 信息，输出，并退出

客户端：

​ 1、链接服务器(ip，端口)

​ 2、连接上后，生成Socket，通过socket.getOutputStream()

​ 3、通过输出流，写入数据到 数据通道

        public static void main(String[] args) {

            //1、链接服务器(ip，端口)
            //解读：链接主机 InetAddress.getLocalHost() 的 9999端口，
            //      如果连接成功，返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(),9999)
            System.out.print("客户端 socket返回 = " + socket.getClass());
            //2、连接上后，生成Socket，通过socket.getOutputStream()
            //  得到 和 socket对象关联的输出流对象
            OutputStream outputStream = socket.getOutputStream();
            //3、通过输出流，写入数据到 数据通道
            OutputStream.write("hello,server".getBytes())
            //4、关闭流对象和socket，必须关闭
            outputStream.close();
            socket.close();
            System.out.print("客户端退出~~~~~~~");
        }

服务端：

​ 1、在本机的 9999端口监听，等待连接

​ 2、当没有客户端链接9999端口时，程序会阻塞，等待连接

​ 3、通过socket.getInputStream()读取客户端写入到数据通道的数据，显示

        public static void main(String[] args) {

            //1、在本机的 9999端口监听，等待连接
            //细节：要求在本机没有其他服务在监听9999
            //      SeverSocket可以通过accept()返回多个Socket   (多个客户端链接服务器的并发)
            SeverSocket severSocket = new SeverSocket(9999);
            System.out.print("服务端，在9999端口监听，等待链接~~");

            //2、当没有客户端链接9999端口时，程序会阻塞，等待连接
            //  如果有客户端链接，则会返回Socket对象，程序继续
            Socket socket = severSocket.accept();
            System.out.print("服务端 socket = " + socket.getClass());
            //3、通过socket.getInputStream()读取客户端写入到数据通道的数据，显示
            InputStream inputStream = socket.getInputStream();
            //4、IO读取
            byte[] guf = new byte[1024];
            int readLen = 0;
            while ((readLen = inputStream.read(buf)) != -1) {
                System.out.print(new String(buf,0,readLen));    //根据读取到的长度显示内容
            }
            //5、关闭流和socket
            inputStream.close();
            socket.close();
            severSocket.close();
        }

例2(使用字节流)：

​ 1、编写一个服务器端，和一个客户端

​ 2、服务器端在9999端口监听

​ 3、客户端连接到服务器端，发送”hello,sever”，并接收服务器端回发的”hello,client”,再退出

​ 4、服务器端接受到 客户端发送的 信息，输出，并发送”hello,client”，再退出

客户端：

​ 1、链接服务器(ip，端口)

​ 2、连接上后，生成Socket，通过socket.getOutputStream()

​ 3、通过输出流，写入数据到 数据通道

​ 4、socket.getInputStream()

​ 5、读取数据通道的数据

​ 6、显示

​ 7、关闭socket和io

            public static void main(String[] args) {

                //1、链接服务器(ip，端口)
                //解读：链接主机 InetAddress.getLocalHost() 的 9999端口，
                //      如果连接成功，返回Socket对象
                Socket socket = new Socket(InetAddress.getLocalHost(),9999)
                System.out.print("客户端 socket返回 = " + socket.getClass());
                //2、连接上后，生成Socket，通过socket.getOutputStream()
                //  得到 和 socket对象关联的输出流对象
                OutputStream outputStream = socket.getOutputStream();
                //3、通过输出流，写入数据到 数据通道
                OutputStream.write("hello,server".getBytes())
                //  设置结束标记
                socket.shutdownOutput();
                //4、获取和socket关联的输入流，读取数据(字节方式)，并显示
                InputStream inputStream = socket.getInputStream();
                byte[] buf=  new byte[1024];
                int readLen = 0;
                while ((readLen = inputStream.read(buf)) != -1) {
                    System.out.print(new String(buf,0,readLen));
                }
                //5、关闭流对象和socket，必须关闭
                inputStream.close();
                outputStream.close();
                socket.close();
                System.out.print("客户端退出~~~~~~~");
            }

服务端：

​ 1、在本机的 9999端口监听，等待连接

​ 2、当没有客户端链接9999端口时，程序会阻塞，等待连接

​ 3、通过socket.getInputStream()读取客户端写入到数据通道的数据，显示

​ 4、写入数据到数据通道

        public static void main(String[] args) {

            //1、在本机的 9999端口监听，等待连接
            //细节：要求在本机没有其他服务在监听9999
            //      SeverSocket可以通过accept()返回多个Socket   (多个客户端链接服务器的并发)
            SeverSocket severSocket = new SeverSocket(9999);
            System.out.print("服务端，在9999端口监听，等待链接~~");
            //2、当没有客户端链接9999端口时，程序会阻塞，等待连接
            //  如果有客户端链接，则会返回Socket对象，程序继续
            Socket socket = severSocket.accept();
            System.out.print("服务端 socket = " + socket.getClass());
            //3、通过socket.getInputStream()读取客户端写入到数据通道的数据，显示
            InputStream inputStream = sock.getInputStream();
            //4、IO读取
            byte[] guf = new byte[1024];
            int readLen = 0;
            while ((readLen = inputStream.read(buf)) != -1) {
                System.out.print(new String(buf,0,readLen));    //根据读取到的长度显示内容
            }
            //5、获取socket相关联的输出流
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("hello,client".getBytes());
            //  设置结束标记
            socket.shutdownOutput();
            //6、关闭流和socket
            outputStream.close();
            inputStream.close();
            socket.close();
            severSocket.close();
        }

例3(使用字符流)：

​ 1、编写一个服务端，和一个客户端

​ 2、服务端在9999端口监听

​ 3、客户端连接到服务端，发送”hello,sever”，并接收服务端回发的”hello,client”，再退出

​ 4、服务端接收到 客户端发送的 信息，输出，并发送”hello,client”，再退出

客户端：

​ 1、socket.getOutputStream()

​ 2、将OutputStream -> writer

​ 3、需要使用转换流 OutputStreamWriter(字节流)

        public static void main(String[] args) {

            //1、链接服务器(ip，端口)
            //解读：链接主机 InetAddress.getLocalHost() 的 9999端口，
            //      如果连接成功，返回Socket对象
            Socket socket = new Socket(InetAddress.getLocalHost(),9999)
            System.out.print("客户端 socket返回 = " + socket.getClass());
            //2、连接上后，生成Socket，通过socket.getOutputStream()
            //  得到 和 socket对象关联的输出流对象
            OutputStream outputStream = socket.getOutputStream();
            //3、通过输出流，写入数据到 数据通道，使用字符流
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
            bufferedWriter.write("hello,sever 字符流");
            //  设置结束标记
            bufferedWriter.newLine();   //插入一个换行符，表示写入的内容结束，
                                        //要求对方使用readLine()来读~

            bufferedWriter.flush(); //如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
            //4、获取和socket关联的输入流，读取数据(字符方式)，并显示
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String s = bufferedReader.readLine();
            System.out.print(s);
            //5、关闭流对象和socket，必须关闭
            bufferedReader.close(); //关闭外层流
            bufferedWriter.close();
            socket.close();
            System.out.print("客户端退出~~~~~~~");
        }

服务端：

​ 1、socket.getInputStream()

​ 2、将InputStream -> Reader

​ 3、使用转换流 InputStreamReader()

​ 4、设置写入结束标记

​ socket.shutdownOutput();

​ 或者:writer.newLine() //换行符，注意需要要求对方使用readLine()来读

        public static void main(String[] args) {

            //1、在本机的 9999端口监听，等待连接
            //细节：要求在本机没有其他服务在监听9999
            //      SeverSocket可以通过accept()返回多个Socket   (多个客户端链接服务器的并发)
            SeverSocket severSocket = new SeverSocket(9999);
            System.out.print("服务端，在9999端口监听，等待链接~~");
            //2、当没有客户端链接9999端口时，程序会阻塞，等待连接
            //  如果有客户端链接，则会返回Socket对象，程序继续
            Socket socket = severSocket.accept();
            System.out.print("服务端 socket = " + socket.getClass());
            //3、通过socket.getInputStream()读取客户端写入到数据通道的数据，显示
            InputStream inputStream = sock.getInputStream();
            //4、IO读取，使用字符流, 使用InputStreamReader 将 niputStream 转换字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String s = bufferedReader.readLine();
            System.out.print(s);    //输出
            //5、获取socket相关联的输出流
            OutputStream outputStream = socket.getOutputStream();
            //使用字符输出流的方式回复信息
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
            bufferedWriter.write("hello client 字符流");
            bufferedWriter.newLine();//插入一个换行符，表示回复内容的结束
            bufferedWriter.flush(); //需要手动刷新
            //6、关闭流和socket
            bufferedWriter.close();
            bufferedReader.close();
            socket.close();
            severSocket.close();
        }

例4(网络上传文件)：

​ 1、编写一个服务端，和一个客户端

​ 2、服务器端在 8888端口监听

​ 3、客户端连接到服务端，发送 一张图片 e:\qie.png

​ 4、服务器端接受到 客户端发送的 图片，保存到src下，发送”收到图片”再退出

​ 5、客户端接收到服务端发送的”收到图片”，再退出

​ 6、该程序要求使用StreamUtils.java(单独写的工具类)

​ 说明：使用BufferedInputStream 和 BufferedOutputStream 字节流

客户端：

public static void main(String[] args) {
    //1、客户端连接服务端 8888，得到Socket对象
    Socket socket = new Socket(InetAddress.getLocalHost(),8888)
    //2、创建读取磁盘文件的输入流
    String filePath = "e:\\qie.png";
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
    //bytes 就是filepath对应的字节数组
    byte[] bytes = StreamUtils.streamToByteArray(bis);
    //通过socket获取到输出流，将bytes数据发送给服务端
    BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
    bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
    bis.close();
    socket.shutdownOutput();//设置写入数据的结束标记
    //接收从服务端回复的消息
    InputStream inputStream = socket.getInputStream();
    //使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
    String s = StreamUtils.streamToString(inputStream);
    System.out.print(s);
    //关闭相关的流
    inputStream.close();
    bos.close();
    socket.close();
}

服务端：

public static void main(String[] args) {

    //1、服务端在本机监听8888接口
    SeverSocket severSocket = new SeverSocket(8888);
    System.out.print("服务端在8888端口监听~~");
    //2、等待连接
    Socket socket = severSocket.accept();
    //3、读取客户端发送的数据
    //通过Socket得到输入流
    BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
    byte[] bytes = StreamUtils.streamToByteArray(bis);
    //4、将得到 bytes 数组，写入到指定的路径，就得到一个文件了
    String destFilePath = "src\\qie2.png";
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
    bos.write(bytes);
    bos.close();
    //向客户端回复 "收到图片"
    //通过socket 获取到输出流(字符)
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    writer.write("收到图片");
    writer.flush(); //把内容刷新到数据通道
    socket.shutdownOutput();//设置写入结束标记
    //关闭其他资源
    writer.close();
    bis.close();
    socket.close();
    severSocket.close();
}

netstat指令：

1. netstat -an 可查看当前主机网络情况，包括端口监听情况和网络连接情况
2. netstat -an | more 可以分页显示
3. 要求在dos控制台下执行

说明：

1. Listening表示某个端口在监听
2. 如果有一个外部程序(客户端)连接到该端口，就会显示一条连接信息
3. 可以输入 ctrl + c 退出指令

TCP网络通讯细节：

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP来分配的，是不确定的，是随机的