java局域网聊天小程序

package chat;

import java.awt.borderlayout; //布置容器的边框布局

import java.awt.color;

import java.awt.container;

import java.awt.gridlayout; //布局处理器

import java.awt.toolkit; //抽象超类

import java.awt.event.actionevent; //指示发生了组件定义的动作的语义事件

import java.awt.event.actionlistener; //用于接收操作事件的侦听器接口

import java.awt.event.mouseevent; //指示组件中发生鼠标动作的事件

import java.awt.event.mouselistener; //鼠标事件的侦听器接口

import java.awt.event.windowadapter; //接收窗口事件的抽象适配器类。此类中的方法为空。此类存在的目的是方便创建侦听器对象

import java.awt.event.windowevent; //指示窗口状态改变的低级别事件

import java.io.bufferedreader; //提供通用的缓冲方式文本读取

import java.io.ioexception; //输入输出异常

import java.io.inputstreamreader; //字节流通向字符流的桥梁

import java.io.printwriter; //向文本输出流打印对象的格式化表示形式

import java.net.socket; //套接字，网络上的两个程序通过一个双向的通信连接实现数据交换的通信

import java.util.hashmap; // hashmap 是 map 接口的常用实现类

import java.util.map; //存数据，将键映射到值的对象

import java.util.stringtokenizer; //允许应用程序将字符串分解为标记

import javax.swing.borderfactory; //创建一个浮雕式的边框

import javax.swing.defaultlistmodel; //列表模型

import javax.swing.jbutton; //按钮

import javax.swing.jframe; //窗口

import javax.swing.jlabel; //标签

import javax.swing.jlist; //列表

import javax.swing.joptionpane; //对话框

import javax.swing.jpanel;

import javax.swing.jscrollpane; //视图

import javax.swing.jsplitpane; //分隔

import javax.swing.jtextarea; //多行文本

import javax.swing.jtextfield; //文本

import javax.swing.border.emptyborder; //一个占用空间但不执行绘制的空透明边框

import javax.swing.border.titledborder; //该类实现在指定位置以指定对齐方式显示字符串标题的任意边框

import oldchat.chatframe;

public class client

{

  private jframe frame;

  private jlist userlist;

  private jtextarea textarea;

  private jtextfield textfield;

  private jtextfield txt_port;

  private jtextfield txt_hostip;

  private jtextfield txt_name;

  private jbutton btn_start;

  private jbutton btn_stop;

  private jbutton btn_send;

  private jpanel northpanel;

  private jpanel southpanel;

  private jscrollpane rightscroll;

  private jscrollpane leftscroll;

  private jsplitpane centersplit;

  private defaultlistmodel listmodel;

  private boolean isconnected = false ;

  private socket socket; //创建套接字

  private printwriter writer;

  private bufferedreader reader;

  private messagethread messagethread; // 负责接收消息的线程

  private map<string, user> onlineusers = new hashmap<string, user>(); // 所有在线用户

  // 主方法,程序入口

  public static void main(string[] args)

  {

  new client();

  }

  // 执行发送

  public void send()

  {

  if (!isconnected)

  {

   joptionpane.showmessagedialog(frame, "还没有连接服务器，无法发送消息！" , "错误" ,

    joptionpane.error_message);

   return ;

  }

  string message = textfield.gettext().trim();

  if (message == null || message.equals( "" ))

  {

   joptionpane.showmessagedialog(frame, "消息不能为空！" , "错误" ,

    joptionpane.error_message);

   return ;

  }

  sendmessage(frame.gettitle() + "@" + "all" + "@" + message);

  textfield.settext( null );

  }

  // 构造方法

  public client()

  {

  textarea = new jtextarea();

  textarea.seteditable( false );

  textarea.setforeground(color.blue);

  textfield = new jtextfield();

  txt_port = new jtextfield( "6666" );

  txt_hostip = new jtextfield();

  txt_name = new jtextfield();

  btn_start = new jbutton( "连接" );

  btn_stop = new jbutton( "断开" );

  btn_send = new jbutton( "发送" );

  listmodel = new defaultlistmodel();

  userlist = new jlist(listmodel);

  northpanel = new jpanel();

  northpanel.setlayout( new gridlayout( 1 , 7 ));

  northpanel.add( new jlabel( "端口" ));

  northpanel.add(txt_port);

  northpanel.add( new jlabel( "服务器ip" ));

  northpanel.add(txt_hostip);

  northpanel.add( new jlabel( "姓名" ));

  northpanel.add(txt_name);

  northpanel.add(btn_start);

  northpanel.add(btn_stop);

  northpanel.setborder( new titledborder( "连接信息" ));

  rightscroll = new jscrollpane(textarea);

  rightscroll.setborder( new titledborder( "群聊消息显示区" ));

  leftscroll = new jscrollpane(userlist);

  leftscroll.setborder( new titledborder( "在线用户(双击私聊)" ));

  southpanel = new jpanel( new borderlayout());

  southpanel.add(textfield, "center" );

  southpanel.add(btn_send, "east" );

  southpanel.setborder( new titledborder( "写消息" ));

  centersplit = new jsplitpane(jsplitpane.horizontal_split, leftscroll,

   rightscroll);

  centersplit.setdividerlocation( 100 );

  frame = new jframe( "客户端" );

  // 更改jframe的图标：

  //frame.seticonimage(toolkit.getdefaulttoolkit().createimage(client.class.getresource("qq.jpg")));

  frame.setlayout( new borderlayout());

  frame.add(northpanel, "north" );

  frame.add(centersplit, "center" );

  frame.add(southpanel, "south" );

  frame.setsize( 600 , 400 );

  int screen_width = toolkit.getdefaulttoolkit().getscreensize().width;

  int screen_height = toolkit.getdefaulttoolkit().getscreensize().height;

  frame.setlocation((screen_width - frame.getwidth()) / 2 ,

   (screen_height - frame.getheight()) / 2 );

  frame.setvisible( true );

  // 写消息的文本框中按回车键时事件

  textfield.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent arg0)

   {

   send();

   }

  });

  // 单击发送按钮时事件

  btn_send.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   send();

   }

  });

  // 单击连接按钮时事件

  btn_start.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   int port;

   if (isconnected) {

    joptionpane.showmessagedialog(frame, "已处于连接上状态，不要重复连接!" ,

     "错误" , joptionpane.error_message);

    return ;

   }

   try {

    try {

    port = integer.parseint(txt_port.gettext().trim());

    } catch (numberformatexception e2) {

    throw new exception( "端口号不符合要求!端口为整数!" );

    }

    string hostip = txt_hostip.gettext().trim();

    string name = txt_name.gettext().trim();

    if (name.equals( "" ) || hostip.equals( "" )) {

    throw new exception( "姓名、服务器ip不能为空!" );

    }

    boolean flag = connectserver(port, hostip, name);

    if (flag == false ) {

    throw new exception( "与服务器连接失败!" );

    }

    frame.settitle(name);

    joptionpane.showmessagedialog(frame, "成功连接!" );

   } catch (exception exc) {

    joptionpane.showmessagedialog(frame, exc.getmessage(),

     "错误" , joptionpane.error_message);

   }

   }

  });

//双击聊天（私聊）

  userlist.addmouselistener( new mouselistener()

  {

   public void mousereleased(mouseevent e) {}

   public void mousepressed(mouseevent e) {}

   public void mouseexited(mouseevent e) {}

   public void mouseentered(mouseevent e) {}

   public void mouseclicked(mouseevent e)

   {

   if (e.getclickcount()== 2 )

   {

    user user=onlineusers.get(userlist.getselectedvalue());

     chatframe.main(user.getip());;

   }

   }

  });

  // 单击断开按钮时事件

  btn_stop.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   if (!isconnected) {

    joptionpane.showmessagedialog(frame, "已处于断开状态，不要重复断开!" ,

     "错误" , joptionpane.error_message);

    return ;

   }

   try {

    boolean flag = closeconnection(); // 断开连接

    if (flag == false ) {

    throw new exception( "断开连接发生异常！" );

    }

    joptionpane.showmessagedialog(frame, "成功断开!" );

   } catch (exception exc) {

    joptionpane.showmessagedialog(frame, exc.getmessage(),

     "错误" , joptionpane.error_message);

   }

   }

  });

  // 关闭窗口时事件

  frame.addwindowlistener( new windowadapter()

  {

   public void windowclosing(windowevent e)

   {

   if (isconnected) {

    closeconnection(); // 关闭连接

   }

   system.exit( 0 ); // 退出程序

   }

  });

  }

  /**

  * 连接服务器

  *

  * @param port

  * @param hostip

  * @param name

  */

  public boolean connectserver( int port, string hostip, string name)

  {

  // 连接服务器

  try {

   socket = new socket(hostip, port); // 根据端口号和服务器ip建立连接

   writer = new printwriter(socket.getoutputstream());

   reader = new bufferedreader( new inputstreamreader(socket

    .getinputstream()));

   // 发送客户端用户基本信息(用户名和ip地址)

   sendmessage(name + "@" + socket.getlocaladdress().tostring());

   // 开启接收消息的线程

   messagethread = new messagethread(reader, textarea);

   messagethread.start();

   isconnected = true ; // 已经连接上了

   return true ;

  } catch (exception e) {

   textarea.append( "与端口号为：" + port + "  ip地址为：" + hostip

    + "  的服务器连接失败!" + "\r\n" );

   isconnected = false ; // 未连接上

   return false ;

  }

  }

  /**

  * 发送消息

  *

  * @param message

  */

  public void sendmessage(string message)

  {

  writer.println(message);

  writer.flush();

  }

  /**

  * 客户端主动关闭连接

  */

  @suppresswarnings ( "deprecation" )

  public synchronized boolean closeconnection()

  {

  try {

   sendmessage( "close" ); // 发送断开连接命令给服务器

   messagethread.stop(); // 停止接受消息线程

   // 释放资源

   if (reader != null ) {

   reader.close();

   }

   if (writer != null ) {

   writer.close();

   }

   if (socket != null ) {

   socket.close();

   }

   isconnected = false ;

   return true ;

  } catch (ioexception e1) {

   e1.printstacktrace();

   isconnected = true ;

   return false ;

  }

  }

  // 不断接收消息的线程

  class messagethread extends thread {

  private bufferedreader reader;

  private jtextarea textarea;

  // 接收消息线程的构造方法

  public messagethread(bufferedreader reader, jtextarea textarea)

  {

   this .reader = reader;

   this .textarea = textarea;

  }

  // 被动的关闭连接

  public synchronized void closecon() throws exception

  {

   // 清空用户列表

   listmodel.removeallelements();

   // 被动的关闭连接释放资源

   if (reader != null ) {

   reader.close();

   }

   if (writer != null ) {

   writer.close();

   }

   if (socket != null ) {

   socket.close();

   }

   isconnected = false ; // 修改状态为断开

  }

  public void run() {

   string message = "" ;

   while ( true ) {

   try {

    message = reader.readline();

    stringtokenizer stringtokenizer = new stringtokenizer(message, "/@" );

    string command = stringtokenizer.nexttoken(); // 命令

    if (command.equals( "close" )) // 服务器已关闭命令

    {

    textarea.append( "服务器已关闭!\r\n" );

    closecon(); // 被动的关闭连接

    return ; // 结束线程

    } else if (command.equals( "add" )) { // 有用户上线更新在线列表

    string username = "" ;

    string userip = "" ;

    if ((username = stringtokenizer.nexttoken()) != null

     && (userip = stringtokenizer.nexttoken()) != null )

    {

     user user = new user(username, userip);

     onlineusers.put(username, user);

     listmodel.addelement(username);

    }

    } else if (command.equals( "delete" )) { // 有用户下线更新在线列表

    string username = stringtokenizer.nexttoken();

    user user = (user) onlineusers.get(username);

    onlineusers.remove(user);

    listmodel.removeelement(username);

    } else if (command.equals( "userlist" )) { // 加载在线用户列表

    int size = integer

     .parseint(stringtokenizer.nexttoken());

    string username = null ;

    string userip = null ;

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

     username = stringtokenizer.nexttoken();

     userip = stringtokenizer.nexttoken();

     user user = new user(username, userip);

     onlineusers.put(username, user);

     listmodel.addelement(username);

    }

    } else if (command.equals( "max" )) { // 人数已达上限

    textarea.append(stringtokenizer.nexttoken()

     + stringtokenizer.nexttoken() + "\r\n" );

    closecon(); // 被动的关闭连接

    joptionpane.showmessagedialog(frame, "服务器缓冲区已满！" , "错误" ,

     joptionpane.error_message);

    return ; // 结束线程

    } else { // 普通消息

    textarea.append(message + "\r\n" );

    }

   } catch (ioexception e) {

    e.printstacktrace();

   } catch (exception e) {

    e.printstacktrace();

   }

   }

  }

  }

}

package chat;

import java.awt.borderlayout;

import java.awt.color;

import java.awt.gridlayout;

import java.awt.toolkit;

import java.awt.event.actionevent;

import java.awt.event.actionlistener;

import java.awt.event.windowadapter;

import java.awt.event.windowevent;

import java.io.bufferedreader;

import java.io.ioexception;

import java.io.inputstreamreader;

import java.io.printwriter;

import java.net.bindexception;

import java.net.serversocket;

import java.net.socket;

import java.util.arraylist;

import java.util.stringtokenizer;

import javax.swing.defaultlistmodel;

import javax.swing.jbutton;

import javax.swing.jframe;

import javax.swing.jlabel;

import javax.swing.jlist;

import javax.swing.joptionpane;

import javax.swing.jpanel;

import javax.swing.jscrollpane;

import javax.swing.jsplitpane;

import javax.swing.jtextarea;

import javax.swing.jtextfield;

import javax.swing.border.titledborder;

public class server

{

  private jframe frame;

  private jtextarea contentarea;

  private jtextfield txt_message;

  private jtextfield txt_max;

  private jtextfield txt_port;

  private jbutton btn_start;

  private jbutton btn_stop;

  private jbutton btn_send;

  private jpanel northpanel;

  private jpanel southpanel;

  private jscrollpane rightpanel;

  private jscrollpane leftpanel;

  private jsplitpane centersplit;

  private jlist userlist;

  private defaultlistmodel listmodel;

  private serversocket serversocket;

  private serverthread serverthread;

  private arraylist<clientthread> clients;

  private boolean isstart = false ;

  // 主方法,程序执行入口

  public static void main(string[] args)

  {

  new server();

  }

  // 执行消息发送

  public void send()

  {

  if (!isstart)

  {

   joptionpane.showmessagedialog(frame, "服务器还未启动,不能发送消息！" , "错误" ,

    joptionpane.error_message);

   return ;

  }

  if (clients.size() == 0 )

  {

   joptionpane.showmessagedialog(frame, "没有用户在线,不能发送消息！" , "错误" ,

    joptionpane.error_message);

   return ;

  }

  string message = txt_message.gettext().trim();

  if (message == null || message.equals( "" ))

  {

   joptionpane.showmessagedialog(frame, "消息不能为空！" , "错误" ,

    joptionpane.error_message);

   return ;

  }

  sendservermessage(message); // 群发服务器消息

  contentarea.append( "服务器说：" + txt_message.gettext() + "\r\n" );

  txt_message.settext( null );

  }

  // 构造放法

  public server()

  {

  frame = new jframe( "服务器" );

  // 更改jframe的图标：

  //frame.seticonimage(toolkit.getdefaulttoolkit().createimage(client.class.getresource("qq.png")));

  //frame.seticonimage(toolkit.getdefaulttoolkit().createimage(server.class.getresource("qq.jpg")));

  contentarea = new jtextarea();

  contentarea.seteditable( false );

  contentarea.setforeground(color.blue);

  txt_message = new jtextfield();

  txt_max = new jtextfield( "30" );

  txt_port = new jtextfield( "6666" );

  btn_start = new jbutton( "启动" );

  btn_stop = new jbutton( "停止" );

  btn_send = new jbutton( "发送" );

  btn_stop.setenabled( false );

  listmodel = new defaultlistmodel();

  userlist = new jlist(listmodel);

  southpanel = new jpanel( new borderlayout());

  southpanel.setborder( new titledborder( "写消息" ));

  southpanel.add(txt_message, "center" );

  southpanel.add(btn_send, "east" );

  leftpanel = new jscrollpane(userlist);

  leftpanel.setborder( new titledborder( "在线用户" ));

  rightpanel = new jscrollpane(contentarea);

  rightpanel.setborder( new titledborder( "群聊消息显示区" ));

  centersplit = new jsplitpane(jsplitpane.horizontal_split, leftpanel,

   rightpanel);

  centersplit.setdividerlocation( 100 );

  northpanel = new jpanel();

  northpanel.setlayout( new gridlayout( 1 , 6 ));

  northpanel.add( new jlabel( "人数上限" ));

  northpanel.add(txt_max);

  northpanel.add( new jlabel( "端口" ));

  northpanel.add(txt_port);

  northpanel.add(btn_start);

  northpanel.add(btn_stop);

  northpanel.setborder( new titledborder( "配置信息" ));

  frame.setlayout( new borderlayout());

  frame.add(northpanel, "north" );

  frame.add(centersplit, "center" );

  frame.add(southpanel, "south" );

  frame.setsize( 600 , 400 );

  //frame.setsize(toolkit.getdefaulttoolkit().getscreensize());//设置全屏

  int screen_width = toolkit.getdefaulttoolkit().getscreensize().width;

  int screen_height = toolkit.getdefaulttoolkit().getscreensize().height;

  frame.setlocation((screen_width - frame.getwidth()) / 2 ,

   (screen_height - frame.getheight()) / 2 );

  frame.setvisible( true );

  // 关闭窗口时事件

  frame.addwindowlistener( new windowadapter()

  {

   public void windowclosing(windowevent e)

   {

   if (isstart) {

    closeserver(); // 关闭服务器

   }

   system.exit( 0 ); // 退出程序

   }

  });

  // 文本框按回车键时事件

  txt_message.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   send();

   }

  });

  // 单击发送按钮时事件

  btn_send.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent arg0)

   {

   send();

   }

  });

  // 单击启动服务器按钮时事件

  btn_start.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   if (isstart) {

    joptionpane.showmessagedialog(frame, "服务器已处于启动状态，不要重复启动！" ,

     "错误" , joptionpane.error_message);

    return ;

   }

   int max;

   int port;

   try {

    try {

    max = integer.parseint(txt_max.gettext());

    } catch (exception e1) {

    throw new exception( "人数上限为正整数！" );

    }

    if (max <= 0 ) {

    throw new exception( "人数上限为正整数！" );

    }

    try {

    port = integer.parseint(txt_port.gettext());

    } catch (exception e1) {

    throw new exception( "端口号为正整数！" );

    }

    if (port <= 0 ) {

    throw new exception( "端口号 为正整数！" );

    }

    serverstart(max, port);

    contentarea.append( "服务器已成功启动!人数上限：" + max + ",端口：" + port

     + "\r\n" );

    joptionpane.showmessagedialog(frame, "服务器成功启动!" );

    btn_start.setenabled( false );

    txt_max.setenabled( false );

    txt_port.setenabled( false );

    btn_stop.setenabled( true );

   } catch (exception exc) {

    joptionpane.showmessagedialog(frame, exc.getmessage(),

     "错误" , joptionpane.error_message);

   }

   }

  });

  // 单击停止服务器按钮时事件

  btn_stop.addactionlistener( new actionlistener()

  {

   public void actionperformed(actionevent e)

   {

   if (!isstart) {

    joptionpane.showmessagedialog(frame, "服务器还未启动，无需停止！" , "错误" ,

     joptionpane.error_message);

    return ;

   }

   try {

    closeserver();

    btn_start.setenabled( true );

    txt_max.setenabled( true );

    txt_port.setenabled( true );

    btn_stop.setenabled( false );

    contentarea.append( "服务器成功停止!\r\n" );

    joptionpane.showmessagedialog(frame, "服务器成功停止！" );

   } catch (exception exc) {

    joptionpane.showmessagedialog(frame, "停止服务器发生异常！" , "错误" ,

     joptionpane.error_message);

   }

   }

  });

  }

  // 启动服务器

  public void serverstart( int max, int port) throws java.net.bindexception

  {

  try {

   clients = new arraylist<clientthread>();

   serversocket = new serversocket(port);

   serverthread = new serverthread(serversocket, max);

   serverthread.start();

   isstart = true ;

  } catch (bindexception e) {

   isstart = false ;

   throw new bindexception( "端口号已被占用，请换一个！" );

  } catch (exception e1) {

   e1.printstacktrace();

   isstart = false ;

   throw new bindexception( "启动服务器异常！" );

  }

  }

  // 关闭服务器

  @suppresswarnings ( "deprecation" )

  public void closeserver() {

  try {

   if (serverthread != null )

   serverthread.stop(); // 停止服务器线程

   for ( int i = clients.size() - 1 ; i >= 0 ; i--) {

   // 给所有在线用户发送关闭命令

   clients.get(i).getwriter().println( "close" );

   clients.get(i).getwriter().flush();

   // 释放资源

   clients.get(i).stop(); // 停止此条为客户端服务的线程

   clients.get(i).reader.close();

   clients.get(i).writer.close();

   clients.get(i).socket.close();

   clients.remove(i);

   }

   if (serversocket != null ) {

   serversocket.close(); // 关闭服务器端连接

   }

   listmodel.removeallelements(); // 清空用户列表

   isstart = false ;

  } catch (ioexception e) {

   e.printstacktrace();

   isstart = true ;

  }

  }

  // 群发服务器消息

  public void sendservermessage(string message) {

  for ( int i = clients.size() - 1 ; i >= 0 ; i--) {

   clients.get(i).getwriter().println( "服务器：" + message);

   clients.get(i).getwriter().flush();

  }

  }

  // 服务器线程

  class serverthread extends thread {

  private serversocket serversocket;

  private int max; // 人数上限

  // 服务器线程的构造方法

  public serverthread(serversocket serversocket, int max) {

   this .serversocket = serversocket;

   this .max = max;

  }

  public void run() {

   while ( true ) { // 不停的等待客户端的链接

   try {

    socket socket = serversocket.accept();

    if (clients.size() == max) { // 如果已达人数上限

    bufferedreader r = new bufferedreader(

     new inputstreamreader(socket.getinputstream()));

    printwriter w = new printwriter(socket

     .getoutputstream());

    // 接收客户端的基本用户信息

    string inf = r.readline();

    stringtokenizer st = new stringtokenizer(inf, "@" );

    user user = new user(st.nexttoken(), st.nexttoken());

    // 反馈连接成功信息

    w.println( "max@服务器：对不起，" + user.getname()

     + user.getip() + "，服务器在线人数已达上限，请稍后尝试连接！" );

    w.flush();

    // 释放资源

    r.close();

    w.close();

    socket.close();

    continue ;

    }

    clientthread client = new clientthread(socket);

    client.start(); // 开启对此客户端服务的线程

    clients.add(client);

    listmodel.addelement(client.getuser().getname()); // 更新在线列表

    contentarea.append(client.getuser().getname()

     + client.getuser().getip() + "上线!\r\n" );

   } catch (ioexception e) {

    e.printstacktrace();

   }

   }

  }

  }

  // 为一个客户端服务的线程

  class clientthread extends thread

  {

  private socket socket;

  private bufferedreader reader;

  private printwriter writer;

  private user user;

  public bufferedreader getreader()

  {

   return reader;

  }

  public printwriter getwriter()

  {

   return writer;

  }

  public user getuser()

  {

   return user;

  }

  // 客户端线程的构造方法

  public clientthread(socket socket)

  {

   try {

   this .socket = socket;

   reader = new bufferedreader( new inputstreamreader(socket

    .getinputstream()));

   writer = new printwriter(socket.getoutputstream());

   // 接收客户端的基本用户信息

   string inf = reader.readline();

   stringtokenizer st = new stringtokenizer(inf, "@" );

   user = new user(st.nexttoken(), st.nexttoken());

   // 反馈连接成功信息

   writer.println(user.getname() + user.getip() + "与服务器连接成功!" );

   writer.flush();

   // 反馈当前在线用户信息

   if (clients.size() > 0 )

   {

    string temp = "" ;

    for ( int i = clients.size() - 1 ; i >= 0 ; i--)

    {

    temp += (clients.get(i).getuser().getname() + "/" + clients

     .get(i).getuser().getip())

     + "@" ;

    }

    writer.println( "userlist@" + clients.size() + "@" + temp);

    writer.flush();

   }

   // 向所有在线用户发送该用户上线命令

   for ( int i = clients.size() - 1 ; i >= 0 ; i--)

   {

    clients.get(i).getwriter().println(

     "add@" + user.getname() + user.getip());

    clients.get(i).getwriter().flush();

   }

   } catch (ioexception e)

   {

   e.printstacktrace();

   }

  }

  @suppresswarnings ( "deprecation" )

  public void run() { // 不断接收客户端的消息，进行处理。

   string message = null ;

   while ( true ) {

   try {

    message = reader.readline(); // 接收客户端消息

    if (message.equals( "close" )) // 下线命令

    {

    contentarea.append( this .getuser().getname()

     + this .getuser().getip() + "下线!\r\n" );

    // 断开连接释放资源

    reader.close();

    writer.close();

    socket.close();

    // 向所有在线用户发送该用户的下线命令

    for ( int i = clients.size() - 1 ; i >= 0 ; i--)

    {

     clients.get(i).getwriter().println(

      "delete@" + user.getname());

     clients.get(i).getwriter().flush();

    }

    listmodel.removeelement(user.getname()); // 更新在线列表

    // 删除此条客户端服务线程

    for ( int i = clients.size() - 1 ; i >= 0 ; i--)

    {

     if (clients.get(i).getuser() == user)

     {

     clientthread temp = clients.get(i);

     clients.remove(i); // 删除此用户的服务线程

     temp.stop(); // 停止这条服务线程

     return ;

     }

    }

    } else {

    dispatchermessage(message); // 转发消息

    }

   } catch (ioexception e)

   {

    e.printstacktrace();

   }

   }

  }

  // 转发消息

  public void dispatchermessage(string message)

  {

   stringtokenizer stringtokenizer = new stringtokenizer(message, "@" );

   string source = stringtokenizer.nexttoken();

   string owner = stringtokenizer.nexttoken();

   string content = stringtokenizer.nexttoken();

   message = source + "说：" + content;

   contentarea.append(message + "\r\n" );

   if (owner.equals( "all" )) { // 群发

   for ( int i = clients.size() - 1 ; i >= 0 ; i--) {

    clients.get(i).getwriter().println(message);

    clients.get(i).getwriter().flush();

   }

   }

  }

  }

}