java基于TCP协议实现聊天程序

java程序设计之基于tcp协议的socket聊天程序 ，供大家参考，具体内容如下

一、程序实现的功能

1、进入客户端界面
2、创建昵称
3、群发信息
4、@私聊
5、下线通知
6、在线人数统计

二、整体架构图

三、简单介绍

本程序实现了基于tcp通信的聊天程序：

1 服务器端：

服务器端继承jframe框架，添加组件。创建服务器端的socket，起一个线程池，每接收到一个客户端的连接，分配给其一个线程处理与客户端的通信，将每个客户端的昵称和服务器分配给其的输出流存储到哈希表中。通过检索哈希表中昵称和输出流实现群聊和私聊。

2 客户端：

客户端继承jframe框架，添加组件。创建客户端的socket，输入昵称，创建客户端socket对应的输入流输出流，与服务器端建立通讯。

四、设计描述

本程序的实现是以服务器端为中继，客户端的所有信息都先发送给服务器端。服务器端辨别是否为私聊信息，私聊信息发送给相应的私聊对象，否则，发送给所有的客户端对象。

（一） 服务器端：

1.1 服务器端继承jframe框架，添加组件。
1.2 创建服务器端socket。建立一个哈希表，用于存储客户端的昵称以及服务器端对于每个连接的客户端建立的输出流。
1.3建立一个线程池，为每个连接的客户端分配一个执行线程。
1.3调用服务器端socket的accept（）函数，等待客户端的连接，每连接到一个客户端，线程池给相应的客户端分配一个线程。
1.4每个线程内，调用服务器端socket，封装getoutputstream（），获得服务器端socket相对应于连接的客户端的输出流和输入流。输入流首先读取到客户端发送来的昵称。将客户端的昵称和服务器端的输出流存储在哈希表中，并遍历整个哈希表，将某人上线的通知发送给所有的在线客户端。
1.5客户端将信息发送给服务器端，当服务器端传来的信息符合“@私聊对象：私聊信息”的格式时，服务器端认为这是私聊信息。服务器端将把私聊对象的昵称从信息中提取出来，通过哈希表找到与昵称对应的输出流。将私聊信息通过输出流发送给私聊对象。
当不是私聊信息时，服务器遍历整个哈希表，通过每个客户端对应的输出流发送给每个客户端。
1.6当客户端下线时，服务器端将移除哈希表中对应存储的客户端昵称以及输出流。并通知在线的每个客户端，某人已下线。

（二） 客户端：

2.1 客户端继承框架jframe，添加各种组件。
2.2 创建客户端socket，设置请求连接服务器端ip，以及使用的端口号。
2.3 封装客户端socket的getinputstream()函数，获得客户端socket的输入流接受服务器端发来的信息，封装socket的getoutputstream()函数，获得socket的输出流向服务器端发送信息。
2.4 通过向文本框添加动作事件监听器，监听文本框的输入。
2.5 当与服务器端连接成功时，系统提醒输入昵称。系统将对输入的昵称进行检索。判断是否有重复的昵称。如有重复则创建不成功，继续输入。
2.6 向服务器端发送信息时，如想对某人发送私聊信息，则需输入符合“@私聊对象的呢称：私聊信息”的格式，此时只有私聊对象和本人可以接收到。否则，发送的信息为公聊信息，所有的客户端都能够收到。
2.7 客户端不断接受服务器端的信息显示在文本域。

五、代码说话

1、服务器端：

package server;

import java.io.*; 
import java.net.*; 
import java.util.hashmap; 
import java.util.map; 
import java.util.concurrent.executorservice; 
import java.util.concurrent.executors; 
import java.util.concurrent.threadpoolexecutor; 
import javax.swing.*;
import java.awt.*;

public class tcpserver extends jframe{   

  private jtextarea m_display=new jtextarea();

  private serversocket serversocket; 

  /** 
  * 创建线程池来管理客户端的连接线程 
  * 避免系统资源过度浪费 
  */ 
  private executorservice exec; 

  // 存放客户端之间私聊的信息 
  private map<string,printwriter> storeinfo; 

  public tcpserver() { 
    super("聊天程序服务器端");
    container c=getcontentpane();
    c.add(new jscrollpane(m_display),borderlayout.center);
    try { 

      serversocket = new serversocket(6666); 
      storeinfo = new hashmap<string, printwriter>(); 
      exec = executors.newcachedthreadpool(); 

    } catch (exception e) { 
      e.printstacktrace(); 
    } 
  } 

  // 将客户端的信息以map形式存入集合中 
  private void putin(string key,printwriter value) { 
    synchronized(this) { 
      storeinfo.put(key, value); 
    } 
  } 

  // 将给定的输出流从共享集合中删除 
  private synchronized void remove(string key) { 
    storeinfo.remove(key); 
    m_display.append("当前在线人数为："+ storeinfo.size());
    //for(string name: storeinfo.key)
  } 

  // 将给定的消息转发给所有客户端 
  private synchronized void sendtoall(string message) { 
    for(printwriter out: storeinfo.values()) { 
      out.println(message); 


      // m_display.append("已经发送了");
    } 
  } 

  // 将给定的消息转发给私聊的客户端 
  private synchronized void sendtosomeone(string name,string message) { 
    printwriter pw = storeinfo.get(name); //将对应客户端的聊天信息取出作为私聊内容发送出去 
    if(pw != null) pw.println("私聊:   "+message);  
  } 

  public void start() { 
    try { 
      m_display.setvisible(true);
      //m_display.append("mayanshuo");
      while(true) { 

      m_display.append("等待客户端连接... ... \n"); 

      socket socket = serversocket.accept(); 

      // 获取客户端的ip地址 
      inetaddress address = socket.getinetaddress(); 
      m_display.append("客户端：“" + address.gethostaddress() + "”连接成功！ "); 
      /* 
      * 启动一个线程，由线程来处理客户端的请求，这样可以再次监听 
      * 下一个客户端的连接 
      */ 
      exec.execute(new listenrclient(socket)); //通过线程池来分配线程 
      } 
    } catch(exception e) { 
      e.printstacktrace(); 
    } 
  } 

  /** 
  * 该线程体用来处理给定的某一个客户端的消息，循环接收客户端发送 
  * 的每一个字符串，并输出到控制台 
  */ 
  class listenrclient implements runnable { 

    private socket socket; 
    private string name; 

    public listenrclient(socket socket) { 
      this.socket = socket; 
    } 

    // 创建内部类来获取昵称 
    private string getname() throws exception { 
      try { 
        //服务端的输入流读取客户端发送来的昵称输出流 
        bufferedreader breader = new bufferedreader( 
          new inputstreamreader(socket.getinputstream(), "utf-8")); 
        //服务端将昵称验证结果通过自身的输出流发送给客户端 
        printwriter ipw = new printwriter( 
          new outputstreamwriter(socket.getoutputstream(), "utf-8"),true); 

        //读取客户端发来的昵称 
        while(true) { 
          string namestring = breader.readline(); 
          if ((namestring.trim().length() == 0) || storeinfo.containskey(namestring)) { 
            ipw.println("fail"); 
          } else { 
            ipw.println("ok"); 
            return namestring; 
          } 
        } 
      } catch(exception e) { 
        throw e; 
      } 
    } 

    @override     
    public void run() { 
      try { 
        /* 
        * 通过服务器端的socket分配给每一个 
        * 用来将消息发送给客户端 
        */ 
        printwriter pw = new printwriter( 
          new outputstreamwriter(socket.getoutputstream(), "utf-8"), true); 

        /* 
        * 将客户昵称和其所说的内容存入共享集合hashmap中 
        */ 
        name = getname(); 
        putin(name, pw); 
        thread.sleep(100); 

        // 服务端通知所有客户端，某用户上线 
        sendtoall("*系统消息* “" + name + "”已上线"); 

        /* 
        * 通过客户端的socket获取输入流 
        * 读取客户端发送来的信息 
        */ 
        bufferedreader breader = new bufferedreader( 
          new inputstreamreader(socket.getinputstream(), "utf-8")); 
        string msgstring = null; 


        while((msgstring = breader.readline()) != null) { 
          // 检验是否为私聊（格式：@昵称：内容） 
          if(msgstring.startswith("@")) { 
            int index = msgstring.indexof("："); 
            if(index >= 0) { 
              //获取昵称 
              string thename = msgstring.substring(1, index); 
              string info = msgstring.substring(index+1, msgstring.length()); 
              info = name + "："+ info; 
              //将私聊信息发送出去 
              sendtosomeone(thename, info);

              sendtosomeone(name,info);

              continue; 
            } 
          } 
          // 遍历所有输出流，将该客户端发送的信息转发给所有客户端 
          m_display.append(name+"："+ msgstring+"\n"); 
          sendtoall(name+"："+ msgstring); 
        }   
      } catch (exception e) { 
        // e.printstacktrace(); 
      } finally { 
        remove(name); 
        // 通知所有客户端，某某客户已经下线 
        sendtoall("*系统消息* "+name + "已经下线了。\n"); 

        if(socket!=null) { 
          try { 
            socket.close(); 
          } catch(ioexception e) { 
            e.printstacktrace(); 
          } 
        }   
      } 
    } 
  } 

  public static void main(string[] args) { 
    tcpserver server = new tcpserver();
    server.setsize(400,400);
    server.setvisible(true);
    server.setdefaultcloseoperation(jframe.exit_on_close);
    server.start(); 
  } 
} 

2、客户端：

package server;

import java.io.*; 
import java.net.*; 
import java.util.scanner; 
import java.util.concurrent.executorservice; 
import java.util.concurrent.executors; 
import java.util.concurrent.threadpoolexecutor; 
import javax.swing.*;
import java.awt.*;
import java.awt.event.actionlistener;
import java.awt.event.actionevent;

public class tcpclient extends jframe { 

  private jtextfield m_enter=new jtextfield();
  private jtextarea m_display=new jtextarea();
  private int m_count=0;
  private static socket clientsocket; 
  //private executorservice exec = executors.newcachedthreadpool(); 
  private bufferedreader br;
  private printwriter pw;

  public tcpclient() 
  {
    super("聊天程序客户端");


    container c=getcontentpane();
    //m_enter.setsize(100,99);
    //m_display.setsize(200,100);
    m_enter.setvisible(true);
    m_display.setvisible(true);
    m_enter.requestfocusinwindow();   //转移输入焦点到输入区域

    //将光标放置在文本区域的尾部
    m_display.setcaretposition(m_display.gettext().length());


    c.add(m_enter,borderlayout.south);
    c.add(new jscrollpane(m_display),borderlayout.center); 
    // this.add(panel);
    // this.setcontentpane(jp);

  } 


  public static void main(string[] args) throws exception { 
    tcpclient client = new tcpclient();
    client.setvisible(true);
    client.setdefaultcloseoperation(jframe.exit_on_close);
    client.setsize(470,708);
    client.start(); 
  } 


  public void start() { 
    try { 
      m_display.append("请创建用户名：");
      clientsocket=new socket("localhost",6666);
      bufferedreader br = new bufferedreader( 
          new inputstreamreader(clientsocket.getinputstream(), "utf-8")); 
      printwriter pw = new printwriter( 
          new outputstreamwriter(clientsocket.getoutputstream(), "utf-8"), true); 
      //listenrservser l=new listenrservser();
      m_enter.addactionlistener(new actionlistener(){
        public void actionperformed(actionevent event)
        {
          try{
          string s=event.getactioncommand();
          m_enter.settext("");
           if(m_count==0)
          {
             pw.println(s);
             m_display.append("\n'"+s+"'"+"昵称设置成功。\n");

          }
          else
          {

              pw.println(s);

          }
          m_count++;

          }catch(exception e)
          {
            e.printstacktrace();
          }
        }
      });


      string msgstring;
      while((msgstring = br.readline())!= null) { 
        m_display.append(msgstring+"\n"); 
      } 


    } catch(exception e) { 
      e.printstacktrace(); 
    } finally { 
      if (clientsocket !=null) { 
        try { 
          clientsocket.close(); 
        } catch(ioexception e) { 
          e.printstacktrace(); 
        } 
      } 
    } 
  } 



} 

六、运行结果

1、这里是服务器端，显示当前连接人数，以及公聊信息：

 

2、此时为群内成员公聊：

这里创建了三个角色：马衍硕、李琦琦、小红。

3、私聊：

私聊格式“@名称：”+内容。
私聊时，只有私聊的两个人可以接收到信息，其余人接收不到交流信息。
例：马衍硕和李琦琦私聊，小红接收不到私聊信息。
马衍硕和李琦琦接收到了私聊信息：

小红没有接收到私聊信息：

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