关于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();

}

}