简单的聊天室制作

简单的聊天室制作

 

一个简单的聊天室，主要是就两个部分，一部分就是我们进行的时候那个聊天窗口，另外一个就是背后的服务器，我们要写一个聊天窗口，也要写一个相对应的服务器。

做一个项目过程中，写一个代码很简单，但是把逻辑分析清楚，将制作的过程中所有的逻辑关系分析清楚是项目的最重要的环节。

下面的一步一步，将这个聊天室的制作过程一步一步制作出来。

第一步：

 

第二步：

第三步：

第四步：

第五步：

第六步：

第七步：

第八步：

第九步：

第十步：

第十一步：

这就是简单的聊天室的制作的过程。这样我们来看一下实现后的代码：

客户端的的代码：

 

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketException;
//该类继承了Frame,所以本质就是一个Fame,具有图新界面的一切特征
public class ChatClient extends Frame {
    //声明一个文本框,用用于客户的消息输入
    TextField tfTxt = new TextField();
    //显示客户的输入,包括别的客户端通过服务器转发过来的消息
    TextArea taContent = new TextArea();
    //声明一个空的socket链接,用于和服务器进行信息交互,下面合适的时候,会进行赋值(变量声明的三个步骤)
    Socket soc = null;
    //声明一个boolean,判断和服务器端是否链接上了,特指socket
    private boolean bConnected = false;
    //接受从服务器端发送过来的信息流
    DataInputStream dis = null;
    //向服务器端发送客户输入消息
    DataOutputStream dos = null;
    //声明一个线程变量,专门用于接受服务器端发过来的消息.死循环,阻塞接受
    Thread tRecv = new Thread(new RecvThread());

    //main程序的入口,用于启动客户端,怎么启动的?静态和成员的区别
    public static void main(String[] args) {
        new ChatClient().launFrame();
    }

    //客户端的启动方法,启动了客户端界面,链接服务器,启动接受线程
    public void launFrame() {
        //设置界面的位置宽高
        setBounds(1000, 300, 300, 300);
        //设置界面的布局.
        this.add(tfTxt, BorderLayout.SOUTH);
        this.add(taContent, BorderLayout.NORTH);
        //把Frame里面的控件打包然后按照默认设计好的方式显示
        this.pack();
        // 窗口关闭按钮,事件监听,用的是匿名内部类,关闭窗口的同时关闭了和服务器端链接,然后退出系统,线程不用管.都关机了
        this.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                disConnect();
                System.exit(0);
            }
        });

        // 添加文本框监听事件,是一个成员内部类,目的是为了获得客户输入的消息,默认触发回车触发
        tfTxt.addActionListener(new TxtListener());
        //让整个界面可见
        setVisible(true);
        
        // 链接服务器方法调用了,怎么就叫链接了.soc,dis,dos都链接上了才叫链接
        connect();
        //全部链接上以后,才启动消息接收线程
        tRecv.start();
    }

    // 添加客户端链接服务器的方法
    public void connect() {
        try {
            //给声明好的Socket指定链接的IP和端口,是个成员变量??
            soc = new Socket("127.0.0.1", 9999);
            //dos通过Socket向服务器端发送消息,用的什么方法?
            dos = new DataOutputStream(soc.getOutputStream());
            //dis通过Socket接收服务器端发过来的消息,什么方法?
            dis = new DataInputStream(soc.getInputStream());
            //System.out.println(dis);
            //上面都都准备好,才叫连接上,所以,把链接成员变量设置为真
            bConnected = true;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //断开服务器连接,把打开的那三个链接全部关闭掉
    public void disConnect() {
        try {
            dos.close();
            dis.close();
            soc.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        /*try{
        bConnected = false;
        tRecv.join();   //合并线程
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            try{
                dos.close();
                dis.close();
                soc.close();
            }catch(IOException e){
                e.printStackTrace();
            }
    }*/
    }
    
    
    // 创建一个内部类,实现控件本身的事件监听,不同的控件有自己默认的事件,有三种/四种来设置监听:匿名内部类,成员内部类,外部类
    private class TxtListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {//获得触发事件的那个最初控件对象
            //经过e获得了事件源对象控件,但是我们没用他,因为我们把事件源对象设置成了成员变量,我们内部类可以直接访问成员变量
            String s = tfTxt.getText().trim();
            // System.out.println(s);
            // 把客户往输入文本框的消息,取到然后输出文本显示框,这里也是为了避免和服务器端发送回来的消息叠加,所以注释掉
            //taContent.setText(s);
            //同时把输入框中客户输入的值清空.要不然会叠加
            tfTxt.setText("");

            // 把数据发送到服务器
            try {
                //DataOutputStream,会把数据的数据类型也保存进去,发送出去,什么样的顺序写,就什么样的顺序.
                //也需要按照对应的数据类型来读取
                dos.writeUTF(s);
                //只要是输出流,都需要flush,要不然会把数据缓存下来,而输出不出去
                dos.flush();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }

    //阻塞是读取服务器端发送过来的消息
    private class RecvThread implements Runnable {
        //当线程类启动该线程的时候,调用start(),然后jvm默认会调用run()方法开启新线程
        public void run() {
            try {
                //如果链接全准备好了,我们就不间断的等待读取服务器端发送过来的消息.
                while (bConnected) {
                    //通过dis的readUTF()读取
                    String str = dis.readUTF();
                    //然后把获取到的消息,和输出到文本显示框中原本的消息一起,加上换行符
                    taContent.setText(taContent.getText() + str + '\n');
                }
            } catch (SocketException e) {
                System.out.println("客户端已经关闭");
            }catch (EOFException e) {
                System.out.println("读取完毕");
            }catch (IOException e) {
                System.out.println("IO异常");
            }
        }

    }
}

服务器端代码：

 

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.xml.stream.events.StartDocument;

/**
 * 思路: 1 开启服务器,接受客户端链接,接受客户端数据 start():方法,负责服务器的开启 client():只负责管道的链接
 * run():负责数据的读取
 * 
 * @author Admin
 *
 */

public class ChatServer {
    // 判断服务器是否启动,启动以后就不间断的接受客户端链接,就是while(true)接受链接,接受链接,不是消息
    boolean started = false;
    //声明一个ServerSocket变量,用于转载启动服务器对象
    ServerSocket ss = null;
    //声明一个Client集合,用于装在所有连接到服务器的客户端
    List<Client> clients = new ArrayList<>();

    //main()方法,调用方法启动服务器,start(),自定义的
    public static void main(String[] args) {
        new ChatServer().start();
    }

    // 负责启动服务器方法声明
    public void start() {
        try {
            //实例化一个服务器对象,然后赋值给上面的服务器变量
            ss = new ServerSocket(9999);
            //启动以后赋值给判断变量
            started = true;
            //如果    启动了,就不间断声明socket接收客户端的链接
            while (started) {
                // 声明socket
                Socket soc = ss.accept();
                //每个Socket对应一个Client对象,然后把Socket传递到对象的内部,Socket和客户端就一一对应了
                Client c = new Client(soc);
                //然后根据客户端开启这个客户端对应的消息收发线程.这样线程,客户端,Socket就一一对应了.
                new Thread(c).start();
                //然后把客户端的引用保存到集合中,这样,客户单就有了顺序,相当于有了一个唯一的识别符号
                clients.add(c);
                // 上一行如果没有链接上会报错,到达这里就证明链接上了

            }
        } catch (IOException e) {
            // e.printStackTrace();
            System.out.println("客户端关闭,服务器端也会关闭");
        } finally {
            try {
                if (ss != null)
                    ss.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

    class Client implements Runnable {
        //每个客户端对象,都肯定具备以下属性
        //对应的Socket
        private Socket soc;
        //对应的输入属性
        private DataInputStream dis = null;
        //对应的输出
        private DataOutputStream dos = null;
        //对应的链接属性,是否链接好了
        private boolean bConnected = false;

        // 构造方法,只是成功的创建这个类,构造方法用于创建这个类
        //同时需要输入对应的Socket,还同时实例化输入和输出的对应的流及其方法,和Socket绑定
        public Client(Socket s) {
            this.soc = s;
            try {
                dis = new DataInputStream(s.getInputStream());//s是绑定
                dos = new DataOutputStream(s.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
            bConnected = true;
        }

        @Override
        public void run() {
            try {
                //如果链接成功的话,这个线程就不间断的读取客户端的消息
                while (bConnected) {
                    //读取客户端发过来的消息
                    String str = dis.readUTF();
                    System.out.println(str);
                    //同时遍历集合中的每一个对象,然后挨个发送收到消息
                    for (int i = 0; i < clients.size(); ++i) {
                        //i是Client,Socket,对应的下标
                        Client c = clients.get(i);
                        //发送方法
                        c.send(str);
                    }
                }
            } catch (EOFException e) {
                //如果客户端断开,就需要移除这个客户端.输入移除和输出移除都一样.因为都是不间断的监听
                clients.remove(this);
                System.out.println("客户端已经断开连接,所以从集合中移除该客户端");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (dis != null) {
                        dis.close();
                    }
                    if (dos != null) {
                        dos.close();
                    }
                    if (soc != null) {
                        soc.close();
                    }
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }
        public void send(String str) {
            try {
                //真正向客户端发送消息的方法
                dos.writeUTF(str);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

 

代码完成了，让我们来看看我们的聊天室做好以后的效果：

在我敲击回车后，观看一下结果：

 

 我们这个小的聊天室就完成了！