Java Dome(实现一个简易版QQ聊天室）

前言

这玩意就是一个基于TCP的建议聊天室，有服务端与客户端。服务端负责对客户端的数据进行转发至另一个客户端。当然前提是每一个客户端连接服务器的时候需要提供一个用户名，也就是需要进行超简陋的登录。

流程图示

功能示意

代码流程示意

Dome结构预览

Message是我们传递的数据，我们传递消息对象
MessageType 是一个用来标注消息类型的

Message类

import java.io.Serializable;

public class Message implements Serializable{
    private String from;//消息发送者
    private String to;//消息接收者
    private int type;//消息类型
    private String info;//发送的消息内容

    public Message(){

    }
    public Message(String from, String to, int type, String info) {
        this.from = from;
        this.to = to;
        this.type = type;
        this.info = info;
    }
    public String getFrom() {
        return from;
    }
    public void setFrom(String from) {
        this.from = from;
    }
    public String getTo() {
        return to;
    }
    public void setTo(String to) {
        this.to = to;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    
}

type类

public final class MessageType {
    public static final int TYPE_LOGIN = 0x1;//登录的消息类型
    public static final int TYPE_SEND = 0x2; //发送的消息类型
}

服务端用户登录与查询与消息转发

先将用户处理的线程加入列表

更据消息类型做适当反馈，如果是发送消息，那么就直接遍历列表中的用户线程，对比线程的用户名是否与我们的发送对象相等，之后使用该用户线程的输出流发送msg对象，实现通信。

服务端代码

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class Server {
    //服务器端负责数据的中转
    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(6);//线程池大小最多同时支持6个人聊天
        Vector<UserThread> vector = new Vector<>();//存储客户端线程
        try{
        ServerSocket server = new ServerSocket(8888);
        System.out.println("服务器已启动......");
        while(true){
            Socket socket = server.accept();
            UserThread user = new UserThread(socket,vector);
            es.execute(user);

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

class UserThread implements Runnable{
    private Socket socket;
    private Vector<UserThread> vector;
    private String name;
    private ObjectInputStream ois;
    private ObjectOutputStream oos;
    private boolean flag=true;
    public UserThread(Socket socket, Vector<UserThread> vector) {
        this.socket = socket;
        this.vector = vector;
        this.vector.add(this);
    }
    public UserThread() {
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try{
        System.out.println("[Host："+socket.getInetAddress().getHostAddress()+"-连接]");
        ois = new ObjectInputStream(socket.getInputStream());
        oos = new ObjectOutputStream(socket.getOutputStream());
        while(flag){

            Message msg = (Message) ois.readObject();
            int type = msg.getType();
            switch(type){
                case MessageType.TYPE_LOGIN:{
                    //登录
                    this.name = msg.getFrom();
                    msg.setInfo("欢迎你："+this.name);
                    oos.writeObject(msg);
                    break;
                }
                case MessageType.TYPE_SEND:{
                    //发送消息
                    String sendto = msg.getTo();
                    for(UserThread user:vector){
                        if(sendto.equals(user.name)&&user!=this){
                            //寻找
                            user.oos.writeObject(msg);
                            System.out.println(this.name+"send message to"+msg.getTo()+"--success");
                            break;
                        }
                        else{
                            System.out.println(this.name+"send message to"+msg.getTo()+"--fail");
                        }
                    }
                    break;
                }
            }
        }
        oos.close();
        ois.close();
        }catch(IOException | ClassNotFoundException e){
            // e.printStackTrace();
            System.out.println("Closed"+name);
            return;
        }

        
    }
    

}

客户端登录

登录

登录后在服务端会发送欢迎消息，所以需要接收。

客户端消息接收与发送

消息接收

消息接受专门在开了一个子线程负责接收消息并展示


消息发送
这个的话我们直接在主线程当中进行发送即可

注意点

当客户端关闭后，我们在服务端的子线程必须关闭，否则继续运行会浪费内存。这里的话，在客户端关闭后，会在我们的服务端抛出IOException异常，那么我在在抛出异常后关闭即可。

客户端代码

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Client {
    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();
        Scanner input  = new Scanner(System.in);
        try{
            Socket socket = new Socket("localhost",8888);
            System.out.println("已连接至服务器");
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //登录
            System.out.print("请输入用户名：");
            String username = input.nextLine();
            Message msg = new Message(username,null,MessageType.TYPE_LOGIN,null);
            oos.writeObject(msg);
            msg = (Message)ois.readObject();
            System.out.println(msg.getInfo());
            //与其他用户接收发送交流消息
            //读取其他用户的消息
            // new Thread(new ReadInfoThread(ois)).start();
            es.execute(new ReadInfoThread(ois));
            //发送直接在主线程发送
            boolean flag = true;
            while(flag){
                msg = new Message();
                System.out.print("To：");
                msg.setTo(input.nextLine());
                msg.setFrom(username);
                msg.setType(MessageType.TYPE_SEND);
                System.out.print("\nmsg:");
                msg.setInfo(input.nextLine());
                oos.writeObject(msg);
            }



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

class ReadInfoThread implements Runnable{
    private ObjectInputStream ois;
    private boolean flag = true;
    public ReadInfoThread(ObjectInputStream ois){
        this.ois = ois;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {

            while(flag){
            Message msg=(Message)ois.readObject();
            System.out.println();
            System.out.println("From:["+msg.getFrom()+"]say:"+msg.getInfo());
            System.out.print("To:");
            }
            if(ois!=null){
                ois.close();
            }

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

运行结果示意