六、TCP实现聊天

客户端：

1. 连接服务器 Socket(address,port)
2. 发送消息

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;

/**
 * 客户端
 */
public class TcpClient {
    public static void main(String[] args) {

        /**
         * 6.因为在关闭资源的时候，作用域不够
         * 为了提升作用域，将变量在方法外部就先赋值
         */
        Socket socket = null;
        OutputStream outputStream = null;
        try {
            //1.要知道服务器的IP和端口号
            InetAddress serverIp = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2. 创建一个socket连接,参数为服务端的IP和端口
             socket = new Socket(serverIp,port);

            //3. 发送消息，利用IO流发送消息
            outputStream = socket.getOutputStream();

            //4. 输入具体的发送内容并进行转化
            outputStream.write("你好，欢迎学习".getBytes());



        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            //5.遵循先开后关的原则，从下到上关闭

            //5.但直接关闭会出现作用域不够的爆红的问题，因此需要在最开始提升作用域
//            outputStream.close();
//            socket.close();



            //7. 提升作用域之后，一个个进行判断后再关闭
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

顺序：

1. 要知道服务器的IP和端口号
2. 创建一个socket连接,参数为服务端的IP和端口
3. 发送消息，利用IO流发送消息
4. 输入具体的发送内容并进行转化
5. 遵循先开后关的原则，从下到上关闭，但直接关闭会出现作用域不够的爆红的问题，因此需要在最开始提升作用域
6. 因为在关闭资源的时候，作用域不够，为了提升作用域，将变量在方法外部就先赋值
7. 提升作用域之后，一个个进行判断后再关闭

2.创建一个socket连接,参数为服务端的IP和端口（这里注释写错了，这里应该是客户端）

 服务端：

import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端
 */
public class TcpServer {
    public static void main(String[] args) {

        /**
         * 6.为了避免关闭时候爆红，在这里进行作用域的提升
         * 为了提升作用域，将变量在方法外部就先赋值
         */
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream is = null;
        ByteOutputStream baos = null;
        // Ctrl + Alt + T 抛出异常
        try {
            //1.客户端先得有一个地址
              serverSocket = new ServerSocket(9999);

            //2.等待客户端连接 调用accept()进行监听，这里的accept就是客户端里保存了端口号和IP地址的socket变量
              accept = serverSocket.accept();

            //3. 读取客户端的消息
              is = accept.getInputStream();

            //4.使用管道流
             baos = new ByteOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer,0,len);
            }

            System.out.println(baos.toString());


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭遵循先开关的原则，意思就是从下往上关

            //5.但会爆红，为了避免这种情况，在最开始提升作用域
//            baos.close();
//            is.close();
//            accept.close();
//            serverSocket.close();

            //7.提升作用域之后，一个个进行判断后再关闭
            if (baos != null) {
                try {
                    baos.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (is!= null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (accept != null) {
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

顺序：

1. 客户端先得有一个地址
2. 等待客户端连接 调用accept()进行监听，这里的accept就是客户端里保存了端口号和IP地址的socket变量
3. 读取客户端的消息
4. 使用管道流
5. 关闭遵循先开关的原则，意思就是从下往上关，但会爆红，为了避免这种情况，在最开始提升作用域
6. 为了避免关闭时候爆红，在这里进行作用域的提升，为了提升作用域，将变量在方法外部就先赋值
7. 提升作用域之后，一个个进行判断后再关闭

最后，先启动服务端，再启动客户端，控制台如下