socket网络编程实战（java）

一些关于java socket通信编程的实例解释

1.需求：客户端实现步骤：

  • 创建客户端的socket对象，请求与服务端的连接。

  • 使用socket对象调用getOutputStream（）方法得到字节输出流

  • 使用字节输出流完成数据的发送

  • 释放资源：关闭socket管道

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1" , 7777);

            OutputStream os = socket.getOutputStream();

            PrintStream ps = new PrintStream(os);

            ps.print("I'm TCP client , have your time?");

            ps.flush();

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

    }

}

2.需求：客户端接收消息

1.注册端口

2.连接socket通信管道，用端口接受信息

3.使用缓冲字符输入流接收消息

实例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

public class ClientDemo1 {
    public static void main(String[] args) {
        try {

            //创建socket管道
            Socket socket = new Socket("192.168.57.1" , 7777);
            //从管道中得到一个字节输出流，负责发送数据
            OutputStream os = socket.getOutputStream();
            //低级字节流 ---- 》 打印流
            PrintStream ps = new PrintStream(os);
            //发送消息
            ps.println("I'm TCP client , have your time?");

            ps.flush();



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


    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo2 {
    public static void main(String[] args) {
        try {

            System.out.println("server start!");

            //注册端口
            ServerSocket serverSocket = new ServerSocket(7777);

            //建立socket通信管道，调用accept接受信息

            Socket socket = serverSocket.accept();

            InputStream is = socket.getInputStream();

            // 缓冲字符输入流

            BufferedReader br = new BufferedReader(new InputStreamReader(is));

            String msg;

            if((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "is saying:" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

3.需求：使用TCP通信方式实现：多发多收

具体要求：

可以使用死循环服务端手腕消息继续wait next message client can use 死循环 等待用户不断输入信息 客户端一旦输入exit关闭客户端程序，并且释放资源

4.服务端实现同时处理多个客户端请求

模型:

img

  • 主线程定义循环负责接收客户端Socket管道连接

  • 每接受到一个Socket通信管道就分配一个独立的线程负责处理

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ServerDemo2 {
    public static void main(String[] args) {
        /**
         * 单线程只能与一个客户端进行通信
         */
        try {
            System.out.println("server start!");
            //注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                //Create a socket communication pipe and call accept to receive messages
                //For each client pipeline received, a single thread is handed over to process the message
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress() + "上线了");
                //开启独立线程
                new ServerReaderThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

客户端：

实现多发多收：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            //创建socket管道
            Socket socket = new Socket("127.0.0.1" , 7777);
            //从管道中得到一个字节输出流，负责发送数据
            //A byte output stream from the pipeline, responsible for sending data
            OutputStream os = socket.getOutputStream();
            //低级字节流 ---- 》 打印流
            PrintStream ps = new PrintStream(os);
            Scanner sc = new Scanner(System.in);
            //output the message!
            while(true) {
                System.out.println(" Please say :");
                String msg = sc.nextLine();

                ps.println(msg);

                ps.flush();//refresh
            }
          // ps.println("I'm TCP client , have your time?");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

线程类：

实现多个客户端发送消息的处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            // 缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "is saying:" + msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+ "下线了！ ");
        }
    }
}

4.线程池优化方案

实际开发中针对于客户端与服务端之间的通不可能为每一个客户端与服务端开一个进程，所以对小型应用平台开发会用线程池进行通信技术的优化。

客户端代码保持不变，主要在服务端上面进行优化

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ServerDemo2 {
    //static --> 线程池
    public static ExecutorService POOL = new ThreadPoolExecutor(3 , 5 , 6 , TimeUnit.SECONDS ,
            new ArrayBlockingQueue<>(2) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy());
    public static void main(String[] args) {
        /**
         * 单线程只能与一个客户端进行通信
         */
        try {
            System.out.println("server start!");
            //注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                //Create a socket communication pipe and call accept to receive messages
                //For each client pipeline received, a single thread is handed over to process the message
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress() + "上线了");
                //开启独立线程
                Runnable target = new ServerReaderRunnable(socket);
                POOL.execute(target);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Runnable任务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ServerReaderRunnable implements Runnable{
     private Socket socket;
     public ServerReaderRunnable(Socket socket)
     { //有参构造器
         this.socket = socket;
     }
    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            // 缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));

            String msg;

            while((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "is saying:" + msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+ "下线了！ ");
        }
    }
}

通信实战案例–即时通信（学习历程）

在上面实例中添加客户端接受转发消息功能。

需求：

1.客户端添加独立线程实现接受转发消息

2.服务端对收到的消息进行转发

关键点：定义管道socket队列list，每有一个客户端就加入一个socket进入list，在服务端进行转发的过程中将消息转发给每个客户端。

Client客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            //创建socket管道
            Socket socket = new Socket("127.0.0.1" , 7777);

            //创建一个独立的才能成负责接受来自服务端的转发消息
            new ClientReaderThread(socket).start();
            //从管道中得到一个字节输出流，负责发送数据
            //A byte output stream from the pipeline, responsible for sending data
            OutputStream os = socket.getOutputStream();
            //低级字节流 ---- 》 打印流
            PrintStream ps = new PrintStream(os);
            Scanner sc = new Scanner(System.in);
            //output the message!
            while(true) {
                System.out.println(" Please say :");
                String msg = sc.nextLine();
                ps.println(msg);
                ps.flush();//refresh
            }
          // ps.println("I'm TCP client , have your time?");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ClientReaderThread extends Thread{
             private Socket socket;

             public ClientReaderThread(Socket socket){
                        this.socket = socket;
              }

               @Override
              public void run() {
                    try {
                      InputStream is = socket.getInputStream();

                       // 缓冲字符输入流

                      BufferedReader br = new BufferedReader(new InputStreamReader(is));

                      String msg;

                      while((msg = br.readLine()) != null){
                          System.out.println("收到消息:" + msg);
               }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+ "服务端踢走！");
        }
    }
}

server端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class ServerDemo2 {
    //定义一个管道存放socket管道
    public static List<Socket> allonLineSocket = new ArrayList<>();
    public static void main(String[] args) {
        /**
         * 单线程只能与一个客户端进行通信
         */
        try {
            System.out.println("server start!");
            //注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                //Create a socket communication pipe and call accept to receive messages
                //For each client pipeline received, a single thread is handed over to process the message
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress() + "上线了");
                allonLineSocket.add(socket);//上线完成
                //开启独立线程
                new ServerReaderThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderThread extends Thread{

    private Socket socket;

    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            // 缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "is saying:" + msg);
                sendMsgtoAll(msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress()+ "下线了！ ");
            ServerDemo2.allonLineSocket.remove(socket);
        }
    }
    private void sendMsgtoAll(String msg) throws IOException {
        for(Socket socket : ServerDemo2.allonLineSocket) {
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println(msg);
            ps.flush();
        }
    }
}

Tip:

即时通信的含义

  • 即时通信是指一个客户端的消息发出，其他客户端也可以收到

  • 即时通信需要进行端口转发的设计思想

  • 服务端需要把在线的socket管道存储起来

  • 一旦受到消息就要推送给其他管道

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徐嘉文<br><br>大三学生<br>专注之后，始能忘忧...