关于java网络聊天程序的几种模式

整理自互联网

import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.OutputStream; 
import java.io.PrintWriter; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.ArrayList; 
import java.util.Date; 
import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JPanel; 
import javax.swing.JScrollPane; 
import javax.swing.JTextArea; 
import javax.swing.JTextField; 
@SuppressWarnings("serial") 
public class IMServer extends JFrame implements ActionListener 
{ 
private static final int maxThreadLimit = 10; 
private JPanel p = new JPanel(); 
private JTextField jtf = new JTextField(); 
private JTextArea jta = new JTextArea(); 
private ArrayList<ThreadServer> threadArray = new ArrayList<ThreadServer>();        //线程数组，用于存放连接线程 
public IMServer() 
{ 
p.setLayout(new BorderLayout()); 
p.add(new JLabel("发送(回车)"),BorderLayout.WEST); 
p.add(jtf,BorderLayout.CENTER); 
jtf.setHorizontalAlignment(JTextField.RIGHT); 
getContentPane().setLayout(new BorderLayout()); 
getContentPane().add(new JScrollPane(jta),BorderLayout.CENTER); 
getContentPane().add(p,BorderLayout.SOUTH); 
jtf.addActionListener(this); 
setTitle("IM"); 
setSize(500,300); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
setVisible(true); 
try 
{ 
ServerSocket serverSocket = new ServerSocket(8189); 
jta.append("服务器开启时间：" + new Date() + '\n'); 
while(true) 
{ 
if(threadArray.size() >= maxThreadLimit) 
{ 
try 
{ 
Thread.sleep(1000); 
} 
catch(InterruptedException ex) 
{ 
} 
} 
else 
{ 
Socket socket = serverSocket.accept(); 
jta.append("用户上线：" + new Date() + '\n'); 
ThreadServer thread = new ThreadServer(socket); 
threadArray.add(thread); 
thread.start(); 
} 
} 
} 
catch(IOException e) 
{ 
System.err.println(e); 
} 
} 
public static void main(String[] args) 
{ 
new IMServer(); 
} 
@Override 
public void actionPerformed(ActionEvent arg0) 
{ 
if (arg0.getSource() instanceof JTextField) 
{ 
String s = jtf.getText(); 
if(s != null) 
{ 
guangBo("服务器广播：" + s); 
s = null; 
} 
jtf.setText(""); 
} 
} 
public void guangBo(String s)            //向所有客户端监听线程发送消息 
{ 
jta.append(s + '\n'); 
if(threadArray.size() > 0)            //遍历这个线程数组 
{ 
for(int i = 0;i < threadArray.size();i++) 
{ 
threadArray.get(i).send(s); 
} 
} 
} 
//线程内部类 
class ThreadServer extends Thread 
{ 
private Socket incoming; 
private PrintWriter out; 
public ThreadServer(Socket i) 
{ 
incoming = i; 
} 
@Override 
public void run() 
{ 
// TODO Auto-generated method stub 
try 
{ 
try 
{ 
BufferedReader inStream = new BufferedReader(new InputStreamReader(incoming.getInputStream())); 
OutputStream outStream = incoming.getOutputStream(); 
out = new PrintWriter(outStream, true); 
while(true) 
{ 
String s = inStream.readLine(); 
if(s != null && !s.equalsIgnoreCase("@exit")) 
{ 
guangBo(s); 
s = null; 
} 
else if(s.equalsIgnoreCase("@exit")) 
break; 
} 
} 
finally 
{ 
threadArray.remove(this); 
incoming.close(); 
} 
} 
catch(IOException e) 
{ 
e.printStackTrace(); 
} 
} 
public void send(String s) 
{ 
if(s != null) 
{ 
out.println(s); 
} 
} 
} 
} 

客户端

import java.awt.BorderLayout; 
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.OutputStream; 
import java.io.PrintWriter; 
import java.net.Socket; 
import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JOptionPane; 
import javax.swing.JPanel; 
import javax.swing.JScrollPane; 
import javax.swing.JTextArea; 
import javax.swing.JTextField; 
@SuppressWarnings("serial") 
public class IMClient extends JFrame implements ActionListener { 
private JPanel p = new JPanel(); 
private JTextField jtf = new JTextField(); 
private JTextArea jta = new JTextArea(); 
private PrintWriter out; 
private String name; 
public IMClient() 
{ 
name = JOptionPane.showInputDialog("请输入您的昵称："); 
p.setLayout(new BorderLayout()); 
p.add(new JLabel("发送(回车)"),BorderLayout.WEST); 
p.add(jtf,BorderLayout.CENTER); 
jtf.setHorizontalAlignment(JTextField.RIGHT); 
getContentPane().setLayout(new BorderLayout()); 
getContentPane().add(new JScrollPane(jta),BorderLayout.CENTER); 
getContentPane().add(p,BorderLayout.SOUTH); 
jtf.addActionListener(this); 
setTitle("用户-" + name); 
setSize(500,300); 
addWindowListener (new WindowAdapter() { 
public void windowClosing(WindowEvent e) { 
setVisible (false); 
out.println("@exit"); 
System.exit(0); 
} 
}  ); 
setVisible(true); 
try 
{ 
Socket socket = new Socket("192.168.36.37",8189); 
OutputStream toServer = socket.getOutputStream(); 
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
out = new PrintWriter(toServer, true); 
while(true) 
{ 
String s = in.readLine(); 
if(s != null) 
{ 
jta.append(s + '\n'); 
} 
s = null; 
} 
} 
catch(IOException e) 
{ 
e.printStackTrace(); 
} 
} 
@Override 
public void actionPerformed(ActionEvent arg0) { 
// TODO Auto-generated method stub 
if (arg0.getSource() instanceof JTextField) 
{ 
String s = jtf.getText(); 
if(s != null) 
{ 
out.println(name + ": " + s); 
s = null; 
} 
jtf.setText(""); 
} 
} 
/** 
* @param args 
*/ 
public static void main(String[] args) { 
// TODO Auto-generated method stub 
new IMClient(); 
} 
} 

二，

服务器程序

单线程

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServer {
    public static void main(String[] args) {
        try {
            /** 创建ServerSocket*/
            // 创建一个ServerSocket在端口2013监听客户请求
            ServerSocket serverSocket =new ServerSocket(2013);
            while (true) {
                // 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行
                Socket socket = serverSocket.accept();
                /** 获取客户端传来的信息 */
                // 由Socket对象得到输入流，并构造相应的BufferedReader对象
              BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
 // 获取从客户端读入的字符
                String result = bufferedReader.readLine();
                System.out.println("Client say : " + result);
                /** 发送服务端准备传输的 */
                // 由Socket对象得到输出流，并构造PrintWriter对象
                PrintWriter printWriter =new PrintWriter(socket.getOutputStream());
                printWriter.print("hello Client, I am Server!");
                printWriter.flush();
  
                /** 关闭Socket*/
                printWriter.close();
                bufferedReader.close();
                socket.close();
            }
        }catch (Exception e) {
            System.out.println("Exception:" + e);
        }finally{
//          serverSocket.close();
        }


    }
}

多线程服务器；

import java.io.*;
import java.net.*;
public class Server extends ServerSocket {
    private static final int SERVER_PORT =2013;
    public Server()throws IOException {
        super(SERVER_PORT);
        try {
            while (true) {
                Socket socket = accept();
                new CreateServerThread(socket);//当有请求时，启一个线程处理
            }
      }catch (IOException e) {
        }finally {
            close();


       }
    }
  
    //线程类
    class CreateServerThread extends Thread {
        private Socket client;
        private BufferedReader bufferedReader;
        private PrintWriter printWriter;
        public CreateServerThread(Socket s){
try{
            client = s;
            bufferedReader =new BufferedReader(new InputStreamReader(client.getInputStream()));
            printWriter =new PrintWriter(client.getOutputStream(),true);
            System.out.println("客户端(" + getName() +") 访问服务器...");
            start();
}
catch(IOException e){
}
        }
  
      public void run() {
            try {
                String line = bufferedReader.readLine();
                while (!line.equals("bye")) {
                  
  BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
                printWriter.println("server:"+sysBuff.readLine());
               printWriter.flush();//刷新该流中的要缓冲
 printWriter.println("继续, 客户端(" + getName() +")!");
                    line = bufferedReader.readLine();
                    System.out.println("客户端(" + getName() +") 说了: " + line);


                }
                printWriter.println("再见, 客户端(" + getName() +")!");
                System.out.println("客户端(" + getName() +") 退出!");
                printWriter.close();
                bufferedReader.close();
                client.close();
            }catch (IOException e) {
            }
        }
    }
  
    public static void main(String[] args)throws IOException {
        new Server();
    }
}

客户端程序

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient {
    public static void main(String[] args) {
        try {
            /** 创建Socket*/
            // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号(本处是本机)
            Socket socket =new Socket("127.0.0.1",2013);
            // 60s超时
            socket.setSoTimeout(60000);
            /** 发送客户端准备传输的信息 */
            // 由Socket对象得到输出流，并构造PrintWriter对象
            PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
            // 将输入读入的字符串输出到Server
            BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
            printWriter.println(sysBuff.readLine());
            // 刷新输出流，使Server马上收到该字符串
            printWriter.flush();
            /** 用于获取服务端传输来的信息 */
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 输入读入一字符串
            String result = bufferedReader.readLine();
           System.out.println("Server say : " + result);
            /** 关闭Socket*/
            printWriter.close();
            bufferedReader.close();
            socket.close();
        }catch (Exception e) {
            System.out.println("Exception:" + e);
        }
    }
}

三，

服务器端

import java.net.*;   
import java.io.*;   
/**  


*@see 创建一个服务器端的端口，并接受客户端得端口，用一个线程来监听各个客户端  
*/   
public class Server {   
private static int  port=6788;   
private static ServerSocket server;   
private static Socket socket;   
public Server()   
{   
try {   
System.out.println("服务器已启动");   
server=new ServerSocket(port);   
while(true)   
{   
socket= server.accept();   
System.out.println("连接上一个服务器");   
MyThread myThread=new MyThread(socket);   
myThread.start();   
}   
} catch (IOException e) {   
e.printStackTrace();   
}   
}   
class MyThread extends Thread   
{   
Socket socket;   
BufferedReader reader;   
PrintStream ps;   
String msg;   
public MyThread(Socket s)   
{   
this.socket=s;   
}   
public void  run()   
{   
try {   
reader=new BufferedReader(new InputStreamReader(socket.getInputStream()) );   
PrintStream out=new PrintStream(socket.getOutputStream(),true);   
while(true)   
{   
msg=reader.readLine();   
if(msg==null)   
{   
return;   
}   
else   
if(msg.equals("exit"))   
break;   
else   
out.println(msg);   
        out.flush();   
        System.out.println("来自："+msg);   
}   
  
  
server.close();   
  
  
} catch (IOException e) {   
e.printStackTrace();   
}   
} 




}   
public static void main(String []args)   
{   
new Server();   
}   
  
}   

客户端

import javax.swing.*;   
  
//import com.chat.Server.MyThread;   
  
import java.io.BufferedReader;   
import java.io.IOException;   
import java.io.InputStream;   
import java.io.InputStreamReader;   
import java.io.PrintStream;   
import java.io.PrintWriter;   
import java.net.*;   
import java.text.SimpleDateFormat;   
import java.util.Date;   
import java.awt.BorderLayout;   
import java.awt.GridLayout;   
import java.awt.event.*;   
  
/**  


*@see客户端要创建一个套接字与服务器连上，不过在这之前得做好用户界面，  
*客户端要做的事就是将信息发给服务器、同时接受服务器端传过来的信息  
*/   
public class Client extends JFrame implements ActionListener{   
PrintStream ps;   
InputStream in;   
private int port=6788;   
Socket socket;   
JLabel label1,label2;   
JTextField nameField;   
JTextArea msgArea;   
JTextArea showmsgArea;   
JButton sendButton;   
JPanel panel,panel1,panel2;   
StringBuffer msg;   
String s1;   
Date datetime;   
public Client()   
{   
super("Chating room");   
panel=new JPanel();   
panel1=new JPanel();   
panel2=new JPanel();   
showmsgArea=new JTextArea();   
showmsgArea.setEditable(false);   
sendButton=new JButton("发送");   
sendButton.addActionListener(this);   
label1=new JLabel("用户名：");   
nameField=new JTextField(10);   
label2=new JLabel("聊天信息：");   
msgArea=new JTextArea(3,20);   
JScrollPane p=new JScrollPane(msgArea);   
panel1.setLayout(new GridLayout(2,1,3,3));   
panel1.add(label1);   
panel1.add(nameField);   
panel2.add(label2);   
panel2.add(p);   
panel2.add(sendButton);   
panel.add(panel1);   
panel.add(panel2);   
this.setLayout(new BorderLayout());   
this.add(panel,BorderLayout.NORTH);   
this.add(showmsgArea,BorderLayout.CENTER);   
this.setSize(500,300);   
this.setLocation(300, 280);   
this.setVisible(true);   
  
}     
  
public void actionPerformed(ActionEvent e) {   
try   
    {   
if(e.getSource()==sendButton)   
{   
if(socket!=null)   
{   
datetime=new Date();   
s1=nameField.getText();   
msg=new StringBuffer(s1+":");   
msg.append(msgArea.getText());   
msgArea.setText("");   
ps.println(datetime);   
ps.println(msg);   
ps.flush();   
}   
if(socket==null)   
{     
  
socket=new Socket("localhost",port);   
ps=new PrintStream(socket.getOutputStream(),true);   
s1=nameField.getText();   
msg=new StringBuffer(s1+":");   
msg.append(msgArea.getText());   
ps.println(datetime);   
ps.println(msg);   
ps.flush();   
}   
MyThread myThread=new MyThread(this,socket);   
myThread.start();   
}   
     }catch(Exception e1)   
     {   
    e1.getMessage();   
     }   
  
  
}   
class MyThread extends Thread   
{   
BufferedReader reader;   
Socket socket;   
Client client;   
public MyThread(Client c,Socket s)   
{   
this.client=c;   
this.socket=s;   
}   
public void run()   
{   
  
try {   
in = socket.getInputStream();   
reader=new BufferedReader(new InputStreamReader(in));   
  
} catch (IOException e) {   
e.printStackTrace();   
}   
while (socket!=null)   
{   
try {   
String msgin=reader.readLine();   
if(msgin.equals(""))   
return;   
else   
    showmsgArea.append(msgin);   
    showmsgArea.append("\n");   
} catch (IOException e) {   
e.printStackTrace();   
}   
}   
  
}   
  
}   
public static void main(String[] args) {   
         new Client();   
}   
  
}   

四

服务器端

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.Socket;
import java.net.ServerSocket;
/**
 * 聊天室服务器端
 */
public class ChatServer2 extends JFrame implements ActionListener {
ServerSocket server; // 服务器端套接字
Socket theClient; // 与客户机端通信的套接字
boolean done; // 通信是否结束
JButton send; // 发送按钮
JTextArea chatContent; // 聊天内容区
JTextField sentence; // 聊天信息栏
/**
* 构造方法，建立服务端聊天室主窗口，准备通信
*/
public ChatServer2() {
buildGUI("聊天室--服器务端"); // 显示聊天室窗口标题
try {
server = new ServerSocket(2011); // 创建服务器端套接字 对象
while (true)
{

theClient = server.accept(); // 得到客户端的套接字
System.out.println("连接上一个服务器");   
MyThread myThread=new MyThread(theClient);   
myThread.start(); 
}
} catch (IOException e1) {
System.out.println(e1);
}
}
/**
* 等待多个客户端的聊天请求
*/
class MyThread extends Thread{
Socket socket; // 与客户机端通信的套接字
DataInputStream in = null; // 来自客户端的输入流
    DataOutputStream out = null; // 发送到客户端的输出流


public MyThread(Socket s)   
{   
try{
this.socket=s; 
 System.out.println("客户端(" + getName() +") 访问服务器...");
out = new DataOutputStream(socket.getOutputStream()); // 得到输出流
in = new DataInputStream(socket.getInputStream()); // 得到输入流
}catch(Exception e){
}
} 
public void run(){
try {   
done = true; // 通信结束标识置为假
String line = null; // 保存从客户端读取的一行信息
while (done) {// 提供Socket服务
while ((line = in.readUTF()) != null) {
// 等待接受输入流数据
chatContent.append("客户端:  " + line + "\n");
                 out.writeUTF("服务器："+line); // 将服务器端的聊天信息发送到客户端
}

in.close(); // 关闭输入流
out.close(); // 关闭输出流
theClient.close(); // 关闭与客户端通信的套接字
}
} catch (Exception e) {
chatContent.append("对方(" + theClient.getInetAddress()
+ ")已经离开聊天室...\n");
}

}
}
/**
* 处理发送按钮被点击、聊天栏回车键事件
*/
public void actionPerformed(ActionEvent e) {
String str = sentence.getText(); // 获取聊天栏里的聊天信息
if (str != null && !str.equals("")) { // 如果聊天内容不为空，则发送信息
// 将本人发送的聊天信息追加到聊天内容区
chatContent.append("本人:  " + str + "\n");
try {
//out.writeUTF(sentence.getText()); // 将服务器端的聊天信息发送到客户端
} catch (Exception e1) {
chatContent.append("客户端不存在....\n");
}
} else {
chatContent.append("聊天信息不能为空\n");
}
sentence.setText(""); // 清空聊天栏里的内容
}

/**
* 创图形用户界面方法，为有关组件注册监听器
*/


public void buildGUI(String title) {
this.setTitle(title); // 设置窗口标题
this.setSize(400, 300); // 设置窗口大小
Container container = this.getContentPane(); // 获得JFrame的内容面板
container.setLayout(new BorderLayout()); // 设置布局方式为BorderLayout
JScrollPane centerPanel = new JScrollPane(); // 创建用于存放聊天记录的滚动面板
chatContent = new JTextArea();// 创建存放聊天内容的多行文本输入区对象
centerPanel.setViewportView(chatContent); // 将文本区放入滚动面板
// 将滚动面板放到主窗口内容面板中央
container.add(centerPanel, BorderLayout.CENTER);
chatContent.setEditable(false);// 将文本区置为不可编辑状态
// 创建底部面板对象，存放聊天标签、聊天栏、发送按钮
JPanel bottomPanel = new JPanel();
sentence = new JTextField(20);// 创建文本输入行对象，存放每次的聊天内容
send = new JButton("发送");// 创建按钮对象
bottomPanel.add(new JLabel("聊天信息")); // 将标签添加到底部面板
bottomPanel.add(sentence);// 把聊天内容栏添加到底部面板上
bottomPanel.add(send);// 把发送按钮添加到底部面板上
container.add(bottomPanel, BorderLayout.SOUTH);// 将底部面板放在主窗口的底部
send.addActionListener(this);// 注册发送按钮的动作事件
sentence.addActionListener(this);// 注册聊天栏的动作事件
this.setVisible(true); // 显示主窗口

/**
* 主方法，创建服务器端对象，启动服务器端主界面
*/


}
public static void main(String[] args) {
new ChatServer2();
}
}

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.Socket;
import java.net.ServerSocket;
/**
 * 聊天室服务器端
 */
public class ChatServer extends JFrame implements ActionListener {
ServerSocket server; // 服务器端套接字
Socket theClient; // 与客户机端通信的套接字
boolean done; // 通信是否结束
JButton send; // 发送按钮
JTextArea chatContent; // 聊天内容区
JTextField sentence; // 聊天信息栏
DataInputStream in = null; // 来自客户端的输入流
DataOutputStream out = null; // 发送到客户端的输出流


/**
* 构造方法，建立服务端聊天室主窗口，准备通信
*/
public ChatServer() {
buildGUI("聊天室--服器务端"); // 显示聊天室窗口标题
try {
server = new ServerSocket(2011); // 创建服务器端套接字 对象
while (true)
{

theClient = server.accept(); // 得到客户端的套接字
System.out.println("连接上一个服务器");   
MyThread myThread=new MyThread(theClient);   
myThread.start(); 
}
} catch (IOException e1) {
System.out.println(e1);
}
}
/**
* 等待多个客户端的聊天请求
*/
class MyThread extends Thread{
Socket socket; // 与客户机端通信的套接字
DataInputStream in = null; // 来自客户端的输入流


public MyThread(Socket s)   
{   

this.socket=s;   
} 
public void run(){



try {
   
   System.out.println("客户端(" + getName() +") 访问服务器...");
out = new DataOutputStream(theClient.getOutputStream()); // 得到输出流
in = new DataInputStream(theClient.getInputStream()); // 得到输入流
done = true; // 通信结束标识置为假
String line = null; // 保存从客户端读取的一行信息
while (done) {// 提供Socket服务
while ((line = in.readUTF()) != null) {
// 等待接受输入流数据
chatContent.append("客户端:  " + line + "\n");
out.writeUTF("我在这里"); // 将服务器端的聊天信息发送到客户端
}

in.close(); // 关闭输入流
out.close(); // 关闭输出流
theClient.close(); // 关闭与客户端通信的套接字
}
} catch (Exception e) {
chatContent.append("对方(" + theClient.getInetAddress()
+ ")已经离开聊天室...\n");
}

}
}
/**
* 处理发送按钮被点击、聊天栏回车键事件
*/
public void actionPerformed(ActionEvent e) {
String str = sentence.getText(); // 获取聊天栏里的聊天信息
if (str != null && !str.equals("")) { // 如果聊天内容不为空，则发送信息
// 将本人发送的聊天信息追加到聊天内容区
chatContent.append("本人:  " + str + "\n");
try {
out.writeUTF(sentence.getText()); // 将服务器端的聊天信息发送到客户端
} catch (Exception e1) {
chatContent.append("客户端不存在....\n");
}
} else {
chatContent.append("聊天信息不能为空\n");
}
sentence.setText(""); // 清空聊天栏里的内容
}

/**
* 创图形用户界面方法，为有关组件注册监听器
*/


public void buildGUI(String title) {
this.setTitle(title); // 设置窗口标题
this.setSize(400, 300); // 设置窗口大小
Container container = this.getContentPane(); // 获得JFrame的内容面板
container.setLayout(new BorderLayout()); // 设置布局方式为BorderLayout
JScrollPane centerPanel = new JScrollPane(); // 创建用于存放聊天记录的滚动面板
chatContent = new JTextArea();// 创建存放聊天内容的多行文本输入区对象
centerPanel.setViewportView(chatContent); // 将文本区放入滚动面板
// 将滚动面板放到主窗口内容面板中央
container.add(centerPanel, BorderLayout.CENTER);
chatContent.setEditable(false);// 将文本区置为不可编辑状态
// 创建底部面板对象，存放聊天标签、聊天栏、发送按钮
JPanel bottomPanel = new JPanel();
sentence = new JTextField(20);// 创建文本输入行对象，存放每次的聊天内容
send = new JButton("发送");// 创建按钮对象
bottomPanel.add(new JLabel("聊天信息")); // 将标签添加到底部面板
bottomPanel.add(sentence);// 把聊天内容栏添加到底部面板上
bottomPanel.add(send);// 把发送按钮添加到底部面板上
container.add(bottomPanel, BorderLayout.SOUTH);// 将底部面板放在主窗口的底部
send.addActionListener(this);// 注册发送按钮的动作事件
sentence.addActionListener(this);// 注册聊天栏的动作事件
this.setVisible(true); // 显示主窗口
/**
* 使用匿名内部类监听窗口关闭操作
* 当关闭服务器端窗口时，向客户端发送结束通信标识，
* 客户端接收到这个标识后，将自动关闭客户端主窗口
*/
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
try {
out.writeUTF("bye");
} catch (IOException e1) {
System.out.println("服务器端窗口关闭...");
} finally {
System.exit(0);
}
}
});
}
/**
* 主方法，创建服务器端对象，启动服务器端主界面
*/
public static void main(String[] args) {
new ChatServer();
}
}

客户端

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.Socket;
/**
 * 聊天室客户端
 */
public class ChatClient extends JFrame implements ActionListener {
Socket client; // 客户机端套接字
boolean done; // 通信是否结束
JButton send; // 发送按钮
JTextArea chatContent; // 聊天内容区
JTextField sentence; // 聊天信息栏
DataInputStream in = null; // 来自服务器的输入流
DataOutputStream out = null; // 发送到服务器的输出流


/**
* 构造方法，建立客户端聊天室主窗口，准备通信
*/
public ChatClient() {
buildGUI("聊天---客户机端"); // 显示聊天程序界面
try {
// 创建客户端套接字对象，
client = new Socket("192.168.36.37",2011); 
in = new DataInputStream(client.getInputStream()); // 得到输入流
out = new DataOutputStream(client.getOutputStream()); // 得到输出流
//done = false; // 通信结束标识置为假
String line = null; // 保存读取的一行信息

while ((line = in.readUTF()) != null) {
chatContent.append("服务器端:  " + line + "\n");
System.out.println("服务器端:  " + line);
}
in.close(); // 关闭输入流
out.close(); // 关闭输出流
System.exit(0); // 退出系统

} catch (Exception e) {
chatContent.append("服务器已关闭...\n");
}
}



/**
* 处理发送按钮被点击、聊天栏回车键事件
*/
public void actionPerformed(ActionEvent ae) {
String str = sentence.getText(); // 获取聊天栏里的聊天信息
if (str != null && !str.equals("")) { // 如果聊天内容不为空，则发送信息
// 将本人发送的聊天信息追加到聊天内容区
chatContent.append("客户端:  " + str + "\n");
try {
out.writeUTF(sentence.getText()); // 将客户端的聊天信息发送到服务器端
} catch (Exception e) {
chatContent.append("服务器没有启动....\n");
}
} else {
chatContent.append("聊天信息不能为空\n");
}
sentence.setText(""); // 清空聊天栏里的内容
}
/**
* 创图形用户界面方法，为有关组件注册监听器
*/
public void buildGUI(String title) {
this.setTitle(title); // 设置窗口标题
this.setSize(400, 300); // 设置窗口大小
Container container = this.getContentPane(); // 获得主窗口的内容面板
container.setLayout(new BorderLayout()); // 设置布局方式为BorderLayout
JScrollPane centerPanel = new JScrollPane(); // 创建用于存放聊天记录的滚动面板
chatContent = new JTextArea(); // 创建存放聊天内容的多行文本输入区对象
chatContent.setLineWrap(true);
centerPanel.setViewportView(chatContent); // 将文本区放入滚动面板
// 将滚动面板放到主窗口内容面板中央
container.add(centerPanel, BorderLayout.CENTER);
chatContent.setEditable(false); // 将文本区置为不可编辑状态
// 创建底部面板对象，存放聊天标签、聊天栏、发送按钮
JPanel bottomPanel = new JPanel();
sentence = new JTextField(20); // 创建文本输入行对象，存放每次的聊天内容
send = new JButton("发送"); // 创建按钮对象
bottomPanel.add(new JLabel("聊天信息")); // 将标签添加到底部面板
bottomPanel.add(sentence); // 把聊天内容栏添加到底部面板上
bottomPanel.add(send); // 把发送按钮添加到底部面板上
container.add(bottomPanel, BorderLayout.SOUTH);// 将底部面板放在主窗口的底部
send.addActionListener(this); // 注册发送按钮的动作事件
sentence.addActionListener(this); // 注册聊天栏的动作事件
this.setVisible(true); // 显示主窗口
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 关闭窗口时退出系统
}


/**
* 主方法，创建客户端对象，启动客户端主界面
*/
public static void main(String[] args) {
new ChatClient();
}
}

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.net.Socket;
/**
 * 聊天室客户端
 */
public class ChatClient extends JFrame implements ActionListener {
Socket client; // 客户机端套接字
boolean done; // 通信是否结束
JButton send; // 发送按钮
JTextArea chatContent; // 聊天内容区
JTextField sentence; // 聊天信息栏
DataInputStream in = null; // 来自服务器的输入流
DataOutputStream out = null; // 发送到服务器的输出流


/**
* 构造方法，建立客户端聊天室主窗口，准备通信
*/
public ChatClient() {
buildGUI("聊天---客户机端"); // 显示聊天程序界面
try {
// 创建客户端套接字对象，这里的localhost也可以是服务器的IP地址，如"218.198.112.154"
client = new Socket("192.168.36.37",2011); 
in = new DataInputStream(client.getInputStream()); // 得到输入流
out = new DataOutputStream(client.getOutputStream()); // 得到输出流
done = false; // 通信结束标识置为假
String line = null; // 保存读取的一行信息
while (!done) {
while ((line = in.readUTF()) != null) {
chatContent.append("服务器端:  " + line + "\n");
System.out.println(line);
if (line.equals("bye")) { // 发送结束通信标识
String msg = "服务器发来结束通信命令!\n";
msg += "系统将在您确认此对话框8秒钟后关闭，\n请及时保存聊天内容!";
JOptionPane.showMessageDialog(this, msg);
Thread.sleep(8000); // 休眠10秒
done = true; // //通信结束标识置为真
break; // 退出读输入流的循环
}
}
in.close(); // 关闭输入流
out.close(); // 关闭输出流
System.exit(0); // 退出系统
}
} catch (Exception e) {
chatContent.append("服务器已关闭...\n");
}
}



/**
* 处理发送按钮被点击、聊天栏回车键事件
*/
public void actionPerformed(ActionEvent ae) {
String str = sentence.getText(); // 获取聊天栏里的聊天信息
if (str != null && !str.equals("")) { // 如果聊天内容不为空，则发送信息
// 将本人发送的聊天信息追加到聊天内容区
chatContent.append("客户端:  " + str + "\n");
try {
out.writeUTF(sentence.getText()); // 将客户端的聊天信息发送到服务器端
} catch (Exception e) {
chatContent.append("服务器没有启动....\n");
}
} else {
chatContent.append("聊天信息不能为空\n");
}
sentence.setText(""); // 清空聊天栏里的内容
}
/**
* 创图形用户界面方法，为有关组件注册监听器
*/
public void buildGUI(String title) {
this.setTitle(title); // 设置窗口标题
this.setSize(400, 300); // 设置窗口大小
Container container = this.getContentPane(); // 获得主窗口的内容面板
container.setLayout(new BorderLayout()); // 设置布局方式为BorderLayout
JScrollPane centerPanel = new JScrollPane(); // 创建用于存放聊天记录的滚动面板
chatContent = new JTextArea(); // 创建存放聊天内容的多行文本输入区对象
chatContent.setLineWrap(true);
centerPanel.setViewportView(chatContent); // 将文本区放入滚动面板
// 将滚动面板放到主窗口内容面板中央
container.add(centerPanel, BorderLayout.CENTER);
chatContent.setEditable(false); // 将文本区置为不可编辑状态
// 创建底部面板对象，存放聊天标签、聊天栏、发送按钮
JPanel bottomPanel = new JPanel();
sentence = new JTextField(20); // 创建文本输入行对象，存放每次的聊天内容
send = new JButton("发送"); // 创建按钮对象
bottomPanel.add(new JLabel("聊天信息")); // 将标签添加到底部面板
bottomPanel.add(sentence); // 把聊天内容栏添加到底部面板上
bottomPanel.add(send); // 把发送按钮添加到底部面板上
container.add(bottomPanel, BorderLayout.SOUTH);// 将底部面板放在主窗口的底部
send.addActionListener(this); // 注册发送按钮的动作事件
sentence.addActionListener(this); // 注册聊天栏的动作事件
this.setVisible(true); // 显示主窗口
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 关闭窗口时退出系统
}


/**
* 主方法，创建客户端对象，启动客户端主界面
*/
public static void main(String[] args) {
new ChatClient();
}
}