TCP通信(四)-天翼云

勿以恶小而为之，勿以善小而不为--------------------------刘备

劝诸君，多行善事积福报，莫作恶

上一章简单介绍了UDP通信实现学生咨询(三),如果没有看过，请观看上一章

TCP/IP 通信是非常重要的，需要掌握。

一. TCP 通信所用到的类

一.一 ServerSocket 服务器类

是服务器端所要用到的类。

一.一.一构造方法

一.一.一.一方法

方法	作用
ServerSocket(int port)	绑定到指定的端口，创建服务器套接字

一.一.一.二演示构造方法

@Test
    public void conTest() throws Exception{

        //放置端口号, 监听9999端口
        ServerSocket serverSocket=new ServerSocket(9999);
    }

一.一.二其他方法

方法	作用
Socket accept()	阻塞式接收连接的那一个客户端对象
int getLocalPort()	获取监听的那个端口

一.二 Socket 客户端类

一.二.一构造方法

一.二.一.一方法

方法	作用
Socket(String host, int port)	传入主机名称包括ip地址和端口号
Socket(InetAddress address, int port)	传入地址对象和端口号

一.二.一.二演示构造方法

@Test
    public void conTest() throws Exception{

        //第一种， 传入主机名和端口号。 注意，这个端口号是服务器的那个监听端口
        Socket socket=new Socket("localhost",9999);

        //第二种,传入地址对象

        InetAddress inetAddress=InetAddress.getByName("localhost");

        Socket socket1=new Socket(inetAddress,9999);

    }

一.二.二其他方法

方法	作用
void close()	关闭套接字
InputStream getInputStream()	获取输入流
OutputStream getOutputStream()	获取输出流

一.三演示服务器和客户端

一.三.一服务器端

@Test
    public void serverTest() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();

        System.out.println("端口:"+serverSocket.getLocalPort());

        System.out.println("连接一个客户端程序");

    }

一.三.二客户端

@Test
    public void clientTest() throws Exception{
        System.out.println("启动客户端");
        Socket socket=new Socket("localhost",9999);
    }

一.三.三测试运行

先运行服务器端，查看控制台输出，

TCP通信(四)

线程一直在阻塞。

再运行客户端

TCP通信(四)

这个时候，再去查询一下服务器端的控制台

TCP通信(四)

会往下运行，接收到客户端的对象信息。

二. 演示各种 TCP 通信

TCP 通信的情况，与 UDP 通信的情况，基本是一样的。

二.一演示单条字符串

二.一.一客户端

@Test
    public void client2Test() throws Exception{
        System.out.println("启动客户端,发送单条数据");
        Socket socket=new Socket("localhost",9999);
        //发送数据
        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();

        //写入单条数据
       outputStream.write("两个蝴蝶飞，你好啊".getBytes());

       outputStream.close();

       socket.close();
    }

二.一.二服务器端

@Test
    public void server2Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();

        System.out.println("连接一个客户端程序");

        //得到输入流
        InputStream inputStream=client.getInputStream();

        byte[]  bytes=new byte[1024];

        //读取内容，放置到 bytes字节数组里面
        int len=inputStream.read(bytes);

        System.out.println("获取客户端传递过来的内容:"+new String(bytes,0,len));

    }

二.一.三运行程序

先启动服务器，再启动客户端

TCP通信(四)

二.二发送多条不同类型的数据

二.二.一客户端

@Test
    public void client3Test() throws Exception{
        System.out.println("启动客户端，发送多条不同类型的数据");
        Socket socket=new Socket("localhost",9999);
        //发送数据
        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();

        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);

        //发送字符串
        dataOutputStream.writeUTF("两个蝴蝶飞");
        //发送int 类型
        dataOutputStream.writeInt(24);
        //发送字符串
        dataOutputStream.writeUTF("一个快乐的程序员");

        dataOutputStream.flush();

        socket.close();
    }

二.二.二服务器端

@Test
    public void server3Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();

        System.out.println("连接一个客户端程序，接收多条数据");

        InputStream inputStream=client.getInputStream();

        DataInputStream dataInputStream=new DataInputStream(inputStream);

        //接收字符串
        String name=dataInputStream.readUTF();

        //接收 int 类型
        int age= dataInputStream.readInt();

        //接收 字符串 
        String desc=dataInputStream.readUTF();

        System.out.printf("姓名是:%s,年龄是:%d,描述是:%s",name,age,desc);

    }

二.二.三运行程序

TCP通信(四)

二.三发送对象数据

二.三.一客户端

@Test
    public void client3ObjectTest() throws Exception{
        System.out.println("启动客户端，发送多条对象数据");
        Socket socket=new Socket("localhost",9999);
        //发送数据
        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();

        ObjectOutputStream objectOutputStream=new ObjectOutputStream(new BufferedOutputStream(outputStream));

        //放入对象
        Person person=new Person();
        person.setId(1);
        person.setName("两个蝴蝶飞");
        person.setSex('男');
        person.setAge(24);
        person.setDesc("一个快乐的程序员");

        objectOutputStream.writeObject(person);
        //放置日期

        objectOutputStream.writeObject(new Date());

        //一定不要忘记刷新
        objectOutputStream.flush();

        socket.close();
    }

二.三.二服务器端

@Test
    public void server3ObjectTest() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();

        System.out.println("连接一个客户端程序，接收对象数据");

        InputStream inputStream=client.getInputStream();


        ObjectInputStream objectInputStream=new ObjectInputStream(new BufferedInputStream(inputStream));

        //读取数据

        Object obj1=objectInputStream.readObject();

        if(obj1 instanceof Person){

            Person person=(Person)obj1;

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

        }else{
            System.out.println("接收格式有误");
        }

        Object obj2=objectInputStream.readObject();

        if(obj2 instanceof Date){

            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

            System.out.println("日期:"+sdf.format((Date)obj2));


        }else{
            System.out.println("接收格式有误");
        }
    }

二.三.三测试运行

先启动服务器，再启动客户端

TCP通信(四)

二.四接收和响应客户端请求数据

二.四.一客户端

public static void main(String[] args) {
        try {
            client4Test();
            // 写多个 client5Test(), client6Test() 等
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void client4Test() throws Exception{
        System.out.println("启动客户端");

        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader((System.in)));

        System.out.println("请输入用户名:");
        String userName=bufferedReader.readLine();
        System.out.println("请输入密码:");
        String password=bufferedReader.readLine();



        Socket socket=new Socket("localhost",9999);
        //发送数据

        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();

        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);

        //拼接请求参数
        String query="userName="+userName+"&password="+password;
        dataOutputStream.writeUTF(query);
        dataOutputStream.flush();


        //获取内容
        DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());

        String content=dataInputStream.readUTF();
        System.out.println("接收服务器端返回的内容:"+content);

        dataInputStream.close();
        dataOutputStream.close();
        socket.close();
    }

二.四.二服务器端

@Test
    public void server4Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();
        System.out.println("连接一个客户端程序，响应数据");

        InputStream inputStream=client.getInputStream();

        DataInputStream dataInputStream=new DataInputStream(inputStream);

        String query=dataInputStream.readUTF();

        //拆分
        String[] qArr=query.split("&");


        String userName="";

        String password="";

        for(String str:qArr){

            String[] tempArr=str.split("=");

            if("userName".equals(tempArr[0])){

                userName=tempArr[1];
            }else if("password".equals(tempArr[0])){

                password=tempArr[1];
            }
        }

        String responseData="";

        System.out.printf("接收的用户名为:%s,密码为%s",userName,password);
        //返回数据
        if("两个蝴蝶飞".equals(userName)&&"1234".equals(password)){

            responseData="用户名和密码输入正确，登录成功";
        }else{
            responseData="用户名或者密码错误，登录失败";
        }

        DataOutputStream dataOutputStream=new DataOutputStream(client.getOutputStream());

        dataOutputStream.writeUTF(responseData);

        dataOutputStream.close();

        dataInputStream.close();

    }

二.四.三测试运行

先运行服务器端

TCP通信(四)

再运行客户端，输入错误的密码

TCP通信(四)

这时，查看服务器端

TCP通信(四)

再次重新测试，输入正确的用户名和密码

TCP通信(四)

发现，服务器端可以接收客户端传递过来的数据，并且可以响应数据，客户端也能够获取到响应的数据。

二.五传输文件

IOUtils 仍然与第二章节的工具类一致。

二.五.一客户端

public static void client5Test() throws Exception{
        System.out.println("启动客户端,发送文件");

        Socket socket=new Socket("localhost",9999);
        //发送数据

        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();

        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);


        String path="E:"+ File.separator+"ideaWork"+File.separator+"Java2"+File.separator+"fileSrc"
                +File.separator+"129.png";

        //将文件转换成字节
        byte[] bytes= IOUtils.fileToByteArray(path);

        //写入图片
        dataOutputStream.write(bytes);

        dataOutputStream.flush();

        DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());

        String content=dataInputStream.readUTF();
        System.out.println("接收服务器端返回的内容:"+content);

        dataInputStream.close();
        dataOutputStream.close();
        socket.close();
    }

二.五.二服务器端

@Test
    public void server5Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();
        System.out.println("连接一个客户端程序");

        InputStream inputStream=client.getInputStream();

        DataInputStream dataInputStream=new DataInputStream(inputStream);


        //图片大小为17k, 这儿接收时接收 20k
        byte[] bytes=new byte[1024*20];

        dataInputStream.read(bytes);


        //将字节转换成图片

        String path="E:"+ File.separator+"ideaWork"+File.separator+"Java2"+File.separator+"fileSrc"
                +File.separator+"129Tcp.png";

        IOUtils.byteArrayToFile(bytes,path);


        String responseData="传输文件成功";


        DataOutputStream dataOutputStream=new DataOutputStream(client.getOutputStream());

        dataOutputStream.writeUTF(responseData);

        dataOutputStream.close();

        dataInputStream.close();

    }

二.五.三测试运行

启动服务器端，再启动客户端，客户端控制台打印输出

TCP通信(四)

查看文件系统

TCP通信(四)

图片，也可以正常的显示出来，没有破坏。

二.六经典的 echo 程序

简单来说，就是响应数据 echo:客户端传递过来的数据

二.六.一单次 echo

二.六.一.一客户端

public static void client6Test() throws Exception{
        System.out.println("启动客户端");

        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader((System.in)));

        Socket socket=new Socket("localhost",9999);
        //发送数据

        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();
        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);


        String content=bufferedReader.readLine();

        //写入数据
        dataOutputStream.writeUTF(content);


        DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());

        //读取数据，并且打印
        String respnseContent=dataInputStream.readUTF();
        System.out.println(respnseContent);

        dataInputStream.close();
        dataOutputStream.close();
        socket.close();
    }

二.六.一.二服务器

@Test
    public void server6Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        //阻塞式接收
        Socket client=serverSocket.accept();
        System.out.println("连接一个客户端程序");

        InputStream inputStream=client.getInputStream();

        DataInputStream dataInputStream=new DataInputStream(inputStream);

        String content=dataInputStream.readUTF();


        String responseData="echo:"+content;


        DataOutputStream dataOutputStream=new DataOutputStream(client.getOutputStream());

        dataOutputStream.writeUTF(responseData);

        dataOutputStream.close();

        dataInputStream.close();

    }

二.六.一.三测试运行

先运行服务器端，再运行客户端

TCP通信(四)

二.六.二多次echo

用while() 进行循环接收控制台传递过来的数据。

二.六.二.一客户端

public static void client7Test() throws Exception{
        System.out.println("启动客户端,多次echo 程序");

        BufferedReader bufferedReader=new BufferedReader(new InputStreamReader((System.in)));

        Socket socket=new Socket("localhost",9999);
        //发送数据


        //客户端的输入
        OutputStream outputStream= socket.getOutputStream();
        DataOutputStream dataOutputStream=new DataOutputStream(outputStream);


        DataInputStream dataInputStream=new DataInputStream(socket.getInputStream());


        boolean isRun=true;
        while(isRun){
            //循环接收数据
            String content=bufferedReader.readLine();
            dataOutputStream.writeUTF(content);
            String respnseContent=dataInputStream.readUTF();
            System.out.println(respnseContent);

            if("bye".equalsIgnoreCase(content)||"quit".equalsIgnoreCase(content)){
                break;
            }
        }

        dataInputStream.close();
        dataOutputStream.close();
        socket.close();
    }

二.六.二.二服务器端

@Test
    public void server7Test() throws Exception{

        System.out.println("服务器启动中");

        ServerSocket serverSocket=new ServerSocket(9999);

        boolean isRun=true;

        while(isRun){

            //阻塞式接收
            Socket client=serverSocket.accept();
            System.out.println("连接一个客户端程序");

            InputStream inputStream=client.getInputStream();

            DataInputStream dataInputStream=new DataInputStream(inputStream);

            DataOutputStream dataOutputStream=new DataOutputStream(client.getOutputStream());

            boolean isBye=false;

            while(!isBye){

                String content=dataInputStream.readUTF();

                String responseData="";

                if("bye".equalsIgnoreCase(content)||"quit".equalsIgnoreCase(content)){
                    responseData="echo:欢迎下次再来";

                    isBye=true;

                }else{
                    responseData= "echo:"+content;
                }
                dataOutputStream.writeUTF(responseData);

            }

            dataOutputStream.close();

            dataInputStream.close();
        }
    }

二.六.二.三测试运行

可以开多个客户端的控制台。但 idea 默认是不能同时开启同一个程序的控制台的，需要进行设置。

老蝴蝶的类 public 名称是 SocketDemo

TCP通信(四)

先运行服务器，再运行客户端的 main()方法，打开一个控制台，再运行客户端的 main()方法，打开新的控制台

对于第一个控制台

TCP通信(四)

对于第二个控制台

TCP通信(四)

两个客户端都关闭了，此时服务器仍然是 true, 死循环，接收客户端连接的状态

TCP通信(四)

连接一个客户端，就打印输出一下。

但是，发现有一个问题，当客户端1 不关闭时，客户端2就无法响应。

客户端1

TCP通信(四)

客户端2

TCP通信(四)

需要用多线程去解决。

二.六.三多线程 echo

二.六.三.一关闭工具类

public class CloseUtils {

    public static void close(Closeable...closeables){

        for(Closeable closeable:closeables){

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

二.六.三.二客户端

public class Client {

    //发送者多线程
   static class Send implements  Runnable{

       private Socket client;
       private DataOutputStream dataOutputStream;

       private BufferedReader bufferedReader;

       //是否继续运行的标识
       private boolean isRunning;
       public Send(Socket client){

           this.client=client;

           this.isRunning=true;
           try {
               this.dataOutputStream=new DataOutputStream(client.getOutputStream());

               this.bufferedReader=new BufferedReader(new InputStreamReader(System.in));

           } catch (IOException e) {
               e.printStackTrace();
               isRunning=false;

               CloseUtils.close(client);
           }
       }
       @Override
        public void run() {
            while(this.isRunning){
                try {
                    //接收数据
                    String content=bufferedReader.readLine();
                    //发送数据
                    sendMsg(content);

                    if("bye".equalsIgnoreCase(content)||"quit".equalsIgnoreCase(content)){
                        //修改标识
                        stop();

                        CloseUtils.close(dataOutputStream);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

        public void stop(){

           this.isRunning=false;
        }
        //发送数据
        public void sendMsg(String msg){
            try {
                dataOutputStream.writeUTF(msg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //接收者
    static class Receiver implements  Runnable{

        private Socket client;

        private DataInputStream dataInputStream;

        private boolean isRunning;
        public Receiver(Socket client){

            this.client=client;
            this.isRunning=true;
            try {
                this.dataInputStream=new DataInputStream(client.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
                this.isRunning=false;
                CloseUtils.close(client);
            }
        }

        @Override
        public void run() {
            while(this.isRunning){

                String content=readMsg();

                System.out.println(content);

                if("echo:欢迎下次再来".equalsIgnoreCase(content)){
                    stop();

                }
            }
            try {
                CloseUtils.close(this.dataInputStream,client.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        public void stop(){

            this.isRunning=false;
        }
        //接收数据
        public String readMsg(){

            String content="";
            try {
                content= dataInputStream.readUTF();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return content;
        }
    }
    public static void main(String[] args) {


        try {
            Socket socket=new Socket("localhost",9999);

            System.out.println("***************连接客户端**************");

            //客户端多线程运行发送和接收
            new Thread(new Send(socket)).start();

            new Thread(new Receiver(socket)).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }



}

二.六.三.三服务器端

public class Server {

    //客户连接类
    static class Channel implements  Runnable{

        private Socket client;

        private DataInputStream dataInputStream;

        private DataOutputStream dataOutputStream;

        private volatile boolean isRunning;

        public Channel(Socket client){

            this.client=client;
            //标识位
            this.isRunning=true;

            try {
                this.dataInputStream=new DataInputStream(client.getInputStream());
                this.dataOutputStream=new DataOutputStream(client.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();

                CloseUtils.close(dataInputStream,dataOutputStream);
            }

        }

        @Override
        public void run() {

            while(this.isRunning){

                String content=readMsg();

                String responseData="";

                if("bye".equalsIgnoreCase(content)||"quit".equalsIgnoreCase(content)){
                   responseData="echo:欢迎下次再来";
                    this.isRunning=false;

                }else{
                    responseData= "echo:"+content;
                }

                sendMsg(responseData);

            }

        }

        //服务器往客户端发送数据
        public void sendMsg(String msg){
            try {
                dataOutputStream.writeUTF(msg);
            } catch (IOException e) {
               // e.printStackTrace();
                CloseUtils.close(dataInputStream,dataOutputStream);
            }
        }
        //服务器读取客户端数据
        public String readMsg(){

            String content="";
            try {
                content= dataInputStream.readUTF();
            } catch (IOException e) {
                CloseUtils.close(dataInputStream,dataOutputStream);
                //e.printStackTrace();
            }
            return content;
        }
    }
    public static void main(String[] args) {

        try {
            ServerSocket serverSocket=new ServerSocket(9999);

            System.out.println("********服务器开启************");

            while(true){
                Socket client=serverSocket.accept();//多线程运行

                System.out.println("连接一个客户端");

                new Thread(new Channel(client)).start();

            }

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

二.六.三.四测试运行

先运行服务器端，再运行创建客户端1，再运行创建客户端2
客户端1：

TCP通信(四)

现在客户端1 还没有断开链接

看一下客户端2，发送数据

TCP通信(四)

是可以进行传递数据的。

要理解多线程 echo 的应用，聊天室时会用得到。

谢谢您的观看，如果喜欢，请关注我，再次感谢 !!!

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

TCP通信(四)

TCP通信(四)

一. TCP 通信所用到的类

一.一 ServerSocket 服务器类

一.一.一 构造方法

一.一.一.一 方法

一.一.一.二 演示构造方法

一.一.二 其他方法

一.二 Socket 客户端类

一.二.一 构造方法

一.二.一.一 方法

一.二.一.二 演示构造方法

一.二.二 其他方法

一.三 演示服务器和客户端

一.三.一 服务器端

一.三.二 客户端

一.三.三 测试运行

二. 演示各种 TCP 通信

二.一 演示单条字符串

二.一.一 客户端

二.一.二 服务器端

二.一.三 运行程序

二.二 发送多条不同类型的数据

二.二.一 客户端

二.二.二 服务器端

二.二.三 运行程序

二.三 发送对象数据

二.三.一 客户端

二.三.二 服务器端

二.三.三 测试运行

二.四 接收和响应客户端请求数据

二.四.一 客户端

二.四.二 服务器端

二.四.三 测试运行

二.五 传输文件

二.五.一 客户端

二.五.二 服务器端

二.五.三 测试运行

二.六 经典的 echo 程序

二.六.一 单次 echo

二.六.一.一 客户端

二.六.一.二 服务器

二.六.一.三 测试运行

二.六.二 多次echo

二.六.二.一 客户端

二.六.二.二 服务器端

二.六.二.三 测试运行

二.六.三 多线程 echo

二.六.三.一 关闭工具类

二.六.三.二 客户端

二.六.三.三 服务器端

二.六.三.四 测试运行

相关文章

Nginx第二天学习笔记-Nginx的负载均衡

TCP/IP与HTTP协议：概念、关系与工作原理

Python3 网络编程详解

深入探讨线程通信的机制与实现方式

QModbus例程分析

网络基础（1.0）

C语言的网络编程

嵌入式软件工程师面试题（五）

JavaEE: 深入探索TCP网络编程的奇妙世界(六)

JavaEE: 深入探索TCP网络编程的奇妙世界(五)

作者介绍

最新文章

QModbus例程分析

远程访问以及控制（2/2）+实验：TCP Wrappers的控制策略

TCP/IP协议、UDP协议介绍

深刻理解VLAN

Linux进程间通信_管道

calico IPIP 同节点通信

热门文章

ensp ：使用静态协议实现两台pc之间的通信

Linux进程间通信

一.一.一构造方法

一.一.一.一方法

一.一.一.二演示构造方法

一.一.二其他方法

一.二.一构造方法

一.二.一.一方法

一.二.一.二演示构造方法

一.二.二其他方法

一.三演示服务器和客户端

一.三.一服务器端

一.三.二客户端

一.三.三测试运行

二.一演示单条字符串

二.一.一客户端

二.一.二服务器端

二.一.三运行程序

二.二发送多条不同类型的数据

二.二.一客户端

二.二.二服务器端

二.二.三运行程序

二.三发送对象数据

二.三.一客户端

二.三.二服务器端

二.三.三测试运行

二.四接收和响应客户端请求数据

二.四.一客户端

二.四.二服务器端

二.四.三测试运行

二.五传输文件

二.五.一客户端

二.五.二服务器端

二.五.三测试运行

二.六经典的 echo 程序

二.六.一单次 echo

二.六.一.一客户端

二.六.一.二服务器

二.六.一.三测试运行

二.六.二多次echo

二.六.二.一客户端

二.六.二.二服务器端

二.六.二.三测试运行

二.六.三多线程 echo

二.六.三.一关闭工具类

二.六.三.二客户端

二.六.三.三服务器端

二.六.三.四测试运行