Java基于Socket实现多人聊天室

本文实例为大家分享了Java基于Socket实现简易版多人聊天室的具体代码,供大家参考,具体内容如下

一、 聊天室需求

1、一个服务端,多个客户端;
2、实现客户端和服务端的交互;
3、客户端发送信息,服务端收到信息,再转发给其他客户端;
4、上下线时显示哪个客户端上下线并且显示在线客户端数量;

二、代码分析

1. 建立连接

客户端类,创建发送端Socket对象,用自己的IP地址和端口号,与服务端建立连接。

class Client:

//用于与服务端通信的Socket
private Socket socket;

public Client() throws Exception {
    /*
     * 初始化Socket的同时要制定服务端的IP地址和端口号
     * ip地址用于我们在网络上找到服务端的所在计算在
     * 端口号用于找到服务器上的服务端应用程序。
     * 
     * 实例化Socket的过程就是连接服务端的过程若
     * 服务端无响应,这里得构造方法得抛出异常。
     * 
     */
    try {
        System.out.println("正在连接服务器......");
        //localhost 127.0.0.1
        socket = new Socket("LAPTOP-TCK59O6Q",8888);
        System.out.println("与服务端连接完毕");
    } catch (Exception e) {
        System.out.println("初始化失败");
        throw e;
    }
} 

服务端类,使用构造方法初始化服务端,创建接收端的Socket对象

class Server:

private ServerSocket server;

//构造方法初始化服务端
public Server() throws IOException {
    //实例化serverSocket的同时,指定服务端的端口号;
    try {
        server = new ServerSocket(8888);
        allOut = new ArrayList<PrintWriter>();
    } catch (Exception e) {
        System.out.println("服务端初始化失败");
        throw e;
    }
}

2. 客户端发送信息

在客户端的类中写一个start()方法,start()是客户端发送信息给服务端的方法
获取输出流对象,把键盘录入的信息发送到服务端。

class Client:

public void start() throws Exception {
    /*
     * 客户端开始工作的方法
     */
    try {
        //启动用于读取服务端发送消息的线程
        ServerHandler handler = new ServerHandler();
        //ServerHandler是自己写的类,实现Runnable接口,有多线程功能
        Thread t = new Thread(handler);
        t.start();
        
        //将数据发送到服务端
        OutputStream out = socket.getOutputStream();//获取输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");//转化成utf-8格式
        PrintWriter pw = new PrintWriter(osw,true);
        Scanner scan = new Scanner(System.in);
        while(true) {
            String message = scan.nextLine();//得到键盘录入的信息
            pw.println(message);//把信息输出到服务端
        }
        
    } catch (Exception e) {
        System.out.println("客户端运行失败");
        throw e;
    } 
    
}

服务端工作的start()方法,accept()方法与客户端连接上

class Server:

//服务端工作的方法
public void start() throws IOException {
    /*
     * ServerSocket提供了一个accept的方法,该方法是一个阻塞方法,
     * 用于监听其打开的8888端口;当一个客户端通过该端口与服务端连接时,
     * accept方法就会解除阻塞,然后创建一个socket实例并返回,
     * socket的作用就是与刚刚连接上的客户端进行通信。
     */
    while(true) {
        System.out.println("等待客户端连接...");
        Socket socket = server.accept();
        System.out.println("一个客户端连接了!");
        //启动一个线程来处理客户端的交互工作
        ClientHandler hander = new ClientHandler(socket);
        Thread t = new Thread(hander);
        t.start();
    }
}

3. 开启多线程、服务端接收读取信息并广播

因为服务端与多个客户端相连,所以要用多线程,即一个客户端用一条线程。

在服务端类中创建一个内部类ClientHandler实现Runnable接口并重写run()方法创建线程
属性有客户端的Socket对象
有参构造方法中通过客户端的Socket获取到其地址host,并且把地址打印出来
这样在main()方法中,实例化服务端类的对象之后,start方法开启服务端,当有客户端连接上时,就能输出这个客户端的ip地址。

ClientHandler类要重写run()方法,使用输入流InputStream读取客户端发来的信息,再使用输出流OutputStream给所有客户端广播收到的信息、用户上下线和在线人数

class Server:

/**
 * ClientHandler
 * 该线程类是与指定的客户端进行交互工作;
 * @author zxm
 *
 */
class ClientHandler implements Runnable{
    //当前线程客户端的Socket
    private Socket socket;
    
    //该客户端的地址
    private String host;
    
    public ClientHandler(Socket socket) {
        this.socket=socket;
        /*
         * 通过socket获取远程计算机地址
         * 对于服务端而言,远程计算机就是客户端
         */
        InetAddress address = socket.getInetAddress();
        
        //获取ip地址
        host = address.getHostAddress();
        System.out.println("host"+host);
    }

    @Override
    public void run() {
        PrintWriter pw = null;
        try {
            //广播给所有客户端,当前用户上线了
            sendMessage("["+host+"]上线了");
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
            pw = new PrintWriter(osw,true);

            //将该客户的输出流存入共享集合,以便消息可以广播给该客户端
            addOut(pw);
            
            //广播当前在线人数
            sendMessage("当前在线人数["+allOut.size()+"]");
            
            //处理来自客户端的数据
            InputStream in = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(in,"utf-8");
            BufferedReader br = new BufferedReader(isr);
            /*
             * 服务端读取客户端发送过来的每一句字符时
             * 由于客户端所在的操作系统不同,这里客户端断开时结果也不同
             * windows客户端开始br.readLine抛出异常
             * Linux客户端断开是返回null
             * 
             */
            String message = null;
            while((message = br.readLine())!=null) {
                sendMessage(host+"说:"+message);
            }
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            //将该客户端的输出流从共享集合中删除
            removeOut(pw);
            
            //广播给所有客户端,当前用户下线
            sendMessage("["+host+"]下线了");
            
            //广播当前在线人数
            sendMessage("当前在线人数["+allOut.size()+"]");
            
            try {
                socket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

因此服务端类中要写一个sendMessage()方法,为了在接收到一个客户端的信息后,把这个信息转发给所有客户端,这就是广播的效果。
写一个集合allOut,用来存放所有客户端的输出流,客户端的数量就是集合里元素的个数
再写两个方法,一个是addOut()方法把上线客户端的输出流放进集合(在run方法中使用addOut(),获取到启用新线程的客户端的输出流,把输出流加到集合中),
另一个是removeOut()方法拿出集合(同理run()方法中使用,把socket关闭的客户端的输出流移除集合)。

所以sendMessage()方法的参数就是某个客户端发的字符串信息message,遍历allOut集合,把message在每个输出流中打印,用PrintWrite类中的print方法。
当客户端连接服务端时,sendMessage()方法打印这个服务端的地址加上上线了,同理客户端关闭socket的时候打印下线了,
同时上下线后再打印allOut集合的大小,也就是当前连接服务端的客户端数量,就是在线人数。

class Server:

//存放所有客户端的输出流的集合,用于广播
private List<PrintWriter> allOut;

//将给定的输出流放入共享集合
private synchronized void addOut(PrintWriter out){
    allOut.add(out);
}

//将给定的输出流移除共享集合
private synchronized void removeOut(PrintWriter out){
    allOut.remove(out);
}

//将给定的消息发给多个客户端
private synchronized void sendMessage(String message) {
    
    for(PrintWriter out:allOut) {
        out.println(message);
    }
}

4. 客户端读取信息

这个时候所有的客户端都收到了某个客户发的消息,但是还没读,所以客户端类中要加输入流才能读取,
创建ServerHandler类实现Runnable接口,输入流读取并输出。

class Client:

class ServerHandler implements Runnable{
    /**
     * 该线程用于读取服务端发送过来的消息,并输出到
     * 客户端的控制台上
     * @author zxm
     *
     */
    @Override
    public void run() {
        try {
            InputStream in = socket.getInputStream();//输入流
            InputStreamReader isr = new InputStreamReader(in,"UTF-8");//以utf-8读
            BufferedReader br = new BufferedReader(isr);
            String message = null;
            while((message=br.readLine())!=null) {
                System.out.println(message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

三、完整代码

1. 客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 * 聊天室服务端
 * @author zxm
 */
public class Client {
    
    //用于与服务端通信的Socket
    private Socket socket;
    
    public Client() throws Exception {
        /*
         * 初始化Socket的同时要制定服务端的IP地址和端口号
         * ip地址用于我们在网络上找到服务端的所在计算在
         * 端口号用于找到服务器上的服务端应用程序。
         * 
         * *实例化Socket的过程就是连接服务端的过程若
         * 服务端无响应,这里得构造方法得抛出异常。
         * 
         */
        try {
            System.out.println("正在连接服务器......");
            //localhost 127.0.0.1
            socket = new Socket("LAPTOP-TCK59O6Q",8888);
            System.out.println("与服务端连接完毕");
        } catch (Exception e) {
            System.out.println("初始化失败");
            throw e;
        }
    }
    
    public void start() throws Exception {
        /*
         * 客户端开始工作的方法
         */
        try {
            //启动用于读取服务端发送消息的线程
            ServerHandler handler = new ServerHandler();
            //ServerHandler是自己写的类,实现Runnable接口,有多线程功能
            Thread t = new Thread(handler);
            t.start();
            
            //将数据发送到服务端
            OutputStream out = socket.getOutputStream();//获取输出流对象
            OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");//转化成utf-8格式
            PrintWriter pw = new PrintWriter(osw,true);
            Scanner scan = new Scanner(System.in);
            while(true) {
                String message = scan.nextLine();//得到键盘录入的信息
                pw.println(message);//把信息输出到服务端
            }
            
        } catch (Exception e) {
            System.out.println("客户端运行失败");
            throw e;
        } 
        
    }

    public static void main(String[] args) throws Exception {
        
        try {
            Client client = new Client();
            client.start();
        } catch (Exception e) {
            System.out.println("客户端运行失败");
            e.printStackTrace();
        }
        

    }
    
    class ServerHandler implements Runnable{
        /**
         * 该线程用于读取服务端发送过来的消息,并输出到
         * 客户端的控制台上
         * @author zxm
         *
         */
        @Override
        public void run() {
            try {
                InputStream in = socket.getInputStream();//输入流
                InputStreamReader isr = new InputStreamReader(in,"UTF-8");//以utf-8读
                BufferedReader br = new BufferedReader(isr);
                String message = null;
                while((message=br.readLine())!=null) {
                    System.out.println(message);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    }
    

}

2. 服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 聊天室服务端
 * @author zxm 
 */
public class Server {
    /*
     * 运行在服务端的socket
     * 该类的作用是:
     *     1.申请服务端口,客户端就是通过它申请的服务端口连接上服务端应用的。
     *  2.监听申请的服务端口感知客户端的连接,并创建一个socket与该客户通信。
     */
    private ServerSocket server;
    
    //存放所有客户端的输出流的集合,用于广播
    private List<PrintWriter> allOut;
    
    //将给定的输出流放入共享集合
    private synchronized void addOut(PrintWriter out){
        allOut.add(out);
    }
    
    //将给定的输出流移除共享集合
    private synchronized void removeOut(PrintWriter out){
        allOut.remove(out);
    }
    
    //将给定的消息发给多个客户端
    private synchronized void sendMessage(String message) {
        
        for(PrintWriter out:allOut) {
            out.println(message);
        }
    }
    
    //构造方法初始化服务端
    public Server() throws IOException {
        //实例化serverSocket的同时,指定服务端的端口号;
        try {
            server = new ServerSocket(8888);
            allOut = new ArrayList<PrintWriter>();
        } catch (Exception e) {
            System.out.println("服务端初始化失败");
            throw e;
        }
    }
    
    //服务端工作的方法
    public void start() throws IOException {
        /*
         * ServerSocket提供了一个accept的方法,该方法是一个阻塞方法,
         * 用于监听其打开的8888端口;当一个客户端通过该端口与服务端连接时,
         * accept方法就会解除阻塞,然后创建一个socket实例并返回,
         * socket的作用就是与刚刚连接上的客户端进行通信。
         */
        while(true) {
            System.out.println("等待客户端连接...");
            Socket socket = server.accept();
            System.out.println("一个客户端连接了!");
            //启动一个线程来处理客户端的交互工作
            ClientHandler hander = new ClientHandler(socket);
            Thread t = new Thread(hander);
            t.start();
        }
    }
    
    
    public static void main(String[] args) throws Exception {
        Server server = new Server();
        server.start();
    }
    
    /**
     * 该线程类是与指定的客户端进行交互工作;
     * @author zxm
     *
     */
    class ClientHandler implements Runnable{
        //当前线程客户端的Socket
        private Socket socket;
        
        //该客户端的地址
        private String host;
        
        public ClientHandler(Socket socket) {
            this.socket=socket;
            /*
             * 通过socket获取远程计算机地址
             * 对于服务端而言,远程计算机就是客户端
             */
            InetAddress address = socket.getInetAddress();
            
            //获取ip地址
            host = address.getHostAddress();
            System.out.println("host"+host);
        }

        @Override
        public void run() {
            PrintWriter pw = null;
            try {
                //广播给所有客户端,当前用户上线了
                sendMessage("["+host+"]上线了");
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
                pw = new PrintWriter(osw,true);

                //将该客户的输出流存入共享集合,以便消息可以广播给该客户端
                addOut(pw);
                
                //广播当前在线人数
                sendMessage("当前在线人数["+allOut.size()+"]");
                
                //处理来自客户端的数据
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in,"utf-8");
                BufferedReader br = new BufferedReader(isr);
                /*
                 * 服务端读取客户端发送过来的每一句字符时
                 * 由于客户端所在的操作系统不同,这里客户端断开时结果也不同
                 * windows客户端开始br.readLine抛出异常
                 * Linux客户端断开是返回null
                 * 
                 */
                String message = null;
                while((message = br.readLine())!=null) {
                    sendMessage(host+"说:"+message);
                }
                
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                //将该客户端的输出流从共享集合中删除
                removeOut(pw);
                
                //广播给所有客户端,当前用户下线
                sendMessage("["+host+"]下线了");
                
                //广播当前在线人数
                sendMessage("当前在线人数["+allOut.size()+"]");
                
                try {
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Java基于socket实现简易聊天室实例

    本文实例讲述了Java基于socket实现简易聊天室的方法.分享给大家供大家参考.具体实现方法如下: chatroomdemo.java package com.socket.demo; import java.io.IOException; import java.net.DatagramSocket; public class ChatRoomDemo { /** * @param args * @throws IOException */ public static void main(S

  • Java Socket聊天室编程(一)之利用socket实现聊天之消息推送

    相关阅读:Java Socket聊天室编程(二)之利用socket实现单聊聊天室 网上已经有很多利用socket实现聊天的例子了,但是我看过很多,多多少有一些问题存在. 这里我将实现一个比较完整的聊天例子,并解释其中的逻辑. 由于socket这一块比较大,所以我将分出几篇来写一个比较完整的socket例子. 这里我们先来实现一个最简单的,服务器与客户端通讯,实现消息推送的功能. 目的:服务器与客户端建立连接,客户端可以向服务器发送消息,服务器可以向客户端推送消息. 1,使用java建立socke

  • 使用Java和WebSocket实现网页聊天室实例代码

    在没介绍正文之前,先给大家介绍下websocket的背景和原理: 背景 在浏览器中通过http仅能实现单向的通信,comet可以一定程度上模拟双向通信,但效率较低,并需要服务器有较好的支持; flash中的socket和xmlsocket可以实现真正的双向通信,通过 flex ajax bridge,可以在javascript中使用这两项功能. 可以预见,如果websocket一旦在浏览器中得到实现,将会替代上面两项技术,得到广泛的使用.面对这种状况,HTML5定义了WebSocket协议,能更

  • java利用Socket实现聊天室功能实例

    最近研究了下Java socket通信基础,利用代码实现了一个简单的多人聊天室功能,现把代码共享下,希望能帮到有兴趣了解的人. 目录结构: ChatClient: package com.panda.chat; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; @SuppressWarnings("serial") public class ChatClient extend

  • 用java WebSocket做一个聊天室

    最近一个项目中,需要用到Java的websocket新特性,于是就学了一下,感觉这技术还挺好玩的,瞬间知道网页上面的那些在线客服是怎么做的了. 先看图: 实现了多客户机进行实时通讯. 下面看代码项目结构图:很简单,就1个类,1个页面 然后看具体代码 先看后端代码 package com.main; import java.io.IOException; import java.util.concurrent.CopyOnWriteArraySet; import javax.websocket.

  • 基于Tomcat7、Java、WebSocket的服务器推送聊天室实例

    前言 HTML5 WebSocket实现了服务器与浏览器的双向通讯,双向通讯使服务器消息推送开发更加简单,最常见的就是即时通讯和对信息实时性要求比较高的应用.以前的服务器消息推送大部分采用的都是"轮询"和"长连接"技术,这两中技术都会对服务器产生相当大的开销,而且实时性不是特别高.WebSocket技术对只会产生很小的开销,并且实时性特别高.下面就开始讲解如何利用WebSocket技术开发聊天室.在这个实例中,采用的是Tomcat7服务器,每个服务器对于WebSoc

  • Java Socket聊天室编程(二)之利用socket实现单聊聊天室

    在上篇文章Java Socket聊天室编程(一)之利用socket实现聊天之消息推送中我们讲到如何使用socket让服务器和客户端之间传递消息,达到推送消息的目的,接下来我将写出如何让服务器建立客户端与客户端之间的通讯. 其实就是建立一个一对一的聊天通讯. 与上一篇实现消息推送的代码有些不同,在它上面加以修改的. 如果没有提到的方法或者类则和上一篇一模一样. 1,修改实体类(服务器端和客户端的实体类是一样的) 1,UserInfoBean 用户信息表 public class UserInfoB

  • Java编程实现基于TCP协议的Socket聊天室示例

    本文实例讲述了Java编程实现基于TCP协议的Socket聊天室.分享给大家供大家参考,具体如下: 这里使用Socket套接字进行编程,完成的是基于TCP可靠服务实现服务器与客户端的双通信. Server服务器端: package com.han; import java.awt.Container; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.Win

  • java socket实现聊天室 java实现多人聊天功能

    用java socket做一个聊天室,实现多人聊天的功能.看了极客学院的视频后跟着敲的.(1DAY) 服务端: 1. 先写服务端的类MyServerSocket,里面放一个监听线程,一启动就好 2. 实现服务端监听类ServerListener.java,用accept来监听,一旦有客户端连上,生成新的socket,就新建个线程实例ChatSocket.启动线程后就把线程交给ChatManager管理 3. 在ChatSocket中实现从客户端读取内容,把读取到的内容发给集合内所有的客户端 4.

  • java实现一个简单TCPSocket聊天室功能分享

    本文实例为大家分享了java实现TCPSocket聊天室功能的相关代码,供大家参考,具体内容如下 1.TCPserver.java import java.net.*; import java.io.*; import java.util.*; import java.util.concurrent.*; public class TCPserver{ private static final int SERVERPORT = 8888; private ServerSocket MyServe

随机推荐