简单的聊天程序，主要用到的是Socket

服务端：

  1 import java.io.*;
  2 
  3 import java.net.*;
  4 
  5 import java.util.*;
  6 
  7 public class ChatServer {
  8 
  9 boolean stat = false;
 10 
 11 ServerSocket ss = null;
 12 
 13 List<Client> clients = new ArrayList<Client>();//用于存客户端
 14 
 15 public static void main(String[] args) {
 16 
 17   new ChatServer().start();
 18 
 19 }
 20 
 21 public void start(){
 22 
 23   try {
 24 
 25    ss = new ServerSocket(8888);
 26 
 27    stat = true;
 28 
 29   } catch(BindException e){  //Sever端已经运行，当重复运行时抛异常
 30 
 31    System.out.println("端口正在使用中。。。。");
 32 
 33    System.out.println("请关掉相关程序并重新运行服务器！"); //还会抛别的异常，所以直接关闭窗口
 34 
 35    System.exit(0);
 36 
 37   } catch(IOException e) {
 38 
 39    e.printStackTrace();
 40 
 41   }
 42 
 43   try{
 44 
 45    while(stat){
 46 
 47     Socket s = ss.accept();
 48 
 49 System.out.println("a client connected!" );  //测试语句写在最左边，以后没用可以删除或注掉
 50 
 51     Client c = new Client(s);    //每建立一个客户端，就new一个客户端对象，启动一个线程
 52 
 53     new Thread(c).start();
 54 
 55     clients.add(c);  //勿忘写，将每个客户端加入到容器里
 56 
 57    }
 58 
 59   } catch (IOException e) {
 60 
 61    e.printStackTrace();
 62 
 63   } finally {
 64 
 65    try {
 66 
 67     ss.close();
 68 
 69    } catch (IOException e) {
 70 
 71     e.printStackTrace();
 72 
 73    }
 74 
 75   }
 76 
 77 }
 78 
 79 class Client implements Runnable {
 80 
 81   private Socket s;
 82 
 83   private DataInputStream dis;
 84 
 85   private DataOutputStream dos;
 86 
 87   private boolean cont = false;
 88 
 89   public Client(Socket s){
 90 
 91    this.s = s; 
 92 
 93    try {
 94 
 95     dis = new DataInputStream(s.getInputStream());//初始化
 96 
 97     dos = new DataOutputStream(s.getOutputStream());
 98 
 99     cont = true;
100 
101    } catch (IOException e) {
102 
103     e.printStackTrace();
104 
105    }
106 
107   }
108 
109   public void send(String str){  //用于发送给客户端
110 
111    try {
112 
113     dos.writeUTF(str);
114 
115    } catch (IOException e) {
116 
117     clients.remove(this);  //移除那个退出的对象
118 
119     System.out.println("一个客户退出了");
120 
121     //e.printStackTrace();
122 
123    }
124 
125   }
126 
127   public void run() {
128 
129    try{
130 
131     while(cont){
132 
133      String str = dis.readUTF(); //阻塞式方法
134 
135 System.out.println(str);
136 
137      for(int i=0; i<clients.size(); i++){
138 
139       Client c = clients.get(i);  //取客户端
140 
141       c.send(str); 
142 
143      }
144 
145      /*     另外两种方法，但不适用，它会锁定服务端
146 
147      for(Iterator<Client> it = clients.iterator(); it.hasNext();){
148 
149       Client c = it.next();
150 
151       c.send(str);
152 
153      }
154 
155      Iterator<Client> it = clients.iterator();
156 
157      while(it.hasNext()){
158 
159       Client c = it.next();
160 
161       c.send(str);
162 
163      }
164 
165      */
166 
167     }
168 
169    } catch (EOFException e){   //readUTF()阻塞式方法，所以关闭客户端会抛异常
170 
171     System.out.println("Client closed!");
172 
173    } catch (IOException e) {
174 
175     e.printStackTrace();
176 
177    } finally {
178 
179     try {
180 
181      if(dis != null) dis.close();
182 
183      if(dos != null) dos.close();
184 
185      if(s != null) {
186 
187       s.close();
188 
189       s = null;//更严格的方法，等于空就没人去用了，垃圾收集器就回收走
190 
191      }
192 
193     } catch (IOException e) {
194 
195      e.printStackTrace();
196 
197     }
198 
199    }
200 
201   }
202 
203 }
204 
205 }

 

客户端：

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

public class ChatClient extends Frame {

Socket s = null;

DataOutputStream dos = null;

DataInputStream dis = null;

private boolean cont = false;

TextField tfTxt = new TextField();

TextArea taContent = new TextArea();

Thread tRecv = new Thread(new RecvThread());

public static void main(String[] args) {

  new ChatClient().launchFrame();

}

public void launchFrame() {

  setLocation(400, 300);

  this.setSize(300, 300);

  add(tfTxt,BorderLayout.SOUTH);

  add(taContent,BorderLayout.NORTH);

  pack(); //包在一起，去掉中间空着的

  this.addWindowListener(new WindowAdapter(){

   public void windowClosing(WindowEvent e){

    disconnect();

    System.exit(0);

   }

  });

  tfTxt.addActionListener(new TfListent());

  setVisible(true);

  connect();

  tRecv.start();   //启动线程

}

public void connect(){

  try {

   s = new Socket("127.0.0.1",8888);//注意不要定义成Socket s,这就成了局部变量而不是成员变量了

System.out.println("connected!");

   dos = new DataOutputStream(s.getOutputStream());

   dis = new DataInputStream(s.getInputStream());

   cont = true;

  } catch (UnknownHostException e) {

   e.printStackTrace();

  } catch (IOException e) {

   e.printStackTrace();

  }

}

public void disconnect(){

  try {

   dos.close();

   dis.close();

   s.close();

  } catch (IOException e) {

   e.printStackTrace();

  }

  /*//无法解决readUTF阻塞式方法

  try {

   cont = false;  //关闭线程

   tRecv.join();  //合并线程，彻底让他停止

  } catch (InterruptedException  e) {

   e.printStackTrace();

  } finally {

   try {

    dos.close(); //线程停止之后才能关流，不然抛SocketException异常

    dis.close();

    s.close();

   } catch (IOException e) {

    e.printStackTrace();

   }

  }

  */

}

private class TfListent implements ActionListener {

  public void actionPerformed(ActionEvent e) {

   String str = tfTxt.getText().trim();

   tfTxt.setText("");

   try {

    dos.writeUTF(str);

    dos.flush();

   } catch (IOException e1) {

    e1.printStackTrace();

   }

  }

}

private class RecvThread implements Runnable{

  public void run() {

   try {

    while(cont){

     String str = dis.readUTF();

     taContent.setText(taContent.getText() + str + '\n');

    }

   } catch (SocketException e){

    System.out.println("退出了，bye!");

   } catch (IOException e) {  

    e.printStackTrace();

   }

  }

}

}

 

简单的聊天程序，主要用到的是Socket，线程以及流

如果没看懂可以去我博客

http://www.cnblogs.com/huidaoli/p/3252924.html

转载于:https://www.cnblogs.com/huidaoli/p/3252924.html