Java网络编程C/S模型

支持多个客户端连接服务器：添加java文件在main函数调用new一个新的客户端

服务器支持群发和私聊信息：群发直接发送就行，私聊在消息前加上客户端端口号+“：”，如“49761:你好啊”

客户端：

package CS;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class Client {

    Socket socket;

    //构造函数1
    public Client(String ip, int port) throws IOException {
        socket = new Socket(ip, port);
    }

    //构造函数2
    public Client(InetAddress inetAddress, int port) throws IOException {
        socket = new Socket(inetAddress, port);
    }

    //连接服务器
    public void connect() throws IOException {
        new ClientSend(socket).start();
        new ClientReceived(socket).start();
    }

    //客户端发送消息线程
    class ClientSend extends Thread{
        Socket socket;
        public ClientSend(Socket socket) throws IOException {
            this.socket = socket;
        }
        public void run() {
            try{
                Writer serverWriter;//服务端输出字符流(用于给服务器发消息)
                serverWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                Scanner scanner = new Scanner(System.in);
                while(true){
                    String str = scanner.next();
                    if("close".equals(str)) {
                        socket.shutdownOutput();
                        socket.shutdownInput();
                        socket.close();
                        break;
                    }
                    serverWriter.write(str);
                    serverWriter.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //客户端接受消息线程
    class ClientReceived extends Thread{
        Socket socket;
        public ClientReceived(Socket socket) throws IOException {
            this.socket = socket;
        }
        public void run() {
            try {
                Reader reader = new InputStreamReader(socket.getInputStream());
                char[] chars = new char[1024];
                int len = 0;
                while((len = reader.read(chars))!=-1) {
                    String str = new String(chars,0,len);
                    if (str != null) System.out.println("服务器端：" + str);
                }
            } catch (IOException e) {
                System.out.println("服务器已断开");
            }
        }
    }

    //main函数
    public static void main(String[] args) throws IOException {
        Client client = new Client("127.0.0.1",3333);
        client.connect();
    }
}

服务器：

package CS;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Server {

    ServerSocket serverSocket;
    //连接的客户端
    List<Socket> list;

    public Server(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        list = new ArrayList<>();
    }

    //服务器初始化
    public void init(){
        new Connection().start();//连接线程启动监听
        new ServerSend().start();//消息发送线程启动
    }

    //接受客户端连接请求线程
    class Connection extends Thread{
        @Override
        public void run() {
            while(true){
                try {
                    Socket socket = serverSocket.accept();
                    System.out.println(socket.getRemoteSocketAddress()+"已连接");
                    list.add(socket);
                    new ServerReceived(socket).start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //服务器发送消息线程
    class ServerSend extends Thread{
        public void run() {
            try {
                Scanner scanner = new Scanner(System.in);
                while(true){
                    String str = scanner.next();
                    //群发消息
                    if(!str.contains(":")) {
                        for(Socket socket :list) {
                            if (socket.isConnected()&&!socket.isClosed()) {
                                Writer clientWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                                clientWriter.write(str);
                                clientWriter.flush();
                            }
                        }
                    }
                    //私聊
                    else{
                        String[] strs = str.split(":");
                        String portStr = strs[0];
                        String info = strs[1];
                        for(Socket socket :list) {
                            if(socket.getRemoteSocketAddress().toString().split(":")[1].equals(portStr)){
                                if (socket.isConnected()&&!socket.isClosed()) {
                                    Writer clientWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                                    clientWriter.write(info);
                                    clientWriter.flush();
                                }else{
                                    System.out.println("该客户端已关闭或断开连接");
                                }
                                break;
                            }
                        }

                    }


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

    //服务器接受消息线程
    class ServerReceived extends Thread{
        Socket client;
        public ServerReceived(Socket socket){
            this.client = socket;
        }
        public void run() {
            try{
                Reader reader = new InputStreamReader(client.getInputStream());
                char[] chars = new char[1024];
                int len = 0;
                while ((len = reader.read(chars))!= -1) {
                    String str = new String(chars, 0, len);
                    System.out.println("客户端"+client.getRemoteSocketAddress()+":"+ str);
                }
            } catch (IOException e) {
                System.out.println(client.getRemoteSocketAddress()+"已断开");
            }
        }
    }

    //main函数
    public static void main(String[] args) throws IOException {
        Server server = new Server(3333);
        server.init();
    }
}

再添加一个客户端：

package CS;
import java.io.IOException;
public class Client1 {
    public static void main(String[] args) throws IOException {
        Client client = new Client("127.0.0.1",3333);
        client.connect();
    }
}

运行效果：

目前启动了一个服务器和两个客户端，绿色字体是本端输入

服务器端：

客户端49761：

客户端49787：