精华内容
下载资源
问答
  • Java控制台实现简单的群聊天室
    2021-04-23 20:34:31

    需求分析:

    实现简单的群聊,需要用到Java的Socket(套接字)和ServerSocket(服务器端套接字)两个类。当客户端(Socket)发送信息到固定的服务器(ServerSocket)的地址和端口,会有服务器端监听到该信息,然后转发至每个用户,即聊天室。要想把信息转发到各个用户,需要把这所有的用户用一个集合(List)存起来,遍历集合内所有用户,进行发送。

    其中难点在于如何使用多线程接受转发信息。对于服务器端,需要不断监听用户端的信息传输,每当监听到一个用户发来消息,会开辟一个线程对消息转发至各个用户。对于客户端,每创建一个用户,需要开辟一条线程,并且该用户需要接收和发送消息,接收和发送消息两者间是不同步的,又需要开辟两条线程,线程下面有线程。

    代码如下:

    1、服务器端

    /**

    服务器端,服务器创建入口

    */

    public Server{

    public static void main(String[] args){

    //创建一个服务器,端口号为8000

    ServerSocket server = new ServerSocket(8000);

    //创建一个死循环,让服务器一直处于监听客户端信息的状态

    while(true){

    Socket socket = server.accept();

    //传入监听到的socket,并且启动线程

    ServerThread st = new SeverThread(socket);

    Thread th = new Thread(st);

    th.start();

    //异常未处理

    }

    }

    }

    2、当监听到来自客户端的消息,开辟新的服务器用来接收

    /**

    服务器子线程端

    */

    public ServerThread implements Runnable {

    private static LinkedList list = new LinkedList<>();

    private Socket socket;

    public ServerSocket(Socket socket){

    //把监听到的socket传过来

    this.socket = socket;

    //并且添加到集合中

    list.add(socket);

    }

    @Override

    public void run(){

    //接收客户端发过来的消息(读)

    //为了提高读写效率,把字节流用转换流转换为字符流

    //然后用缓存流封装转换流

    BufferedReader br = null;

    try{

    br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

    String msg = null;

    while((msg = br.readLine()) != null){

    sendAll(msg);

    }

    } catch(IOException e){

    e.printStackTrace();

    }

    }

    //发送给所有人

    public void sendAll(String msg){

    //遍历集合,然后发送给集合(群)里面的所有人

    PrintStream ps = null;

    for(Socket sk : list){

    try{

    ps = new PrintStream(sk.getOutputStream());

    ps.println(msg);

    ps,flush();

    } catch(IOException e){

    e.printStackTrace();

    }

    }

    }

    }

    3、客户端,每个用户的入口,每当有用户进入,会开辟一条线程

    public Client{

    public static void main(String[] srgs){

    ClientThread ct = new ClientThread();

    Thread th = new Thread(ct);

    th.start();

    }

    }

    4、客户端子线程,每当接收和发送消息,会开辟线程用来同步

    public ClientThread implements Runnable{

    @Override

    public run(){

    Socket socket = null;

    try {

    //使用当前主机服务器,端口号设为8000

    socket = new Socket("localhost", 8000);

    Thread th_1 = new Thread(new ClientReceive(socket));

    th_1.start();

    Thread th_2 = new Thread(new ClientSend(socket));

    th_2.start();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    5、客户端发送信息子线程

    public ClientSend implements Runnable{

    private Socket socket;

    public ClientSend(Socket socket){

    this.socket = socket;

    }

    @Override

    public void run(){

    //发送信息

    PrintStream ps = null;

    Scanner input = new Scanner(System.in);

    try {

    while(ture) {

    //输入发送的信息(写)

    ps = new PrintStream(socket.getOutputStream());

    String msg = input.next();

    ps.println(msg);

    ps.flush();

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    6、客户端接受信息子线程

    public ClientReceive implements Runnable{

    private Socket socket;

    public ClientReceive(Socket socket){

    this.socket = socket;

    }

    @Override

    public void run(){

    BufferedReader br = null;

    String msg = null;

    //接收信息(读)

    try {

    while(true) {

    br = new BufferedReader(new InputStreamReader(socket.getInputStream));

    while((msg = br.readLine()) != null) {

    System.out.println(msg);

    }

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    更多相关内容
  • 我们小组大二做的一个简单的聊天系统,分为服务器端和客户端,启动服务器端之后,客户端之间进行收发信息,还有群组聊天功能。完整的项目描述见压缩包内的报告和源码。使用mysql数据库,已导出为qq.sql文件。 解压...
  • 服务端代码 开启ServerSocketChannel,设置为非阻塞,并...import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.util.Iterator;

    服务端代码

    • 开启ServerSocketChannel,设置为非阻塞,并声明为全局变量
    • 开启一个selector,并绑定客户端链接事件
    • 启动监听方法,循环监听事件,阻塞监听事件
    • 读取到客户端消息,并转发给其他客户端
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.*;
    import java.util.Iterator;
    
    public class GroupChatServer {
        private ServerSocketChannel serverSocketChannel;
        private Selector selector;
        private static final int PORT = 6666;
    
    
        public GroupChatServer() {
            try {
                serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.configureBlocking(false);
                serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
                selector = Selector.open();
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                System.out.println("服务端已启动");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public void listen() {
            try {
    
                while (true) {
                    int count = selector.select();
                    if (count == 0) {
                        continue;
                    }
                    Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                    while (keyIterator.hasNext()) {
                        SelectionKey key = keyIterator.next();
                        if (key.isAcceptable()) {
                            SocketChannel socketChannel = serverSocketChannel.accept();
                            socketChannel.configureBlocking(false);
                            socketChannel.register(selector, SelectionKey.OP_READ);
                            System.out.println(socketChannel.getRemoteAddress() + "上线了");
                        }
                        if (key.isReadable()) {
                            //处理数据读取
                            readData(key);
                        }
                        keyIterator.remove();
                    }
                }
    
            } catch (Exception e) {
    
            } finally {
    
            }
        }
    
        private void readData(SelectionKey key) {
            SocketChannel channel = null;
    
            try {
                channel = (SocketChannel) key.channel();
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                int read = channel.read(byteBuffer);
                if (read > 0) {
                    //输出读取到的数据
                    String msg = new String(byteBuffer.array(), 0, read);
                    System.out.println("转发客户端消息:" + msg);
                    //向其他客户端转发消息
                    sendMsgToOther(msg, channel);
                }
    
            } catch (IOException e) {
                try {
                    System.out.println(channel.getRemoteAddress() + " 已下线");
                    //取消注册事件,并关闭通道
                    key.cancel();
                    channel.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
    
        }
    
        private void sendMsgToOther(String msg, SocketChannel self) {
            selector.keys().forEach(key -> {
                SelectableChannel channel = key.channel();
                if (channel instanceof SocketChannel && channel != self) {
                    //发给所有除自己意外的客户端
                    SocketChannel socketChannel = (SocketChannel) channel;
                    ByteBuffer src = ByteBuffer.wrap(msg.getBytes());
                    try {
                        socketChannel.write(src);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
    
        }
    
        public static void main(String[] args) {
            GroupChatServer server = new GroupChatServer();
            server.listen();
        }
    }
    
    

    客户端代码

    • 链接到服务器端,得到SocketChannel,并设置为非阻塞
    • 开启一个selector,并绑定read事件
    • 启动一个线程,每隔3秒,读取从服务器端发送过来的数据
    • 开启一个Scanner,通过控制台发送信息给服务端
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    import java.util.Scanner;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class GroupChatClient {
    
        private static final String SERVER = "127.0.0.1";
        private static final int PORT = 6666;
        private SocketChannel channel;
        private Selector selector;
        private String userName;
    
        public GroupChatClient() throws IOException {
            //链接到服务器
            channel = SocketChannel.open(new InetSocketAddress(SERVER, PORT));
            //设置为非阻塞
            channel.configureBlocking(false);
            selector = Selector.open();
            //绑定read事件到selector
            channel.register(selector, SelectionKey.OP_READ);
            userName = channel.getLocalAddress().toString();
            System.out.println(userName + " 我已上线");
        }
    
        public void sendInfo(String msg) {
            msg = userName + "说:" + msg;
            try {
                channel.write(ByteBuffer.wrap(msg.getBytes()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public void readInfo() {
            try {
                //线程阻塞,等待消息
                int count = selector.select();
                if (count > 0) {
                    Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                    while (keyIterator.hasNext()) {
                        SelectionKey key = keyIterator.next();
                        if (key.isReadable()) {
                            SocketChannel channel = (SocketChannel) key.channel();
                            //得到一个ByteBuffer
                            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                            //读取数据到Buffer
                            int read = channel.read(byteBuffer);
                            System.out.println(new String(byteBuffer.array(), 0, read));
                        }
                        //移除已处理的key
                        keyIterator.remove();
    
                    }
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws IOException {
            GroupChatClient groupChatClient = new GroupChatClient();
    
            //启动一个线程,每隔3秒,读取从服务器端发送过来的数据
            ExecutorService executor = Executors.newSingleThreadExecutor();
            executor.submit(() -> {
                while (true) {
                    groupChatClient.readInfo();
                    Thread.sleep(3000l);
                }
            });
    
            //发送数据给服务端
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String str = scanner.nextLine();
                groupChatClient.sendInfo(str);
            }
        }
    }
    

    测试

    1)启动服务端
    2)启动3个客户端

    服务端控制台

    服务端已启动
    /127.0.0.1:57806上线了
    /127.0.0.1:57814上线了
    /127.0.0.1:57825上线了
    转发客户端消息:/127.0.0.1:57825说:我是01
    转发客户端消息:/127.0.0.1:57814说:我是02
    转发客户端消息:/127.0.0.1:57806说:我是03
    /127.0.0.1:57825 已下线
    /127.0.0.1:57814 已下线
    /127.0.0.1:57806 已下线
    

    客户端控制台

    /127.0.0.1:57825 我已上线
    我是01
    /127.0.0.1:57814说:我是02
    /127.0.0.1:57806说:我是03
    
    /127.0.0.1:57814 我已上线
    /127.0.0.1:57825说:我是01
    我是02
    /127.0.0.1:57806说:我是03
    
    /127.0.0.1:57806 我已上线
    /127.0.0.1:57825说:我是01
    /127.0.0.1:57814说:我是02
    我是03
    
    展开全文
  • java的容易群聊实现

    2021-04-23 20:33:32
    import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;/*** 创建调用服务器线程的主类* @author Administrator**/public class ThreadMain {/*** @param args*/public stat...

    服务器总类:

    package GroupChat;

    import java.io.IOException;

    import java.net.ServerSocket;

    import java.net.Socket;

    /**

    * 创建调用服务器线程的主类

    * @author Administrator

    *

    */

    public class ThreadMain {

    /**

    * @param args

    */

    public static void main(String[] args) {

    ThreadMain tm=new ThreadMain();

    tm.StrSer(1234);

    }

    public void StrSer(int port){

    try {

    ServerSocket ss=new ServerSocket(port);

    System.out.println("服务器创建成功");

    while(true){

    Socket client=ss.accept();

    System.out.println("客户机连接");

    ServerThread st=new ServerThread(client);

    st.start();

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    服务器单个线程类:

    package GroupChat;

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStream;

    import java.io.InputStreamReader;

    import java.io.OutputStream;

    import java.net.Socket;

    /**

    * 创建服务器线程类,该类继承自Thread

    * @author Administrator

    *

    */

    public class ServerThread extends Thread{

    private Socket client;//服务器连接对象

    private OutputStream out;//输出流对象

    private InputStream in;//输入流对象

    public User use=new User();

    /**

    * 构造方法,传入该线程要处理的连接对象

    * @param lient:要处理的连接对象

    */

    public ServerThread(Socket client){

    this.client=client;

    }

    /**

    * 重写线程的Run方法

    */

    public void run(){

    //处理连接的方法

    ProcessChat();

    }

    /**

    * 处理连接的方法

    */

    private void ProcessChat() {

    try {

    out=client.getOutputStream();//获得相应的输出流对象

    in=client.getInputStream();//获得相应的输入流对象

    BufferedReader br=new BufferedReader(new InputStreamReader(in));//实例化缓冲读取信息的对象

    SendMsg("欢迎来到服务器\n请输入用户名:");

    use.name=br.readLine();

    SendMsg("请输入密码:");

    use.pew=br.readLine();

    boolean bool=DOT.Checkuse(use);//检验用户信息

    if(!bool){

    client.close();//如果检查不通过就关闭

    return;

    }

    ChatTool.AddThread(this);//添加线程

    use.logintime=System.currentTimeMillis();

    use.adress=client.getRemoteSocketAddress().toString();

    String str="";

    str=br.readLine();

    //当str为空时,也要退出。处理强行关闭客户机

    while(!"bye".equals(str)&&str!=null){

    System.out.println(use.name+":"+str);

    ChatTool.SendAll(use, str);

    str=br.readLine();

    }

    out.write(str.getBytes());

    ChatTool.DeleThread(this);

    client.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    /**

    * 向客户机发送信息的方法

    * @param string:要发送的信息

    */

    public void SendMsg(String str) {

    str=str+"\r\n";

    try {

    out.write(str.getBytes());

    out.flush();//强制输出

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    用户验证类(预加载好了几个用户):

    package GroupChat;

    import java.util.HashMap;

    import java.util.Map;

    /**

    * 创建验证用户信息的类,用来验证用户信息

    * @author Administrator

    *

    */

    public class DOT {

    private static Map map=new HashMap();

    /**

    * 创建验证用户信息的方法

    * @param use:要验证的用户

    * @return:是否成功

    */

    public static boolean Checkuse(User use){

    if(use.pew.equals(map.get(use.name))){

    return true;//验证成功就返回True

    }

    return false;

    }

    static{

    for(int i=0;i<5;i++){

    User use=new User();

    use.name="name"+i;

    use.pew="pew"+i;

    map.put(use.name,use.pew);//放入map中

    }

    }

    }

    存装静态方法:

    package GroupChat;

    import java.util.HashMap;

    import java.util.Map;

    /**

    * 创建验证用户信息的类,用来验证用户信息

    * @author Administrator

    *

    */

    public class DOT {

    private static Map map=new HashMap();

    /**

    * 创建验证用户信息的方法

    * @param use:要验证的用户

    * @return:是否成功

    */

    public static boolean Checkuse(User use){

    if(use.pew.equals(map.get(use.name))){

    return true;//验证成功就返回True

    }

    return false;

    }

    static{

    for(int i=0;i<5;i++){

    User use=new User();

    use.name="name"+i;

    use.pew="pew"+i;

    map.put(use.name,use.pew);//放入map中

    }

    }

    }

    用户类:

    package GroupChat;

    /**

    * 创建用户信息类,用来存放用户信息

    * @author Administrator

    *

    */

    public class User {

    public String name;//用户名字

    public String pew;//用户密码

    public long logintime;//用户的上线时间

    public String adress;//用户的地址

    }

    展开全文
  • java swing实现群聊功能

    2018-07-11 16:18:50
    群聊功能。使用java swing,socket,多线程实现。 1) 客户端用来接收和展示数据,服务器实现与底层数据的交互。 2) 实现服务器端与客户端的分离,如果要操作数据库,可以在服务器端改代码调用Model。 3) 实现用户...
  • 主要用servlet+jsp+Qracle实现聊天室的私聊+群聊功能,灵活运用了javaWeb的四个范围实现私聊
  • 主要介绍了java利用TCP协议实现小型局域网群聊功能(C/S模式) ,感兴趣的小伙伴们可以参考一下
  • java聊天室,采用BIO通信方式,支持群聊天,私聊功能,GUI界面,一键登录.。
  • Java聊天室(实现群聊、私聊功能)GUI界面

    千次阅读 多人点赞 2020-09-22 19:51:05
    一对多群聊。 1、先启动服务端,等待客户端连接…。 2、启动三个客户端,代表不同的用户。右上角分别选择不同的用户进行登录。 3、登录的用户可对所有用户发送消息,也可以对某个用户发送消息。 下面是具体的...

    不说废话,先看效果,目前实现的基本功能有一对一私聊。一对多群聊。
    1、先启动服务端,等待客户端连接…。
    在这里插入图片描述
    2、启动三个客户端,代表不同的用户。右上角分别选择不同的用户进行登录。
    在这里插入图片描述
    在这里插入图片描述
    3、登录的用户可对所有用户发送消息,也可以对某个用户发送消息。
    在这里插入图片描述
    下面是具体的代码实现(采用传统的BIO实现,也可参考我另一篇博客NIO实现其中的功能)。
    server端代码:

    package Server;
    
    import java.io.*;
    import java.net.*;
    import java.util.*;
    
    /*
    server端
     */
    
    
    public class ChatServer {
        private ServerSocket ss;
        private boolean flag = false;
        private Map<String, Client> clients = new HashMap<>();
    
        public static void main(String args[]) {
            new ChatServer().start();
        }
    
        public void start() {
            try {
                ss = new ServerSocket(8888);
                flag = true;
                System.out.println("Server启动成功...");
            } catch (BindException e) {
                System.out.println("端口使用中!!!");
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                //接收客户端的连接
                while (flag) {
                    //accept方法是一个阻塞的方法,会阻塞当前的线程。
                    Socket socket = ss.accept();
                    Client c = new Client(socket);
                    System.out.println("一个客户端已经连接...");
                    new Thread(c).start();
                }
            } catch (IOException e) {
                System.out.println("Client closed...");
            } finally {
                try {
                    if (ss != null)
                        ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
    
        private class Client implements Runnable {
            private Socket s;
            private String userName = "";
            private DataInputStream input = null;
            private DataOutputStream output = null;
            private boolean connected = false;
            private BufferedOutputStream fout = null;
            private String saveFilePath = "";
            public Client(Socket s) {
                this.s = s;
                try {
                    input = new DataInputStream(s.getInputStream());
                    output = new DataOutputStream(s.getOutputStream());
                    connected = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
            @Override
            public void run() {
                byte buffer[] = new byte[1024];
                int len = 0;
                try {
                    while (connected) {
                        String msg[] = input.readUTF().split("#");//msg={"  ","登录用户","目标用户","要发送的信息"}
                        switch (msg[0]) {
                            case "LOGIN":
                                String userName = msg[1];
                                if (clients.containsKey(userName)) {
                                    output.writeUTF("FAIL");//已经登录
                                    System.out.println("拒绝了一个重复连接...");
                                    closeConnect();
                                } else {
                                    output.writeUTF("SUCCESS");
                                    clients.put(userName, this);
                                    //将所有登录用户信息发送给新登录的用户
                                    StringBuffer allUsers = new StringBuffer();
                                    allUsers.append("ALLUSERS#");
                                    for (String user : clients.keySet())
                                        allUsers.append(user + "#");
                                    output.writeUTF(allUsers.toString());
                                    //将新登录的用户信息发送给其他用户
                                    String newLogin = "LOGIN#" + userName;
                                    sendMsg(userName, newLogin);
                                    this.userName = userName;
                                }
                                break;
                            case "LOGOUT":
                                clients.remove(this.userName);
                                String logoutMsg = "LOGOUT#" + this.userName;
                                sendMsg(this.userName, logoutMsg);
                                System.out.println("用户" + this.userName + "已下线...");
                                closeConnect();
                                break;
                            case "SENDONE":
                                Client c = clients.get(msg[1]);//获取目标用户的连接
                                String msgToOne="";
                                if (c != null) {
                                    msgToOne="SENDONE#" + this.userName + "#" + msg[2];
                                    c.output.writeUTF(msgToOne);
                                    c.output.flush();
                                }
                                break;
                            case "SENDALL":
                                String msgToAll = "";
                                msgToAll = "SENDALL#" + this.userName + "#" + msg[1];
                                sendMsg(this.userName, msgToAll);
                                break;
    
                        }
    
                    }
                } catch (IOException e) {
                    System.out.println("Client closed...");
                    connected = false;
                } finally {
    
                    try {
                        if (input != null)
                            input.close();
                        if (output != null)
                            output.close();
                        if (fout != null)
                            fout.close();
                        if (s != null)
                            s.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }
    
            public void closeConnect() {
                connected = false;
                try {
                    if (input != null)
                        input.close();
                    if (output != null)
                        output.close();
                    if (s != null)
                        s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            public void sendMsg(String fromUser, String msg) {
                String tempUser = "";
                try {
                    for (String toUser : clients.keySet()) {
                        if (!toUser.equals(fromUser)) {
                            tempUser = toUser;
                            DataOutputStream out = clients.get(toUser).output;
                            out.writeUTF(msg);
                            out.flush();
                        }
                    }
                } catch (IOException e) {
                    System.out.println("用户" + tempUser + "已经离线!!!");
                }
            }
        }
    }
    
    
    

    客户client端:

    package Client;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    import java.io.*;
    import java.net.Socket;
    import java.net.SocketException;
    /*
        客户client端
     */
    
    public class ChatClient extends JFrame {
        private JTextArea sendArea, contentArea;
        JPanel p1, p11, p12, p2, p21, p22;
        JComboBox<String> user1, user2;
        private RecvThread clientThread = null;
        private String filePath = null;
    
        public void start() {
            Container con = getContentPane();
            con.setLayout(new BorderLayout());
            Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
            int screenWidth = screenSize.width / 2;
            int screenHeight = screenSize.height / 2;
            int height = getHeight();
            int width = getWidth();
            setSize(350, 400);
            setLocation((screenWidth - width) / 2, (screenHeight - height) / 2);
            sendArea = new JTextArea(3, 10);//设置发送区域几行几列
            sendArea.setBorder(BorderFactory.createLineBorder(Color.BLUE, 1));
            sendArea.setLineWrap(true);
            sendArea.setWrapStyleWord(true);//激活断行不断字功能
            sendArea.addKeyListener(new KeyAdapter() {
                @Override
                public void keyPressed(KeyEvent e) {
                    if ('\n' == e.getKeyCode())
                        if (clientThread != null) {
                            clientThread.sendMsg();
                        }
                }
            });
            contentArea = new JTextArea(6, 10);
            contentArea.setBorder(BorderFactory.createLineBorder(Color.BLUE, 1));
            //北边接收消息区域
            p1 = new JPanel();
            p1.setLayout(new BorderLayout());
            p11 = new JPanel();
            p11.setLayout(new GridLayout(1, 2));
            JLabel l1 = new JLabel("选择你的身份:");
            user1 = new JComboBox<>();
            user1.addItem("-----选择-----");
            user1.addItem("张三");
            user1.addItem("李四");
            user1.addItem("王五");
            user1.addItem("小六");
    
            user1.addItemListener(e -> {
                if (e.getStateChange() == ItemEvent.SELECTED) {
    //                    System.out.println("选中的项:" + user1.getSelectedItem());
                    if (user1.getSelectedIndex() == 0) {
                        return;
                    }
                    clientThread = new RecvThread((String) user1.getSelectedItem());
                    new Thread(clientThread).start();
                }
            });
            p11.add(l1);
            p11.add(user1);
            p12 = new JPanel();
            p12.setLayout(new GridLayout(1, 1));
            p12.add(new JScrollPane(contentArea));
            p1.add(p11, BorderLayout.NORTH);
            p1.add(p12, BorderLayout.SOUTH);
            //南边发送消息区域
            p2 = new JPanel();
            p2.setLayout(new BorderLayout());
            p21 = new JPanel();
            p21.setLayout(new GridLayout(2, 2));
            user2 = new JComboBox<>();
            user2.addItem("所有用户");
            JLabel l2 = new JLabel("选择要发送的用户:");
    
            p21.add(l2);
            p21.add(user2);
            p22 = new JPanel();
            p22.setLayout(new GridLayout(1, 1));
            p22.add(new JScrollPane(sendArea));
            p2.add(p21, BorderLayout.NORTH);
            p2.add(p22, BorderLayout.SOUTH);
            con.add(p1, BorderLayout.NORTH);
            con.add(p2, BorderLayout.SOUTH);
            setVisible(true);
            setDefaultCloseOperation(EXIT_ON_CLOSE);
            addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {
                    if (clientThread != null)
                        clientThread.exit();
                    System.exit(0);
                }
            });
        }
    
        private class RecvThread implements Runnable {
            private Socket s = null;
            private DataInputStream in = null;
            private DataOutputStream out = null;
            private String userName;
            private boolean isLogin = false;
            StringBuilder msg = new StringBuilder();
    
            public RecvThread(String userName) {
                this.userName = userName;
            }
    
            //用户登录
            public void login() {
                try {
                    s = new Socket("127.0.0.1", 8888);//监听本机的8888端口
                    in = new DataInputStream(s.getInputStream());
                    out = new DataOutputStream(s.getOutputStream());
                    String sendMsg = "LOGIN#" + userName;
                    out.writeUTF(sendMsg);
                    out.flush();
                    //服务器返回的信息
                    String recv = in.readUTF();
                    if (recv.equals("FAIL")) {
                        showMsg(userName + "已经登录!!!");
                        user1.setEnabled(true);
                        exit();
                        return;
                    } else if (recv.equals("SUCCESS")) {
                        showMsg("登录成功!!!");
                        user1.setEnabled(false);
                        isLogin = true;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            public void exit() {//用户退出,释放资源
                try {
                    if (isLogin) {
                        out.writeUTF("LOGOUT");
                        out.flush();
                        isLogin = false;
                    }
                    if (in != null)
                        in.close();
                    if (out != null)
                        out.close();
                    if (s != null)
                        s.close();
    
                } catch (IOException e) {
                    System.out.println("连接已关闭!!!");
                }
            }
    
            //用户发送消息
            public void sendMsg() {
                int len = 0;
             //   String fileName = "";
                if (!isLogin) {
                    showMsg("没有登录,请登录!!!");
                    return;
                }
                msg.setLength(0);
                String sendInfo = sendArea.getText().trim();
                String user = (String) user2.getSelectedItem();
                if(sendInfo.equals(""))
                    sendInfo=" ";
                try {
    
                    if (user.equals("所有用户")) {//给所有用户发送消息
                        msg.append("SENDALL#");
    
                            msg.append(sendInfo);
    
    
                    } else {//只给某个用户发送消息
                        msg.append("SENDONE#");
                            msg.append(user+"#" + sendInfo);//如果这里sendinfo=SENDFILE那么可能就会发生错误。有待改进....
    
                    }
                    out.writeUTF(msg.toString());
                    showMsg("我说:" + sendInfo);
    
                    sendArea.setText("");
    
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
            @Override
            public void run() {
                login();
                try {
                    while (isLogin) {
                        String msgs[] = in.readUTF().split("#");
                        switch (msgs[0]) {
                            case "LOGIN":
                                user2.addItem(msgs[1]);//后面可以加个提示信息
                                break;
                            case "ALLUSERS":
                                for (int i = 1; i < msgs.length; i++) {
                                    if (!"".equals(msgs[i]))
                                        user2.addItem(msgs[i]);
                                }
                                break;
                            case "SENDONE":
    
                                    showMsg(msgs[1] + ":" + msgs[2]);
                                break;
                            case "SENDALL":
    
                                    showMsg(msgs[1] + "对所有人说:" + msgs[2]);
    
                                break;
                            case "LOGOUT":
                                showMsg("用户" + msgs[1] + "已下线!!!");
                                user2.removeItem(msgs[1]);
                                break;
                        }
                    }
                } catch (SocketException e) {
                    System.out.println(userName + "已退出...");
                } catch (IOException e) {
                    isLogin = false;//返回数据出现异常,退出登录
                    e.printStackTrace();
                }
            }
        }
    
        //设置显示信息
        public void showMsg(String msg) {
            contentArea.append(msg + "\n");
            contentArea.setCaretPosition(contentArea.getText().length());// 自动滚动到文本区的最后一行
        }
    
    
        public static void main(String args[]) {
            //将swing风格控件渲染成Windows风格
            try {
                UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
            } catch (Exception e) {
                e.printStackTrace();
            }
            new ChatClient().start();
        }
    }
    
    

    上面代码我都放在gitte上面,需要的自己去拿聊天室源代码

    展开全文
  • java聊天室群聊及私聊实现!

    千次阅读 2019-03-16 21:52:12
    java聊天室群聊及私聊实现! 一:业务逻辑 连接数据库,实现注册登录账号的功能 使用serverSocket接收并发送消息实现服务器功能 客户端使用socket与服务器交互 二:类设计及代码结构 MyMessage类:该类主要用于...
  • 预备小知识连接: 小小聊天室,慢慢的回忆啊!(TCP 通信实现) 先看效果 主要可以分为三个层:服务端层,客户端...import java.io.Closeable; import java.io.IOException; /** * 用于关闭的工具类 * */ publ
  • 3.多用户之间的群组聊天(群聊) 4.用户与用户之间的聊天(私聊),也称为悄悄话 5.聊天内容实时自动更新 6.管理员对非法用户的踢人功能。 7.保存聊天记录 8.清除聊天记录 9.程序各种情况的业务校验 10.人性化的提示
  • 利用Java实现的一个简单的群聊程序,模仿群聊,通过本地通讯,实现了简单的群聊功能,目的是为了熟悉Java的Socket、线程、输入/输出流、Swing以及利用javadoc生成HTML文档。练习时候写的,所以功能和界面都比较简单...
  • websocket实现群聊

    2021-05-23 20:51:48
    websocket实现群聊一、Server层代码层次图DL.javaWSServer.javaHelloServlet.java二、主页index.html三、实现效果图: 一、Server层 代码层次图 注意:端口号要一致9090 DL.java public class DL { /** * 私有的...
  • 是不是试了很多次都没有达到自己想要的效果呢? 没关系,看到这你就已经有收获了 文章目录一、动图效果展示二、服务端代码(核心)三、bug吐槽四、分享交流 一、动图效果展示 ...import java.util.conc
  • packagecom.dragon.java.tcpchat;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.PrintStream;importjava.net.InetAddress;importjava.net.Socket;importj...
  • 功能模型如下: 运行截图:1、需要先启动服务器端,界面如下: 2、启动2或2个以上个客户端(名字随机): 3、聊天结果: 代码部分:服务器端代码实现:package pack2;import java.net.*;import java...
  • java网络编程 socket通信实现多人聊天,群聊,私聊功能
  • Java 实现群消息聊天

    2021-08-20 11:37:32
    Java 实现群消息聊天
  • 主要为大家详细介绍了java Socket实现多人群聊与私聊功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 适合课设参考哦
  • java实现群聊功能

    2011-03-29 00:10:36
    java语言实现群聊系统的啦,绝对能用,放心。。。。。。。。
  • 主要介绍了JAVA Netty实现聊天室+私聊功能的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java网络编程:TCP实现群聊功能代码 实现的功能:群聊 具体操作流程的大致思路: 某个客户端发送消息,服务器将该消息转发给其余客户端(除了自己)。 代码一共分两个端(服务器和客户端(其中客户端一共3个代码))...
  • Java 实现局域网聊天室功能(私聊,群聊)
  • Java中用网络通信实现聊天室私聊和群聊功能客户端代码(Client):服务端代码(Server): 客户端代码(Client): package homework10.homework1015; import java.io.BufferedReader; import java.io.IOException; ...
  • Java网络编程,模拟QQ群聊功能

    千次阅读 2020-07-01 18:16:23
    Java网络编程,模拟QQ群聊功能 一、网络编程知识点简介: 1.C/S架构:Client客户端/Server服务器: 涉及到的应用:桌面的应用软件,QQ,王者荣耀 涉及到的技术:Socket网络编程 2.网络: 各个孤立的工作站或主机相连在...
  • 首先明确一下目的:实现一个服务端加多个客户端可用,带有群聊和私聊功能的小项目(通过控制台输入); 服务端 服务端起到了转发的作用,一个client通过发送消息给服务端,服务端接受到消息之后判断是要群发还是私发...
  • 本文主要来讲解如何使用WebSocket来实现一个简易的群聊功能 引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,800
精华内容 2,720
关键字:

java群聊功能

java 订阅