Java网络编程

5.网络编程

5.1.软件结构

B/S结构：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。
C/S结构：全称为Client/Server结构，是指客户端和服务器结构。常见程序有QQ、迅雷等软件。

5.2.网络通信协议

网络通信协议：通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。这就好比在道路中行驶的汽车一定要遵守交通规则一样，协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。
TCP/IP协议：传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。
网络通信7层模型：
- 物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。
- 数据链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。
- 网络层：网络层是整个TCP/IP协议的核心，主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。
- 传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量
  大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。
- 会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）
- 表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。
- 应用层：主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用），主要负责应用程序的协议，例如HTTP协议、FTP协议等。
应用层：HTTP FTP TFTP SMTP SNMP DNS
传输层：TCP UDP
- 网络层：ICMP IGMP IP ARP RARP
- 数据链路层，物理层：由底层网络定义的协议

OSI参考模型	TCP/IP参考模型
应用层	应用层
表示层
会话层
传输层	传输层
网络层	网际层
数据链路层	主机至网络层
物理层

5.3.TCP与UDP协议

5.3.1.TCP协议

TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。创建前需要三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
- TCP连接时，需要客户端和服务器共发送3个包。
  - 第一次：客户端发送初始序号x和syn=1请求标志
  - 第二次：服务器发送请求标志syn，发送确认标志ACK，发送自己的序号seq=y，发送客户端的确认序号ack=x+1
  - 第三次：客户端发送ACK确认号，发送自己的序号seq=x+1，发送对方的确认号ack=y+1
- 三次握手过程分析：
  - 第一次：客户端发送请求到服务器，服务器知道客户端发送，自己接收正常。SYN=1,seq=x
  - 第二次：服务器发给客户端，客户端知道自己发送、接收正常，服务器接收、发送正常。ACK=1,ack=x+1,SYN=1,seq=y
  - 第三次：客户端发给服务器：服务器知道客户端发送，接收正常，自己接收，发送也正常.seq=x+1,ACK=1,ack=y+1
  概括：
  1. 第一次握手，客户端向服务器端发出连接请求，等待服务器确认
  2. 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
  3. 第三次握手，客户端再次向服务器端发送确认信息，确认连接
- TCP断开连接时：
  - 第一次挥手：客户端发出释放FIN=1，自己序列号seq=u，进入FIN-WAIT-1状态
  - 第二次挥手：服务器收到客户端的后，发出ACK=1确认标志和客户端的确认号ack=u+1，自己的序列号seq=v，进入CLOSE-WAIT状态
  - 第三次挥手：客户端收到服务器确认结果后，进入FIN-WAIT-2状态。此时服务器发送释放FIN=1信号，确认标志ACK=1，确认序号ack=u+1，自己号seq=w，服务器进入LAST-ACK（最后确认态）
  - 第四次挥手：客户端收到回复后，发送确认ACK=1，ack=w+1，自己的seq=u+1，客户端进入TIME-WAIT（时间等待）。客户端经过2个最长报文段命后，客户端CLOSE；服务器收到确认后，立刻进入CLOSE状态。
- 四次挥手过程分析
  - 第一次：客户端请求断开FIN,seq=u
  - 第二次：服务器确认客户端的断开请求ACK,ack=u+1,seq=v
  - 第三次：服务器请求断开FIN,seq=w,ACK,ack=u+1
  - 第四次：客户端确认服务器的断开ACK,ack=w+1,seq=u+1
  概括：
  1. 第一次挥手：客户端向服务器发出断开连接的请求，等待服务器确认
  2. 第二次挥手：服务器向客户端发送一个回应，通知客户端收到了断开连接请求
  3. 第三次挥手：服务器向客户端发出通知，即将断开连接
  4. 第四次挥手：客户端回应服务器，已经知道即将断开连接，准备好了

5.3.2.UDP协议

UDP：用户数据报协议(User Datagram Protocol)。UDP协议是一个面向无连接的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中，例如视频会议、QQ聊天，音频视频以及普通的数据传输等。

UDP协议特点：数据被限制在64KB以内，超出这个范围就不能发送了

5.3.3.TCP、UDP的优缺点

TCP：面向连接。安全可靠效率稍低。通过三次握手确保连接的建立。
UDP：面向无连接。不可靠。速度快。将数据封包传输，数据包最大64k。

5.4.网络编程三要素

5.4.1.通信协议

协议：计算机网络通信必须遵守的规则

5.4.2.IP地址

IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。
IP地址分类
- IPv4：是一个32位的二进制数，通常被分为4个字节，表示成 a.b.c.d 的形式，例如 192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
- IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。有资料显示，全球IPv4地址在2011年2月分配完毕。为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 ，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。
常用命令
- ipconfig
- ping ip地址
特殊IP地址
- 本机IP地址：127.0.0.1、localhost

5.4.3.端口号

端口号：用两个字节表示的整数，它的取值范围是0_{65535。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

5.5.UDP通信

5.5.1.介绍

UDP传输（需要知道接收端的IP地址和端口号）
DatagramPacket：JDK中提供了一个DatagramPacket类，该类的实例对象就相当于一个集装箱，用于封装UDP通信中发送或者接收的数据。
- 构造方法：
  - public DatagramPacket(byte[] buf, int length)：构造 DatagramPacket，用来接收长度为 length 的数据包
  - public DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)：构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。length 参数必须小于等于 buf.length。
- 常用方法：
  - public InetAddress getAddress() 获取发送端的IP地址
  - public int getPort() 获取发送端的端口号
  - public byte[] getData() 获取数据缓冲区，即发送过来的数据
  - public int getLength 获取数据的实际长度
DatagramSocket：JDK中提供的一个DatagramSocket类。使用这个类的实例对象就可以发送和接收DatagramPacket数据包
- 构造方法：
  - public DatagramSocket()：构造数据报套接字并将其绑定到本地主机上任何可用的端口。
    - IP：本机IP
    - 端口：随机分配一个可用端口
  - public DatagramSocket(int port)：创建数据报套接字并将其绑定到本地主机上的指定端口。
    - IP：主机IP
    - 端口：指定
  - public DatagramSocket(int port,InetAddress laddr)：创建数据报套接字，将其绑定到指定的本地地址。
    - IP：指定
    - 端口：指定
- 常用方法：
  - public void receive(DatagramPacket p)：从此套接字接收数据报包。该方法是一个阻塞方法，没有接收到数据会一直运行。
  - public void send(DatagramPacket p)：从此套接字发送数据报包。

5.5.2.使用步骤

UDP协议—发送端设计
1. 建立udp的socket服务
2. 将要发送的数据封装成数据包，必须要指定目的地的IP地址和端口
3. 通过udp的socket服务,将数据包发送出
4. 关闭资源
UDP协议—接收端设计
1. 建立udp的socket服务，要指定监听的端口，如果监听到发送来的数据包，就获取
2. 新建一个字节数组，利用它才创建新的数据包
3. 通过receive方法接收数据
4. 将收到的数据存储到自己新建的数据包对象中
5. 拆包，通过数据包对象的功能来完成对接收到数据进行解析.
6. 可以对Socket资源进行关闭
Example：采用多线程，实现模拟两个用户聊天程序

//一个用户：
public class OnePerson {

    // 定义标志位，标识发送线程已经发出了886
    static boolean isSenderOffline = false;

    // 对访问 isSenderOffline 的发送和接收线程做线程同步
    static Object senderLock = new Object();


    public static void main(String[] args) throws SocketException, UnknownHostException {

        // 创建一个DatagramSocket对象
        DatagramSocket socket = new DatagramSocket(9999);

        // 创建任务对象
        ReceiveTask receiveTask = new ReceiveTask(socket);
        String targetIp = "127.0.0.1";
        int port = 10000;
        SendTask sendTask = new SendTask(socket, targetIp, port);

        // 让任务在线程中运行
        new Thread(sendTask).start();
        new Thread(receiveTask).start();


    }
}

//该用户接收端
public class ReceiveTask implements Runnable{
    private DatagramSocket socket;
    public ReceiveTask(DatagramSocket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        boolean flag = true;
        // 接收数据的数据报包
        byte[] bytes = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);

        try {
            while (flag) {
                socket.receive(receivePacket);

                byte[] data = receivePacket.getData();
                int offset = receivePacket.getOffset();
                int length = receivePacket.getLength();

                String s = new String(data, offset, length);
                System.out.println(s);

                if ("886".equals(s)) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 1.  当代码执行到这里的时候，我们能确定，
            //      接收线程不在需要使用DatagramSocket对象
            // 2. 判断，发送线程发出了886
            while (true) {
                synchronized (OnePerson.senderLock) {
                    if (OnePerson.isSenderOffline) {
                        break;
                    }
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 当发送线程和接收线程都不在使用套接字对象的时候关闭
            socket.close();
        }
    }
}

//该用户发送端
public class SendTask implements Runnable {
    private DatagramSocket socket;
    private InetAddress targetIp;
    private int targetPort;

    public SendTask(DatagramSocket socket, String ip, int port) throws UnknownHostException {
        this.socket = socket;
        targetIp = InetAddress.getByName(ip);
        this.targetPort = port;
    }
    
    @Override
    public void run() {
        // 利用socket对象发送数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {
            String data;
            while ((data = br.readLine()) != null) {
                byte[] bytes = data.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, targetIp, targetPort);

                // 将数据发送出去
                socket.send(datagramPacket);

                if ("886".equals(data)) {
                    // 标识发送线程发出了886
                    synchronized (OnePerson.senderLock) {
                        OnePerson.isSenderOffline = true;
                    }
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}



//另一个用户：
public class AnotherPerson {
    static boolean isSenderOffline = false;
    static Object senderLock = new Object();

    public static void main(String[] args) throws SocketException, UnknownHostException {
        // 创建一个DatagramSocket对象
        DatagramSocket socket = new DatagramSocket(10000);

        // 创建任务对象
        ReceiveTask receiveTask = new ReceiveTask(socket);
        String targetIp = "127.0.0.1";
        int port = 9999;
        SendTask sendTask = new SendTask(socket, targetIp, port);

        // 让任务在线程中运行
        new Thread(sendTask).start();
        new Thread(receiveTask).start();
    }
}

//该用户接收端：
public class ReceiveTask implements Runnable{
    private DatagramSocket socket;
    public ReceiveTask(DatagramSocket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        boolean flag = true;
        // 接收数据的数据报包
        byte[] bytes = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);

        try {
            while (flag) {
                socket.receive(receivePacket);

                byte[] data = receivePacket.getData();
                int offset = receivePacket.getOffset();
                int length = receivePacket.getLength();

                String s = new String(data, offset, length);
                System.out.println(s);

                if ("886".equals(s)) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            while (true) {
                synchronized (AnotherPerson.senderLock) {
                    if (AnotherPerson.isSenderOffline) {
                        break;
                    }
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            socket.close();
        }
    }
}

//该用户发送端：
public class SendTask implements Runnable {
    private DatagramSocket socket;
    private InetAddress targetIp;
    private int targetPort;

    public SendTask(DatagramSocket socket, String ip, int port) throws UnknownHostException {
        this.socket = socket;
        targetIp = InetAddress.getByName(ip);
        this.targetPort = port;
    }

    @Override
    public void run() {

        // 利用socket对象发送数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            String data;
            while ((data = br.readLine()) != null) {
                byte[] bytes = data.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, targetIp, targetPort);

                // 将数据发送出去
                socket.send(datagramPacket);

                if ("886".equals(data)) {
                    synchronized (AnotherPerson.senderLock) {
                        AnotherPerson.isSenderOffline = true;
                    }
                    break;
                }
            }

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

Example：模拟聊天室

//接收端
public class ReceiveTask implements Runnable{
    private DatagramSocket socket;
    public ReceiveTask(DatagramSocket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        boolean flag = true;
        // 接收数据的数据报包
        byte[] bytes = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(bytes, 0, bytes.length);

        try {
            while (flag) {
                socket.receive(receivePacket);

                byte[] data = receivePacket.getData();
                int offset = receivePacket.getOffset();
                int length = receivePacket.getLength();

                String s = new String(data, offset, length);
                System.out.println(s);

                if ("886".equals(s)) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 1.  当代码执行到这里的时候，我们能确定，
            //      接收线程不在需要使用DatagramSocket对象
            // 2. 判断，发送线程发出了886
            while (true) {
                synchronized (OnePerson.senderLock) {
                    if (OnePerson.isSenderOffline) {
                        break;
                    }
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 当发送线程和接收线程都不在使用套接字对象的时候关闭
            socket.close();
        }
    }
}

//客户端
public class SendTask implements Runnable {
    private DatagramSocket socket;
    private InetAddress targetIp;
    private int targetPort;
    public SendTask(DatagramSocket socket, String ip, int port) throws UnknownHostException {
        this.socket = socket;
        targetIp = InetAddress.getByName(ip);
        this.targetPort = port;
    }

    @Override
    public void run() {
        // 利用socket对象发送数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {
            String data;
            while ((data = br.readLine()) != null) {
                byte[] bytes = data.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, targetIp, targetPort);
                // 将数据发送出去
                socket.send(datagramPacket);
                if ("886".equals(data)) {
                    // 标识发送线程发出了886
                    synchronized (OnePerson.senderLock) {
                        OnePerson.isSenderOffline = true;
                    }
                    break;
                }0
            }

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

//用户
public class OnePerson {

    // 定义标志位，标识发送线程已经发出了886
    static boolean isSenderOffline = false;
    // 对访问 isSenderOffline 的发送和接收线程做线程同步
    static Object senderLock = new Object();

    public static void main(String[] args) throws SocketException, UnknownHostException {
        // 创建一个DatagramSocket对象
        DatagramSocket socket = new DatagramSocket(9999);
        // 创建任务对象
        ReceiveTask receiveTask = new ReceiveTask(socket);
        // 该发送的目标端的ip地址， 目标ip地址，必须是一个广播地址
        String targetIp = "192.168.3.255";
        int port = 9999;
        SendTask sendTask = new SendTask(socket, targetIp, port);

        // 让任务在线程中运行
        new Thread(sendTask).start();
        new Thread(receiveTask).start();

    }
}

5.6.TCP通信

5.6.1.背景

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

5.6.2.通信步骤

服务端程序，需要事先启动，等待客户端的连接。
客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

5.6.3.TCP通信类

客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
服务端： java.net.ServerSocket 类表示。创建 ServerSocket 对象，相当于开启一个服务，并等待客户端的连接。

5.6.4.Socket类

该类实现客户端套接字，套接字指的是两台设备之间通讯的端点（套接字：包含了IP地址和端口号的网络单位）
构造方法：
public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。
回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输
成员方法：
- public InputStream getInputStream() ：返回此套接字的输入流。如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。关闭生成的InputStream也将关闭相关的Socket。
- public OutputStream getOutputStream() ：返回此套接字的输出流。如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。关闭生成的OutputStream也将关闭相关的Socket。
- public void close() ：关闭此套接字。一旦一个socket被关闭，它不可再使用。关闭此socket也将关闭相关的InputStream和OutputStream 。
- public void shutdownOutput() ：禁用此套接字的输出流。任何先前写出的数据将被发送，随后终止输出流。

5.6.5.ServerSocket类

这个类实现了服务器套接字，该对象等待通过网络的请求。
构造方法：
public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。
成员方法：
- public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

5.6.6.通信实现

客户端向服务器发送数据

//服务端
public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
        // 4.1 创建字节数组
        byte[] b = new byte[1024];
        // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
        //5.关闭资源.
        is.close();
        server.close();
    }
}


//客户端
public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.获取流对象 . 输出流
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
        // 4. 关闭资源 .
        os.close();
        client.close();
    }
}

服务器向客户端回写数据

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待连接 .... ");
        // 1.创建 ServerSocket对象，绑定端口，开始等待连接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收连接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.通过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
        // 4.1 创建字节数组
        byte[] b = new byte[1024];
        // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
        // =================回写数据=======================
        // 5. 通过 socket 获取输出流
        OutputStream out = server.getOutputStream();
        // 6. 回写数据
        out.write("我很好,谢谢你".getBytes());
        // 7.关闭资源.
        out.close();
        is.close();
        server.close();
    }
}

客户端实现

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.通过Scoket,获取输出流对象
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
        // ==============解析回写=========================
        // 4. 通过Scoket,获取 输入流对象
        InputStream in = client.getInputStream();
        // 5. 读取数据数据
        byte[] b = new byte[100];
        int len = in.read(b);
        System.out.println(new String(b, 0, len));
        // 6. 关闭资源 .
        in.close();
        os.close();
        client.close();
    }
}

文件上传问题：

//服务端
public class Server {

    public static void main(String[] args) throws IOException {

        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();

        InputStream in = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(in));

        // 利用该流将接收到的数据写入服务器端文件
        FileWriter fileWriter = new FileWriter("b.txt");

        String line;
        // readLine方法因为使用的是socket对象的输入流的read方法，所以它也变成了阻塞方法
        while ((line = br.readLine()) != null) {
//            if ("finish".equals(line)) {
//                break;
//            }
            fileWriter.write(line);
            fileWriter.write(System.lineSeparator());
            fileWriter.flush();
        }
//        //  文件数据接收完毕后，发送反馈消息给客户端，告知文件上传完毕
//        OutputStream out = socket.getOutputStream();
//        out.write("文件山川完毕".getBytes());


        // 关闭Socket及流资源
        // close() 方法 幂等方法
        socket.close();
        br.close();
        serverSocket.close();
        fileWriter.close();
    }
}

//客户端
public class Client {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9999);

        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        OutputStream out = socket.getOutputStream();

        // 读取文件数据，并上传
        String line;
        while ((line = br.readLine()) != null) {
            out.write(line.getBytes());
            out.write(System.lineSeparator().getBytes());
            // 第一种解决思路
//            if ("finish".equals(line)) {
//                break;
//            }
        }

//        // 禁用或者关闭发送端的输出流, 从而以这种方式告诉服务器端，文件内容上传完毕
//        socket.shutdownOutput();
//
//        // 接收服务器端发送的文件上传的反馈消息
//        InputStream in = socket.getInputStream();
//        byte[] bytes = new byte[1024];
//        // 阻塞方法， 在这里阻塞等待，服务器端发送的反馈消息
//        int len = in.read(bytes);
//        System.out.println(new String(bytes, 0, len));

        // 关闭socket，以及流
        socket.close();
        br.close();
    }
}




//图片上传

//服务端
public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动..... ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 建立连接
        Socket accept = serverSocket.accept();
        // 3. 创建流对象
        // 3.1 获取输入流,读取文件数据
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        // 3.2 创建输出流,保存到本地 .
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
        // 4. 读写数据
        byte[] b = new byte[1024 * 8];
        int len;
        while ((len = bis.read(b)) != ‐1) {
        	bos.write(b, 0, len);
        }
        //5. 关闭 资源
        bos.close();
        bis.close();
        accept.close();
        System.out.println("文件上传已保存");
    }
}

//客户端
public class FileUPload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //2.写出数据.
        byte[] b = new byte[1024 * 8 ];
        int len ;
        while (( len = bis.read(b))!=‐1) {
            bos.write(b, 0, len);
            bos.flush();
        }
        System.out.println("文件发送完毕");
        // 3.释放资源
        bos.close();
        socket.close();
        bis.close();
        System.out.println("文件上传完毕 ");
    }
}

图片上传问题分析：

文件名称写死的问题
- 服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一
```
   FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
   BufferedOutputStream bos = new BufferedOutputStream(fis);
```
循环接收的问题
- 服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件
```
   // 每次接收新的连接,创建一个Socket
   while（true）{
       Socket accept = serverSocket.accept();
       ......
   }
```

效率问题

服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化

   while（true）{
         Socket accept = serverSocket.accept();
         // accept 交给子线程处理.
         new Thread(() ‐> {
             ......
             InputStream bis = accept.getInputStream();
             ......
         }).start();
     }

优化后的代码如下：

   public class FileUpload_Server {
       public static void main(String[] args) throws IOException {
           System.out.println("服务器 启动..... ");
           // 1. 创建服务端ServerSocket
           ServerSocket serverSocket = new ServerSocket(6666);
           // 2. 循环接收,建立连接
           while (true) {
               Socket accept = serverSocket.accept();
               /*
               3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
               */
               new Thread(() ‐> {
                   try (
                       //3.1 获取输入流对象
                       BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                       //3.2 创建输出流对象, 保存到本地 .
                       FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() +
                       ".jpg");
                       BufferedOutputStream bos = new BufferedOutputStream(fis);
                       // 3.3 读写数据
                       byte[] b = new byte[1024 * 8];
                       int len;
                       while ((len = bis.read(b)) != ‐1) {
                           bos.write(b, 0, len);
                       }
                       //4. 关闭 资源
                       bos.close();
                       bis.close();
                       accept.close();
                       System.out.println("文件上传已保存");
           		} catch (IOException e) {
           			e.printStackTrace();
           		}
           	}).start();
   		}
   	}
   }

信息回写分析

【服务端】获取输出流，回写数据。
【客户端】获取输入流，解析回写数据。
回写实现：

//服务端
public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动..... ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
            /*
            3. socket对象交给子线程处理,进行读写操作
            Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() ‐> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() +".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != ‐1) {
                        bos.write(b, 0, len);
                    }
                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================
                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

//客户端
public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //2.写出数据.
        byte[] b = new byte[1024 * 8 ];
        int len ;
        while (( len = bis.read(b))!=‐1) {
            bos.write(b, 0, len);
        }
        // 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================        // 4.释放资源
        socket.close();
        bis.close();
    }
}