java实现基于Tcp的socket聊天程序

package jack;

import java.awt.list;

import java.awt.event.actionevent;

import java.awt.event.actionlistener;

import java.io.bufferedreader;

import java.io.datainputstream;

import java.io.dataoutputstream;

import java.io.eofexception;

import java.io.ioexception;

import java.io.inputstream;

import java.io.inputstreamreader;

import java.io.printwriter;

import java.net.serversocket;

import java.net.socket;

import java.time.format.textstyle;

import java.util.arraylist;

import javax.swing.jbutton;

import javax.swing.jframe;

import javax.swing.jlabel;

import javax.swing.jpanel;

import javax.swing.jscrollpane;

import javax.swing.jtabbedpane;

import javax.swing.jtextarea;

import javax.swing.jtextfield;

import javax.swing.jtoolbar;

import javax.swing.plaf.basic.basictabbedpaneui.tabbedpanelayout;

import javax.xml.bind.annotation.adapters.xmljavatypeadapter. default ;

import org.omg.corba.private_member;

/**

  * 被请求连接时称为服务器；主动连接对方时称为客户端。

  * @author administrator

  *

  */

public class client4 extends jframe implements actionlistener{

  private static int sign = 0 ;    //用来记录选项卡的标签，0标示第一个。

  private jtoolbar toolbar1,toolbar2;

  private jlabel waitportlabel,hostlabel,portlabel;

  private jtextfield waitporttf,hosttf,porttf,sendtf;

  private jtabbedpane tab;

  private jbutton sendb,leaveb,deleteb,connb;

  private arraylist<chatthread> serverthreads; //存放服务器线程的容器。即存放被请求连接时所创建的线程的容器。

  private arraylist<chatthread> clientthreads; //存放客户端线程的容器。即存放主动连接对方时所创建的线程的容器。

  private arraylist<serversocket> servers;  //服务对象的容器。

  private arraylist<myjtextarea> servertextareas; //作为服务器时，存放所创建的对话记录显示区域的容器。

  private arraylist<myjtextarea> clienttextareas; //作为客户端时，岑芳所创建的对话记录显示区域的容器。

  private arraylist<socket> serversockets;  //存放被请求连接时所创建的socket的容器。

  private arraylist<socket> clientsockets; //存放主动请求连接时所创立的socket的容器。

  private arraylist<printwriter> serverpwriters;  //存放服务端输出流对象的容器。

  private arraylist<bufferedreader> serverbreaders; //存放服务端输入流对象的容器。

  private arraylist<printwriter> clientpwriters;  //存放客户端输出流对象的容器。

  private arraylist<bufferedreader> clientbreaders; //存放客户端输入流对象的容器。

  private arraylist<integer> ports;  //存放作为服务器时已连接的端口。

  private int port = 2041 ; //指定自己开放的第一个端口号，方便其他人连接。

  private string name;     //储存自己的名称。

  public client4(string name) throws ioexception{

  super (name);

  this .name = name;    

  toolbar1 = new jtoolbar();

  toolbar2 = new jtoolbar();

  waitportlabel = new jlabel( "等待端口" );

  hostlabel = new jlabel( "主机" );

  portlabel = new jlabel( "端口" );

  waitporttf = new jtextfield( "2041" );

  hosttf = new jtextfield( "127.0.0.1" );

  porttf = new jtextfield( 5 );

  sendtf = new jtextfield();

  tab = new jtabbedpane();

  sendb = new jbutton( "发送" );

  leaveb = new jbutton( "离线" );

  deleteb = new jbutton( "删除页" );

  connb = new jbutton( "连接端口" );

  servers = new arraylist<serversocket>();

  servertextareas = new arraylist<myjtextarea>();

  clienttextareas = new arraylist<myjtextarea>();

  serversockets = new arraylist<socket>();

  clientsockets = new arraylist<socket>();

  serverpwriters = new arraylist<printwriter>();

  serverbreaders = new arraylist<bufferedreader>();

  clientpwriters = new arraylist<printwriter>();

  clientbreaders = new arraylist<bufferedreader>();

  serverthreads = new arraylist<chatthread>();

  clientthreads = new arraylist<chatthread>();

  ports = new arraylist<integer>();

  toolbar1.add(waitportlabel);

  toolbar1.add(waitporttf);

  toolbar1.add(hostlabel);

  toolbar1.add(hosttf);

  toolbar1.add(portlabel);

  toolbar1.add(porttf);

  toolbar1.add(connb);

  toolbar2.add(sendtf);

  toolbar2.add(sendb);

  toolbar2.add(leaveb);

  toolbar2.add(deleteb);

  waitporttf.setenabled( false );   //设置等待的textfield不可以编辑。

  hosttf.setenabled( false ); //设置连接的ip地址不可编辑，当然这里可以更改成其他电脑的ip地址。

  this .getcontentpane().add(toolbar1, "north" ); //添加工具栏到最上方。

  this .getcontentpane().add(tab, "center" ); //添加选项卡窗格。

  this .getcontentpane().add(toolbar2, "south" ); //添加工具栏到下方。

  this .setbounds( 200 , 200 , 350 , 300 );

  this .setvisible( true );

  this .setdefaultcloseoperation(jframe.exit_on_close);

  sendb.addactionlistener( this );

  leaveb.addactionlistener( this );

  deleteb.addactionlistener( this );

  connb.addactionlistener( this );

  //主线程进入之后 在server.accept()阻塞等待客户端来连接。

  while ( true ){

  serversocket server = new serversocket(port); //作为服务器，开发自己供连接的端口。

  servers.add(server); 

  socket serversocket = server.accept();  //等待对方连接。

  serversockets.add(serversocket);

  ports.add(port);   //将已连接的端口加入容器。

  printwriter serverpwriter = new printwriter(serversocket.getoutputstream(), true ); //初始化输出流对象。

  serverpwriters.add(serverpwriter);

  bufferedreader serverbreader = new bufferedreader( new inputstreamreader(serversocket.getinputstream())); //初始化输入流对象。

  serverbreaders.add(serverbreader);

  serverpwriter.println( "连接" +name+ "成功" );  //将连接成功的消息发送给请求方，提醒对方连接成功。

  serverpwriter.println(name);  //将自己的名称发送给对方，方便对方设置选项卡的名称。

  string content = serverbreader.readline();  //此时对方也发送了上面两条消息过来。读入对方发送过来的提醒消息。

  string name2 = serverbreader.readline(); //读取对方的名称。方便后面设置选项卡的名称。

  system.out.println(content);

  system.out.println(name2);

  myjtextarea servertextarea = new myjtextarea(sign);

  sign++;      //new了一个textarea后，sign自动增加1，好和选项卡对应，

        //知道这个选项卡加到哪个容器了，是服务器的还是客户端的。

  servertextareas.add(servertextarea);

  this .tab.addtab(name2, new jscrollpane(servertextarea)); //在选项卡窗格中添加一个选项卡。

  servertextarea.seteditable( false ); //设置对话记录显示区域不可编辑。

  servertextarea.setlinewrap( true ); //设置对话记录显示区域自动换行。

  servertextarea.append(content+ "\n" ); //在对话记录区域输出连接成功这条消息。

  chatthread thread = new chatthread(); //new了一个线程去执行run方法，用于和对方交流，对方也会开启一个线程来和你交流。

   //这里要开启新线程的原因是main线程经过一轮后会在上面accept方法处阻塞。

  serverthreads.add(thread);

  thread.start();     //启动该线程，方便接收对方发来的消息。

  port++;  //端口号加一，开放下一个供连接的端口。

  waitporttf.settext(port+ "" );   //更新显示等待的下个端口。

  }

  }

  private class chatthread extends thread {

  private string[] servercontents = new string[ 10 ]; //当作为服务端时，用来存放相互发送消息时的一句话。

  private string[] clientcontents = new string[ 10 ]; //当作为客户端时，用来存放相互发送消息时的一句话。

  private boolean isserverthread = true ;  //判断当前在执行run方法的线程是不是服务端线程。

  @override

  public void run() {

  while ( true ){

  if (serverthreads.size()> 0 ){ //判断当前的线程是否是服务线程。先判断是否大于0，是为了防止serverthreads

  for ( int i= 0 ;i<serverthreads.size();i++){ //报数组越界。

  if (thread.currentthread() == serverthreads.get(i)){ //拿当前线程和服务端容器里的线程去比，看是否是服务端的线程。

  isserverthread = true ;

  }

  }

  }

  if (clientthreads.size()> 0 ){   //判断当前的线程是否是客户线程。 先判断是否大于0，是为了防止clientthreads

  for ( int i= 0 ;i<clientthreads.size();i++){ //报数组越界。

  if (thread.currentthread() == clientthreads.get(i)){ //拿当前线程和客户端容器里的线程去比，看是否是客户端的线程。

  isserverthread = false ;

  }

  }

  }

  if (isserverthread){   //如果是服务端的线程，将readline方法接受到的值赋给相应的content。

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

  if (thread.currentthread() == serverthreads.get(i)){ //判断具体是服务端里的那条线程。

  try {

  servercontents[i] = serverbreaders.get(i).readline(); //将对方发送过来的消息赋值给这条线程的接受消息字符串。

  } catch (ioexception e) {

  e.printstacktrace();

  return ;  //出现异常时直接退出方法。

  }

  if (servercontents[i]== null ){  //在自己点击离线按钮时，servercontents[i]为null，

  return ;  //因此在这里进行处理，避免后面报错。

  }

  if (servercontents[i].equals( "关闭" )){ //接收到对方因点击离开按钮而发出的消息[离开]，关闭自己的连接。

  sendtf.settext( "已断开连接" );

  serverpwriters.get(i).close();

  try {

   serverbreaders.get(i).close();

   serversockets.get(i).close();

  } catch (ioexception e) {

   e.printstacktrace();

  }

  return ;    //关闭完后退出。

  }

  servertextareas.get(i).append(servercontents[i]+ "\n" ); //将接受到的消息显示在自己的对话记录区域。

  break ;

  }

  }

  } else {    //如果是客户线程，将readline方法接受到的值赋给相应的content。

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

  if (thread.currentthread() == clientthreads.get(i)){ //判断具体是客户端中的哪一条线程。

  try {

  clientcontents[i] = clientbreaders.get(i).readline(); //拿到对方发送过来的消息并保存给自己的字符串。

  } catch (ioexception e) {

  e.printstacktrace();

  }

  if (clientcontents[i] == null ){ //当自己点击离线按钮时，clientcontents[i]会为null，

  return ; //为了防止下面报错，在这里进行处理。

  }

  if (clientcontents[i].equals( "关闭" )){ //接收到对方因点击离线按钮而发出的消息[关闭]，而关闭自己的连接。

  sendtf.settext( "已断开连接" );

  clientpwriters.get(i).close();

  try {

   clientbreaders.get(i).close();

   clientsockets.get(i).close();

  } catch (ioexception e) {

   e.printstacktrace();

  }

  return ;

  }

  clienttextareas.get(i).append(clientcontents[i]+ "\n" ); //作为客户端时，将接受到的消息显示在对话记录显示区域。

  break ;

  }

  }

  }

  }

  }

  }

  @override

  public void actionperformed(actionevent e) {

  switch (e.getactioncommand()){

  case "连接端口" :      //如果是连接端口，则执行以下操作。

  try {

  socket clientsocket = new socket(hosttf.gettext(),integer.parseint(porttf.gettext())); //拿到工具栏一中填的端口号并生成socket去连接对方。

  clientsockets.add(clientsocket);

  printwriter clientpwriter = new printwriter(clientsocket.getoutputstream(), true ); //初始化输出流对象。

  clientpwriters.add(clientpwriter);

  bufferedreader clientbreader = new bufferedreader( new inputstreamreader(clientsocket.getinputstream())); //初始化输入流对象。

  clientbreaders.add(clientbreader);

  clientpwriter.println( "连接" +name+ "成功" );  //将连接成功的消息发送给对方，提醒对方连接成功。

  clientpwriter.println(name); //将自己的名称发送给对方，方便对方设置选项卡的名称。

  system.out.println( 11111111 );

  string content = clientbreader.readline(); //读入对方发送过来的提醒消息。对方已执行了上面两条语句，发送了对应的消息。

  system.out.println( 22222222 );

  string name2 = clientbreader.readline(); //读取对方的名称。

  system.out.println(content);

  system.out.println(name2);

  myjtextarea clienttextarea = new myjtextarea(sign);

  sign++;  //配和选项卡的index，记录每个选项卡加到那个容器里去了，是服务器的容器还是客户端的容器。

  clienttextareas.add(clienttextarea);

  this .tab.addtab(name2, new jscrollpane(clienttextarea)); //在选项卡窗格中添加一个选项卡。

  clienttextarea.seteditable( false );  //设置对话记录区域不可编辑。

  clienttextarea.setlinewrap( true );  //设置对话记录区域自动换行。

  clienttextarea.append(content+ "\n" ); //在对话记录区域显示连接成功这条消息。

  chatthread clientthread = new chatthread();

  clientthreads.add(clientthread);

  clientthread.start();    //启动该线程，方便和对方相互发送消息，因为主线程已经在上面accept（）处阻塞。

  } catch (ioexception e1) {

  e1.printstacktrace();

  }

  break ;

  case "发送" :

  if (servertextareas.size()> 0 ){    //如果是被请求连接时而创建的选项卡要发送消息。即服务端。

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

  if (tab.getselectedindex() == servertextareas.get(i).getsign()){ //通过获取当前选项卡的index去和jtextarea的sign比，因为他们的index和sign是匹配的，

  string sendcontent = sendtf.gettext(); //从而确定它是服务端的哪条线程,该用那对输入输出流进行发送和接受消息。

  if (serversockets.get(i).isclosed()){ //如果已断开连接,则直接返回。

  sendtf.settext( "已断开连接" );

  return ;

  }

  if (sendcontent.equals( "" )){  //如果发送的内容为空则直接接结束。

  sendtf.settext( "请输入内容" );

  return ;

  } else {

  serverpwriters.get(i).println(name+ ": " +sendcontent); //将发送消息框中的消息发送出去，并在前面加上自己的姓名。

  servertextareas.get(i).append( "我: " +sendcontent+ "\n" ); //在自己的对话记录区域加上这句话。

  sendtf.settext( "" );     //将发送消息框中的数据清空。

  return ;

  }

  }

  }

  }

  if (clienttextareas.size()> 0 ){    //如果是客户端。

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

  if (tab.getselectedindex() == clienttextareas.get(i).getsign()){ //通过获取当前选项卡的index去和jtextarea的sign比，因为他们的index和sign是匹配的，

  string sendcontent = sendtf.gettext();   //从而确定它是客户端的哪条线程,该用那对输入输出流进行发送和接受消息。

  if (clientsockets.get(i).isclosed()){ //如果连接已断开则直接返回。

  sendtf.settext( "已断开连接" );

  return ;

  }

  if (sendcontent.equals( "" )){  //如果发送的内容为空则直接接结束。

  sendtf.settext( "请输入内容" );

  return ;

  } else {

  clientpwriters.get(i).println(name+ ": " +sendcontent); //将发送消息框中的消息发送出去，并在前面加上自己的姓名。

  clienttextareas.get(i).append( "我: " +sendcontent+ "\n" ); //在自己的对话记录区域加上这句话

  sendtf.settext( "" );     //将发送消息框中的数据清空。

  return ;

  }

  }

  }

  }

  break ;

  case "离开" :

  if (servertextareas.size()> 0 ){      //如果是服务端。

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

  if (tab.getselectedindex() == servertextareas.get(i).getsign()){ //更前面一样的道理，判断是服务端的那个选项卡需要闭关。

  serverpwriters.get(i).println( "关闭" );   //发送关闭消息，提醒对方也要关闭该socket连接。

  sendtf.settext( "已断开连接" );

  serverpwriters.get(i).close();

  try {

  serverbreaders.get(i).close();

  serversockets.get(i).close();   

  } catch (ioexception e1) {

  e1.printstacktrace();

  }

  break ;

  }

  }

  }

  if (clienttextareas.size()> 0 ){      //如果是客户端。

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

  if (tab.getselectedindex() == clienttextareas.get(i).getsign()){ //更前面一样的道理，判断是客户端的那个选项卡需要闭关。

  clientpwriters.get(i).println( "关闭" );   //发送关闭消息，提醒对方也要关闭该socket连接。

  sendtf.settext( "已断开连接" );

  clientpwriters.get(i).close();

  try {

  clientbreaders.get(i).close();

  clientsockets.get(i).close();   

  } catch (ioexception e1) {

  e1.printstacktrace();

  }

  break ;

  }

  }

  }

  break ;

  case "删除页" :

  if (servertextareas.size()> 0 ){ //为了防止下面的servertextareas数组越界。

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

  if (tab.getselectedindex() == servertextareas.get(i).getsign()){ //跟上面一样的道理，判断当前选项卡是属于服务端还是客户端。

  if (serversockets.get(i).isclosed()){ //先判断是否断开连接，否则不允许关闭。

  tab.remove(i);  //删除当前选项卡。

  } else {

  sendtf.settext( "请先关闭当前的连接" );

  return ;

  }

  }

  }

  }

  if (clienttextareas.size()> 0 ){ //为了防止下面的servertextareas数组越界。

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

  if (tab.getselectedindex() == clienttextareas.get(i).getsign()){ //跟上面一样的道理，判断当前选项卡是属于服务端还是客户端。

  if (clientsockets.get(i).isclosed()){ //先判断是否断开连接，否则不允许关闭。

  tab.remove(i);   //删除当前选项卡。

  } else {

  sendtf.settext( "请先关闭当前的连接" );

  return ;

  }

  }

  }

  }

  break ;

  default :

  break ;

  }

  }

  public static void main(string[] args) throws ioexception{

  new client4( "喜洋洋" );

  }

}