devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现私聊和群聊功能之美_javasocket窗口群聊和私聊

作者：很楠不爱3 | 2024-03-02 02:49:09

赞

踩

javasocket窗口群聊和私聊

工程构成如下图：

1、ClientGUI包里面

（1）LogOn.java代码如下：

  1. package ClientGUI;
  2.  
  3. import java.awt.BorderLayout;
  4. import java.awt.FlowLayout;
  5. import java.awt.GridLayout;
  6. import java.awt.event.ActionEvent;
  7. import java.awt.event.ActionListener;
  8.  
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JOptionPane;
  13. import javax.swing.JPanel;
  14. import javax.swing.JPasswordField;
  15. import javax.swing.JTextField;
  16. import javax.swing.SwingUtilities;
  17. import javax.swing.UIManager;
  18.  
  19. import ClientSide.Client;
  20. import ClientSide.Client.ClientThread;
  21. import ServerSide.Server;
  22.  
  23. //登录窗口
  24. public class LogOn extends JFrame implements ActionListener {
  25. 	
  26. 	private Register register;
  27. 	
  28. 	private ClientThread clientThread;
  29. 	
  30. 	private Server server=Server.GetServer();
  31.  
  32. 	private JLabel jlUserName;
  33.  
  34. 	private JLabel jlPassword;
  35.  
  36. 	private JTextField jtUserName;
  37.  
  38. 	private JPasswordField jpPassword;
  39.  
  40. 	private JButton jbLogOn;
  41.  
  42. 	private JButton jbRegister;
  43.  
  44. 	private JPanel jpDown;
  45.  
  46. 	private JPanel jpCenter;
  47.  
  48. 	public LogOn() {
  49. 		Init();
  50. 	}
  51.  
  52. 	private void Init() {
  53. 		jlUserName = new JLabel("用户名");
  54. 		jlPassword = new JLabel("密   码");
  55. 		jtUserName = new JTextField(15);
  56. 		jpPassword = new JPasswordField(15);
  57. 		jbLogOn = new JButton("登录");
  58. 		jbRegister = new JButton("注册");
  59.  
  60. 		jbLogOn.addActionListener(this);
  61. 		jbRegister.addActionListener(this);
  62.  
  63. 		jpCenter = new JPanel();
  64. 		jpCenter.setLayout(new GridLayout(2, 2));
  65. 		jpCenter.add(jlUserName);
  66. 		jpCenter.add(jtUserName);
  67. 		jpCenter.add(jlPassword);
  68. 		jpCenter.add(jpPassword);
  69.  
  70. 		jpDown = new JPanel();
  71. 		jpDown.setLayout(new FlowLayout());
  72. 		jpDown.add(jbLogOn);
  73. 		jpDown.add(jbRegister);
  74.  
  75. 		this.setLayout(new BorderLayout());
  76. 		this.add("Center", jpCenter);
  77. 		this.add("South", jpDown);
  78. 		
  79. 		this.setTitle("用户登录界面");
  80. 		this.setSize(350, 150);
  81. 		this.setLocationRelativeTo(null);
  82. 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  83. 		this.setVisible(true);
  84.  
  85. 		// 更改窗体样式
  86. 		try {
  87. 			String style = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  88. 			UIManager.setLookAndFeel(style);
  89. 			SwingUtilities.updateComponentTreeUI(this);
  90. 		} catch (Exception e) {
  91. 			e.printStackTrace();
  92. 		}
  93. 	}
  94.  
  95.  
  96. 	@Override
  97. 	public void actionPerformed(ActionEvent e) {
  98. 		Object source = e.getSource();
  99. 		if (source == jbLogOn) {
  100. 			//判断是否为空
  101. 			if(jtUserName.getText()==null || jtUserName.getText().equals("")
  102. 					|| String.valueOf(jpPassword.getPassword())==null || 
  103. 					String.valueOf(jpPassword.getPassword()).equals(""))
  104. 			{
  105. 				JOptionPane.showMessageDialog(null, "请输入账号或者密码");
  106. 			}else
  107. 			{
  108. 				if(server.LogOn(jtUserName.getText(), String.valueOf(jpPassword.getPassword())))
  109. 				{
  110. 					MainUI mainUI=new MainUI(jtUserName.getText());
  111. 					Client client=Client.GetClient();
  112. 					client.SetMainUI(mainUI);
  113. 					client.SetUserName(mainUI.GetUserName());	
  114. 					clientThread=client.new ClientThread();
  115. 					client.SetClientThread(clientThread);
  116. 					clientThread.start();
  117. 					this.setVisible(false);
  118. 				}else
  119. 				{
  120. 					JOptionPane.showMessageDialog(null, "账号或者密码错误");
  121. 				}
  122. 			}		
  123. 		} else if (source == jbRegister) {
  124. 			register=new Register(this);
  125. 			this.setVisible(false);
  126. 		}
  127.  
  128. 	}
  129. 	
  130. 	public static void main(String[] args) {
  131. 		new LogOn();
  132. 	}
  133.  
  134. }

（2）MainUI代码如下：

  1. package ClientGUI;
  2.  
  3. import java.awt.Color;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6.  
  7. import javax.swing.ButtonGroup;
  8. import javax.swing.DefaultListModel;
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JList;
  13. import javax.swing.JRadioButton;
  14. import javax.swing.JScrollPane;
  15. import javax.swing.JTextArea;
  16. import javax.swing.JTextField;
  17. import javax.swing.ListSelectionModel;
  18. import javax.swing.SwingUtilities;
  19. import javax.swing.UIManager;
  20.  
  21. import ClientSide.Client;
  22.  
  23. public class MainUI{
  24. 	
  25. //	private static MainUI mainUIInstance=null;
  26. //	
  27. //	public static synchronized MainUI GetMainUI()
  28. //	{
  29. //		if(mainUIInstance==null)
  30. //		{
  31. //			mainUIInstance=new MainUI();
  32. //		}
  33. //		return mainUIInstance;
  34. //	}
  35. //	
  36. 	
  37. 	private JFrame frmtcp;
  38. 	private JTextField textServerIP;// IP
  39. 	private JTextField textServerPort;// 端口
  40. 	private JTextArea textAreaRecord;// 消息文本记录框
  41. 	private JButton btnSend;// 发送按钮
  42. 	private JButton btnQuit;// 退出按钮
  43. 	private JLabel jlUsername;// 用户名
  44. 	private JList<String> listUsers;// 用户列表 Jlist控件显示客户端的用户列表。数据保存在DefaultListmodel数据模型对象中。
  45. 	private final ButtonGroup buttonGroup = new ButtonGroup();
  46. 	private JRadioButton rdbtnBrocast;// 群聊
  47. 	private JRadioButton rdbtnPrivateChat;// 私聊
  48. 	private JTextArea textAreaMsg;// 消息框
  49. 	private DefaultListModel<String> modelUsers;// 数据模型，用于更新数据
  50. 	
  51. 	public JTextField GetTextServerIP()
  52. 	{
  53. 		return textServerIP;
  54. 	}
  55. 	public JTextField GetTextServerPort()
  56. 	{
  57. 		return textServerPort;
  58. 	}
  59. 	public void SetUserName(String userName)
  60. 	{
  61. 		jlUsername.setText(userName);
  62. 	}
  63. 	public String GetUserName()
  64. 	{
  65. 		return jlUsername.getText();
  66. 	}	
  67. 	public JTextArea GetTextAreaMsg()
  68. 	{
  69. 		return textAreaMsg;
  70. 	}
  71. 	public JButton GetBtnQuit()
  72. 	{
  73. 		return btnQuit;
  74. 	}
  75. 	public JButton GetBtnSend()
  76. 	{
  77. 		return btnSend;
  78. 	}
  79. 	public JList<String> GetListUsers()
  80. 	{
  81. 		return listUsers;
  82. 	}
  83. 	public DefaultListModel<String> GetModelUsers()
  84. 	{
  85. 		return modelUsers;
  86. 	}
  87. 	public JRadioButton GetRdbtnBrocast()
  88. 	{
  89. 		return rdbtnBrocast;
  90. 	}
  91. 	public JRadioButton GetRdbtnPrivateChat()
  92. 	{
  93. 		return rdbtnPrivateChat;
  94. 	}
  95. 	
  96. 	public JTextArea GetTextAreaRecord()
  97. 	{
  98. 		return textAreaRecord;
  99. 	}
  100. 	
  101. 	public JFrame GetJfrmtcp()
  102. 	{
  103. 		return frmtcp;
  104. 	}
  105. 	public MainUI(String userName)
  106. 	{
  107. 		Init(userName);		
  108. 		modelUsers = new DefaultListModel();
  109. 		modelUsers = new DefaultListModel<String>();
  110. 		listUsers.setModel(modelUsers);
  111. 		
  112. 	}
  113. 	private void Init(String userName)
  114. 	{
  115. 		frmtcp = new JFrame();
  116. 		frmtcp.setResizable(false);
  117. 		frmtcp.setTitle("聊天主界面");
  118. 		frmtcp.setBounds(100, 100, 715, 476);
  119. 		frmtcp.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  120. 		frmtcp.getContentPane().setLayout(null);
  121. 		frmtcp.setVisible(true);
  122. 		
  123.  
  124. 		// IP
  125. 		JLabel lblNewLabel = new JLabel("服务器IP地址:");
  126. 		lblNewLabel.setBounds(14, 24, 121, 18);
  127. 		frmtcp.getContentPane().add(lblNewLabel);
  128. 		textServerIP = new JTextField();
  129. 		textServerIP.setText("127.0.0.1");
  130. 		textServerIP.setBounds(121, 21, 121, 24);
  131. 		frmtcp.getContentPane().add(textServerIP);
  132. 		textServerIP.setColumns(10);
  133. 		
  134. 		// 端口
  135. 		JLabel lblNewLabel_1 = new JLabel("端口号:");
  136. 		lblNewLabel_1.setBounds(256, 24, 58, 18);
  137. 		frmtcp.getContentPane().add(lblNewLabel_1);
  138. 		textServerPort = new JTextField();
  139. 		textServerPort.setText("6666");
  140. 		textServerPort.setBounds(313, 21, 48, 24);
  141. 		frmtcp.getContentPane().add(textServerPort);
  142. 		textServerPort.setColumns(10);
  143. 		
  144. 		// 用户名
  145. 		JLabel label_1 = new JLabel("用户名:");
  146. 		label_1.setBounds(375, 24, 58, 18);
  147. 		frmtcp.getContentPane().add(label_1);
  148. 		jlUsername = new JLabel(userName);
  149. 		jlUsername.setBounds(433, 21, 95, 24);
  150. 		frmtcp.getContentPane().add(jlUsername);
  151.  
  152. 		//退出按钮
  153. 		btnQuit = new JButton("退出");
  154. 		btnQuit.setBounds(596, 20, 95, 27);
  155. 		frmtcp.getContentPane().add(btnQuit);
  156. 		btnQuit.addActionListener(new ActionListener() {
  157. 			@Override
  158. 			public void actionPerformed(ActionEvent arg0) {
  159. 				
  160.  
  161.  
  162. 			}
  163. 		});
  164.  
  165.  
  166.  
  167. 		// 发送按钮
  168. 		btnSend = new JButton("发送");
  169. 		btnSend.setEnabled(false);
  170. 		btnSend.setBounds(444, 409, 88, 27);
  171. 		frmtcp.getContentPane().add(btnSend);
  172. 		// 连接按钮事件处理程序
  173. 		btnSend.addActionListener(new ActionListener() {
  174. 			@Override
  175. 			public void actionPerformed(ActionEvent arg0) {
  176. 				
  177. 			}
  178. 		});
  179.  
  180. 		// 聊天记录框
  181. 		JLabel label = new JLabel("聊天区");
  182. 		label.setBounds(14, 55, 72, 18);
  183. 		frmtcp.getContentPane().add(label);
  184. 		JScrollPane scrollPane = new JScrollPane();
  185. 		scrollPane.setBounds(14, 72, 518, 228);
  186. 		frmtcp.getContentPane().add(scrollPane);
  187. 		textAreaRecord = new JTextArea();
  188. 		textAreaRecord.setBackground(Color.pink);
  189. 		textAreaRecord.setEditable(false);
  190. 		scrollPane.setViewportView(textAreaRecord);
  191.  
  192.  
  193. 		// 消息输入框
  194. 		JScrollPane scrollPane_1 = new JScrollPane();
  195. 		scrollPane_1.setBounds(14, 332, 518, 73);
  196. 		frmtcp.getContentPane().add(scrollPane_1);
  197. 		textAreaMsg = new JTextArea();
  198. 		scrollPane_1.setViewportView(textAreaMsg);
  199.  
  200. 		JLabel label_2 = new JLabel("在线用户");
  201. 		label_2.setBounds(543, 55, 72, 18);
  202. 		frmtcp.getContentPane().add(label_2);
  203. 		
  204. 		// 用户列表框
  205. 		JScrollPane scrollPane_2 = new JScrollPane();
  206. 		scrollPane_2.setBounds(546, 72, 149, 334);
  207. 		frmtcp.getContentPane().add(scrollPane_2);
  208. 		listUsers = new JList<String>();
  209. 		listUsers.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  210. 		scrollPane_2.setViewportView(listUsers);
  211. 		
  212. 		rdbtnBrocast = new JRadioButton("群聊");
  213. 		buttonGroup.add(rdbtnBrocast);
  214. 		rdbtnBrocast.setBounds(66, 306, 104, 22);
  215. 		frmtcp.getContentPane().add(rdbtnBrocast);
  216. 		rdbtnBrocast.setSelected(true);
  217. 		rdbtnPrivateChat = new JRadioButton("私聊");
  218. 		buttonGroup.add(rdbtnPrivateChat);
  219. 		//rdbtnPrivateChat.setSelected(true);
  220. 		rdbtnPrivateChat.setBounds(192, 306, 72, 22);
  221. 		frmtcp.getContentPane().add(rdbtnPrivateChat);
  222. 		
  223. 		
  224. 		// 更换样式
  225. 		try {
  226. 			String style = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  227. 			UIManager.setLookAndFeel(style);
  228. 			// 更新窗体样式
  229. 			SwingUtilities.updateComponentTreeUI(this.frmtcp);
  230. 		} catch (Exception e) {
  231. 			e.printStackTrace();
  232. 		}
  233. 	
  234. 	}
  235. 	
  236. }

（3）Register代码如下：

  1. package ClientGUI;
  2.  
  3. import java.awt.BorderLayout;
  4. import java.awt.FlowLayout;
  5. import java.awt.GridLayout;
  6. import java.awt.event.ActionEvent;
  7. import java.awt.event.ActionListener;
  8.  
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JOptionPane;
  13. import javax.swing.JPanel;
  14. import javax.swing.JPasswordField;
  15. import javax.swing.JTextField;
  16. import javax.swing.SwingUtilities;
  17. import javax.swing.UIManager;
  18.  
  19. import ClientSide.Client;
  20. import ServerSide.Server;
  21.  
  22. //注册窗口
  23. public class Register extends JFrame implements ActionListener {
  24.  
  25.  
  26. 	private LogOn logOn;
  27.  
  28. 	private JLabel jlUserName;
  29.  
  30. 	private JLabel jlPassword;
  31.  
  32. 	private JTextField jtUserName;
  33. 	
  34. 	public JTextField GetJtUserName()
  35. 	{
  36. 		return jtUserName;
  37. 	}
  38.  
  39. 	private JPasswordField jpPassword;
  40.  
  41. 	private JButton jbreturn;
  42.  
  43. 	private JButton jbRegister;
  44.  
  45. 	private JPanel jpDown;
  46.  
  47. 	private JPanel jpCenter;
  48.  
  49. 	private Server server = Server.GetServer();
  50.  
  51. 	public Register(LogOn logOn) {
  52. 		Init(logOn);
  53. 	}
  54.  
  55. 	private void Init(LogOn logOn) {
  56. 		this.logOn=logOn;
  57. 		jlUserName = new JLabel("用户名");
  58. 		jlPassword = new JLabel("密   码");
  59. 		jtUserName = new JTextField(15);
  60. 		jpPassword = new JPasswordField(15);
  61. 		jbreturn = new JButton("返回");
  62. 		jbRegister = new JButton("注册");
  63.  
  64. 		jbreturn.addActionListener(this);
  65. 		jbRegister.addActionListener(this);
  66.  
  67. 		jpCenter = new JPanel();
  68. 		jpCenter.setLayout(new GridLayout(2, 2));
  69. 		jpCenter.add(jlUserName);
  70. 		jpCenter.add(jtUserName);
  71. 		jpCenter.add(jlPassword);
  72. 		jpCenter.add(jpPassword);
  73.  
  74. 		jpDown = new JPanel();
  75. 		jpDown.setLayout(new FlowLayout());
  76. 		jpDown.add(jbRegister);
  77. 		jpDown.add(jbreturn);
  78.  
  79. 		this.setLayout(new BorderLayout());
  80. 		this.add("Center", jpCenter);
  81. 		this.add("South", jpDown);
  82. 		
  83. 		this.setTitle("用户注册界面");
  84. 		this.setSize(350, 150);
  85. 		this.setLocationRelativeTo(null);
  86. 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  87. 		this.setVisible(true);
  88.  
  89. 		// 更改窗体样式
  90. 		try {
  91. 			String style = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  92. 			UIManager.setLookAndFeel(style);
  93. 			SwingUtilities.updateComponentTreeUI(this);
  94. 		} catch (Exception e) {
  95. 			e.printStackTrace();
  96. 		}
  97. 	}
  98.  
  99. 	@Override
  100. 	public void actionPerformed(ActionEvent e) {
  101. 		Object source = e.getSource();
  102. 		if (source == jbreturn) {
  103. 			logOn.setVisible(true);
  104. 			this.setVisible(false);
  105.  
  106. 		} else if (source == jbRegister) {
  107. 			// 判断是否为空
  108. 			if (jtUserName.getText() == null || jtUserName.getText().equals("")
  109. 					|| String.valueOf(jpPassword.getPassword()) == null
  110. 					|| String.valueOf(jpPassword.getPassword()).equals("")) {
  111. 				JOptionPane.showMessageDialog(null, "请输入账号和密码");
  112. 			} else {
  113. 				// 数据传给服务器进行注册
  114. 				if (server.Register(jtUserName.getText(), String.valueOf(jpPassword.getPassword()))) {
  115. 					JOptionPane.showMessageDialog(null, "注册成功");
  116. 				}else {
  117. 					JOptionPane.showMessageDialog(null, "注册失败，改用户名已注册");
  118. 				}
  119. 			}
  120. 		}
  121.  
  122. 	}
  123.  
  124. }

2、ClientSide包里面

（1）Client代码如下：

  1. package ClientSide;
  2.  
  3. import java.awt.Component;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.DataInputStream;
  7. import java.io.DataOutputStream;
  8. import java.io.IOException;
  9. import java.net.Socket;
  10.  
  11. import javax.swing.JButton;
  12. import javax.swing.JList;
  13. import javax.swing.JOptionPane;
  14.  
  15. import ClientGUI.MainUI;
  16. import ClientGUI.Register;
  17. import Utils.Utils;
  18.  
  19. public class Client{
  20. 	
  21. 	private static Client clientInstance=null;
  22. 	public static synchronized Client GetClient()
  23. 	{
  24. 		if(clientInstance==null)
  25. 		{
  26. 			clientInstance=new Client();
  27. 		}
  28. 		return clientInstance;
  29. 	}
  30.  
  31. 	private MainUI mainUI;
  32. 	public void SetMainUI(MainUI mainUI)
  33. 	{
  34. 		this.mainUI=mainUI;
  35. 	}
  36. 	
  37. 	private ClientThread clientThread;
  38. 	public void SetClientThread(ClientThread clientThread)
  39. 	{
  40. 		if(clientThread!=null)
  41. 		{
  42. 			this.clientThread=clientThread;
  43. 		}
  44. 	}
  45. 	
  46.  
  47. 	private String username;
  48.  
  49. 	public void SetUserName(String userName)
  50. 	{
  51. 		this.username=userName;
  52. 	}
  53.  
  54. 	
  55.  
  56.  
  57. 	// 内部类.客户端线程,负责与服务器交互
  58. 	public class ClientThread extends Thread{
  59. 		private final Component frmtcp = null;
  60. 		// 通信套接字
  61. 		private Socket socket;
  62. 		// 基本数据输入流
  63. 		private DataInputStream dis;
  64. 		// 基本数据输出流
  65. 		private DataOutputStream dos;
  66. 		// 是否登录
  67. 		private boolean isLogged;
  68.  
  69. 		// 连接服务器
  70. 		public void ConnectServer() {
  71. 			// 获取服务器IP地址和端口
  72. 			String serverIp = mainUI.GetTextServerIP().getText();
  73. 			int serverPort = Integer.parseInt(mainUI.GetTextServerPort().getText());
  74. 			try {
  75. 				// 连接服务器,获取套接字IO流
  76. 				socket = new Socket(serverIp, serverPort);
  77. 				dis = new DataInputStream(socket.getInputStream());
  78. 				dos = new DataOutputStream(socket.getOutputStream());
  79. 				// 获取用户名，构建、发送登录报文
  80. 				//String username = mainUI.GetUserName();
  81. 				
  82. 				String msgConnect = "CONNECT#" + username;
  83. 				dos.writeUTF(msgConnect);
  84. 				dos.flush();
  85.  
  86. 				// 读取服务器返回的信息,判断是否登录成功
  87. 				String response = dis.readUTF();
  88.  
  89. 				// 登录失败
  90. 				if (response.equals("FAIL")) {
  91. 					addMsg("username+连接服务器失败");
  92. 					dis.close();
  93. 					dos.close();
  94. 					socket.close();
  95. 					return;
  96. 				} else {
  97. 					addMsg(username+"上线了！");
  98. 					isLogged = true;
  99. 					mainUI.GetBtnQuit().setText("退出");
  100. 					mainUI.GetBtnSend().setEnabled(true);
  101. 					String[] self = { username };
  102. 					UpdateJList(mainUI.GetListUsers(), self, "ADD");
  103. 				}
  104.  
  105. 			} catch (IOException e) {
  106. 				e.printStackTrace();
  107. 			}
  108. 		}
  109.  
  110. 		// 退出聊天室功能实现
  111. 		public  void DisConnectServer() {
  112. 			try {
  113. 				Utils.sendMsg(socket, "DISCONNECT#" + username);
  114. 				mainUI.GetModelUsers().clear();
  115. 				mainUI.GetListUsers().setModel(mainUI.GetModelUsers());
  116. 				addMsg(username+"下线了");
  117. 				isLogged=false;
  118. 				mainUI.GetBtnQuit().setEnabled(false);
  119. 				mainUI.GetBtnSend().setEnabled(false);
  120. 				String[] self = { username };
  121. 				UpdateJList(mainUI.GetListUsers(), self, "DEL");
  122. 				dis.close();
  123. 				dos.close();
  124. 				socket.close();
  125. 				clientThread.interrupt();
  126. 			} catch (IOException e) {
  127.  
  128. 				e.printStackTrace();
  129. 			}
  130. 		}
  131.  
  132. 		// 更新用户列表
  133. 		public void UpdateJList(JList jList, String[] items, String op) {
  134. 			switch (op) {
  135. 			case "ADD": // 添加新数据
  136. 				for (int i = 0; i < items.length; ++i) {
  137. 					mainUI.GetModelUsers().addElement(items[i]);
  138. 					break;
  139. 				}
  140. 			case "DEL":// 删除数据
  141. 				for (int i = 0; i < items.length; ++i) {
  142. 					mainUI.GetModelUsers().removeElement(items[i]);
  143. 					break;
  144. 				}
  145. 			default:
  146. 				break;
  147. 			}
  148. 			jList.setModel(mainUI.GetModelUsers());// 更新数据
  149.  
  150. 		}
  151.  
  152. 		// 发送消息
  153. 		public void SendChatMsg() {
  154.  
  155. 			String msgChat = null;
  156. 			String dstUser = "所有人";
  157. 			if (mainUI.GetRdbtnBrocast().isSelected()) {
  158. 				msgChat = "TALKTO_ALL#" + mainUI.GetTextAreaMsg().getText();
  159. 			}
  160. 			if (mainUI.GetRdbtnPrivateChat().isSelected()) {
  161. 				dstUser = (String) mainUI.GetListUsers().getSelectedValue();
  162. 				if (dstUser == null) {
  163. 					JOptionPane.showMessageDialog(this.frmtcp, "请选择需要私聊的用户!");
  164. 					return;
  165. 				}
  166. 				msgChat = "TALKTO#" + dstUser + "#" + mainUI.GetTextAreaMsg().getText();
  167. 			}
  168. 			// 发送聊天报文到服务器
  169. 			Utils.sendMsg(socket, msgChat);
  170. 			// 添加到消息记录框
  171. 			addMsg(" 我对" + dstUser + "说：" + mainUI.GetTextAreaMsg().getText());
  172. //			if (null != msgChat) {
  173. //				try {
  174. //					dos.writeUTF(msgChat);
  175. //					dos.flush();
  176. //				} catch (IOException e) {
  177. //					e.printStackTrace();
  178. //				}
  179. //			}
  180.  
  181. 		}
  182. 		
  183. 		
  184.  
  185. 		// 线程主体
  186. 		@Override
  187. 		public void run() {
  188. 			ConnectServer();
  189. 			//发送消息按钮
  190. 			mainUI.GetBtnSend().addActionListener(new ActionListener() {
  191. 				
  192. 				@Override
  193. 				public void actionPerformed(ActionEvent e) {
  194. 					SendChatMsg();
  195. 					
  196. 				}
  197. 			});
  198. 			//退出按钮
  199. 			mainUI.GetBtnQuit().addActionListener(new ActionListener() {
  200. 				
  201. 				@Override
  202. 				public void actionPerformed(ActionEvent e) {
  203. 					DisConnectServer();
  204. 					
  205. 				}
  206. 			});
  207. 			
  208. 			//消息处理
  209. 			while (isLogged) {
  210. 				try {	
  211. 				
  212. 					
  213. 					String msg = dis.readUTF();
  214. 					String[] parts = msg.split("#");
  215.  
  216. 					switch (parts[0]) {
  217. 					// 处理服务器发来的用户列表报文
  218. 					case "USERLIST":
  219. 						String[] self = { username };
  220. 						UpdateJList(mainUI.GetListUsers(), self, "ADD");
  221. 						for (int i = 1; i < parts.length; i++) {
  222. 							mainUI.GetModelUsers().addElement(parts[i]);
  223. 						}
  224. 						break;
  225. 					// 处理服务器发来的新用户连接表报文
  226. 					case "CONNECT":
  227. 						mainUI.GetModelUsers().addElement(parts[1]);
  228. 						addMsg(" " + parts[1] + "上线了");
  229. 						break;
  230. 					case "DISCONNECT":
  231. 						mainUI.GetModelUsers().removeElement(parts[1]);
  232. 						addMsg(" " + parts[1] + "下线了");
  233. 						break;
  234. 					case "TALKTO_ALL":
  235. 						addMsg(parts[1] + " 跟所有人说：" + parts[2]);
  236. 						break;
  237. 					case "TALKTO":
  238. 						addMsg(parts[1] + " 跟我说：" + parts[2]);
  239. 						break;
  240. 					default:
  241. 						break;
  242. 					}
  243. 				} catch (IOException e) {
  244. 					isLogged = false;
  245. 					e.printStackTrace();
  246. 				}
  247. 				
  248. 			}
  249. 			
  250. 		}
  251. 		
  252. 		
  253. 		// 添加消息到文本框textAreaRecord
  254. 		public  void  addMsg(String msg) {
  255. 			// 在文本区中添加一条消息,并加上换行
  256. 			mainUI.GetTextAreaRecord().append(msg + "\n");
  257. 			// 自动滚动到文本区的最后一行
  258. 			mainUI.GetTextAreaRecord().setCaretPosition(mainUI.GetTextAreaRecord().getText().length());
  259. 		}
  260.  
  261. 		
  262. 	}
  263.  
  264.  
  265. }

3、ConnectMysql包里面

（1）Connect代码如下：

  1. package ConnectMysql;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8.  
  9. public class Connect {
  10.  
  11. 	private Connection con;
  12.  
  13. 	public Connection GetConnection() {
  14. 		try {
  15. 			Class.forName("com.mysql.cj.jdbc.Driver");
  16. 			System.out.println("数据库驱动加载成功");
  17. 		} catch (ClassNotFoundException e) {
  18. 			e.printStackTrace();
  19. 		}
  20. 		try {
  21. 			con = DriverManager.getConnection("jdbc:mysql://localhost:3306/student?useSSL=false&serverTimezone=UTC",
  22. 					"root", "249913");
  23. 			System.out.println("数据库连接成功");
  24. 		} catch (SQLException e) {
  25. 			e.printStackTrace();
  26. 		}
  27. 		return con;
  28. 	}
  29.  
  30. 	//关闭数据库
  31. 	public void CloseConn(ResultSet rs, PreparedStatement pstm, Connection conn) throws Exception {
  32. 		if (rs != null) {
  33. 			rs.close();
  34. 		}
  35. 		if (pstm != null) {
  36. 			pstm.close();
  37. 		}
  38. 		if (conn != null) {
  39. 			conn.close();
  40. 		}
  41. 	}
  42.  
  43. }

（2）OperatorMysql代码如下

  1. package ConnectMysql;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7.  
  8.  
  9. public class OperatorMysql {
  10.  
  11. 	Connect connect = new Connect();
  12.  
  13. 	private Connection con;
  14.  
  15. 	// 增加数据(增加数据前先查询用户名是否已存在)
  16. 	public void Insert(String userName, String userPassword) {
  17. 		con = connect.GetConnection();
  18. 		PreparedStatement pstm = null;
  19. 		String sql_insert = "insert into user(userName,userPassword) values(?,?)";
  20. 		try {
  21. 			pstm = con.prepareStatement(sql_insert);
  22. 			pstm.setString(1, userName);
  23. 			pstm.setString(2, userPassword);
  24. 			pstm.executeUpdate();
  25. 			connect.CloseConn(null, pstm, con);
  26.  
  27. 		} catch (SQLException e) {
  28. 			e.printStackTrace();
  29. 		} catch (Exception e) {
  30. 			e.printStackTrace();
  31. 		}
  32.  
  33. 	}
  34.  
  35. 	// 查找数据(用户名重复返回false)
  36. 	public Boolean Search(String userName) {
  37. 		con = connect.GetConnection();
  38. 		PreparedStatement pstm = null;
  39. 		ResultSet rs = null;
  40. 		String sql_Search = "select *from user where userName=?";
  41. 		try {
  42. 			pstm = con.prepareStatement(sql_Search);
  43. 			pstm.setString(1, userName);
  44. 			rs = pstm.executeQuery();
  45. 			if(rs.next())
  46. 			{
  47. 				return false;
  48. 			}
  49. 			
  50. 		} catch (SQLException e) {
  51. 			e.printStackTrace();
  52. 		}
  53. 		return true;
  54. 	}
  55.  
  56. }

4、ServerGUI包里面

（1）ServerUI代码如下：

  1. package ServerGUI;
  2.  
  3. import java.awt.Color;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.io.IOException;
  7.  
  8. import javax.swing.JButton;
  9. import javax.swing.JFrame;
  10. import javax.swing.JLabel;
  11. import javax.swing.JScrollPane;
  12. import javax.swing.JTable;
  13. import javax.swing.JTextArea;
  14. import javax.swing.JTextField;
  15. import javax.swing.ListSelectionModel;
  16. import javax.swing.SwingUtilities;
  17. import javax.swing.UIManager;
  18. import javax.swing.table.DefaultTableModel;
  19.  
  20. import ServerSide.Server;
  21.  
  22. public class ServerUI {
  23. 	// 单例
  24. 	private static ServerUI serverUIInstance = null;
  25.  
  26. 	public static synchronized ServerUI GetServerUI() {
  27. 		if (serverUIInstance == null) {
  28. 			serverUIInstance = new ServerUI();
  29. 		}
  30. 		return serverUIInstance;
  31. 	}
  32.  
  33. 	private JFrame frmTcp;
  34. 	private JTextField textServerIP;
  35. 	private JTextField textPort;
  36. 	private JButton btnStart;
  37. 	private JButton btnStop;
  38. 	private JTextArea textAreaRecord;
  39. 	private JTable tblUsers;// 在线用户列表
  40.  
  41. 	public JTextField GetTextServerIP() {
  42. 		return textServerIP;
  43. 	}
  44.  
  45. 	public JTextField GetTextPort() {
  46. 		return textPort;
  47. 	}
  48.  
  49. 	public JButton GetBtnStart() {
  50. 		return btnStart;
  51. 	}
  52.  
  53. 	public JButton GetBtnStop() {
  54. 		return btnStop;
  55. 	}
  56.  
  57. 	public JTextArea GetTextAreaRecord() {
  58. 		return textAreaRecord;
  59. 	}
  60.  
  61. 	private ServerUI() {
  62. 		Init();
  63. 	}
  64.  
  65. 	private void Init() {
  66. 		frmTcp = new JFrame();
  67. 		frmTcp.setResizable(false);
  68. 		frmTcp.setTitle("服务器界面");
  69. 		frmTcp.setBounds(100, 100, 700, 509);
  70. 		frmTcp.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  71. 		frmTcp.getContentPane().setLayout(null);
  72.  
  73. 		// IP框
  74. 		JLabel lblip = new JLabel("服务器IP地址:");
  75. 		lblip.setBounds(10, 27, 105, 18);
  76. 		frmTcp.getContentPane().add(lblip);
  77. 		textServerIP = new JTextField();
  78. 		textServerIP.setText("0.0.0.0");
  79. 		textServerIP.setBounds(114, 24, 141, 24);
  80. 		frmTcp.getContentPane().add(textServerIP);
  81. 		textServerIP.setColumns(10);
  82. 		// 端口框
  83. 		JLabel label = new JLabel("端口号:");
  84. 		label.setBounds(293, 27, 72, 18);
  85. 		frmTcp.getContentPane().add(label);
  86. 		textPort = new JTextField();
  87. 		textPort.setText("6666");
  88. 		textPort.setBounds(356, 24, 86, 24);
  89. 		frmTcp.getContentPane().add(textPort);
  90. 		textPort.setColumns(10);
  91. 		// 开始按钮
  92. 		btnStart = new JButton("开始");
  93. 		btnStart.setBounds(479, 23, 95, 27);
  94. 		frmTcp.getContentPane().add(btnStart);
  95. 		
  96. 		// 启动按钮事件监听处理
  97. 		btnStart.addActionListener(new ActionListener() {
  98. 			@Override
  99. 			public void actionPerformed(ActionEvent arg0) {
  100. 				// 创建、启动服务器通信线程
  101. 				Thread serverThread = new Thread(new Server().new ServerThread());
  102. 				serverThread.start();
  103. 			}
  104. 		});
  105. 		// 停止按钮
  106. 		btnStop = new JButton("停止");
  107. 		btnStop.setEnabled(false);
  108. 		btnStop.setBounds(588, 23, 95, 27);
  109. 		frmTcp.getContentPane().add(btnStop);
  110. 		
  111. 		// 停止按钮事件监听处理
  112. 		btnStop.addActionListener(new ActionListener() {
  113. 			@Override
  114. 			public void actionPerformed(ActionEvent arg0) {
  115. 			
  116. 			}
  117. 				
  118. 		});
  119.  
  120. 		JLabel label_1 = new JLabel("消息记录");
  121. 		label_1.setBounds(10, 58, 72, 18);
  122. 		frmTcp.getContentPane().add(label_1);
  123.  
  124. 		JScrollPane scrollPane = new JScrollPane();
  125. 		scrollPane.setBounds(10, 78, 673, 159);
  126. 		frmTcp.getContentPane().add(scrollPane);
  127.  
  128. 		textAreaRecord = new JTextArea();
  129. 		textAreaRecord.setBackground(Color.pink);
  130. 		textAreaRecord.setEditable(false);
  131. 		scrollPane.setViewportView(textAreaRecord);
  132. 		
  133. 		JLabel lblNewLabel = new JLabel("在线用户列表");
  134. 		lblNewLabel.setBounds(10, 250, 105, 18);
  135. 		frmTcp.getContentPane().add(lblNewLabel);
  136. 		
  137. 		JScrollPane scrollPane_1 = new JScrollPane();
  138. 		scrollPane_1.setBounds(10, 273, 673, 191);
  139. 		frmTcp.getContentPane().add(scrollPane_1);
  140. 		
  141. 		// 在线用户列表
  142. 		tblUsers = new JTable();
  143. 		tblUsers.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  144. 		tblUsers.setModel(new DefaultTableModel(new Object[][] {}, new String[] { "序号", "用户名",
  145. 				"IP地址", "端口号", "登录时间" }) {
  146. 			private static final long serialVersionUID = 1L;
  147. 			boolean[] columnEditables = new boolean[] { true, true, true, false, true };
  148.  
  149. 			public boolean isCellEditable(int row, int column) {
  150. 				return columnEditables[column];
  151. 			}
  152. 		});
  153. 		tblUsers.getColumnModel().getColumn(0).setPreferredWidth(56);
  154. 		tblUsers.getColumnModel().getColumn(1).setPreferredWidth(118);
  155. 		tblUsers.getColumnModel().getColumn(2).setPreferredWidth(126);
  156. 		tblUsers.getColumnModel().getColumn(3).setResizable(false);
  157. 		tblUsers.getColumnModel().getColumn(3).setPreferredWidth(61);
  158. 		tblUsers.getColumnModel().getColumn(4).setPreferredWidth(122);
  159. 		scrollPane_1.setViewportView(tblUsers);
  160.  
  161. 		// 更换样式
  162. 		try {
  163. 			String style = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
  164. 			UIManager.setLookAndFeel(style);
  165. 			SwingUtilities.updateComponentTreeUI(this.frmTcp);
  166. 		} catch (Exception e) {
  167. 			e.printStackTrace();
  168. 		}
  169. 	}
  170.  
  171. 	public static void main(String[] args) {
  172. 		ServerUI serverUI = ServerUI.GetServerUI();
  173. 		serverUI.frmTcp.setVisible(true);
  174. 	}
  175.  
  176. }

5、ServerSide包里面

（1）Server代码

  1. package ServerSide;
  2.  
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5. import java.io.DataInputStream;
  6. import java.io.DataOutputStream;
  7. import java.io.IOException;
  8. import java.net.InetSocketAddress;
  9. import java.net.ServerSocket;
  10. import java.net.Socket;
  11. import java.net.SocketAddress;
  12. import java.util.HashMap;
  13. import ConnectMysql.OperatorMysql;
  14. import ServerGUI.ServerUI;
  15.  
  16. public class Server {
  17. 	private static Server serverInstance=null;
  18. 	public static synchronized Server GetServer()
  19. 	{
  20. 		if(serverInstance==null)
  21. 		{
  22. 			serverInstance=new Server();
  23. 		}
  24. 		return serverInstance;
  25. 	}
  26. 	
  27. 	
  28. 	
  29. 	// 对数据库进行操作
  30. 	private static OperatorMysql operatorMysql = new OperatorMysql();
  31.  
  32. 	private String userName;
  33. 	private String userPassword;
  34.  
  35. 	ServerUI serverUI = ServerUI.GetServerUI();
  36. 	// 服务器套接字
  37. 	private ServerSocket server;
  38. 	// 服务器是否运行
  39. 	private boolean isRunning;
  40. 	// 用户名不能相同,存放每个用户和客户端套接字的映射。
  41. 	private HashMap<String, ClientHandler> clientHandlerMap = new HashMap<String, ClientHandler>();
  42.  
  43. 	// 注册
  44. 	public  Boolean Register(String userName, String userPassword) {
  45. 		if (operatorMysql.Search(userName)) {
  46. 			operatorMysql.Insert(userName, userPassword);
  47. 			this.userName = userName;
  48. 			this.userPassword = userPassword;
  49. 			return true;
  50. 		}
  51. 		return false;
  52. 	}
  53.  
  54. 	// 登录
  55. 	public Boolean LogOn(String userName, String userPassword) {
  56. 		if (operatorMysql.Search(userName)) {
  57. 			return false;
  58. 		}
  59. 		return true;
  60. 	}
  61. 	
  62.  
  63. 	// 内部类，服务器后台线程
  64. 	public class ServerThread implements Runnable {
  65. 		// 启动
  66. 		private void startServer() {
  67. 			try {
  68. 				// 获取serverIp 和 serverPort
  69. 				String serverIp = serverUI.GetTextServerIP().getText();
  70. 				int serverPort = Integer.parseInt(serverUI.GetTextPort().getText());
  71. 				// 创建套接字地址
  72. 				SocketAddress socketAddress = new InetSocketAddress(serverIp, serverPort);
  73. 				// 创建ServerSocket，绑定套接字地址
  74. 				server = new ServerSocket();
  75. 				server.bind(socketAddress);
  76. 				// 修改判断服务器是否运行的标识变量
  77. 				isRunning = true;
  78. 				// 修改启动和停止按钮状态
  79. 				serverUI.GetBtnStart().setEnabled(false);
  80. 				serverUI.GetBtnStop().setEnabled(true);
  81. 				addMsg("服务器启动成功");
  82. 				System.out.println("服务器启动成功");
  83.  
  84. 			} catch (IOException e) {
  85. 				addMsg("服务器启动失败，请检查端口是否被占用");
  86. 				e.printStackTrace();
  87. 				isRunning = false;
  88. 			}
  89. 		}
  90.  
  91. 		// 线程主体
  92. 		@Override
  93. 		public void run() {
  94. 			startServer();
  95. 			CloseServer();
  96. 			// 当服务器处于运行状态时,循环监听客户端的连接请求
  97. 			while (isRunning) {
  98. 				try {
  99. 					
  100. 					Socket socket = server.accept();
  101. 					// 创建与客户端交互的线程
  102. 					Thread thread = new Thread(new ClientHandler(socket));
  103. 					thread.start();
  104. 				} catch (IOException e) {
  105.  
  106. 				}
  107. 			}
  108. 		}
  109.  
  110. 	}
  111.  
  112. 	public void CloseServer() {
  113. 		serverUI.GetBtnStop().addActionListener(new ActionListener() {
  114.  
  115. 			@Override
  116. 			public void actionPerformed(ActionEvent e) {
  117. 				try {
  118. 					isRunning = false;
  119. 					server.close();
  120. 					clientHandlerMap.clear();
  121. 					// 修改按钮状态
  122. 					serverUI.GetBtnStart().setEnabled(true);
  123. 					serverUI.GetBtnStop().setEnabled(false);
  124. 					addMsg("服务器关闭成功");
  125. 				} catch (IOException e1) {
  126. 					e1.printStackTrace();
  127. 				}
  128. 			}
  129. 		});
  130. 	}
  131.  
  132. 	// 添加消息到文本框textAreaRecord
  133. 	private void addMsg(String msg) {
  134. 		// 在文本区中添加一条消息，并加上换行
  135. 		serverUI.GetTextAreaRecord().append(msg + "\n");
  136. 		// 自动滚动到文本区的最后一行
  137. 		serverUI.GetTextAreaRecord().setCaretPosition(serverUI.GetTextAreaRecord().getText().length());
  138.  
  139. 	}
  140.  
  141. 	//更新服务器在线用户表
  142. 	public void UpdateUserTbl() {
  143.  
  144. 	}
  145.  
  146. 	//获取IP地址
  147. 	public Object GetInetAddress() {
  148.  
  149. 		return null;
  150. 	}
  151. 	//获取端口号
  152. 	public int GetPort()
  153. 	{
  154. 		return 6666;
  155. 	}
  156.  
  157. 	// 内部类,用于和客户端交互
  158. 	class ClientHandler implements Runnable {
  159. 		private Socket socket;
  160. 		private DataInputStream dis;
  161. 		private DataOutputStream dos;
  162. 		private boolean isConnected;
  163. 		private String username;
  164.  
  165. 		public ClientHandler(Socket socket) {
  166. 			this.socket = socket;
  167. 			try {
  168. 				this.dis = new DataInputStream(socket.getInputStream());
  169. 				this.dos = new DataOutputStream(socket.getOutputStream());
  170. 				isConnected = true;
  171. 			} catch (IOException e) {
  172. 				isConnected = false;
  173. 				e.printStackTrace();
  174. 			}
  175. 		}
  176.  
  177. 		@Override
  178. 		public void run() {
  179. 			while (isRunning && isConnected) {
  180. 				try {
  181. 					// 读取客户端发送的报文
  182. 					String msg = dis.readUTF();
  183. 					String[] parts = msg.split("#");
  184. 					switch (parts[0]) {
  185. 					// 处理登录报文
  186. 					case "CONNECT":
  187. 						String connectUsername = parts[1];
  188. 						// 如果该用户名已登录,则返回失败报文,否则返回成功报文
  189. 						if (clientHandlerMap.containsKey(connectUsername)) {
  190. 							dos.writeUTF("FAIL");
  191. 						} else {
  192. 							dos.writeUTF("SUCCESS");
  193. 							// 将此客户端处理线程的信息添加到clientHandlerMap中
  194. 							clientHandlerMap.put(connectUsername, this);
  195. 							// 将现有用户的信息发给新用户
  196. 							StringBuffer msgUserList = new StringBuffer();
  197. 							msgUserList.append("USERLIST#");
  198. 							for (String username : clientHandlerMap.keySet()) {
  199. 								msgUserList.append(username + "#");
  200. 							}
  201. 							dos.writeUTF(msgUserList.toString());
  202. 							// 将新登录的用户信息广播给其他用户
  203. 							String msgLogin = "CONNECT#" + connectUsername;
  204. 							BroadcastMsg(connectUsername, msgLogin);
  205. 							// 存储登录的用户名
  206. 							this.username = connectUsername;
  207. 							UpdateUserTbl();// 未实现
  208. 						}
  209. 						break;
  210. 					// 处理退出报文
  211. 					case "DISCONNECT":
  212. 						clientHandlerMap.remove(username);
  213. 						String msgLogout = "DISCONNECT#" + username;
  214. 						BroadcastMsg(username, msgLogout);
  215. 						isConnected = false;
  216. 						dis.close();
  217. 						dos.close();
  218. 						socket.close();
  219. 						UpdateUserTbl();
  220. 						break;
  221. 					case "TALKTO_ALL":
  222. 						String msgTalkToAll = "TALKTO_ALL#" + username + "#" + parts[1];
  223. 						BroadcastMsg(username, msgTalkToAll);
  224. 						break;
  225. 					case "TALKTO":
  226. 						ClientHandler clientHandler = clientHandlerMap.get(parts[1]);
  227. 						if (null != clientHandler) {
  228. 							String msgTalkTo = "TALKTO#" + username + "#" + parts[2];
  229. 							clientHandler.dos.writeUTF(msgTalkTo);
  230. 							clientHandler.dos.flush();
  231. 						}
  232.  
  233. 					default:
  234. 						break;
  235. 					}
  236. 				} catch (IOException e) {
  237. 					isConnected = false;
  238. 					e.printStackTrace();
  239. 				}
  240. 			}
  241. 		}
  242.  
  243. 		// 将某个用户发来的消息广播给其它用户
  244. 		private void BroadcastMsg(String fromUsername, String msg) throws IOException {
  245. 			for (String toUserName : clientHandlerMap.keySet()) {
  246. 				if (fromUsername.equals(toUserName) == false) {
  247. 					DataOutputStream dos = clientHandlerMap.get(toUserName).dos;
  248. 					dos.writeUTF(msg);
  249. 					dos.flush();
  250. 				}
  251. 			}
  252. 		}
  253.  
  254. 	}
  255. }

6、Utils包里面

（1）Utils代码

  1. package Utils;
  2.  
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.Socket;
  7.  
  8.  
  9. import javax.swing.JTextArea;
  10.  
  11. public class Utils {
  12. 	// 通过套接字S发送字符串
  13. 	public static void sendMsg(Socket s, String msg) {
  14. 		try {
  15. 			// 字符流
  16. 			DataOutputStream dos = new DataOutputStream(s.getOutputStream());
  17. 			dos.writeUTF(msg);
  18. 			dos.flush();
  19. 		} catch (IOException e) {
  20. 			e.printStackTrace();
  21. 		}
  22. 	}
  23.  
  24. 	// 在套接字S上读取字符串,如果TCP连接关闭,返回null
  25. 	public static String recvMsg(Socket s) throws IOException {
  26. 		String msg = null;
  27. 		DataInputStream dis = (DataInputStream) new DataInputStream(s.getInputStream());
  28. 		msg = ((DataInputStream) dis).readUTF();
  29. 		return msg;
  30.  
  31. 	}
  32.  
  33. 	// 添加消息到文本记录框JTextArea,并且滚动显示到最后一行
  34. 	public static void addMsgRec(JTextArea textArea, String msg) {
  35. 		textArea.append(msg + "\n");
  36. 		textArea.setCaretPosition(textArea.getText().length());
  37. 	}
  38. }

最后添加一个Mysql的库文件就可以连接数据库了。

测试如下：

首先，打开mysql数据库，然后启动服务器启动成功，如下图。

然后启动登录界面，如下图：

点击注册按钮，进入注册界面，如下图：

进行注册，如果注册成功就会进行注册成功提示，如下图：

如果用户名已经注册就会进行注册失败提示，如下图：

点击返回按钮进入登录界面进行登录，如果用户名不存在会提示登录失败，如下图：

如果不输入任何东西点击登录也会提示用户进行输入，如下图：

登录成功以后就进入客户端主界面，如下图：

界面上有在线用户和上线提示。

然后通过重复前面的步骤在开两个客户端，此时界面，如下图：

然后就可以进行聊天了，首先默认的是群聊，如下图：

群聊正常的实现了。

私聊主要就是选择私聊按钮，然后选择想要私聊的用户，如果不选择私聊用户，就会进行提醒，如下图：‘

选择在线用户后就可以进行私聊了，如下图：

正常实现了，不过这里还有一个问题就是如果选择自己的话也能进行私聊，这就不对了，如下图：

因为时间原因，服务器端没有全部进行完善，还有一部分功能没有实现，如下图：

源代码下载：下载链接

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/178623
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号