//需求：一个简单的窗体，能够实现最基本的聊天功能。
//但是功能实现不了，求高手指导！！！！！！！！！！！！！！！
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
//负责发送信息的类。
class Send implements Runnable
{
    DatagramSocket sds;
    Jf j;
public Send(DatagramSocket sds,Jf j)
{
  this.j = j;
  this.sds=sds;
}
//覆盖run()方法。
public void run()
{
  System.out.println("发送来了！");
  //按钮事件。
  j.b.addActionListener(new ActionListener()
  {
   
   public void actionPerformed(ActionEvent v)
   {
    System.out.println("点击了发送！");
    File f=new File("c:\\","chat.txt");
    BufferedReader br = null;
    BufferedWriter bw = null;
    DatagramPacket dp = null;
    try
    {
     bw=new BufferedWriter(new FileWriter(f));
     String s = j.ta2.getText();
     bw.write(s);
     System.out.println("制造发送");
     b = new BufferedReader(new FileReader(f));
     String line = null;
     //System.out.println(1);
     while((line=br.readLine())!=null)//为什么程序执行到这儿的时候，总会卡掉呢？？？
                                                                                   //信息发送不出去！！！是while循环的问题吗？？？求高人指教！！！
     {
      //System.out.println(2);
      byte[] buf = line.getBytes();
      //System.out.println(3);
      dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10008);
      //System.out.println(4);
      System.out.println("发送前！");
      sds.send(dp);
      System.out.println("发送成功！");
      j.ta1.append(dp.getAddress().getHostAddress()+s+"\r\n");
             j.ta2.setText("");
      
     }
        }
    catch(Exception e)
    {
     throw new RuntimeException("写入失败！");
    }
    finally
    {
     if(bw!=null)
     {
      try
      {
       bw.close();
      }
      catch(Exception e)
      {
       throw new RuntimeException("发送端失败！");
      }
     }
     if(br!=null)
     {
      try
      {
       br.close();
      }
      catch(Exception e)
      {
       throw new RuntimeException("发送端失败！");
      }
     }
    }
   
   
   
   
   
   
   }
  });
  
  }
}
//负责接收信息的类。
class Receive  implements Runnable
{
  private DatagramSocket rds;
  private Jf j;
  Receive(DatagramSocket rds,Jf j)
  {
   this.j = j;
   this.rds = rds;
  }
  public void run()
  {
   try
   {
    while(true)
    {
     System.out.println("来了！");
     byte[] buf = new byte[1024*64];
     DatagramPacket dp = new DatagramPacket(buf,buf.length);
     rds.receive(dp);
     String ip = dp.getAddress().getHostAddress();
     String data = new String(dp.getData(),0,dp.getLength());
     j.t.setText("");
     j.t.setText("与"+ip+"聊天中"+"");
     j.ta1.append(ip+"..."+data+"\r\n");
     
     
    }
   }
   catch(Exception e)
   {
    throw new RuntimeException("接受端失败！");
   }
  }

}
//创建窗口类。
class Jf
{
Frame f;
TextField t;
TextArea ta1,ta2;
Button b;


Jf()
{
  
  cf();
}
  
//创建一个窗口的方法。
public void cf()
{
  
  f = new Frame("QQ");
  f.setSize(500,450);
  f.setLocation(100,200);
  f.setLayout(new FlowLayout());
  t=new TextField(20);
  ta1 = new TextArea(10,60);
  b = new Button("发送");
  ta2 = new TextArea(6,60);
  f.add(t);
  f.add(ta1);
  f.add(ta2);
  f.add(b);
  ce();
  f.setVisible(true);
  
  
  
}
//创建事件的方法。
public void ce()
{
  f.addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    System.exit(0);
   }
  });
}

}
//主函数。
public class Chat
{
public static void main(String[] args)throws Exception
{
  Jf j = new Jf();
  DatagramSocket sds = new DatagramSocket();
  DatagramSocket rds = new DatagramSocket(10008);

  new Thread(new Receive(rds,j)).start();
  new Thread(new Send(sds,j)).start();
  
}
}

你写的服务器端我没看见，服务器与客户端应该是分开写的。基本的思路是
1、服务器开启 2、客户端连接服务器 3、客户端发送给服务器信息  4、服务器接收信息并发送给每一个客户端
每接入一个客户端，服务器就开启一个线程进行监听。   GUI界面写在客户端就好了

服务器：

import java.io.*;
import java.net.*;
import java.util.*;

public class ChatServer {
        boolean started = false;
        ServerSocket ss = null;
        
        List<Client> clients = new ArrayList<Client>();

        public static void main(String[] args) {
                new ChatServer().start();
        }
        
        public void start() {
                try {
                        ss = new ServerSocket(8555);
                        started = true;
                } catch (BindException be) {
                        System.out.println("The port is using...\nPlease shut down referrence project and restart the server.");
                        System.exit(0);
                } catch (IOException e2) {
                        e2.printStackTrace();
                }
               
                try {
                        while(started){
                                Socket s = ss.accept();
                                Client c = new Client(s);
                                System.out.println("a client connected!");
                                new Thread(c).start();
                                clients.add(c);
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }finally {
                        try {
                                ss.close();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }
        
        class Client implements Runnable {
                private Socket s;
                private DataInputStream dis = null;
                private DataOutputStream dos = null;
                private boolean bConnected = false;
                public Client(Socket s) {
                        this.s = s;
                        try {
                                dis = new DataInputStream(s.getInputStream());
                                dos = new DataOutputStream(s.getOutputStream());
                                bConnected = true;
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
               
               
                public void send(String str) {
                                try {
                                        dos.writeUTF(str);
                                } catch (IOException e) {
                                        clients.remove(this);
                                        System.out.println("对方已退出！");
                                        //e.printStackTrace();
                                }
                }
               
                public void run() {
                                try {
                                        while(bConnected) {
                                                String str = dis.readUTF();
System.out.println(str);
                                                for(int i=0;i<clients.size();i++){
                                                        Client c = clients.get(i);
                                                        c.send(str);
                                                }
                                        }
                                } catch (EOFException eof) {
                                        System.out.println("Client closed!");
                                } catch (IOException e) {
                                        e.printStackTrace();
                                } finally {
                                        try {
                                                if(dis != null) {
                                                        dis.close();
                                                        dis = null;
                                                }
                                                if(dos != null) {
                                                        dos.close();
                                                        dos = null;
                                                }
                                                if(s != null) {
                                                        s.close();
                                                        s = null;
                                                }
                                        }catch (IOException e1) {
                                                e1.printStackTrace();
                                        }
                                       
                                }
                        }
                }
        }
        
        

客户端：
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.*;
import java.net.*;



public class ChatClient extends Frame {
        
        TextField tfText = new TextField();
        TextArea taContent = new TextArea();
        Socket s = null;
        DataOutputStream dos = null;
        DataInputStream dis = null;
        private boolean bConnected = false;
        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(tfText,BorderLayout.SOUTH);
                add(taContent,BorderLayout.NORTH);
                this.pack();
                setVisible(true);
                this.addWindowListener(new WindowAdapter(){

                        public void windowClosing(WindowEvent e) {
                                disconnect();
                                System.exit(0);
                        }

                });
                tfText.addActionListener(new TFListener());
                setVisible(true);
                connect();
                tRecv.start();
        }
        
        
        public void connect() {
                try {
                        s = new Socket("127.0.0.1",8555);
                        dos = new DataOutputStream(s.getOutputStream());
                        dis = new DataInputStream(s.getInputStream());
                        bConnected = true;
System.out.println("Connected!");
                } 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();
                }
                /*
                try {
                        bConnected = false;
                        tRecv.join();
                } catch (InterruptedException ie) {
                        ie.printStackTrace();
                } finally {
                        try {
                        dos.close();
                        dis.close();
                        s.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                }
                */
               
        }
        
        
        private class TFListener implements ActionListener {

                public void actionPerformed(ActionEvent e) {
                        String str = tfText.getText().trim();
                        //taContent.setText(str);
                        tfText.setText("");
                        try {
                                dos.writeUTF(str);
                                dos.flush();
                                //dos.close();
                        } catch (IOException e1) {
                                e1.printStackTrace();
                        }
                        
                }
        }
        
        
        private class RecvThread implements Runnable {
               
                public void run() {
                                try {
                                       
                                        while(bConnected) {
                                                String str = dis.readUTF();
                                                //System.out.println(str);
                                                taContent.setText(taContent.getText()+ str + '\n');
                                        }
        
                                } catch (SocketException e) {
                                        System.out.println("退出了，bye!");
                                } catch (EOFException eof){
                                        System.out.println("退出了，bye!");
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                }
               
        }
        
}

刘伯阳 发表于 2012-6-1 15:24
嗯  写的不错 我也写了一个~
服务器：

但是我的功能没实现，求指导！！谢谢！！！

刘伯阳 发表于 2012-6-1 15:24
你写的服务器端我没看见，服务器与客户端应该是分开写的。基本的思路是
1、服务器开启 2、客户端连接服务器 ...

恩，我试试，谢谢