java基於socket的網絡通訊，實現一個服務端多個客戶端的羣聊，傳輸文件功能，界面使用Swing

時間 2020-08-08

標籤 java 基於 socket 網絡通訊實現一個服務多個客戶端的傳輸文件功能界面使用 swing 欄目 Java 简体版

原文原文鏈接

最近在複習java的io流及網絡編程。但複習寫那些樣板程序老是乏味的。便準備寫個項目來鞏固。想來想去仍是聊天項目比較好玩。若是往後完成的比較好本身也能夠用（哈哈哈）。而且本身後面也要繼續鞏固java多線程和集合（這兩部分學的不好）。html

我給這個項目命名爲很大衆的名字——" chat "java

這算是"chat 1.0" 吧目前只實現了羣聊+文件傳輸功能，沒有用戶註冊模塊。編程

由於本身在阿里雲上的服務器以前到期沒有續費，因此就沒法將服務端實現兩個局域網之間的信息傳輸。只能在本身電腦上開多個客戶端本身和本身聊天。服務器

不是很甘心，上網找到了一個比較好的方法，內網穿透。某神，某花，都是免費能夠映射一兩個公網ip的。這樣就能夠實現不一樣局域網之間的通訊了網絡

效果演示：多線程

打開圖形界面不會馬上執行，會有啓動服務器，鏈接服務器按鈕。圖中2暱稱僅支持本地本身的界面顯示來分辨是本身發的消息（哈哈哈）併發

點擊發送文件按鈕，會顯示文件對話框，來選擇要發送的本地文件。app

發送完畢後其它客戶端會收到文件消息，並詢問是否接收文件。less

接收時也會彈出文件對話框，並選擇存儲的路徑和文件名稱eclipse

字很少打，上代碼。（主要使用tcp通訊）

服務端：

Server類實現一直監聽客戶端的套接字鏈接，並開啓服務端讀寫線程

 1 import java.io.IOException;
 2 import java.net.ServerSocket;
 3 import java.net.Socket;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 import view.ServerStart_View;
 8 
 9 public class Server implements Runnable{
10 
11     public static ArrayList<Socket> socketList = new ArrayList<>();    //存儲鏈接的Socket對象
12     private static int num = 0;
13     static ServerStart_View gui;    //定義爲靜態的
14 //    public static final Server server = new Server();
15     
16     public void get(ServerStart_View gui) {
17         this.gui=gui;
18     }
19     
20     public void run() {
21         ServerSocket socket=null;
22         Socket socket2 = null;
23         try {
24             socket = new ServerSocket(12345);
25         } catch (IOException e) {
26             e.printStackTrace();
27         }
28 
29         while(true) {
30 //            System.out.println("didi");
31             //無限監聽客戶端鏈接，併爲此開啓讀寫線程。
32             try {
33                 Thread.sleep(1);
34                 socket2=socket.accept();
35                 socketList.add(socket2);
36                 ++num;
37             } catch (IOException e) {
38                 e.printStackTrace();
39             } catch (InterruptedException e1) {
40                 e1.printStackTrace();
41             }
42             gui.setText("第"+num+"個客戶端已經鏈接");
43             try {
44                 //開啓消息讀入轉發線程。
45                 Server_IO io = new Server_IO(socket2,gui);
46                 Thread thread  = new Thread(io);
47                 thread.start();
48             } catch (IOException e) {
49                 e.printStackTrace();
50             }
51         }
52     }
53 }

Server_IO類是實現服務端的讀寫功能，讀取客戶端傳來的字節並轉發給其它客戶端

 1 import java.io.DataInputStream;
 2 import java.io.DataOutputStream;
 3 import java.io.IOException;
 4 import java.net.Socket;
 5 
 6 import view.ServerStart_View;
 7 
 8 public class Server_IO implements Runnable {
 9     private DataInputStream stream = null;
10     private Socket socket = null;
11     private static ServerStart_View start_View;
12     
13     public Server_IO(Socket socket,ServerStart_View start_View) throws IOException {
14         this.start_View = start_View;
15         this.socket = socket;
16         stream = new DataInputStream(socket.getInputStream());
17     }
18     
19     @Override
20     public void run() {
21         String rece = null;
22 //        boolean judg = true;
23         while(true) {
24             try {
25                 Thread.sleep(1);
26                 if (stream.available()!=0) {
27                     try {
28                         rece = stream.readUTF();
29                         start_View.setText(rece);
30                     } catch (IOException e) {
31                         e.printStackTrace();
32 //                        judg=false;
33                     }
34                     for (Socket Ssocket:Server.socketList) 
35                         new DataOutputStream(Ssocket.getOutputStream()).writeUTF(rece);
36                     
37 //                    System.out.println(rece);
38                 }
39             } catch (IOException e) {
40                 e.printStackTrace();
41             } catch (InterruptedException e1) {
42                 // TODO Auto-generated catch block
43                 e1.printStackTrace();
44             }
45         }
46     }
47 }

服務端文件傳輸：

服務端消息和文件傳輸是分開的，兩個不一樣的端口。但原理同樣，都是服務端不斷監聽客戶端發來的鏈接請求。而後三次握手創建鏈接通訊，開啓輸入流，輸出流。

File類和Server類功能大體相同，只不過是用於接收轉發文件信息

 1 import java.io.IOException;
 2 import java.net.ServerSocket;
 3 import java.net.Socket;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 public class File implements Runnable{
 8     
 9     public static ArrayList<Socket> socketList_IO = new ArrayList<>();
10     ServerSocket ssocket;
11     Socket socket;
12 
13     public void run() {
14         //文件傳輸開啓另外一個端口監聽。
15         try {
16             ssocket = new ServerSocket(12306);
17         } catch (IOException e) {
18             e.printStackTrace();
19         }
20         while(true) {
21             try {
22                 Thread.sleep(1);
23                 socket = ssocket.accept();
24                 socketList_IO.add(socket);
25             } catch (IOException e) {
26                 e.printStackTrace();
27             } catch (InterruptedException e1) {
28                 e1.printStackTrace();
29             }
30             File_IO file_IO;
31             try {
32                 file_IO = new File_IO(socket);
33                 Thread thread = new Thread(file_IO);
34                 thread.start();
35             } catch (IOException e) {
36                 e.printStackTrace();
37             }
38             
39         }
40     }
41 
42 }

File_IO類接收客戶端的文件，並轉發給其餘客戶端

 1 import java.io.DataInputStream;
 2 import java.io.DataOutputStream;
 3 import java.io.IOException;
 4 import java.net.Socket;
 5 
 6 public class File_IO implements Runnable {
 7     DataInputStream input;
 8     DataOutputStream output;
 9     Socket socket;
10 
11     public File_IO(Socket socket) throws IOException{
12         this.socket = socket;
13         System.out.println(socket.getInetAddress());
14     }
15 
16     @Override
17     public void run() {
18         byte[] read = new byte[1024];
19         String name;
20         try {
21             input = new DataInputStream(socket.getInputStream());
22         } catch (IOException e1) {
23             e1.printStackTrace();
24         }
25         while(true) {
26             try {
27                 Thread.sleep(1);
28                 if(input.available()!=0) {
29                     name=input.readUTF();
30                     System.out.println(name);
31                     int len=0;
32                     while((len=input.read(read,0,read.length))>0) {
33                         for(Socket soc:File.socketList_IO) {
34                             if(soc != socket)
35                             { 
36                                 output = new DataOutputStream(soc.getOutputStream());
37                                 output.writeUTF(name);
38                                 output.write(read,0,len);
39                                 output.flush();
40 //                                System.out.println("開始向客戶機轉發");
41                             }
42                         }
43 //                        System.out.println("執行");
44 //                        System.out.println(len);
45                     }
46                 }
47             } catch (IOException e) {
48                 e.printStackTrace();
49             } catch (InterruptedException e) {
50                 e.printStackTrace();
51             }
52         }
53     }
54 }

Swing圖形界面。服務端若是是放在Linux系統的服務器中是不須要圖形界面的。但我這主要在本身電腦上運行因此作個簡單的可視化界面比較好。

客戶端仍是服務端的圖形界面我都是藉助於eclipse的windowbuilder插件進行繪製的，因此圖形界面類我貼上主要的方法及按鈕的事件監聽代碼部分。

服務端的界面

public class ServerStart_View extends JFrame {

    private JPanel contentPane;
    private JScrollPane scrollPane;
    private JTextArea textArea;
    private static Server server = new Server();  //定義爲靜態的
    private static File file = new File();  
    private final Action action = new SwingAction();
    private JButton btnNewButton;
    
//打印收到的消息在服務端的文本域中
    public void setText(String string) {
        textArea.append("\n"+">>: "+string);
    }

   //
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                ServerStart_View frame = new ServerStart_View();
                frame.setVisible(true);
                server.get(frame);   //傳遞對象變量
            }
        });
    }

............
............
............

//啓動服務按鈕的事件處理。
    private class SwingAction extends AbstractAction {
        public SwingAction() {
            putValue(NAME, "啓動服務");
            putValue(SHORT_DESCRIPTION, "Some short description");
        }
        public void actionPerformed(ActionEvent e) {
            //開啓服務端監聽客戶端鏈接線程（消息服務）
            Thread thread = new Thread(server);
            thread.start();
           //同上 （文件服務）
            Thread thread2 = new Thread(file);
            thread2.start();
        }
    }

}

服務端代碼到此結束。主要是消息和文件分別各監聽一個端口的等待鏈接。

客戶端：

原本是定義Client類的但由於某些前期緣由致使客戶端的類名不是很規範。

chat_Client類

 1 package client;
 2 
 3 import view.ClientStart_View;
 4 import java.io.DataOutputStream;
 5 import java.io.IOException;
 6 import java.net.Socket;
 7 import java.net.UnknownHostException;
 8 
 9 public class chat_Client{
10     public chat_Client() {
11     }
12 
13     private Socket socket = null;
14     //    private int Port = 0;
15     private static ClientStart_View jframe;  //定義爲靜態的
16 
17     public void text(ClientStart_View jframe) {
18         this.jframe = jframe;
19     }
20 
21     //「鏈接服務器」 button 按鈕點擊事件，調用此方法
22     public void con(int port) throws UnknownHostException, IOException {
23         try {
24             socket = new Socket("127.0.0.1", port);
25 //            System.out.println("客戶端------------------------");
26 //            System.out.println("鏈接到的地址"+socket.getInetAddress()+":"+socket.getLocalPort());  //打印在控制檯
27             jframe.TextA("已鏈接");
28         } catch (IOException e1) {
29             e1.printStackTrace();
30         }
31 
32         Runnable runnable = new chat_Client_I(socket,jframe);  //啓動消息讀寫線程，並將傳遞socket，jframe對象變量
33         Thread thread = new Thread(runnable);
34         thread.start();
35     }
36 
37     //send()方法，發送消息給服務器。 「發送」button 按鈕點擊事件，調用此方法
38     public void send(String send) throws IOException {
39         DataOutputStream stream = new DataOutputStream(socket.getOutputStream());
40         stream.writeUTF(send);
41     }
42 
43 }

chat_Client_I類客戶端的消息字符讀取類。讀取服務端發來的消息字符並打印在界面的文本域中

 1 import view.ClientStart_View;
 2 
 3 import java.io.DataInputStream;
 4 import java.io.IOException;
 5 import java.net.Socket;
 6 
 7 public class chat_Client_I implements Runnable{
 8     private String rece = null;
 9     private static DataInputStream stream;
10     private ClientStart_View jframe;
11 
12     public chat_Client_I(Socket socket,ClientStart_View jframe) {
13         this.jframe = jframe;
14         try {
15             stream = new DataInputStream(socket.getInputStream());
16         } catch (IOException e2) {
17             e2.printStackTrace();
18         }
19     }
20 
21     @Override
22     public void run() {
23         while(true) {
24             try {
25                 //if條件判斷是否有可獲取的字節 ，若是不是判斷而一直讀取的話，在結束時會有讀取異常拋出。運行時是沒有的。
26                 if(stream.available()!=0) {
27                     rece = stream.readUTF();
28                     jframe.TextA(rece);    //調用 ClientStart_View.java類中方法將讀入的字符串打印在文本域中
29                 }
30             } catch (IOException e) {
31                 // TODO Auto-generated catch block
32                 e.printStackTrace();
33             }
34         }
35     }
36 }

客戶端的文件模塊寫的有點亂。客戶端文件模塊要實現發送和接收保存

發送要從計算機本地經過輸入流讀取文件，並經過輸出流發送給服務端。

接收要從服務端經過輸入流進行讀入，而後經過輸出流寫入本地保存。

File_start類，鏈接服務端，並開啓輸入流讀取服務端發來的文件

 1 import java.io.IOException;
 2 import java.net.Socket;
 3 import java.net.UnknownHostException;
 4 
 5 public class File_start implements Runnable{
 6     Socket socket=null;
 7 
 8     @Override
 9     public void run() {
10         try {
11             socket = new Socket("127.0.0.1", 12306);
12 //            System.out.println("已鏈接");
13 //            System.out.println(socket.getInetAddress()+":"+socket.getLocalPort());
14         } catch (UnknownHostException e) {
15             // TODO Auto-generated catch block
16             e.printStackTrace();
17         } catch (IOException e) {
18             e.printStackTrace();
19         }
20 
21         File_I file_i;
22         try {
23             File_O file_O = new File_O(socket);
24             //開啓從服務器的輸入流線程
25             file_i = new File_I(socket);
26             Thread thread = new Thread(file_i);
27             thread.start();
28         } catch (IOException e) {
29             e.printStackTrace();
30         }
31 
32     }
33 }

File_O類，讀取本地文件併發送到服務端

 1 import java.io.DataInputStream;
 2 import java.io.DataOutputStream;
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.net.Socket;
 6 
 7 public class File_O{
 8     public static File_O file_O = new File_O();
 9     //    private Socket socket=null;
10     private byte[] readAllBytes = new byte[1024];
11     private static DataOutputStream outputstream;
12     private DataInputStream inputstream;
13 
14     public File_O() {}
15     public File_O(Socket socket) throws IOException {
16 //        this.socket = socket;
17         outputstream = new DataOutputStream(socket.getOutputStream());
18     }
19 
20     //讀取本地文件，併發送到服務端。面板中發送文件按鈕在事件處理時會調用此函數
21     public void read(String url,String name) throws IOException {
22         outputstream.writeUTF(name);
23         inputstream = new DataInputStream(new FileInputStream(url));
24         int len=0;
25         while((len=inputstream.read(readAllBytes))>0) {
26             outputstream.write(readAllBytes, 0, len);
27             outputstream.flush();
28         }
29         //outputstream.close();
30 //        System.out.println("發送完成");
31     }
32 
33     //此方法暫時沒有用到
34     public byte[] getread() {
35         return readAllBytes;
36     }
37 }

File_I類從服務端的輸出流讀取文件，並保存到本地。

 1 import view.ClientStart_View;
 2 
 3 import java.awt.HeadlessException;
 4 import java.io.DataInputStream;
 5 import java.io.DataOutputStream;
 6 import java.io.File;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 import java.net.Socket;
10 
11 import javax.swing.JOptionPane;
12 
13 public class File_I implements Runnable{
14 
15     //    public static File_I file_I = new File_I();
16     private static ClientStart_View jframe;
17     private DataOutputStream output;
18     private static DataInputStream input;
19     private Socket socket;
20 
21     public File_I() {}
22     public File_I(Socket socket) throws IOException {
23         this.socket = socket;
24         input = new DataInputStream(socket.getInputStream());
25     }
26 
27     public void getfile(ClientStart_View jframe) {
28         this.jframe = jframe;
29     }
30 
31     @Override
32     public void run() {
33         String url = null;
34         String name = null;
35         byte[] rece = new byte[1024];
36         while(true) {
37             try {
38                 //if判斷服務端輸出流中是否有可讀取字節
39                 if (input.available()!=0) {
40                     name = input.readUTF();
41                     //                System.out.println(name);
42 
43                     //是否接受此文件，接收纔會進行輸入流讀入保存
44                     JOptionPane jOptionPane = new JOptionPane();
45                     int result=jOptionPane.showConfirmDialog(null, "是否接收該文件", "嘀嘀：一份文件消息", jOptionPane.YES_NO_OPTION);
46                     //                System.out.println(result);
47                     if (result == jOptionPane.YES_OPTION) {
48                         //默認存儲路徑及從服務端獲取的文件名稱
49                         File file = new File("D:\\", name);
50                         //                    file_I.jframe.getJF().setCurrentDirectory(new File("D:\\"));
51                         jframe.getJF().setSelectedFile(file);
52                         jframe.getJF().showSaveDialog(null);
53                         url = jframe.getJF().getSelectedFile().getPath();
54                         //                    name =file_I.jframe.getJF().getSelectedFile().getName();
55 
56                         int len;
57                         try {
58                             while((len=input.read(rece,0,rece.length))!=-1) {
59 //                                System.out.println("zhixing-1");
60                                 output = new DataOutputStream(new FileOutputStream(url));
61                                 output.write(rece, 0, len);
62                                 output.flush();
63                             }
64                         } catch (IOException e) {
65                             e.printStackTrace();
66                         }
67                     }
68                 }
69             } catch (HeadlessException | IOException e) {
70                 e.printStackTrace();
71             }
72         }
73     }
74 }

客戶端的圖形界面也是使用插件，因此只貼上主要的代碼段

public class ClientStart_View extends JFrame {

    public JPanel contentPane;
    private JTextField textField;
    JTextArea textArea;
    private static client.chat_Client chat_Client=new chat_Client();
    private static File_I file_I = new File_I();
    private JFileChooser fileChooser =new JFileChooser();
    private final Action action = new SwingAction();
    private final Action action_2 = new SwingAction_2();
    private JTextField textField_1;
    private final Action action_3 = new SwingAction_3();
//JFileChooser 用於建立文件對話框
    public JFileChooser getJF() {
        return fileChooser;
    }
    
   //此方法將接收到服務端的消息打印文本域中
    public void TextA(String rece) {
        textArea.append("\n"+textField_1.getText()+" > "+rece);
        System.out.println(rece);
    }

public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ClientStart_View frame = new ClientStart_View();
                    frame.setVisible(true);
                    chat_Client.text(frame);
//                    chat_Client.get().text(frame);
                    file_I.getfile(frame);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

.........
.........
.........
.........

//事件處理，鏈接服務端，並開啓客戶端的文件讀取線程
 private class SwingAction extends AbstractAction {
        public SwingAction() {
            putValue(NAME, "鏈接服務器");
            putValue(SHORT_DESCRIPTION, "Some short description");
        }
        public void actionPerformed(ActionEvent e) {
            try {
                //chat_Client.get().con(12345);  //QQ
                chat_Client.con(12345);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            File_start file_start = new File_start();
            Thread thread = new Thread(file_start);
            thread.start();

        }
    }

//發送按鈕的事件處理，從輸入文本中讀取輸入的字符，發送至服務端
    private class SwingAction_2 extends AbstractAction {
        public SwingAction_2() {
            putValue(NAME, "發送");
            putValue(SHORT_DESCRIPTION, "Some short description");
        }
        public void actionPerformed(ActionEvent e) {
            String text = null;
            text = textField.getText();
            if(text.length()!=0) {
                try {
//                chat_Client.get().send(text);
                    chat_Client.send(text);
                } catch (IOException e1) {
                    e1.printStackTrace();
                }}
            textField.setText(null);   //輸入文本框置空
        }
    }

//發送文件按鈕事件處理，從本地讀取文件信息，發送至服務端
    private class SwingAction_3 extends AbstractAction {
        public SwingAction_3() {
            putValue(NAME, "發送文件/圖片");
            putValue(SHORT_DESCRIPTION, "Some short description");
        }
        public void actionPerformed(ActionEvent e) {
            String name=null;    String paths=null;
//            fileChooser = new JFileChooser();
            fileChooser.setCurrentDirectory(new java.io.File("E:\\"));
            int result=fileChooser.showOpenDialog(null);
            if (result == fileChooser.APPROVE_OPTION) {
                paths = fileChooser.getSelectedFile().getPath();  //返回所選文件的路徑
                name= fileChooser.getSelectedFile().getName(); //返回所選文件的名稱
//                System.out.println(name); System.out.println(paths);
                try {
                    File_O.file_O.read(paths,name);
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        }
    }