聊天程序
分为服务器端和客户端分别实现。
1、 客户端
messageThread = importjava.awt.BorderLayout;
importjava.awt.Color;
importjava.awt.GridLayout;
importjava.awt.Toolkit;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.Socket;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.StringTokenizer;
importjavax.swing.DefaultListModel;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JLabel;
importjavax.swing.JList;
importjavax.swing.JOptionPane;
importjavax.swing.JPanel;
importjavax.swing.JScrollPane;
import javax.swing.JSplitPane;
importjavax.swing.JTextArea;
importjavax.swing.JTextField;
importjavax.swing.border.TitledBorder;
public classClient{
private JFrame frame;
private JList userList;
private JTextArea textArea;
private JTextField textField;
private JTextField txt_port;
private JTextField txt_hostIp;
private JTextField txt_name;
private JButton btn_start;
private JButton btn_stop;
private JButton btn_send;
private JPanel northPanel;
private JPanel southPanel;
private JScrollPane rightScroll;
private JScrollPane leftScroll;
private JSplitPane centerSplit;
private DefaultListModel listModel;
private boolean isConnected = false;
private Socket socket;
private PrintWriter writer;
private BufferedReader reader;
private MessageThread messageThread;// 负责接收消息的线程
private Map
// 主方法,程序入口
public static void main(String[] args) {
new Client();
}
// 执行发送
public void send() {
if (!isConnected) {
JOptionPane.showMessageDialog(frame,"还没有连接服务器，无法发送消息！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message =textField.getText().trim();
if (message == null ||message.equals("")) {
JOptionPane.showMessageDialog(frame,"消息不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
sendMessage(frame.getTitle() +"@" + "ALL" + "@" + message);
textField.setText(null);
}
// 构造方法
public Client() {
textArea = new JTextArea();
textArea.setEditable(false);
textArea.setForeground(Color.blue);
textField = new JTextField();
txt_port = newJTextField(""); //设置端口号和
txt_hostIp = newJTextField("127.0.0.1");
txt_name = newJTextField("");
btn_start = new JButton("连接");
btn_stop = new JButton("断开");
btn_send = new JButton("发送");
listModel = new DefaultListModel();
userList = new JList(listModel);
northPanel = new JPanel();
northPanel.setLayout(newGridLayout(1, 7));
northPanel.add(new JLabel("端口"));
northPanel.add(txt_port);
northPanel.add(new JLabel("服务器IP"));
northPanel.add(txt_hostIp);
northPanel.add(new JLabel("昵称"));
northPanel.add(txt_name);
northPanel.add(btn_start);
northPanel.add(btn_stop);
northPanel.setBorder(newTitledBorder("连接信息显示区"));
rightScroll = newJScrollPane(textArea);
rightScroll.setBorder(newTitledBorder("消息显示区"));
leftScroll = newJScrollPane(userList);
leftScroll.setBorder(newTitledBorder("在线用户显示区"));
southPanel = new JPanel(newBorderLayout());
southPanel.add(textField,"Center");
southPanel.add(btn_send,"East");
southPanel.setBorder(newTitledBorder("输入消息"));
centerSplit = newJSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScroll,
rightScroll);
centerSplit.setDividerLocation(100);
frame = new JFrame("客户端界面");
// 更改JFrame的图标：
// frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));
frame.setLayout(new BorderLayout());
frame.add(northPanel,"North");
frame.add(centerSplit,"Center");
frame.add(southPanel,"South");
frame.setSize(600, 400);
int screen_width =Toolkit.getDefaultToolkit().getScreenSize().width;
int screen_height =Toolkit.getDefaultToolkit().getScreenSize().height;
frame.setLocation((screen_width -frame.getWidth()) / 2,
(screen_height -frame.getHeight()) / 2);
frame.setVisible(true);
// 写消息的文本框中按回车键时事件
textField.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent arg0) {
send();
}
});
// 单击发送按钮时事件
btn_send.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
send();
}
});
// 单击连接按钮时事件
btn_start.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
int port;
if (isConnected) {
JOptionPane.showMessageDialog(frame,"已处于连接上状态，不要重复连接!",
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
try {
try {
port =Integer.parseInt(txt_port.getText().trim());
} catch(NumberFormatException e2) {
throw newException("端口号不符合要求!端口为整数!");
}
String hostIp =txt_hostIp.getText().trim();
String name =txt_name.getText().trim();
if(name.equals("") || hostIp.equals("")) {
throw newException("姓名、服务器IP不能为空!");
}
booleanflag = connectServer(port, hostIp, name);
if (flag ==false) {
throw newException("与服务器连接失败!");
}
frame.setTitle(name);
JOptionPane.showMessageDialog(frame,"成功连接!");
} catch (Exception exc){
JOptionPane.showMessageDialog(frame,exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
}
}
});
// 单击断开按钮时事件
btn_stop.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
if (!isConnected) {
JOptionPane.showMessageDialog(frame, "已处于断开状态，不要重复断开!",
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
try {
boolean flag =closeConnection();// 断开连接
if (flag ==false) {
throw newException("断开连接发生异常！");
}
JOptionPane.showMessageDialog(frame,"成功断开!");
} catch (Exception exc){
JOptionPane.showMessageDialog(frame,exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
}
}
});
// 关闭窗口时事件
frame.addWindowListener(newWindowAdapter() {
public voidwindowClosing(WindowEvent e) {
if (isConnected) {
closeConnection();//关闭连接
}
System.exit(0);// 退出程序
}
});
}
/**
* 连接服务器
*
*@param port
*@param hostIp
*@param name
*/
public boolean connectServer(int port,String hostIp, String name) {
// 连接服务器
try {
socket = new Socket(hostIp,port);// 根据端口号和服务器ip建立连接
writer = newPrintWriter(socket.getOutputStream());
reader = newBufferedReader(new InputStreamReader(socket
.getInputStream()));
// 发送客户端用户基本信息(用户名和ip地址)
sendMessage(name +"@" + socket.getLocalAddress().toString());
// 开启接收消息的线程
newMessageThread(reader, textArea);
messageThread.start();
isConnected = true;// 已经连接上了
return true;
} catch (Exception e) {
textArea.append("与端口号为：" + port + " IP地址为：" + hostIp
+ " 的服务器连接失败!" +"\r\n");
isConnected = false;// 未连接上
return false;
}
}
/**
* 发送消息
*
*@param message
*/
public void sendMessage(String message) {
writer.println(message);
writer.flush();
}
/**
* 客户端主动关闭连接
*/
@SuppressWarnings("deprecation")
public synchronized booleancloseConnection() {
try {
sendMessage("CLOSE");//发送断开连接命令给服务器
messageThread.stop();// 停止接受消息线程
// 释放资源
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
if (socket != null) {
socket.close();
}
isConnected = false;
return true;
} catch (IOException e1) {
e1.printStackTrace();
isConnected = true;
return false;
}
}
// 不断接收消息的线程
class MessageThread extends Thread {
private BufferedReader reader;
private JTextArea textArea;
// 接收消息线程的构造方法
public MessageThread(BufferedReaderreader, JTextArea textArea) {
this.reader = reader;
this.textArea = textArea;
}
// 被动的关闭连接
public synchronized void closeCon()throws Exception {
// 清空用户列表
listModel.removeAllElements();
// 被动的关闭连接释放资源
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
if (socket != null) {
socket.close();
}
isConnected = false;// 修改状态为断开
}
public void run() {
String message = "";
while (true) {
try {
message =reader.readLine();
StringTokenizerstringTokenizer = new StringTokenizer(
message,"/@");
String command =stringTokenizer.nextToken();// 命令
if(command.equals("CLOSE"))// 服务器已关闭命令
{
textArea.append("服务器已关闭!\r\n");
closeCon();//被动的关闭连接
return;//结束线程
} else if(command.equals("ADD")) {// 有用户上线更新在线列表
Stringusername = "";
StringuserIp = "";
if((username = stringTokenizer.nextToken()) != null
&&(userIp = stringTokenizer.nextToken()) != null) {
Useruser = new User(username, userIp);
onLineUsers.put(username,user);
listModel.addElement(username);
}
} else if(command.equals("DELETE")) {// 有用户下线更新在线列表
Stringusername = stringTokenizer.nextToken();
User user= (User) onLineUsers.get(username);
onLineUsers.remove(user);
listModel.removeElement(username);
} else if(command.equals("USERLIST")) {// 加载在线用户列表
int size= Integer
.parseInt(stringTokenizer.nextToken());
Stringusername = null;
StringuserIp = null;
for (inti = 0; i < size; i++) {
username= stringTokenizer.nextToken();
userIp= stringTokenizer.nextToken();
Useruser = new User(username, userIp);
onLineUsers.put(username,user);
listModel.addElement(username);
}
} else if(command.equals("MAX")) {// 人数已达上限
textArea.append(stringTokenizer.nextToken()
+stringTokenizer.nextToken() + "\r\n");
closeCon();//被动的关闭连接
JOptionPane.showMessageDialog(frame,"服务器缓冲区已满！", "错误",
JOptionPane.ERROR_MESSAGE);
return;//结束线程
} else {// 普通消息
textArea.append(message+ "\r\n");
}
} catch (IOException e){
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
2、 服务器端
import java.awt.BorderLayout;
importjava.awt.Color;
importjava.awt.GridLayout;
importjava.awt.Toolkit;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
import java.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.BindException;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.ArrayList;
importjava.util.StringTokenizer;
importjavax.swing.DefaultListModel;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JLabel;
importjavax.swing.JList;
importjavax.swing.JOptionPane;
importjavax.swing.JPanel;
importjavax.swing.JScrollPane;
importjavax.swing.JSplitPane;
importjavax.swing.JTextArea;
importjavax.swing.JTextField;
importjavax.swing.border.TitledBorder;
public classServer {
private JFrame frame;
private JTextArea contentArea;
private JTextField txt_message;
private JTextField txt_max;
private JTextField txt_port;
private JButton btn_start;
private JButton btn_stop;
private JButton btn_send;
private JPanel northPanel;
private JPanel southPanel;
private JScrollPane rightPanel;
private JScrollPane leftPanel;
private JSplitPane centerSplit;
private JList userList;
private DefaultListModel listModel;
private ServerSocket serverSocket;
private ServerThread serverThread;
private ArrayList
private boolean isStart = false;
// 主方法,程序执行入口
public static void main(String[] args) {
new Server();
}
// 执行消息发送
public void send() {
if (!isStart) {
JOptionPane.showMessageDialog(frame,"服务器还未启动,不能发送消息！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
if (clients.size() == 0) {
JOptionPane.showMessageDialog(frame,"没有用户在线,不能发送消息！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message =txt_message.getText().trim();
if (message == null ||message.equals("")) {
JOptionPane.showMessageDialog(frame,"消息不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
sendServerMessage(message);// 群发服务器消息
contentArea.append("服务器说：" + txt_message.getText() + "\r\n");
txt_message.setText(null);
}
// 构造方法
public Server() {
frame = new JFrame("服务器端界面");
// 更改JFrame的图标：
//frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));
// frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Server.class.getResource("qq.png")));
contentArea = new JTextArea();
contentArea.setEditable(false);
contentArea.setForeground(Color.blue);
txt_message = new JTextField();
txt_max = newJTextField("30");
txt_port = newJTextField("6666");
btn_start = new JButton("启动");
btn_stop = new JButton("停止");
btn_send = new JButton("发送");
btn_stop.setEnabled(false);
listModel = new DefaultListModel();
userList = new JList(listModel);
southPanel = new JPanel(newBorderLayout());
southPanel.setBorder(newTitledBorder("输入消息"));
southPanel.add(txt_message,"Center");
southPanel.add(btn_send,"East");
leftPanel = newJScrollPane(userList);
leftPanel.setBorder(newTitledBorder("在线用户"));
rightPanel = newJScrollPane(contentArea);
rightPanel.setBorder(newTitledBorder("消息显示区"));
centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,leftPanel,
rightPanel);
centerSplit.setDividerLocation(100);
northPanel = new JPanel();
northPanel.setLayout(newGridLayout(1, 6));
northPanel.add(new JLabel("人数上限"));
northPanel.add(txt_max);
northPanel.add(new JLabel("端口"));
northPanel.add(txt_port);
northPanel.add(btn_start);
northPanel.add(btn_stop);
northPanel.setBorder(newTitledBorder("配置信息"));
frame.setLayout(new BorderLayout());
frame.add(northPanel,"North");
frame.add(centerSplit,"Center");
frame.add(southPanel,"South");
frame.setSize(600, 400);
//frame.setSize(Toolkit.getDefaultToolkit().getScreenSize());//设置全屏
int screen_width =Toolkit.getDefaultToolkit().getScreenSize().width;
int screen_height =Toolkit.getDefaultToolkit().getScreenSize().height;
frame.setLocation((screen_width -frame.getWidth()) / 2,
(screen_height -frame.getHeight()) / 2);
frame.setVisible(true);
// 关闭窗口时事件
frame.addWindowListener(newWindowAdapter() {
public voidwindowClosing(WindowEvent e) {
if (isStart) {
closeServer();//关闭服务器
}
System.exit(0);// 退出程序
}
});
// 文本框按回车键时事件
txt_message.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
send();
}
});
// 单击发送按钮时事件
btn_send.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent arg0) {
send();
}
});
// 单击启动服务器按钮时事件
btn_start.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
if (isStart) {
JOptionPane.showMessageDialog(frame,"服务器已处于启动状态，不要重复启动！",
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
int max;
int port;
try {
try {
max =Integer.parseInt(txt_max.getText());
} catch(Exception e1) {
throw newException("人数上限为正整数！");
}
if (max <= 0){
throw newException("人数上限为正整数！");
}
try {
port =Integer.parseInt(txt_port.getText());
} catch(Exception e1) {
throw newException("端口号为正整数！");
}
if (port <=0) {
throw newException("端口号为正整数！");
}
serverStart(max,port);
contentArea.append("服务器已成功启动!人数上限：" + max + ",端口：" + port
+"\r\n");
JOptionPane.showMessageDialog(frame,"服务器成功启动!");
btn_start.setEnabled(false);
txt_max.setEnabled(false);
txt_port.setEnabled(false);
btn_stop.setEnabled(true);
} catch (Exception exc){
JOptionPane.showMessageDialog(frame,exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
}
}
});
// 单击停止服务器按钮时事件
btn_stop.addActionListener(newActionListener() {
public voidactionPerformed(ActionEvent e) {
if (!isStart) {
JOptionPane.showMessageDialog(frame,"服务器还未启动，无需停止！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
try {
closeServer();
btn_start.setEnabled(true);
txt_max.setEnabled(true);
txt_port.setEnabled(true);
btn_stop.setEnabled(false);
contentArea.append("服务器成功停止!\r\n");
JOptionPane.showMessageDialog(frame,"服务器成功停止！");
} catch (Exception exc){
JOptionPane.showMessageDialog(frame,"停止服务器发生异常！", "错误",
JOptionPane.ERROR_MESSAGE);
}
}
});
}
// 启动服务器
public void serverStart(int max, int port)throws java.net.BindException {
try{
clients = newArrayList
serverSocket = newServerSocket(port);
serverThread = newServerThread(serverSocket, max);
serverThread.start();
isStart = true;
} catch (BindException e) {
isStart = false;
throw new BindException("端口号已被占用，请换一个！");
} catch (Exception e1) {
e1.printStackTrace();
isStart = false;
throw new BindException("启动服务器异常！");
}
}
// 关闭服务器
@SuppressWarnings("deprecation")
public void closeServer() {
try {
if (serverThread != null)
serverThread.stop();// 停止服务器线程
for (int i = clients.size() -1; i >= 0; i--) {
// 给所有在线用户发送关闭命令
clients.get(i).getWriter().println("CLOSE");
clients.get(i).getWriter().flush();
// 释放资源
clients.get(i).stop();//停止此条为客户端服务的线程
clients.get(i).reader.close();
clients.get(i).writer.close();
clients.get(i).socket.close();
clients.remove(i);
}
if (serverSocket != null) {
serverSocket.close();//关闭服务器端连接
}
listModel.removeAllElements();//清空用户列表
isStart= false;
} catch (IOException e) {
e.printStackTrace();
isStart = true;
}
}
// 群发服务器消息
public void sendServerMessage(Stringmessage) {
for (int i = clients.size() - 1; i>= 0; i--) {
clients.get(i).getWriter().println("服务器：" + message + "(多人发送)");
clients.get(i).getWriter().flush();
}
}
// 服务器线程
class ServerThread extends Thread {
private ServerSocket serverSocket;
private int max;// 人数上限
// 服务器线程的构造方法
public ServerThread(ServerSocketserverSocket, int max) {
this.serverSocket =serverSocket;
this.max = max;
}
public void run() {
while (true) {// 不停的等待客户端的链接
try {
Socket socket =serverSocket.accept();
if(clients.size() == max) {// 如果已达人数上限
BufferedReaderr = new BufferedReader(
newInputStreamReader(socket.getInputStream()));
PrintWriterw = new PrintWriter(socket
.getOutputStream());
// 接收客户端的基本用户信息
Stringinf = r.readLine();
StringTokenizerst = new StringTokenizer(inf, "@");
User user= new User(st.nextToken(), st.nextToken());
// 反馈连接成功信息
w.println("MAX@服务器：对不起，" + user.getName()
+user.getIp() + "，服务器在线人数已达上限，请稍后尝试连接！");
w.flush();
// 释放资源
r.close();
w.close();
socket.close();
continue;
}
ClientThreadclient = new ClientThread(socket);
client.start();//开启对此客户端服务的线程
clients.add(client);
listModel.addElement(client.getUser().getName());//更新在线列表
contentArea.append(client.getUser().getName()
+client.getUser().getIp() + "上线!\r\n");
} catch (IOException e){
e.printStackTrace();
}
}
}
}
// 为一个客户端服务的线程
class ClientThread extends Thread {
private Socket socket;
private BufferedReader reader;
private PrintWriter writer;
private User user;
public BufferedReader getReader() {
return reader;
}
public PrintWriter getWriter() {
return writer;
}
public User getUser() {
return user;
}
// 客户端线程的构造方法
public ClientThread(Socket socket) {
try {
this.socket = socket;
reader = newBufferedReader(new InputStreamReader(socket
.getInputStream()));
writer = newPrintWriter(socket.getOutputStream());
// 接收客户端的基本用户信息
String inf =reader.readLine();
StringTokenizer st =new StringTokenizer(inf, "@");
user = newUser(st.nextToken(), st.nextToken());
// 反馈连接成功信息
writer.println(user.getName()+ user.getIp() + "与服务器连接成功!");
writer.flush();
// 反馈当前在线用户信息
if (clients.size() >0) {
Stringtemp = "";
for (int i =clients.size() - 1; i >= 0; i--) {
temp +=(clients.get(i).getUser().getName() + "/" + clients
.get(i).getUser().getIp())
+"@";
}
writer.println("USERLIST@"+ clients.size() + "@" + temp);
writer.flush();
}
// 向所有在线用户发送该用户上线命令
for (int i =clients.size() - 1; i >= 0; i--) {
clients.get(i).getWriter().println(
"ADD@"+ user.getName() + user.getIp());
clients.get(i).getWriter().flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
@SuppressWarnings("deprecation")
public void run() {// 不断接收客户端的消息，进行处理。
String message = null;
while (true) {
try {
message =reader.readLine();// 接收客户端消息
if(message.equals("CLOSE"))// 下线命令
{
contentArea.append(this.getUser().getName()
+this.getUser().getIp() + "下线!\r\n");
// 断开连接释放资源
reader.close();
writer.close();
socket.close();
// 向所有在线用户发送该用户的下线命令
for (inti = clients.size() - 1; i >= 0; i--) {
clients.get(i).getWriter().println(
"DELETE@"+ user.getName());
clients.get(i).getWriter().flush();
}
listModel.removeElement(user.getName());//更新在线列表
// 删除此条客户端服务线程
for (inti = clients.size() - 1; i >= 0; i--) {
if(clients.get(i).getUser() == user) {
ClientThreadtemp = clients.get(i);
clients.remove(i);//删除此用户的服务线程
temp.stop();//停止这条服务线程
return;
}
}
} else {
dispatcherMessage(message);// 转发消息
}
} catch (IOException e){
e.printStackTrace();
}
}
}
// 转发消息
public void dispatcherMessage(Stringmessage) {
StringTokenizerstringTokenizer = new StringTokenizer(message, "@");
String source =stringTokenizer.nextToken();
String owner =stringTokenizer.nextToken();
String content =stringTokenizer.nextToken();
message = source + "说：" + content;
contentArea.append(message +"\r\n");
if(owner.equals("ALL")) {// 群发
for (int i =clients.size() - 1; i >= 0; i--) {
clients.get(i).getWriter().println(message+ "(多人发送)");
clients.get(i).getWriter().flush();
}
}
}
}
}