java 通过TCP\UDP 协议实现多人聊天，点对点，文件传送-----分服务器端和客户端
启动界面如下图：
首先启动服务器：
客户端登陆，登陆成功后为：
默认发送是全部用户，是多人发送。 当在边列表里面选择了用户后，可以与此用户建立点对点链接进行聊天，可以发送文件。
用户在线离线状态会实时更新，如果离线，则存为离线消息。当下次上线的时候，会接受到离线消息
从一个用户接受文件的同时，还可以接受从服务器发过来的文件
接受文件完成后，显示记录，并显示保存目录
消息发送演示
服务器端代码：
import sun.misc.BASE64Encoder; import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.Toolkit;
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.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.StringTokenizer; import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener; public class Server { 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 JButton btn_send_file;
private JPanel northPanel;
private JPanel southPanel;
private JPanel sendPanel;
private JScrollPane rightPanel;
private JScrollPane leftPanel;
private JScrollPane rightPanel2;
private JSplitPane centerSplit;
private JSplitPane centerSplit2;
private JList userList;
private JList all_userList;
private DefaultListModel listModel;
private static DefaultListModel all_listModel; private ServerSocket serverSocket;
private ServerThread serverThread;
private ArrayList<ClientThread> clients;//客户线程数组 private boolean isStart = false;//标志服务器是否启动或关闭 private int sendfor_who = 0;//监听左边jlist，保存给哪个用户发消息 // 主方法,程序执行入口
public static void main(String[] args) { new Server(); try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); } catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
} /**利用MD5进行加密
* @param str 待加密的字符串
* @return 加密后的字符串
* @throws NoSuchAlgorithmException 没有这种产生消息摘要的算法
* @throws UnsupportedEncodingException
*/
public String EncoderByMd5(String str) throws NoSuchAlgorithmException, UnsupportedEncodingException {
//确定计算方法
MessageDigest md5=MessageDigest.getInstance("MD5");
BASE64Encoder base64en = new BASE64Encoder();
//加密后的字符串
String newstr=base64en.encode(md5.digest(str.getBytes("utf-8")));
return newstr;
} /**判断用户密码是否正确
* @param newpasswd 用户输入的密码
* @param oldpasswd 数据库中存储的密码－－用户密码的摘要
* @return
* @throws NoSuchAlgorithmException
* @throws UnsupportedEncodingException
*/
public boolean checkpassword(String newpasswd,String oldpasswd) throws NoSuchAlgorithmException, UnsupportedEncodingException{
if(EncoderByMd5(newpasswd).equals(oldpasswd))
return true;
else
return false;
} /**
* 刚服务器突然关闭时，把所有用户状态置为离线
*/
public void set_user_state_off() {
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); int id = 0;
String selectSql = "UPDATE user SET state = 0";
stmt.executeUpdate(selectSql);
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
} /**
* 更新用户状态
*/
public void user_name_update() { try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); all_listModel.removeAllElements();
all_listModel.addElement("全部用户"); String username_db;
int state = 0;
//查询用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
username_db = selectRes.getString("username");
state = selectRes.getInt("state");
if (state == 1) {
all_listModel.addElement(username_db + "---(在线)");
} } selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
username_db = selectRes.getString("username");
state = selectRes.getInt("state");
if (state == 0) {
all_listModel.addElement(username_db + "---(离线)");
} }
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
} } /**
* 执行消息发送
*/
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, sendfor_who);// 群发服务器消息
//contentArea.append("对 "+listModel.getElementAt(sendfor_who)+" 说：" + txt_message.getText() + "\r\n");
txt_message.setText(null);
} // 构造放法
public Server() {
SelecTry selectIndex = new SelecTry();
frame = new JFrame("服务器");
contentArea = new JTextArea();
contentArea.setEditable(false);
contentArea.setForeground(Color.blue);
txt_message = new JTextField();
txt_max = new JTextField("30");
txt_port = new JTextField("6666");
btn_start = new JButton("启动");
btn_stop = new JButton("停止");
btn_send = new JButton("发送");
btn_send_file = new JButton("文件");
btn_stop.setEnabled(false);
listModel = new DefaultListModel();
all_listModel = new DefaultListModel();
//listModel.addElement("全部用户");
userList = new JList(all_listModel);//listModel
userList.addListSelectionListener(selectIndex); user_name_update();//更新用户状态 // all_userList = new JList(all_listModel); southPanel = new JPanel(new BorderLayout());
sendPanel = new JPanel(new BorderLayout());
southPanel.setBorder(new TitledBorder("写消息"));
southPanel.add(txt_message, "Center");
sendPanel.add(btn_send, BorderLayout.NORTH);
sendPanel.add(btn_send_file, BorderLayout.SOUTH); southPanel.add(sendPanel, "East"); leftPanel = new JScrollPane(userList);
leftPanel.setBorder(new TitledBorder("用户列表")); // rightPanel2 = new JScrollPane(all_userList);
// rightPanel2.setBorder(new TitledBorder("全部用户")); rightPanel = new JScrollPane(contentArea);
rightPanel.setBorder(new TitledBorder("消息显示区")); centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel,
rightPanel);
centerSplit.setDividerLocation(150); // centerSplit2 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, centerSplit,
// rightPanel2);
// centerSplit2.setDividerLocation(450); northPanel = new JPanel();
northPanel.setLayout(new GridLayout(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(new TitledBorder("配置信息")); frame.setLayout(new BorderLayout());
frame.add(northPanel, "North");
frame.add(centerSplit, "Center");
//frame.add(rightPanel2,BorderLayout.EAST);
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(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
if (isStart) {
closeServer();// 关闭服务器
}
System.exit(0);// 退出程序
}
}); // 文本框按回车键时事件
txt_message.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
send();
}
}); // 单击发送按钮时事件
btn_send.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
send();
}
}); //单机文件按钮时事件
btn_send_file.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
//文件选择对话框启动，当选择了文件以后给每一个client发送文件
JFileChooser sourceFileChooser = new JFileChooser(".");
sourceFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
int status = sourceFileChooser.showOpenDialog(frame);
File sourceFile = new File(sourceFileChooser.getSelectedFile().getPath());
//服务器text area提示
contentArea.append("发送文件：" + sourceFile.getName() + "\r\n");
for (int i = clients.size() - 1; i >= 0; i--) {
SendFileThread sendFile = new SendFileThread(frame, clients.get(i).socket, "服务器", sourceFileChooser, status);
sendFile.start();
//client端提示
clients.get(i).getWriter().println("服务器发送一个文件：" + sourceFile.getName() + "(多人发送)");
clients.get(i).getWriter().flush();
} }
}); // 单击启动服务器按钮时事件
btn_start.addActionListener(new ActionListener() {
public void actionPerformed(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 new Exception("人数上限为正整数！");
}
if (max <= 0) {
throw new Exception("人数上限为正整数！");
}
try {
port = Integer.parseInt(txt_port.getText());
} catch (Exception e1) {
throw new Exception("端口号为正整数！");
}
if (port <= 0) {
throw new Exception("端口号 为正整数！");
}
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);
listModel.addElement("全部用户");
user_name_update();
} catch (Exception exc) {
JOptionPane.showMessageDialog(frame, exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
}
}
}); // 单击停止服务器按钮时事件
btn_stop.addActionListener(new ActionListener() {
public void actionPerformed(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);
}
}
});
} /**
* 监听左边jlist选择的是哪一个用户
*/
class SelecTry implements ListSelectionListener {
int change = 0, who; public void valueChanged(ListSelectionEvent e) {
//System.out.println("you selected:"+listModel.getElementAt(userList.getSelectedIndex()));
sendfor_who = userList.getSelectedIndex();
} } /**
* 找回密码模块
*
* @param username
* @param youxiang
* @param new_password
* @return
*/
public int user_forget(String username, String youxiang, String new_password) {
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); String codingpassword = EncoderByMd5(new_password); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
int userid = selectRes.getInt("Id");
String username_db = selectRes.getString("username");
String youxiang_db = selectRes.getString("youxiang");
if (username.equals(username_db)) {
if (youxiang_db.equals(youxiang)) {
//更新一条数据
String updateSql = "UPDATE user SET password = '" + codingpassword + "' WHERE Id = " + userid + "";
long updateRes = stmt.executeUpdate(updateSql);
return 1;
} }
}
return 0;
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} /**
* 注册模块
*
* @param username
* @param password
* @param youxiang
* @return
*/
public int user_register(String username, String password, String youxiang) { try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); String codingPassword = EncoderByMd5(password); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
String username_db = selectRes.getString("username");
if (username.equals(username_db)) {
return 2;
}
}
//新增一条数据
stmt.executeUpdate("INSERT INTO user (username, password,youxiang) VALUES ('" + username + "', '" + codingPassword + "','" + youxiang + "')");
all_listModel.addElement(username);
return 1;
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} /**
* 当有用户下线时，在服务器改变状态
*
* @param name
* @return
*/
public int user_offLine(String name) {
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //
String username_fromDb;
int id = 0;
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
username_fromDb = selectRes.getString("username");
id = selectRes.getInt("Id");
if (name.equals(username_fromDb)) {
selectSql = "UPDATE user SET state = 0 WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
selectSql = "UPDATE user SET serverPort = 0 WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
selectSql = "UPDATE user SET ipAdres = '' WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
return 1;
}
}
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} /**
* 登陆模块
*
* @param username
* @param password
* @return
*/
public int user_login(String username, String password,int serverPort,String myIP) {
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //
String username_fromDb;
String password_fromDb;
String codingNewPassword;
int state = 0, id = 0;
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
username_fromDb = selectRes.getString("username");
password_fromDb = selectRes.getString("password");
codingNewPassword = EncoderByMd5(password);
id = selectRes.getInt("Id");
state = selectRes.getInt("state");
if (username.equals(username_fromDb) && codingNewPassword.equals(password_fromDb)) {
if (state == 0) {
selectSql = "UPDATE user SET state = 1 WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
selectSql = "UPDATE user SET serverPort = " + serverPort + " WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
selectSql = "UPDATE user SET ipAdres = '" + myIP + "' WHERE Id = " + id + "";
stmt.executeUpdate(selectSql);
return 1;//还没有登陆，可以登陆
} else {
return 2;//已登陆状态，无法登陆
} }
}
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} /**
* 启动服务器
*
* @param max
* @param port
* @throws java.net.BindException
*/
public void serverStart(int max, int port) throws java.net.BindException {
try {
clients = new ArrayList<ClientThread>();
serverSocket = new ServerSocket(port);
serverThread = new ServerThread(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;
set_user_state_off();
user_name_update();
} catch (IOException e) {
e.printStackTrace();
isStart = true;
}
} /**
* 群发服务器消息
*
* @param message
* @param who
*/
public void sendServerMessage(String message, int who) {
if (who == 0) {
StringTokenizer stringTokenizer;
int flag = 0;
for (int i = all_listModel.size(); i > 0; i--) {
flag = 0;
String msg = all_listModel.getElementAt(i - 1) + "";
stringTokenizer = new StringTokenizer(
msg, "---");
String user_name = stringTokenizer.nextToken();
for (int j = clients.size() - 1; j >= 0; j--) {
if (user_name.equals(clients.get(j).getUser().getName())) {
clients.get(j).getWriter().println("服务器对你说 " + message);
clients.get(j).getWriter().flush();
flag = 1;//该用户在线状态，已发出去
break;
}
}
if (flag == 0) {
//用户离线状态，则留言
send_messageTo_board("服务器", user_name, message);
}
}
contentArea.append("对 全部用户 发送：" + message + "\r\n");
} else {
int flag = 0;
String msg = "" + all_listModel.getElementAt(who);
StringTokenizer stringTokenizer = new StringTokenizer(
msg, "---");
String user_name = stringTokenizer.nextToken();
for (int i = clients.size() - 1; i >= 0; i--) {
if (user_name.equals(clients.get(i).getUser().getName())) {
clients.get(i).getWriter().println("服务器对你说 " + message);
clients.get(i).getWriter().flush();
flag = 1;//该用户在线状态，已发出去
break;
}
}
if (flag == 0) {
// JOptionPane.showMessageDialog(frame, "该用户不在线，已存为留言板！", "错误",
// JOptionPane.ERROR_MESSAGE);
send_messageTo_board("服务器", user_name, message);
contentArea.append("对 " + user_name + " 留言：" + message + "\r\n");
} else {
contentArea.append("对 " + user_name + " 说：" + message + "\r\n");
}
} } /**
* 用户不在线时，离线消息保存到服务器里面
* @param send_from
* @param send_for
* @param message
* @return
*/
public int send_messageTo_board(String send_from, String send_for, String message) {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String msg = send_from + "#" + df.format(new Date()) + "#" + message + "#";
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
int Id = selectRes.getInt("Id");
String username_db = selectRes.getString("username");
if (send_for.equals(username_db)) {
String old_message = selectRes.getString("message");
String updateSql = "UPDATE user SET message = '" + old_message + msg + "' WHERE Id = " + Id + "";
stmt.executeUpdate(updateSql);
return 1;
}
}
return 0;
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} /**
* 服务器线程
*/
class ServerThread extends Thread {
private ServerSocket serverSocket;
private int max;// 人数上限 // 服务器线程的构造方法
public ServerThread(ServerSocket serverSocket, int max) {
this.serverSocket = serverSocket;
this.max = max;
} public void run() {
while (true) {// 不停的等待客户端的链接
try {
Socket socket = serverSocket.accept();
if (clients.size() == max) {// 如果已达人数上限
BufferedReader r = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
PrintWriter w = new PrintWriter(socket
.getOutputStream());
// 接收客户端的基本用户信息
String inf = r.readLine();
StringTokenizer st = 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;
}
ClientThread client = new ClientThread(socket);
client.start();// 开启对此客户端服务的线程
client.getUser().setState(1);//在线状态
clients.add(client);
listModel.addElement(client.getUser().getName());// 更新在线列表
contentArea.append(client.getUser().getName()
+ client.getUser().getIp() + "上线!\r\n");
// user_name_update();
} 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 = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
writer = new PrintWriter(socket.getOutputStream());
// 接收客户端的基本用户信息
String inf = reader.readLine();
StringTokenizer st = new StringTokenizer(inf, "#");
user = new User(st.nextToken(), st.nextToken());
// 反馈连接成功信息
writer.println(user.getName() + user.getIp() + "与服务器连接成功!");
writer.flush(); } catch (IOException e) {
e.printStackTrace();
}
} @SuppressWarnings("deprecation")
public void run() {// 不断接收客户端的消息，进行处理。
String message = null;
while (true) {
try {
message = reader.readLine();// 接收客户端消息
StringTokenizer stringTokenizer = new StringTokenizer(
message, "#");
String command = stringTokenizer.nextToken();// 命令
if (command.equals("CLOSE"))// 下线命令
{
contentArea.append(this.getUser().getName()
+ this.getUser().getIp() + "下线!\r\n");
// 断开连接释放资源
user_offLine(this.getUser().getName());
this.getUser().setState(0);
reader.close();
writer.close();
socket.close(); user_name_update();//更新用户状态 //反馈用户状态
String liststr = "";
for (int j = 1; j < all_listModel.size(); j++) {
liststr += all_listModel.get(j) + "#";
}
// 向所有在线用户发送该用户上线命令
for (int j = clients.size()-1 ; j >= 0; j--) {
clients.get(j).getWriter().println(
"USERLIST#" + all_listModel.size() + "#" + liststr);
clients.get(j).getWriter().flush();
}
//user_name_update();//更新用户状态 listModel.removeElement(user.getName());// 更新在线列表 // 删除此条客户端服务线程
for (int i = clients.size() - 1; i >= 0; i--) {
if (clients.get(i).getUser() == user) {
ClientThread temp = clients.get(i);
clients.remove(i);// 删除此用户的服务线程
temp.stop();// 停止这条服务线程
return;
}
}
} else if (command.equals("USERLOGIN")) {
String username = stringTokenizer.nextToken();
String password = stringTokenizer.nextToken();
int serverPort = Integer.parseInt(stringTokenizer.nextToken());
String myIP = stringTokenizer.nextToken();
int i = user_login(username, password,serverPort,myIP);
if (1 == i) {
user_name_update();
String msg = get_message(username);
if (msg.equals("")) {
writer.println("USERLOGIN#OK#");
writer.flush();
} else {
writer.println("USERLOGIN#OK#" + msg);
writer.flush();
} //反馈用户状态
String temp = "";
for (int j = 1; j < all_listModel.size(); j++) {
temp += all_listModel.get(j) + "#";
}
// 向所有在线用户发送该用户上线命令
for (int j = clients.size()-1 ; j >= 0; j--) {
clients.get(j).getWriter().println(
"USERLIST#" + all_listModel.size() + "#" + temp);
clients.get(j).getWriter().flush();
} } else if (2 == i) {
writer.println("USERLOGIN#ALREADY");
writer.flush();
} else {
writer.println("USERLOGIN#NO");
writer.flush(); }
//user_name_update();
} else if (command.equals("USERZHUCE")) {
String username = stringTokenizer.nextToken();
String password = stringTokenizer.nextToken();
String youxiang = stringTokenizer.nextToken();
int i = user_register(username, password, youxiang);
if (1 == i) {
writer.println("USERZHUCE#OK");
writer.flush();
contentArea.append("有新用户注册！ 用户名：" + username + "\r\n");
user_name_update();//更新用户状态
} else if (i == 2) {
writer.println("USERZHUCE#exict");
writer.flush();
} else {
writer.println("USERZHUCE#NO");
writer.flush();
}
} else if (command.equals("USERFORGET")) {
String username = stringTokenizer.nextToken();
String youxiang = stringTokenizer.nextToken();
String new_password = stringTokenizer.nextToken();
int i = user_forget(username, youxiang, new_password);
if (1 == i) {
//JOptionPane.showMessageDialog(frame, "登陆成功!" );
writer.println("USERFORGET#OK");
writer.flush();
contentArea.append(" 用户：" + username + " 修改密码！\r\n");
} else if (i == 2) {
writer.println("USERFORGET#YOUXIANG_WRONG");
writer.flush();
} else if (i == 3) {
writer.println("USERFORGET#NAME_NO_exict");
writer.flush();
} else {
writer.println("USERFORGET#NO");
writer.flush();
}
} else if (command.equals("P2P")) {
String username = stringTokenizer.nextToken();
int i = get_user_serverPort(username);
String ip = get_user_serverIP(username);
if(i!=0){
writer.println("P2P#OK#"+username+"#"+i+"#"+ip);
writer.flush();
}else{
writer.println("P2P#NO#"+username);
writer.flush();
}
}else if(command.equals("LIXIAN")){
String username_sent = stringTokenizer.nextToken();
String username_receive = stringTokenizer.nextToken();
String msg = stringTokenizer.nextToken();
send_messageTo_board(username_sent,username_receive,msg);
System.out.println("离线发送ok");
} else {
dispatcherMessage(message);// 转发消息
}
} catch (IOException e) {
e.printStackTrace();
}
}
} public int get_user_serverPort(String user_name){
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
String username_db = selectRes.getString("username");
if (user_name.equals(username_db)) {
int serverPort = selectRes.getInt("serverPort");
return serverPort;
}
}
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return 0;
} public String get_user_serverIP(String user_name){
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
String username_db = selectRes.getString("username");
if (user_name.equals(username_db)) {
String serverIP = selectRes.getString("ipAdres");
return serverIP;
}
}
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return "";
} public String get_message(String name) {
try {
Connection con = null; //定义一个MYSQL链接对象
Class.forName("com.mysql.jdbc.Driver").newInstance();//MYSQL驱动
con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/server_db", "root", "root"); //链接本地MYSQL
Statement stmt; //创建声明
stmt = con.createStatement(); //查询数据，不能有相同的用户名
String selectSql = "SELECT * FROM user";
ResultSet selectRes = stmt.executeQuery(selectSql);
while (selectRes.next()) { //循环输出结果集
int Id = selectRes.getInt("Id");
String username_db = selectRes.getString("username");
if (name.equals(username_db)) {
String message = selectRes.getString("message");
String updateSql = "UPDATE user SET message = '' WHERE Id = " + Id + "";
stmt.executeUpdate(updateSql);
return message;
}
}
return "";
} catch (Exception e) {
System.out.print("MYSQL ERROR:" + e.getMessage());
}
return "";
} // 转发消息
public void dispatcherMessage(String message) {
StringTokenizer stringTokenizer = new StringTokenizer(message, "#");
String source = stringTokenizer.nextToken();
String owner = stringTokenizer.nextToken();
String content = stringTokenizer.nextToken(); if (owner.equals("ALL")) {// 群发
message = source + "说：" + content;
contentArea.append(message + "\r\n");
for (int i = clients.size() - 1; i >= 0; i--) {
clients.get(i).getWriter().println(message + "(多人发送)");
clients.get(i).getWriter().flush();
}
} else {
for (int i = clients.size() - 1; i >= 0; i--) {
if (clients.get(i).user.getName().equals(owner)) {
clients.get(i).getWriter().println(owner + " 对你说: " + content);
clients.get(i).getWriter().flush();
//contentArea.append(owner+" 对 "+ clients.get(i).user.getName()+ " 说 :"+ content+"\r\n");
}
if (clients.get(i).user.getName().equals(source)) {
clients.get(i).getWriter().println("对 " + source + " 说: " + content);
clients.get(i).getWriter().flush();
}
}
}
}
}
}
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket; import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.ProgressMonitor;
import javax.swing.ProgressMonitorInputStream; public class SendFileThread extends Thread {
private Socket clientSocket;
private String name;
JFileChooser sourceFileChooser;
int status;
JFrame JFrame; public SendFileThread(JFrame frame, Socket socket, String name, JFileChooser sourceFileChooser, int status) {
this.clientSocket = socket;
this.name = name;
this.sourceFileChooser = sourceFileChooser;
this.status = status;
this.JFrame = frame;
} public void run() {
// JFileChooser sourceFileChooser = new JFileChooser(".");
// sourceFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
// int status = sourceFileChooser.showOpenDialog(null);
if (status == JFileChooser.APPROVE_OPTION) {
File sourceFile = new File(sourceFileChooser.getSelectedFile().getPath());
String sourceFilePath = sourceFile.getAbsolutePath();
String fileName = sourceFile.getName();
//System.out.println(sourceFilePath+"\\"+fileName);
try {
PrintWriter sendToClient = new PrintWriter(clientSocket.getOutputStream());
BufferedReader getFromClient = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
ServerSocket fileSenderSocket = null;
try {
fileSenderSocket = new ServerSocket(0);
} catch (IOException ex1) {
JOptionPane.showMessageDialog(JFrame, "无法分配端口以发送此文件!", "错误", JOptionPane.ERROR_MESSAGE);
}
sendToClient.println("FILE#" + fileSenderSocket.getLocalPort() + "#" + fileName + "#"
+ String.valueOf(sourceFile.length()) + "#" + clientSocket.getInetAddress().getHostAddress() + "#" + name);
sendToClient.flush();
//System.out.println("Sender: "+fileSenderSocket.getLocalSocketAddress());
Socket fileReceiverSocket = fileSenderSocket.accept(); BufferedReader getFromReceiver = null;
PrintWriter sendToReceiver = null;
try {
getFromReceiver = new BufferedReader(new InputStreamReader(fileReceiverSocket.getInputStream()));
sendToReceiver = new PrintWriter(fileReceiverSocket.getOutputStream());
} catch (IOException ex) {
} finally {
}
String judge = getFromReceiver.readLine();
if (judge.equals("accepted")) {
DataOutputStream sendFileToReceiver = new DataOutputStream(new BufferedOutputStream(fileReceiverSocket.getOutputStream()));
ProgressMonitorInputStream monitor;
FileInputStream sendFileStream = null;
try {
sendFileStream = new FileInputStream(sourceFile);
} catch (FileNotFoundException ex) {
sendToReceiver.flush();
sendFileToReceiver.writeByte(0);
sendFileToReceiver.flush();
return;
}
monitor = new ProgressMonitorInputStream(JFrame, "正在发送： " + fileName, sendFileStream);
ProgressMonitor progressMonitor = monitor.getProgressMonitor(); int read_unit = 500;
long fileSize = monitor.available();
int readed = 0;
byte[] data = new byte[read_unit];
try {
sendFileToReceiver.writeByte(1);
sendFileToReceiver.flush();
while (monitor.available() > 0) {
int in = monitor.read(data);
readed += in;
float process = (float) readed / fileSize * 100;
progressMonitor.setNote(process + " % 完成");
if (in > 0) {
sendFileToReceiver.write(data, 0, in);
}
}
sendFileToReceiver.flush();
} catch (IOException e) {
JOptionPane.showMessageDialog(JFrame, "传输中断!", "错误", JOptionPane.ERROR_MESSAGE);
} finally {
if (sendFileStream != null)
try {
sendFileStream.close();
monitor.close();
} catch (IOException e) {
}
}
try {
fileReceiverSocket.close();
} catch (IOException ex1) {
}
} else if (judge.equals("refused")) {
JOptionPane.showMessageDialog(JFrame, "对方拒绝接受文件 " + fileName, "错误！", JOptionPane.INFORMATION_MESSAGE);
} } catch (IOException ex) {
} finally {
}
}
}
}
//用户信息类
public class User{
private String name;
private String ip;
private int state; public User(String name, String ip) {
this.name = name;
this.ip = ip;
state = 0;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getIp() {
return ip;
} public void setIp(String ip) {
this.ip = ip;
} public int getState() {
return state;
} public void setState(int state) {
this.state = state;
}
}
数据库：
是通过MD5加密保存。
客户端代码：
package com.company; import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.Toolkit;
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.BindException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer; import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener; //import socket_chat_server.Server.ClientThread;
//import socket_chat_server.Server.SelecTry; public class Client{ private JPanel sendPanel;
private JButton btn_send_file;
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 JPanel logPanle;
private JFrame loginframe;
private JLabel label_username;
private JLabel label_password;
private JTextField txt_login_name;
private JTextField txt_password;
private JTextField txt_login_ip;
private JTextField txt_login_port;
private JTextField txt_login_forget;
private JButton btn_submit;
private JButton btn_zhuce;
private JButton btn_forget_pass; private DefaultListModel listModel;
private boolean isConnected = false; private int sendfor_who;
private int server_port=0; private ServerSocket serverSocket;
private ServerThread serverThread;
private Socket socketfor_p2p;
private boolean isConnected_p2p = false;
private ArrayList<ClientThread> clients;//客户线程数组
private PrintWriter P2P_printWriter;//点对点服务的输出流
private BufferedReader P2P_bufferReader;//点对点服务的输入流
private MessageThread_P2P messageThread_for_p2p;// 负责接收p2p消息的线程
private Map<String, Boolean> P2P_connected_user = new HashMap<String, Boolean>(); private Socket socket;
private PrintWriter writer;
private BufferedReader reader;
private MessageThread messageThread;// 负责接收消息的线程
private Map<String, User> onLineUsers = new HashMap<String, User>();// 所有在线用户
private String myIP = "";//每一个客户端都有唯一的IP地址 // 主方法,程序入口
public static void main(String[] args) throws BindException {
new Client(); } class SelecTry implements ListSelectionListener
{
int change=0,who;
public void valueChanged(ListSelectionEvent e){
//System.out.println("you selected:"+listModel.getElementAt(userList.getSelectedIndex()));
sendfor_who=userList.getSelectedIndex();
isConnected_p2p = false;
} } /**
* 连接服务器
*
* @param port
* @param hostIp
* @param name
*/
public boolean connectServer_p2p(int port, String hostIp, String name) {
// 连接服务器
try {
socketfor_p2p = new Socket(hostIp, port);// 根据端口号和服务器ip建立连接
P2P_printWriter = new PrintWriter(socketfor_p2p.getOutputStream());
P2P_bufferReader = new BufferedReader(new InputStreamReader(socketfor_p2p
.getInputStream())); messageThread_for_p2p = new MessageThread_P2P(P2P_bufferReader);
messageThread_for_p2p.start();
P2P_connected_user.put(name,true);
isConnected_p2p = true;// 已经连接上了
return true;
} catch (Exception e) {
textArea.append("与端口号为：" + port + " IP地址为：" + hostIp
+ " 的服务连接失败!" + "\r\n");
isConnected_p2p = false;// 未连接上
return false;
}
} /**
* 关闭服务
*/
@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#"+frame.getTitle());
clients.get(i).getWriter().flush();
// 释放资源
clients.get(i).stop();// 停止此条为客户端服务的线程
clients.get(i).reader_ptp.close();
clients.get(i).writer_ptp.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;
}
} // 不断接收消息的线程
class MessageThread_P2P extends Thread {
private BufferedReader reader_ptp; // 接收消息线程的构造方法
public MessageThread_P2P(BufferedReader reader) {
this.reader_ptp = reader; } // 被动的关闭连接
public synchronized void closeCon() throws Exception {
System.out.println("close :*************");
// 被动的关闭连接释放资源
if (reader_ptp != null) {
reader_ptp.close();
}
if (P2P_printWriter != null) {
P2P_printWriter.close();
}
if (socketfor_p2p != null) {
socketfor_p2p.close();
}
isConnected_p2p = false;// 修改状态为断开 } public void run() {
String message = "";
while (true) {
try {
message = reader_ptp.readLine();
StringTokenizer stringTokenizer = new StringTokenizer(
message, "/#");
String command = stringTokenizer.nextToken();// 命令
if (command.equals("CLOSE"))// 服务器已关闭命令
{
String user = stringTokenizer.nextToken();
textArea.append("用户 "+user+" 已下线，p2p服务已关闭!\r\n");
closeCon();// 被动的关闭连接
JOptionPane.showMessageDialog(frame, "用户 "+user+" 已下线，p2p服务已关闭!", "错误",
JOptionPane.ERROR_MESSAGE);
return;// 结束线程
} else if (command.equals("FILE")) {
int portNumber = Integer.parseInt(stringTokenizer.nextToken());
String fileName = stringTokenizer.nextToken();
long fileSize = Long.parseLong(stringTokenizer.nextToken());
String ip = stringTokenizer.nextToken();
String Nickname = stringTokenizer.nextToken();
ReceiveFileThread receiveFile = new ReceiveFileThread(textArea,frame,ip, portNumber, fileName, fileSize, Nickname);
receiveFile.start();
textArea.append("从 "+Nickname+" 接受文件:"+fileName+",大小为:"+fileSize
+"ip:"+ip+"port:"+portNumber+"\r\n");
} else {// 普通消息
textArea.append(""+message + "\r\n");
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}
} /**
* 启动服务器
*
* @param port
* @throws java.net.BindException
*/
public void serverStart(int port) throws java.net.BindException {
try {
clients = new ArrayList<ClientThread>();
serverSocket = new ServerSocket(port);
serverThread = new ServerThread(serverSocket);
serverThread.start();
server_port = serverSocket.getLocalPort();
InetAddress addr = InetAddress.getLocalHost();
myIP = addr.getHostAddress();//获得本机IP
// myIP = serverSocket.getInetAddress().getHostAddress();
System.out.println("mmyIP=="+myIP+"\r\n");
} catch (BindException e) {
throw new BindException("端口号已被占用，请换一个！");
} catch (Exception e1) {
e1.printStackTrace();
throw new BindException("启动服务器异常！");
}
} /**
* 为另一个主动链接的客户端提供服务的线程
*/
class ClientThread extends Thread {
private Socket socket;
private BufferedReader reader_ptp;
private PrintWriter writer_ptp;
private User user; public BufferedReader getReader() {
return reader_ptp;
} public PrintWriter getWriter() {
return writer_ptp;
} public User getUser() {
return user;
} // 客户端线程的构造方法
public ClientThread(Socket socket) {
try {
this.socket = socket;
reader_ptp = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
writer_ptp = new PrintWriter(socket.getOutputStream()); // 接收客户端的基本用户信息
String inf = reader_ptp.readLine();
StringTokenizer st = new StringTokenizer(inf, "#");
user = new User(st.nextToken(), socket.getLocalAddress().toString());
// 反馈连接成功信息
writer_ptp.println(frame.getTitle()+" 对你说： "+user.getName()+"/"+user.getIp()+"你好！"+"与我"+frame.getTitle()+"建立链接成功！");
writer_ptp.flush();
// // 反馈当前在线用户信息
// if (clients.size() > 0) {
// String temp = "";
// 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_ptp.readLine();// 接收客户端消息
StringTokenizer stringTokenizer = new StringTokenizer(message,"/#");
String command = stringTokenizer.nextToken();
if (command.equals("CLOSE"))// 下线命令
{
textArea.append("与"+this.getUser().getName()
+ this.getUser().getIp() + "建立连接成功!\r\n");
// 断开连接释放资源
this.getUser().setState(0);
reader.close();
writer.close();
socket.close(); } else if (command.equals("FILE")) {
int portNumber = Integer.parseInt(stringTokenizer.nextToken());
String fileName = stringTokenizer.nextToken();
long fileSize = Long.parseLong(stringTokenizer.nextToken());
String ip = stringTokenizer.nextToken();
String Nickname = stringTokenizer.nextToken();
ReceiveFileThread receiveFile = new ReceiveFileThread(textArea,frame,ip, portNumber, fileName, fileSize, Nickname);
receiveFile.start();
textArea.append("从 "+Nickname+" 接受文件 :"+fileName+",大小为: "+fileSize
+" ip: "+ip+" port:"+portNumber+"\r\n");
}else {
textArea.append(user.getName()+" 对你说： "+message+"\r\n");
}
} catch (IOException e) {
e.printStackTrace();
}
}
} } /**
* 服务线程
*/
class ServerThread extends Thread {
private ServerSocket serverSocket; // 服务器线程的构造方法
public ServerThread(ServerSocket serverSocket) {
this.serverSocket = serverSocket;
} public void run() {
while (true) {// 不停的等待客户端的链接
try {
Socket socket = serverSocket.accept();
ClientThread client = new ClientThread(socket);
client.start();// 开启对此客户端服务的线程
clients.add(client);
textArea.append("有新用户p2p链接\r\n");
// user_name_update();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} public void sendFile() {
//文件选择对话框启动，当选择了文件以后给每一个client发送文件
JFileChooser sourceFileChooser = new JFileChooser(".");
sourceFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
int status = sourceFileChooser.showOpenDialog(frame);
File sourceFile = new File(sourceFileChooser.getSelectedFile().getPath());
//服务器text area提示
textArea.append("发送文件：" + sourceFile.getName() + "\r\n"); if(sendfor_who==0){
textArea.append("对服务器发送文件!");
}else{
StringTokenizer st = new StringTokenizer(listModel.getElementAt(sendfor_who)+"", "---()");
String user_name = st.nextToken();
String user_state = st.nextToken();
if (user_state.equals("在线")) {
for (int i = clients.size()-1; i >= 0; i--) {
if (clients.get(i).getUser().getName().equals(user_name)) {
SendFileThread sendFile = new SendFileThread(frame, clients.get(i).socket, frame.getTitle(), sourceFileChooser, status);
sendFile.start();
//client端提示
textArea.append("给 "+user_name+" 发送一个文件：" + sourceFile.getName() + "\r\n");
return;
}
}
SendFileThread sendFile = new SendFileThread(frame, socketfor_p2p, frame.getTitle(), sourceFileChooser, status);
sendFile.start();
//client端提示
textArea.append("给 "+user_name+" 发送一个文件：" + sourceFile.getName() + "\r\n");
}else{
JOptionPane.showMessageDialog(frame, "用户不在线，不能发送文件！");
}
} } // 执行发送
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);
if(sendfor_who==0){
sendMessage(frame.getTitle() + "#" + "ALL" + "#" + message);
textField.setText(null);
}else{
StringTokenizer st = new StringTokenizer(listModel.getElementAt(sendfor_who)+"", "---()");
String user_name = st.nextToken();
String user_state = st.nextToken();
if (user_state.equals("在线")) {
for (int i = clients.size()-1; i >= 0; i--) {
if (clients.get(i).getUser().getName().equals(user_name)) {
clients.get(i).writer_ptp.println("对 "+user_name+" 说： "+message+"\r\n");
clients.get(i).writer_ptp.flush();
textArea.append("对 "+user_name+" 说： "+message+"\r\n");
textField.setText(null);
return;
}
}
if (!isConnected_p2p) {
JOptionPane.showMessageDialog(frame, "点对点即将连接！");
sendMessage("P2P#"+user_name);
}else{
P2P_printWriter.println(message);
P2P_printWriter.flush();
textArea.append("对 "+user_name+" 说： "+message+"\r\n");
textField.setText(null);
} }else{
JOptionPane.showMessageDialog(frame, "用户不在线，已存为留言！");
sendMessage("LIXIAN#"+frame.getTitle() + "#" + user_name + "#" + message);
textArea.append("对 "+user_name+" 留言： "+message+"\r\n");
textField.setText(null);
}
}
} public void Login(){
Font font = new Font("宋体", 1, 16); logPanle = new JPanel();
//logPanle.setLayout(new GridLayout(2, 2));
logPanle.setBounds(2, 45, 250, 225);
logPanle.setBackground(Color.lightGray);
logPanle.setLayout(new GridLayout(5, 2, 20, 20)); label_username = new JLabel("用户名:");
label_username.setFont(font);
label_username.setHorizontalAlignment(SwingConstants.CENTER);
logPanle.add(label_username); txt_login_name = new JTextField("name");
txt_login_name.setFont(font);
logPanle.add(txt_login_name); label_password = new JLabel("密 码:");
label_password.setFont(font);
label_password.setHorizontalAlignment(SwingConstants.CENTER);
logPanle.add(label_password); txt_password = new JTextField("");
txt_password.setFont(font);
logPanle.add(txt_password); txt_login_ip = new JTextField("127.0.0.1");
txt_login_ip.setFont(font);
logPanle.add(txt_login_ip); txt_login_port = new JTextField("6666");
txt_login_port.setFont(font);
logPanle.add(txt_login_port); logPanle.add(txt_login_ip);
logPanle.add(txt_login_port); btn_submit = new JButton("登陆");
btn_submit.setFont(font);
btn_submit.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int port;
String message_name = txt_login_name.getText().trim();
if (message_name == null || message_name.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message_pw = txt_password.getText().trim();
if (message_pw == null || message_pw.equals("")) {
JOptionPane.showMessageDialog(logPanle, "密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
if (isConnected) {
String message1 = txt_login_name.getText().trim();
if (message1 == null || message1.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message2 = txt_password.getText().trim();
if (message2 == null || message2.equals("")) {
JOptionPane.showMessageDialog(logPanle, "密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
sendMessage("USERLOGIN#"+message1+"#"+message2+"#"+server_port+"#"+myIP);
return;
}else{
try {
try {
port = Integer.parseInt(txt_login_port.getText().trim());
} catch (NumberFormatException e2) {
throw new Exception("端口号不符合要求!端口为整数!");
}
String hostIp = txt_login_ip.getText().trim();
String name = txt_login_name.getText().trim();
if (name.equals("") || hostIp.equals("")) {
throw new Exception("姓名、服务器IP不能为空!");
}
boolean flag = connectServer(port, hostIp, name);
if (flag == false) {
throw new Exception("与服务器连接失败!");
}
frame.setTitle(name);
listModel.addElement("全部用户");
} catch (Exception exc) {
JOptionPane.showMessageDialog(loginframe, exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
} sendMessage("USERLOGIN#"+message_name+"#"+message_pw+"#"+server_port+"#"+myIP);
}
});
logPanle.add(btn_submit); btn_zhuce = new JButton("注册");
btn_zhuce.setFont(font);
btn_zhuce.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int port;
String message_name = txt_login_name.getText().trim();
if (message_name == null || message_name.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message_pw = txt_password.getText().trim();
if (message_pw == null || message_pw.equals("")) {
JOptionPane.showMessageDialog(logPanle, "密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message_yx = txt_login_forget.getText().trim();
if (message_yx == null || message_yx.equals("")) {
JOptionPane.showMessageDialog(logPanle, "注册邮箱不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
} if (isConnected) {
String message1 = txt_login_name.getText().trim();
if (message1 == null || message1.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message2 = txt_password.getText().trim();
if (message2 == null || message2.equals("")) {
JOptionPane.showMessageDialog(logPanle, "密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message3 = txt_login_forget.getText().trim();
if (message3 == null || message3.equals("")) {
JOptionPane.showMessageDialog(logPanle, "注册邮箱不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
sendMessage("USERZHUCE#"+message1+"#"+message2+"#"+message3);
return;
}else{
try {
try {
port = Integer.parseInt(txt_login_port.getText().trim());
} catch (NumberFormatException e2) {
throw new Exception("端口号不符合要求!端口为整数!");
}
String hostIp = txt_login_ip.getText().trim();
String name = txt_login_name.getText().trim();
if (name.equals("") || hostIp.equals("")) {
throw new Exception("姓名、服务器IP不能为空!");
}
boolean flag = connectServer(port, hostIp, name);
if (flag == false) {
throw new Exception("与服务器连接失败!");
}
frame.setTitle(name);
listModel.addElement("全部用户");
} catch (Exception exc) {
JOptionPane.showMessageDialog(frame, exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
} sendMessage("USERZHUCE#"+message_name+"#"+message_pw+"#"+message_yx);
}
});
logPanle.add(btn_zhuce); txt_login_forget = new JTextField("");
txt_login_forget.setFont(font);
logPanle.add(txt_login_forget); btn_forget_pass = new JButton("密码找回");
btn_forget_pass.setFont(font);
btn_forget_pass.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int port; String message_name = txt_login_name.getText().trim();
if (message_name == null || message_name.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message_yx = txt_login_forget.getText().trim();
if (message_yx == null || message_yx.equals("")) {
JOptionPane.showMessageDialog(logPanle, "注册邮箱不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message_pw = txt_password.getText().trim();
if (message_pw == null || message_pw.equals("")) {
JOptionPane.showMessageDialog(logPanle, "修改密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
} if (isConnected) {
String message1 = txt_login_name.getText().trim();
if (message1 == null || message1.equals("")) {
JOptionPane.showMessageDialog(logPanle, "用户名不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message2 = txt_login_forget.getText().trim();
if (message2 == null || message2.equals("")) {
JOptionPane.showMessageDialog(logPanle, "注册邮箱不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
String message3 = txt_password.getText().trim();
if (message3 == null || message3.equals("")) {
JOptionPane.showMessageDialog(logPanle, "修改密码不能为空！", "错误",
JOptionPane.ERROR_MESSAGE);
return;
}
sendMessage("USERFORGET#"+message1+"#"+message2+"#"+message3);
return;
}else{
try {
try {
port = Integer.parseInt(txt_login_port.getText().trim());
} catch (NumberFormatException e2) {
throw new Exception("端口号不符合要求!端口为整数!");
}
String hostIp = txt_login_ip.getText().trim();
String name = txt_login_name.getText().trim();
if (name.equals("") || hostIp.equals("")) {
throw new Exception("姓名、服务器IP不能为空!");
}
boolean flag = connectServer(port, hostIp, name);
if (flag == false) {
throw new Exception("与服务器连接失败!");
}
frame.setTitle(name);
listModel.addElement("全部用户");
} catch (Exception exc) {
JOptionPane.showMessageDialog(frame, exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
} sendMessage("USERFORGET#"+message_name+"#"+message_yx+"#"+message_pw);
}
});
logPanle.add(btn_forget_pass); logPanle.setBorder(new TitledBorder("登陆"));
loginframe = new JFrame("登陆窗口");
loginframe.add(logPanle,"Center");
loginframe.setSize(300, 300);
int screen_width = Toolkit.getDefaultToolkit().getScreenSize().width;
int screen_height = Toolkit.getDefaultToolkit().getScreenSize().height;
loginframe.setLocation((screen_width - loginframe.getWidth()) / 2,
(screen_height - loginframe.getHeight()) / 2);
loginframe.setVisible(true); // 关闭窗口时事件
loginframe.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
if (isConnected) {
closeConnection();// 关闭连接
closeServer();//关闭服务程序
}
System.exit(0);// 退出程序
}
});
} // 构造方法
public Client() throws BindException { serverStart(0); SelecTry selectIndex=new SelecTry(); textArea = new JTextArea();
textArea.setEditable(false);
textArea.setForeground(Color.blue);
textField = new JTextField();
txt_port = new JTextField("6666");
txt_hostIp = new JTextField("127.0.0.1");
txt_name = new JTextField("姓名");
btn_start = new JButton("连接");
btn_stop = new JButton("断开");
btn_send = new JButton("发送");
btn_send_file = new JButton("文件");
listModel = new DefaultListModel();
userList = new JList(listModel);
//listModel.addElement("全部用户");
userList.addListSelectionListener(selectIndex);
northPanel = new JPanel();
northPanel.setLayout(new GridLayout(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(new TitledBorder("连接信息")); rightScroll = new JScrollPane(textArea);
rightScroll.setBorder(new TitledBorder("消息显示区"));
leftScroll = new JScrollPane(userList);
leftScroll.setBorder(new TitledBorder("用户列表"));
southPanel = new JPanel(new BorderLayout());
sendPanel = new JPanel(new BorderLayout());
southPanel.setBorder(new TitledBorder("写消息"));
southPanel.add(textField, "Center");
sendPanel.add(btn_send, BorderLayout.NORTH);
sendPanel.add(btn_send_file, BorderLayout.SOUTH);
southPanel.add(sendPanel, "East"); centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftScroll,
rightScroll);
centerSplit.setDividerLocation(150); 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(false); // 写消息的文本框中按回车键时事件
textField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
send();
}
}); // 单击发送按钮时事件
btn_send.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
send();
}
}); //单机文件按钮时事件
btn_send_file.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
sendFile();
}
}); // 单击连接按钮时事件
// btn_start.addActionListener(new ActionListener() {
// public void actionPerformed(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 new Exception("端口号不符合要求!端口为整数!");
// }
// String hostIp = txt_hostIp.getText().trim();
// String name = txt_name.getText().trim();
// if (name.equals("") || hostIp.equals("")) {
// throw new Exception("姓名、服务器IP不能为空!");
// }
// boolean flag = connectServer(port, hostIp, name);
// if (flag == false) {
// throw new Exception("与服务器连接失败!");
// }
// listModel.addElement("全部用户");
// frame.setTitle(name);
// JOptionPane.showMessageDialog(frame, "成功连接!");
// } catch (Exception exc) {
// JOptionPane.showMessageDialog(frame, exc.getMessage(),
// "错误", JOptionPane.ERROR_MESSAGE);
// }
// }
// }); // 单击断开按钮时事件
btn_stop.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (!isConnected) {
JOptionPane.showMessageDialog(frame, "已处于断开状态，不要重复断开!",
"错误", JOptionPane.ERROR_MESSAGE);
return;
}
try {
boolean flag = closeConnection();// 断开连接
closeServer();
if (flag == false) {
throw new Exception("断开连接发生异常！");
}
JOptionPane.showMessageDialog(frame, "成功断开!");
frame.setVisible(false);
textArea.setText("");
loginframe.setVisible(true);
listModel.removeAllElements();
} catch (Exception exc) {
JOptionPane.showMessageDialog(frame, exc.getMessage(),
"错误", JOptionPane.ERROR_MESSAGE);
}
}
}); // 关闭窗口时事件
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
if (isConnected) {
closeConnection();// 关闭连接
closeServer();//关闭服务程序
}
System.exit(0);// 退出程序
}
});
Login();
} /**
* 连接服务器
*
* @param port
* @param hostIp
* @param name
*/
public boolean connectServer(int port, String hostIp, String name) {
// 连接服务器
try {
socket = new Socket(hostIp, port);// 根据端口号和服务器ip建立连接
writer = new PrintWriter(socket.getOutputStream());
reader = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
// 发送客户端用户基本信息(用户名和ip地址)
sendMessage(name + "#" + socket.getLocalAddress().toString());
// 开启接收消息的线程
messageThread = new MessageThread(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 boolean closeConnection() {
try {
sendMessage("CLOSE");// 发送断开连接命令给服务器
messageThread.stop();// 停止接受消息线程
// 释放资源
if (reader != null) {
reader.close();
}
if (writer != null) {
writer.close();
}
if (socket != null) {
socket.close();
}
isConnected = false;
listModel.removeAllElements();
return true;
} catch (IOException e1) {
e1.printStackTrace();
isConnected = true;
return false;
}
} // 不断接收消息的线程
class MessageThread extends Thread {
private BufferedReader reader;
private JTextArea textArea; // 接收消息线程的构造方法
public MessageThread(BufferedReader reader, 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();
StringTokenizer stringTokenizer = new StringTokenizer(
message, "/#");
String command = stringTokenizer.nextToken();// 命令
if (command.equals("CLOSE"))// 服务器已关闭命令
{
textArea.append("服务器已关闭!\r\n");
closeCon();// 被动的关闭连接
JOptionPane.showMessageDialog(frame, "服务器已关闭！", "错误",
JOptionPane.ERROR_MESSAGE);
frame.setVisible(false);
textArea.setText("");
loginframe.setVisible(true);
return;// 结束线程
} else if (command.equals("ADD")) {// 有用户上线更新在线列表
String username = "";
String userIp = "";
if ((username = stringTokenizer.nextToken()) != null
&& (userIp = stringTokenizer.nextToken()) != null) {
User user = new User(username, userIp);
onLineUsers.put(username, user);
listModel.addElement(username);
}
} else if (command.equals("DELETE")) {// 有用户下线更新在线列表
String username = stringTokenizer.nextToken();
User user = (User) onLineUsers.get(username);
onLineUsers.remove(user);
listModel.removeElement(username);
} else if (command.equals("USERLIST")) {// 加载在线用户列表
listModel.removeAllElements();
listModel.addElement("全部用户");
StringTokenizer strToken ;
String user ;// 命令
int size = Integer
.parseInt(stringTokenizer.nextToken());
String username = null;
String userIp = null;
for (int i = 0; i < size-1; i++) {
username = stringTokenizer.nextToken();
strToken = new StringTokenizer(username, "---()");
if (strToken.nextToken().equals(frame.getTitle())) {
continue;
}else{
listModel.addElement(username);
}
//userIp = stringTokenizer.nextToken();
//User user = new User(username, userIp);
//onLineUsers.put(username, user);
}
} else if (command.equals("MAX")) {// 人数已达上限
textArea.append(stringTokenizer.nextToken()
+ stringTokenizer.nextToken() + "\r\n");
closeCon();// 被动的关闭连接
JOptionPane.showMessageDialog(frame, "服务器缓冲区已满！", "错误",
JOptionPane.ERROR_MESSAGE);
return;// 结束线程
} else if(command.equals("FILE")){
int portNumber = Integer.parseInt(stringTokenizer.nextToken());
String fileName = stringTokenizer.nextToken();
long fileSize = Long.parseLong(stringTokenizer.nextToken());
String ip = stringTokenizer.nextToken();
String Nickname = stringTokenizer.nextToken();
ReceiveFileThread receiveFile = new ReceiveFileThread(textArea,frame,ip, portNumber, fileName, fileSize, Nickname);
receiveFile.start();
textArea.append("从"+Nickname+"接受文件:"+fileName+",大小为:"+fileSize
+"ip:"+ip+"port:"+portNumber+"\r\n");
}else if(command.equals("USERLOGIN")){
String st = stringTokenizer.nextToken();
if(st.equals("OK")){
JOptionPane.showMessageDialog(loginframe, "登陆成功!" );
loginframe.setVisible(false);
txt_name.setText(txt_login_name.getText());
frame.setVisible(true);
int count = stringTokenizer.countTokens();
while(true){
if(count==0){
break;
}
textArea.append(stringTokenizer.nextToken()+" 对你留言 ，");
textArea.append("时间： "+stringTokenizer.nextToken()+"\r\n ");
textArea.append("留言内容： "+stringTokenizer.nextToken()+"\r\n");
count-=3;
} }else if(st.equals("ALREADY")){
JOptionPane.showMessageDialog(loginframe, "账号已登陆!" );
}else{
JOptionPane.showMessageDialog(loginframe, "登陆失败!" );
}
}else if(command.equals("USERZHUCE")){
String st = stringTokenizer.nextToken();
if(st.equals("OK")){
JOptionPane.showMessageDialog(loginframe, "注册成功!" ); }else if(st.equals("exict")){
JOptionPane.showMessageDialog(loginframe, "用户名已存在!" );
}else{
JOptionPane.showMessageDialog(loginframe, "注册失败!" );
}
}else if(command.equals("USERFORGET")){
String st = stringTokenizer.nextToken();
if(st.equals("OK")){
JOptionPane.showMessageDialog(loginframe, "修改密码成功!" ); }else if(st.equals("YOUXIANG_WRONG")){
JOptionPane.showMessageDialog(loginframe, "邮箱错误!" );
}else if(st.equals("NAME_NO_exict")){
JOptionPane.showMessageDialog(loginframe, "用户不存在!" );
}else{
JOptionPane.showMessageDialog(loginframe, "找回密码失败!" );
}
} else if (command.equals("P2P")) {
String st = stringTokenizer.nextToken();
if(st.equals("OK")){
String username = stringTokenizer.nextToken();
int serverPort = Integer.parseInt(stringTokenizer.nextToken());
String ip = stringTokenizer.nextToken();
boolean cn = connectServer_p2p(serverPort,ip,username);
if (cn) {
JOptionPane.showMessageDialog(frame, "与"+username+"的连接成功，端口号为："+serverPort+"IP:"+ip );
P2P_printWriter.println(frame.getTitle()+"#"+myIP);
P2P_printWriter.flush(); String msg = textField.getText().trim();
P2P_printWriter.println(msg);
P2P_printWriter.flush(); textArea.append("对 "+username+" 说： "+msg+"\r\n"); textField.setText(null);
} }else{
String username = stringTokenizer.nextToken();
JOptionPane.showMessageDialog(frame, "与"+username+"的连接失败！");
}
} else {// 普通消息
textArea.append(message + "\r\n");
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
package com.company; import javax.swing.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; public class SendFileThread extends Thread {
private Socket clientSocket;
private String name;
JFileChooser sourceFileChooser;
int status;
JFrame JFrame; public SendFileThread(JFrame frame, Socket socket, String name, JFileChooser sourceFileChooser, int status) {
this.clientSocket = socket;
this.name = name;
this.sourceFileChooser = sourceFileChooser;
this.status = status;
this.JFrame = frame;
} public void run() {
// JFileChooser sourceFileChooser = new JFileChooser(".");
// sourceFileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
// int status = sourceFileChooser.showOpenDialog(null);
if (status == JFileChooser.APPROVE_OPTION) {
File sourceFile = new File(sourceFileChooser.getSelectedFile().getPath());
String sourceFilePath = sourceFile.getAbsolutePath();
String fileName = sourceFile.getName();
//System.out.println(sourceFilePath+"\\"+fileName);
try {
PrintWriter sendToClient = new PrintWriter(clientSocket.getOutputStream());
BufferedReader getFromClient = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
ServerSocket fileSenderSocket = null;
try {
fileSenderSocket = new ServerSocket(0);
} catch (IOException ex1) {
JOptionPane.showMessageDialog(JFrame, "无法分配端口以发送此文件!", "错误", JOptionPane.ERROR_MESSAGE);
}
sendToClient.println("FILE#" + fileSenderSocket.getLocalPort() + "#" + fileName + "#"
+ String.valueOf(sourceFile.length()) + "#" + clientSocket.getLocalAddress() + "#" + name);
sendToClient.flush();
//System.out.println("Sender: "+fileSenderSocket.getLocalSocketAddress());
Socket fileReceiverSocket = fileSenderSocket.accept(); BufferedReader getFromReceiver = null;
PrintWriter sendToReceiver = null;
try {
getFromReceiver = new BufferedReader(new InputStreamReader(fileReceiverSocket.getInputStream()));
sendToReceiver = new PrintWriter(fileReceiverSocket.getOutputStream());
} catch (IOException ex) {
} finally {
}
String judge = getFromReceiver.readLine();
if (judge.equals("accepted")) {
DataOutputStream sendFileToReceiver = new DataOutputStream(new BufferedOutputStream(fileReceiverSocket.getOutputStream()));
ProgressMonitorInputStream monitor;
FileInputStream sendFileStream = null;
try {
sendFileStream = new FileInputStream(sourceFile);
} catch (FileNotFoundException ex) {
sendToReceiver.flush();
sendFileToReceiver.writeByte(0);
sendFileToReceiver.flush();
return;
}
monitor = new ProgressMonitorInputStream(JFrame, "正在发送： " + fileName, sendFileStream);
ProgressMonitor progressMonitor = monitor.getProgressMonitor(); int read_unit = 500;
long fileSize = monitor.available();
int readed = 0;
byte[] data = new byte[read_unit];
try {
sendFileToReceiver.writeByte(1);
sendFileToReceiver.flush();
while (monitor.available() > 0) {
int in = monitor.read(data);
readed += in;
float process = (float) readed / fileSize * 100;
progressMonitor.setNote(process + " % 完成");
if (in > 0) {
sendFileToReceiver.write(data, 0, in);
}
}
sendFileToReceiver.flush();
} catch (IOException e) {
JOptionPane.showMessageDialog(JFrame, "传输中断!", "错误", JOptionPane.ERROR_MESSAGE);
} finally {
if (sendFileStream != null)
try {
sendFileStream.close();
monitor.close();
} catch (IOException e) {
}
}
try {
fileReceiverSocket.close();
} catch (IOException ex1) {
}
} else if (judge.equals("refused")) {
JOptionPane.showMessageDialog(JFrame, "对方拒绝接受文件 " + fileName, "错误！", JOptionPane.INFORMATION_MESSAGE);
} } catch (IOException ex) {
} finally {
}
}
}
}
package com.company;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket; import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import javax.swing.ProgressMonitor;
import javax.swing.ProgressMonitorInputStream; public class ReceiveFileThread extends Thread {
private String fileSenderIPAddress;
private int fileSenderPortNumber;
private String fileName;
private long fileSize;
private String otherNickname;
JFrame frame;
JTextArea textArea; public ReceiveFileThread(JTextArea textArea,JFrame frame,String ip, int port_number, String file_name, long file_size, String other_nickname) {
this.fileSenderIPAddress = ip;
this.fileSenderPortNumber = port_number;
this.fileName = file_name;
this.fileSize = file_size;
this.otherNickname = other_nickname;
this.frame = frame;
this.textArea = textArea;
} public void run() {
Socket fileSenderSocket = null;
try {
fileSenderSocket = new Socket(fileSenderIPAddress, fileSenderPortNumber);
}
catch(IOException ex) {
JOptionPane.showMessageDialog(frame, "无法连接到服务器接收文件!", "错误", JOptionPane.ERROR_MESSAGE);
}
finally {
}
DataInputStream getFromSender = null;
DataOutputStream sendToSender = null;
try {
getFromSender = new DataInputStream(new BufferedInputStream(fileSenderSocket.getInputStream()));
sendToSender = new DataOutputStream(new BufferedOutputStream(fileSenderSocket.getOutputStream()));
BufferedReader getInfoFromSender =new BufferedReader(new InputStreamReader(getFromSender)); int permit = JOptionPane.showConfirmDialog(frame, "接受文件:"+fileName+" 从 "+otherNickname+"?", "文件传输请求：", JOptionPane.YES_NO_OPTION);
if(permit == JOptionPane.YES_OPTION) {
sendToSender.writeBytes("accepted\n");
sendToSender.flush(); JFileChooser destinationFileChooser = new JFileChooser(".");
destinationFileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int status = destinationFileChooser.showSaveDialog(frame);
File destinationPath = null;
if (status == JFileChooser.APPROVE_OPTION) {
destinationPath = new File(destinationFileChooser.getSelectedFile().getPath());
//String destinationFile = destinationPath.getAbsolutePath()+"\\"+fileName;
//System.out.println(destinationFilePath);
}
try {
byte judge = getFromSender.readByte();
if (judge > 0) {
File savedFile = new File(destinationPath.getAbsolutePath()+"\\"+fileName);
FileOutputStream saveFileStream = new FileOutputStream(savedFile);
DataOutputStream fileOutput = new DataOutputStream(saveFileStream);
ProgressMonitorInputStream monitor = new ProgressMonitorInputStream(frame, "接受文件： "+fileName, getFromSender);
//ProgressMonitor progressMonitor = new ProgressMonitor(null, "Receiving "+fileName, "", 0, (int)fileSize);
ProgressMonitor progressMonitor = monitor.getProgressMonitor();
progressMonitor.setMaximum((int)fileSize); int read_unit = 500;
int readed = 0;
float process = 0;
try {
while (true) {
byte[] data = new byte[read_unit];
int in = monitor.read(data);
readed += in;
process = (float) readed / fileSize * 100;
progressMonitor.setNote(process+" % 完成");
progressMonitor.setProgress(readed);
if (in <= 0) {
break;
}
fileOutput.write(data,0,in);
} fileOutput.flush();
if(savedFile.length() < fileSize) {
JOptionPane.showMessageDialog(frame, "传输中断!", "错误", JOptionPane.ERROR_MESSAGE);
}
textArea.append("接受文件："+fileName+" 保存地址："+destinationPath+"\r\n");
}
catch(IOException e){
JOptionPane.showMessageDialog(frame, "传输中断!", "错误", JOptionPane.ERROR_MESSAGE);
}
finally {
try {
fileOutput.close();
saveFileStream.close();
progressMonitor.close();
}
catch(IOException e){
}
}
}
else {
JOptionPane.showMessageDialog(frame, "源文件没有找到!", "错误", JOptionPane.ERROR_MESSAGE);
}
}
catch(IOException e){
}
finally {
fileSenderSocket.close();
}
}
else if(permit == JOptionPane.NO_OPTION) {
sendToSender.writeBytes("refused\n");
sendToSender.flush();
}
}
catch(IOException ex) {
}
finally {
}
//System.out.println("Receiver: "+fileReceiverSocket.getRemoteSocketAddress());
} }
package com.company; //用户信息类
public class User{
private String name;
private String ip;
private int state; public User(String name, String ip) {
this.name = name;
this.ip = ip;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getIp() {
return ip;
} public void setIp(String ip) {
this.ip = ip;
} public int getState() {
return state;
} public void setState(int state){
this.state=state;
}
}
是一次实验课的第一次实验，可能还有bug，请理解！
后期会更新。