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("喜洋洋");
 }
}