2. 程式人生 > >java寫的簡單的聊天室

java寫的簡單的聊天室

阿新 • • 發佈：2019-01-14 
//伺服器端
package doudou;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

import java.io.*;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.StringTokenizer;

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 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<ClientThread> clients;

	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() + "/n");
		txt_message.setText(null);
	}

	// 構造放法
	public Server() {
		frame = new JFrame("伺服器");
		// 更改JFrame的圖示：
		frame.setIconImage(Toolkit.getDefaultToolkit().createImage(
				Client.class.getResource("qq.png")));
		contentArea = new JTextArea();
		contentArea.setEditable(false);
		contentArea.setForeground(Color.blue);
		txt_message = new JTextField();
		txt_max = new JTextField("30");
		txt_port = new JTextField("6999");
		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(new BorderLayout());
		southPanel.setBorder(new TitledBorder("寫訊息"));
		southPanel.add(txt_message, "Center");
		southPanel.add(btn_send, "East");
		leftPanel = new JScrollPane(userList);
		leftPanel.setBorder(new TitledBorder("線上使用者"));

		rightPanel = new JScrollPane(contentArea);
		rightPanel.setBorder(new TitledBorder("訊息顯示區"));

		centerSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel,
				rightPanel);
		centerSplit.setDividerLocation(100);
		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(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);

		// 關閉視窗時事件
		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_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
							+ "/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(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("伺服器成功停止!/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 = 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;
		} catch (IOException e) {
			e.printStackTrace();
			isStart = true;
		}
	}

	// 群發伺服器訊息
	public void sendServerMessage(String message) {
		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(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("
 
[email protected]伺服器：對不起，" + user.getName()
								+ user.getIp() + "，伺服器線上人數已達上限，請稍後嘗試連線！");
						w.flush();
						// 釋放資源
						r.close();
						w.close();
						socket.close();
						continue;
					}
					ClientThread client = new ClientThread(socket);
					client.start();// 開啟對此客戶端服務的執行緒
					clients.add(client);
					listModel.addElement(client.getUser().getName());// 更新線上列表
					contentArea.append(client.getUser().getName()
							+ client.getUser().getIp() + "上線!/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 = 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();
				// 反饋當前線上使用者資訊
				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("
 
[email protected]" + clients.size() + "@" + temp);
					writer.flush();
				}
				// 向所有線上使用者傳送該使用者上線命令
				for (int i = clients.size() - 1; i >= 0; i--) {
					clients.get(i).getWriter().println(
							"[email protected]" + 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() + "下線!/n");
						// 斷開連線釋放資源
						reader.close();
						writer.close();
						socket.close();

						// 向所有線上使用者傳送該使用者的下線命令
						for (int i = clients.size() - 1; i >= 0; i--) {
							clients.get(i).getWriter().println(
									"
 
[email protected]" + user.getName());
							clients.get(i).getWriter().flush();
						}

						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 {
						dispatcherMessage(message);// 轉發訊息
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

		// 轉發訊息
		public void dispatcherMessage(String message) {
			StringTokenizer stringTokenizer = new StringTokenizer(message, "@");
			String source = stringTokenizer.nextToken();
			String owner = stringTokenizer.nextToken();
			String content = stringTokenizer.nextToken();
			message = source + "說：" + content;
			contentArea.append(message + "/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();
				}
			}
		}
	}
}
//使用者資訊類
package doudou;

public class User {
	private String name;
	private String ip;

	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;
	}
}

//客戶機端
package doudou;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.TitledBorder;
import java.io.*;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public class Client {

	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<String, User> onLineUsers = new HashMap<String, User>();// 所有線上使用者

	// 主方法,程式入口
	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 = new JTextField("6999");
		txt_hostIp = new JTextField("127.0.0.1");
		txt_name = new JTextField("doudou");
		btn_start = new JButton("連線");
		btn_stop = new JButton("斷開");
		btn_send = new JButton("傳送");
		listModel = new DefaultListModel();
		userList = new JList(listModel);

		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());
		southPanel.add(textField, "Center");
		southPanel.add(btn_send, "East");
		southPanel.setBorder(new TitledBorder("寫訊息"));

		centerSplit = new JSplitPane(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(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				send();
			}
		});

		// 單擊發送按鈕時事件
		btn_send.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				send();
			}
		});

		// 單擊連線按鈕時事件
		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("與伺服器連線失敗!");
					}
					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();// 斷開連線
					if (flag == false) {
						throw new Exception("斷開連線發生異常！");
					}
					JOptionPane.showMessageDialog(frame, "成功斷開!");
				} catch (Exception exc) {
					JOptionPane.showMessageDialog(frame, exc.getMessage(),
							"錯誤", JOptionPane.ERROR_MESSAGE);
				}
			}
		});

		// 關閉視窗時事件
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(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 = 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
					+ "   的伺服器連線失敗!" + "/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;
			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("伺服器已關閉!/n");
						closeCon();// 被動的關閉連線
						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")) {// 載入線上使用者列表
						int size = Integer
								.parseInt(stringTokenizer.nextToken());
						String username = null;
						String userIp = null;
						for (int i = 0; i < size; i++) {
							username = stringTokenizer.nextToken();
							userIp = stringTokenizer.nextToken();
							User user = new User(username, userIp);
							onLineUsers.put(username, user);
							listModel.addElement(username);
						}
					} else if (command.equals("MAX")) {// 人數已達上限
						textArea.append(stringTokenizer.nextToken()
								+ stringTokenizer.nextToken() + "/n");
						closeCon();// 被動的關閉連線
						JOptionPane.showMessageDialog(frame, "伺服器緩衝區已滿！", "錯誤",
								JOptionPane.ERROR_MESSAGE);
						return;// 結束執行緒
					} else {// 普通訊息
						textArea.append(message + "/n");
					}
				} catch (IOException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
}


本文轉自：<a target=_blank target="_blank" href="http://blog.csdn.net/doudou15223155621/article/details/5402190">http://blog.csdn.net/doudou15223155621/article/details/5402190</a>

相關推薦

日常改bug之寫簡單聊天室並放到伺服器上

一.查詢資料庫時查詢不了中文的問題 當查詢語句是這樣時，如果${name}是中文，則查詢不到資料 `select * from admin_table where name=${name}` 改為以下，即在${name}前加入N即可 `select * from admi

ASP.NET 使用application與session物件寫的簡單聊天室程式

ASP.Net中有兩個重要的物件，一個是application物件，一個是session物件。 Application：記錄應用程www.usus.cc序引數的物件，該物件用於共享應用程式級資訊。 Session：記錄瀏覽器端的變數物件，www.e78.com用來儲存跨網頁

Golang之寫一個聊天室

gpo 動作 color 字母數 信息 數據 用戶登錄 clas 是否 1. 海量用戶在線聊天系統 2. 點對點聊天 3. 用戶登錄&註冊 一、服務端開發 1. 用戶管理 用戶id：數字 用戶密碼：字母數字組合

C# Redis輔助類封裝與簡單聊天室的實現思路說明

執行 sum 頭部 lis 有序 += wait connected 相同 雖然redis api的功能比較齊全，但個人覺得為了更好的方便學習和使用，還是很有必有做一個類似DBHelper的幫助類 輔助類主要功能(代碼會在最後放出來) 1. 事件監聽： 重新配置廣播

java實戰——網路聊天室

因特網已經成為了人們交流的海洋，上網的使用者越來越多，更多的人願意使用網路來認識別人，瞭解別人，這就是當下諸如qq、微信等聊天工具火熱的原因。 我們雖然不能立馬就開發出來一個像上述兩個一樣功能強大的聊天室，但我們可以自己製作一個簡單的聊天室。 我們採用傳統的Client/Server結構，功

使用socket.io寫一個聊天室

之前學習了常用的api，以及概念，這裡為了簡單的使用，寫一個demo，為了方便查詢api，這裡給一個傳送門socket.io 準備 老規矩，新建一個目錄，一個index.html, app.js index.html 為客戶端 app.js 為服

Socket.IO實現簡單聊天室

Socket.IO介紹 官方文件 https://socket.io/docs/ Socket.io是一個跨瀏覽器支援WebSocket的實時通訊的JS。它不僅簡化了介面，使得操作更容易，而且對於那些不支援WebSocket的瀏覽器，會自動降為Ajax連線，最大限度地保證了相容性。它

SpringBoot 搭建簡單聊天室

SpringBoot 搭建簡單聊天室（queue 點對點） 1、引用 SpringBoot 搭建 WebSocket 連結 　　https://www.cnblogs.com/yi1036943655/p/10089100.html 2、整合Spring Security package com

百度t7 課程， websocket 實現簡單聊天室

最簡單的聊天室，我寫了一個小時， 寫了10 分鐘，除錯50分鐘 因為 我是小菜鳥，不過凡事都有過程 index.html <!DOCTYPE html> <html lang="en"> <head> <meta c

自己寫的聊天室專案

作業：（服務端，客戶端） 寫一個聊天室 功能：類似qq群聊 1.進入聊天室需要輸入姓名，提示一下姓名不能重複 2.有人進入聊天室會向其他人傳送通知 xxx 進入了聊天室 3.一個人發訊息，其他人會收到訊息，自己不收到 xxx 說：xxxxxxxxxxx 4.某人

基於UDP的網路程式設計實現簡單聊天室

import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.util.Scanner; pu

boost asio非同步讀寫網路聊天室【官方示例】

// // chat_message.hpp // ~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distri

C#簡單聊天室

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.

goland 簡單聊天室服務端

nag rename accept lis read 發送消息 listen ddr quit package main import ( "fmt" "net" "strings" "time" ) type Client struct { C

Jaguar_websocket結合Flutter搭建簡單聊天室

1.定義訊息 在開始建立webSocket之前，我們需要定義訊息，如：傳送人，傳送時間，傳送人id等.. import 'dart:convert'; class ChatMessageData { final String id; final String msg;

java實現qq聊天室功能

一下是伺服器端原始碼，供大家參考 下面是main.javapackage com; public class Main { public static void main(String args[]) { new ServerListener().start();

基於tcp和qt的簡單聊天室搭建

使用Qt庫中的 <QTcpServer>  和<QTcpSocket>類實現區域網絡下的聊天室。 分為服務端和客戶端； 服務端接收來自各個客戶端的資訊，併發送到所有客戶端； 客戶端用於使用者登陸及聊天。 客戶端： 使用<QTcpSo

Python socket實現簡單聊天室

服務端使用了select模組，實現了對多個socket的監控。客戶端由於select在Windows下只能對socket使用，所以使用了多執行緒來實現對客戶端輸入和socket連線的同時監控。注意這裡的

pyqt5 基於UDP的簡單聊天室

UDP通訊過程:建立QUdpSocket,之後將socket繫結到對應的埠號，在接受文字時，socket函式會觸發readyRead訊號，在對應的槽函式中編寫處理資料處理的過程，讀取資料使用readDatagram函式。# def readDatagram(self, p_i

使用nodejs-websocket 20行程式碼實現簡單聊天室

安裝nodejs-websocket： npm install nodejs-websocketindex.html<!DOCTYPE html> <html> <hea