java基于socket的网络通信，实现一个服务端多个客户端的群聊，传输文件功能，界面使用Swing

最近在复习java的io流及网络编程。但复习写那些样板程序总是乏味的。便准备写个项目来巩固。想来想去还是聊天项目比较好玩。如果日后完成的比较好自己也可以用（哈哈哈）。并且自己后面也要继续巩固java多线程和集合（这两部分学的很差）。

我给这个项目命名为很大众的名字——" chat "

这算是"chat 1.0" 吧目前只实现了群聊+文件传输功能，没有用户注册模块。

因为自己在阿里云上的服务器之前到期没有续费，所以就无法将服务端实现两个局域网之间的信息传输。只能在自己电脑上开多个客户端自己和自己聊天。

不是很甘心，上网找到了一个比较好的方法，内网穿透。某神，某花，都是免费可以映射一两个公网ip的。这样就可以实现不同局域网之间的通信了

 

效果演示：

打开图形界面不会立刻执行，会有启动服务器，连接服务器按钮。图中2昵称仅支持本地自己的界面显示来分辨是自己发的消息（哈哈哈）

 

 

点击发送文件按钮，会显示文件对话框，来选择要发送的本地文件。

 

 

发送完毕后其它客户端会收到文件消息，并询问是否接收文件。

 

接收时也会弹出文件对话框，并选择存储的路径和文件名称

 

字不多打，上代码。（主要使用tcp通信）

服务端：

Server类实现一直监听客户端的套接字连接，并开启服务端读写线程

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import view.ServerStart_View;

public class Server implements Runnable{

    public static ArrayList<Socket> socketList = new ArrayList<>();    //存储连接的Socket对象
    private static int num = 0;
    static ServerStart_View gui;    //定义为静态的
//    public static final Server server = new Server();
    
    public void get(ServerStart_View gui) {
        this.gui=gui;
    }
    
    public void run() {
        ServerSocket socket=null;
        Socket socket2 = null;
        try {
            socket = new ServerSocket(12345);
        } catch (IOException e) {
            e.printStackTrace();
        }

        while(true) {
//            System.out.println("didi");
            //无限监听客户端连接，并为此开启读写线程。
            try {
                Thread.sleep(1);
                socket2=socket.accept();
                socketList.add(socket2);
                ++num;
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            gui.setText("第"+num+"个客户端已经连接");
            try {
                //开启消息读入转发线程。
                Server_IO io = new Server_IO(socket2,gui);
                Thread thread  = new Thread(io);
                thread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

Server_IO类是实现服务端的读写功能，读取客户端传来的字节并转发给其它客户端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import view.ServerStart_View;

public class Server_IO implements Runnable {
    private DataInputStream stream = null;
    private Socket socket = null;
    private static ServerStart_View start_View;
    
    public Server_IO(Socket socket,ServerStart_View start_View) throws IOException {
        this.start_View = start_View;
        this.socket = socket;
        stream = new DataInputStream(socket.getInputStream());
    }
    
    @Override
    public void run() {
        String rece = null;
//        boolean judg = true;
        while(true) {
            try {
                Thread.sleep(1);
                if (stream.available()!=0) {
                    try {
                        rece = stream.readUTF();
                        start_View.setText(rece);
                    } catch (IOException e) {
                        e.printStackTrace();
//                        judg=false;
                    }
                    for (Socket Ssocket:Server.socketList) 
                        new DataOutputStream(Ssocket.getOutputStream()).writeUTF(rece);
                    
//                    System.out.println(rece);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }
}

 

服务端文件传输：

服务端消息和文件传输是分开的，两个不同的端口。但原理一样，都是服务端不断监听客户端发来的连接请求。然后三次握手建立连接通信，开启输入流，输出流。

File类和Server类功能大致相同，只不过是用于接收转发文件信息

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class File implements Runnable{
    
    public static ArrayList<Socket> socketList_IO = new ArrayList<>();
    ServerSocket ssocket;
    Socket socket;

    public void run() {
        //文件传输开启另一个端口监听。
        try {
            ssocket = new ServerSocket(12306);
        } catch (IOException e) {
            e.printStackTrace();
        }
        while(true) {
            try {
                Thread.sleep(1);
                socket = ssocket.accept();
                socketList_IO.add(socket);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            File_IO file_IO;
            try {
                file_IO = new File_IO(socket);
                Thread thread = new Thread(file_IO);
                thread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
    }

}

 

File_IO类 接收客户端的文件，并转发给其他客户端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class File_IO implements Runnable {
    DataInputStream input;
    DataOutputStream output;
    Socket socket;

    public File_IO(Socket socket) throws IOException{
        this.socket = socket;
        System.out.println(socket.getInetAddress());
    }

    @Override
    public void run() {
        byte[] read = new byte[1024];
        String name;
        try {
            input = new DataInputStream(socket.getInputStream());
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        while(true) {
            try {
                Thread.sleep(1);
                if(input.available()!=0) {
                    name=input.readUTF();
                    System.out.println(name);
                    int len=0;
                    while((len=input.read(read,0,read.length))>0) {
                        for(Socket soc:File.socketList_IO) {
                            if(soc != socket)
                            { 
                                output = new DataOutputStream(soc.getOutputStream());
                                output.writeUTF(name);
                                output.write(read,0,len);
                                output.flush();
//                                System.out.println("开始向客户机转发");
                            }
                        }
//                        System.out.println("执行");
//                        System.out.println(len);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

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类

package client;

import view.ClientStart_View;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class chat_Client{
    public chat_Client() {
    }

    private Socket socket = null;
    //    private int Port = 0;
    private static ClientStart_View jframe;  //定义为静态的

    public void text(ClientStart_View jframe) {
        this.jframe = jframe;
    }

    //“连接服务器” button 按钮点击事件，调用此方法
    public void con(int port) throws UnknownHostException, IOException {
        try {
            socket = new Socket("127.0.0.1", port);
//            System.out.println("客户端------------------------");
//            System.out.println("连接到的地址"+socket.getInetAddress()+":"+socket.getLocalPort());  //打印在控制台
            jframe.TextA("已连接");
        } catch (IOException e1) {
            e1.printStackTrace();
        }

        Runnable runnable = new chat_Client_I(socket,jframe);  //启动消息读写线程，并将传递socket，jframe对象变量
        Thread thread = new Thread(runnable);
        thread.start();
    }

    //send()方法，发送消息给服务器。 “发送”button 按钮点击事件，调用此方法
    public void send(String send) throws IOException {
        DataOutputStream stream = new DataOutputStream(socket.getOutputStream());
        stream.writeUTF(send);
    }

}

 

chat_Client_I类  客户端的消息字符读取类。读取服务端发来的消息字符并打印在界面的文本域中

import view.ClientStart_View;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;

public class chat_Client_I implements Runnable{
    private String rece = null;
    private static DataInputStream stream;
    private ClientStart_View jframe;

    public chat_Client_I(Socket socket,ClientStart_View jframe) {
        this.jframe = jframe;
        try {
            stream = new DataInputStream(socket.getInputStream());
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true) {
            try {
                //if条件判断是否有可获取的字节 ，如果不是判断而一直读取的话，在结束时会有读取异常抛出。运行时是没有的。
                if(stream.available()!=0) {
                    rece = stream.readUTF();
                    jframe.TextA(rece);    //调用 ClientStart_View.java类中方法将读入的字符串打印在文本域中
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

 

客户端的文件模块写的有点乱。客户端文件模块要实现发送和接收保存

发送要从计算机本地通过输入流读取文件，并通过输出流发送给服务端。

接收要从服务端通过输入流进行读入，然后通过输出流写入本地保存。

 

File_start类，连接服务端，并开启输入流读取服务端发来的文件

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class File_start implements Runnable{
    Socket socket=null;

    @Override
    public void run() {
        try {
            socket = new Socket("127.0.0.1", 12306);
//            System.out.println("已连接");
//            System.out.println(socket.getInetAddress()+":"+socket.getLocalPort());
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        File_I file_i;
        try {
            File_O file_O = new File_O(socket);
            //开启从服务器的输入流线程
            file_i = new File_I(socket);
            Thread thread = new Thread(file_i);
            thread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

 

File_O类，读取本地文件并发送到服务端

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;

public class File_O{
    public static File_O file_O = new File_O();
    //    private Socket socket=null;
    private byte[] readAllBytes = new byte[1024];
    private static DataOutputStream outputstream;
    private DataInputStream inputstream;

    public File_O() {}
    public File_O(Socket socket) throws IOException {
//        this.socket = socket;
        outputstream = new DataOutputStream(socket.getOutputStream());
    }

    //读取本地文件，并发送到服务端。面板中发送文件按钮在事件处理时会调用此函数
    public void read(String url,String name) throws IOException {
        outputstream.writeUTF(name);
        inputstream = new DataInputStream(new FileInputStream(url));
        int len=0;
        while((len=inputstream.read(readAllBytes))>0) {
            outputstream.write(readAllBytes, 0, len);
            outputstream.flush();
        }
        //outputstream.close();
//        System.out.println("发送完成");
    }

    //此方法暂时没有用到
    public byte[] getread() {
        return readAllBytes;
    }
}

 

File_I类 从服务端的输出流读取文件，并保存到本地。

import view.ClientStart_View;

import java.awt.HeadlessException;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.Socket;

import javax.swing.JOptionPane;

public class File_I implements Runnable{

    //    public static File_I file_I = new File_I();
    private static ClientStart_View jframe;
    private DataOutputStream output;
    private static DataInputStream input;
    private Socket socket;

    public File_I() {}
    public File_I(Socket socket) throws IOException {
        this.socket = socket;
        input = new DataInputStream(socket.getInputStream());
    }

    public void getfile(ClientStart_View jframe) {
        this.jframe = jframe;
    }

    @Override
    public void run() {
        String url = null;
        String name = null;
        byte[] rece = new byte[1024];
        while(true) {
            try {
                //if判断服务端输出流中是否有可读取字节
                if (input.available()!=0) {
                    name = input.readUTF();
                    //                System.out.println(name);

                    //是否接受此文件，接收才会进行输入流读入保存
                    JOptionPane jOptionPane = new JOptionPane();
                    int result=jOptionPane.showConfirmDialog(null, "是否接收该文件", "嘀嘀：一份文件消息", jOptionPane.YES_NO_OPTION);
                    //                System.out.println(result);
                    if (result == jOptionPane.YES_OPTION) {
                        //默认存储路径及从服务端获取的文件名称
                        File file = new File("D:\\", name);
                        //                    file_I.jframe.getJF().setCurrentDirectory(new File("D:\\"));
                        jframe.getJF().setSelectedFile(file);
                        jframe.getJF().showSaveDialog(null);
                        url = jframe.getJF().getSelectedFile().getPath();
                        //                    name =file_I.jframe.getJF().getSelectedFile().getName();

                        int len;
                        try {
                            while((len=input.read(rece,0,rece.length))!=-1) {
//                                System.out.println("zhixing-1");
                                output = new DataOutputStream(new FileOutputStream(url));
                                output.write(rece, 0, len);
                                output.flush();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } catch (HeadlessException | IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

客户端的图形界面也是使用插件，所以只贴上主要的代码段

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();
                }
            }
        }
    }

 

至此代码结束

这段代码只是实现一部分简单功能，还参杂着不少问题，”线程开的太多，并且是死循环，在运行是cpu使用总是达到100%“，”文件的发送只有文本txt能成功打开，其他发送后格式乱码无法打开“。，，，，

欢迎大家交流和指教。

ps : 项目更新，增加登录，注册功能，发现并优化了一些已知bug 

进入主页查看阅读最新文章

链接：https://www.cnblogs.com/yuqingsong-cheng/p/12822628.html