基于java socket的聊天室项目文档
用javaWebSocket做一个聊天室
⽤javaWebSocket做⼀个聊天室最近⼀个项⽬中，需要⽤到Java的websocket新特性，于是就学了⼀下，感觉这技术还挺好玩的，瞬间知道⽹页上⾯的那些在线客服是怎么做的了。
先看图：实现了多客户机进⾏实时通讯。
下⾯看代码项⽬结构图：很简单，就1个类，1个页⾯然后看具体代码先看后端代码package com.main;import java.io.IOException;import java.util.concurrent.CopyOnWriteArraySet;import javax.websocket.*;import javax.websocket.server.ServerEndpoint;/*** @ServerEndpoint 注解是⼀个类层次的注解，它的功能主要是将⽬前的类定义成⼀个websocket服务器端,* 注解的值将被⽤于监听⽤户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端*/@ServerEndpoint("/websocket")public class H5ServletServerSocket {// 静态变量，⽤来记录当前在线连接数。
应该把它设计成线程安全的。
private static int onlineCount = 0;// concurrent包的线程安全Set，⽤来存放每个客户端对应的MyWebSocket对象。
若要实现服务端与单⼀客户端通信的话，可以使⽤Map来存放，其中Key可以为⽤户标识 private static CopyOnWriteArraySet<H5ServletServerSocket> webSocketSet = new CopyOnWriteArraySet<H5ServletServerSocket>();// 与某个客户端的连接会话，需要通过它来给客户端发送数据private Session session;/*** 连接建⽴成功调⽤的⽅法** @param session* 可选的参数。
基于Java Socket的聊天室系统设计与实现
户端根据输入 Ｓｒ ｒ Ｉ ｅ ｅ 的 Ｐ地址连入相应的服务器参与聊天活动， ｖ 服务器上显示当前在线的用户信
息 ， 对用户进 入或 断开 的信 息加 以显示。 并 关键词 ：ａａ 接 字 ； Ｊｖ 套 聊天 室 ； 户端 ； 客 服务器
Ｄ Ｉ 码 ： ．９ ９ ｉｉ ｎ １ ０ ２ ７ ．０ ０ ０ ． １ Ｏ编 １ ３ ６ ／．ｓ ． ０ ２— ２ ９ ２ １ ．５ ０ ９ ０ ｓ
中图分 类号 ：Ｐ ９ Ｔ ３３
文献标识 码 ： Ａ
文章编号 ：０ ２— ２ ９ ２ １ ）５— ０ ６— ２ １０ ２ ７ （０ ０ Ｏ ０ ６ ０
Ｄｅ ｉｎ ＆ Ｉ ｌｍｅ ｔｏ ａ ｙ ｔ ｍ ａ ｅ ｎ Ｊ ｖ ｃ ｅ ｓｇ ｍｐｅ ｎ ｆＣｈ ｔＳ ｓｅ Ｂ ｓ ｄ ｏ ａ ａ Ｓｏ ｋ ｔ
ｃｉ ｔ ｏ ｎ ｃ ｄｗｔ ｃｍ ａ ｂｅｓｒ ｒ ｎ ｉｅ ｈ ｔｎ ｃｏｄｎ ｅＩ ｆ ｅ ｅ ｉ ｕｔ ．ｎｔｅ ｌ ｎ ｃｎ ｅｔ ｉ ｏ ｐ ｔ ｌ ｅｖ ｄｊ ｎｄｃａｔ ｇａｃｒｉ ｔ ｔ Ｐｏ ｒ ｒ ｎ ｔ ｄ Ｉ ｈ ｅ ｅ ｈ ｉ ｅａ ｏ ｉ ｇｏｈ ｓｖ ｐ ｅ
Ｈ ｉｇ ｊ ｇ Ｌ ａ ｇ ｈ ｎ Ｕ Ｊ — ｉ ，Ｕ Ｍ ｎ — ｏｇ ｎ ｎ
（ ｕ ａ ｉｏ ｉ ｌ ｎ ｌ ｔ ｍ ｃａ ｉ ｌ ｏ ｔ ｈ ｉ， ｈ ｎｓａ４ ０ ２ ，ｈｎ ） Ｈ ｎ ｎＢｏ ｇｃ ｄＥｅ ｒ ｅｈ ｎ ａ ｌｅ ｎ Ｃ ａ ｇｈ １ １６ Ｃ ｉ ｌ ａａ ｃｏ ｃ Ｐ ｙｃ ｃ ａ
Java Socket实现多人聊天室
Java Socket实现多人聊天室---swing做UI标签：socket聊天javaexception服务器string2011-08-31 15:06 20679人阅读评论(25) 收藏举报分类：java（21）版权声明：本文为博主原创文章，未经博主允许不得转载。
今天翻硬盘的workspace发现一个Java Socket实现多人聊天室的源码，不记得是什么时候的事情了，貌似不是我写的。
但写得还不错，至少算个有模有样的聊天室工具。
我简单的修改了一下，拿出来跟大家分享一下，仅供参考。
界面是用swing写的，还不懒，简约大方。
有图有真相：正如上图所示，这个程序分为服务器端和客户端，说白了就是两个main class，用eclipse 直接运行之。
聊天室的设计思想是：在局域网下，利用socket进行连接通信，当服务器端启动的时候，利用Thread线程不停的等待客户端的链接；当有客户端开启连接的时候，服务器端通过IO流反馈“上线用户”信息给客户端，客户端也使用线程不停的接收服务器的信息，从而实现多人在线聊天功能。
程序中有三个类，分别Server.java（服务器端）、Client（客户端）、User.java（javabean）。
代码如下：Server.java（服务器端）：[html]view plaincopy1.import java.awt.BorderLayout;2.import java.awt.Color;3.import java.awt.GridLayout;4.import java.awt.Toolkit;5.import java.awt.event.ActionEvent;6.import java.awt.event.ActionListener;7.import java.awt.event.WindowAdapter;8.import java.awt.event.WindowEvent;9.import java.io.BufferedReader;10.i mport java.io.IOException;11.i mport java.io.InputStreamReader;12.i mport java.io.PrintWriter;13.i mport .BindException;14.i mport .ServerSocket;15.i mport .Socket;16.i mport java.util.ArrayList;17.i mport java.util.StringTokenizer;18.19.i mport javax.swing.DefaultListModel;20.i mport javax.swing.JButton;21.i mport javax.swing.JFrame;22.i mport javax.swing.JLabel;23.i mport javax.swing.JList;24.i mport javax.swing.JOptionPane;25.i mport javax.swing.JPanel;26.i mport javax.swing.JScrollPane;27.i mport javax.swing.JSplitPane;28.i mport javax.swing.JTextArea;29.i mport javax.swing.JTextField;30.i mport javax.swing.border.TitledBorder;31.32.p ublic class Server {33.34. private JFrame frame;35. private JTextArea contentArea;36. private JTextField txt_message;37. private JTextField txt_max;38. private JTextField txt_port;39. private JButton btn_start;40. private JButton btn_stop;41. private JButton btn_send;42. private JPanel northPanel;43. private JPanel southPanel;44. private JScrollPane rightPanel;45. private JScrollPane leftPanel;46. private JSplitPane centerSplit;47. private JList userList;48. private DefaultListModel listModel;49.50. private ServerSocket serverSocket;51. private ServerThread serverThread;52. private ArrayList<ClientThread> clients;53.54. private boolean isStart = false;55.56. // 主方法,程序执行入口57. public static void main(String[] args) {58. new Server();59. }60.61. // 执行消息发送62. public void send() {63. if (!isStart) {64. JOptionPane.showMessageDialog(frame, "服务器还未启动,不能发送消息！", "错误",65. JOptionPane.ERROR_MESSAGE);66. return;67. }68. if (clients.size() == 0) {69. JOptionPane.showMessageDialog(frame, "没有用户在线,不能发送消息！", "错误",70. JOptionPane.ERROR_MESSAGE);71. return;72. }73. String message = txt_message.getText().trim();74. if (message == null || message.equals("")) {75. JOptionPane.showMessageDialog(frame, "消息不能为空！", "错误",76. JOptionPane.ERROR_MESSAGE);77. return;78. }79. sendServerMessage(message);// 群发服务器消息80. contentArea.append("服务器说：" + txt_message.getText() + "\r\n");81. txt_message.setText(null);82. }83.84. // 构造放法85. public Server() {86.frame = new JFrame("服务器");87. // 更改JFrame的图标：88. //frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Client.class.getResource("qq.png")));89. frame.setIconImage(Toolkit.getDefaultToolkit().createImage(Server.class.getResource("qq.png")));90.contentArea = new JTextArea();91. contentArea.setEditable(false);92. contentArea.setForeground(Color.blue);93.txt_message = new JTextField();94.txt_max = new JTextField("30");95.txt_port = new JTextField("6666");96.btn_start = new JButton("启动");97.btn_stop = new JButton("停止");98.btn_send = new JButton("发送");99. btn_stop.setEnabled(false);100.listModel = new DefaultListModel();erList = new JList(listModel);102.103.southPanel = new JPanel(new BorderLayout()); 104. southPanel.setBorder(new TitledBorder("写消息")); 105. southPanel.add(txt_message, "Center");106. southPanel.add(btn_send, "East");107.leftPanel = new JScrollPane(userList);108. leftPanel.setBorder(new TitledBorder("在线用户"));109.110.rightPanel = new JScrollPane(contentArea);111. rightPanel.setBorder(new TitledBorder("消息显示区"));112.113.centerSplit = new JSplitPane(JSplitPane.HORIZONTAL _SPLIT, leftPanel,114. rightPanel);115. centerSplit.setDividerLocation(100);116.northPanel = new JPanel();117. northPanel.setLayout(new GridLayout(1, 6)); 118. northPanel.add(new JLabel("人数上限"));119. northPanel.add(txt_max);120. northPanel.add(new JLabel("端口"));121. northPanel.add(txt_port);122. northPanel.add(btn_start);123. northPanel.add(btn_stop);124. northPanel.setBorder(new TitledBorder("配置信息"));125.126. frame.setLayout(new BorderLayout());127. frame.add(northPanel, "North");128. frame.add(centerSplit, "Center");129. frame.add(southPanel, "South");130. frame.setSize(600, 400);131. //frame.setSize(Toolkit.getDefaultToolkit().getScr eenSize());//设置全屏132. int screen_width = Toolkit.getDefaultToolkit().get ScreenSize().width;133. int screen_height = Toolkit.getDefaultToolkit().ge tScreenSize().height;134. frame.setLocation((screen_width - frame.getWidth() ) / 2,135. (screen_height - frame.getHeight()) / 2);136. frame.setVisible(true);137.138. // 关闭窗口时事件139. frame.addWindowListener(new WindowAdapter() { 140. public void windowClosing(WindowEvent e) { 141. if (isStart) {142. closeServer();// 关闭服务器143. }144. System.exit(0);// 退出程序145. }146. });147.148. // 文本框按回车键时事件149. txt_message.addActionListener(new ActionListener() {150. public void actionPerformed(ActionEvent e) { 151. send();152. }153. });154.155. // 单击发送按钮时事件156. btn_send.addActionListener(new ActionListener() {157. public void actionPerformed(ActionEvent arg0) {158. send();159. }160. });161.162. // 单击启动服务器按钮时事件163. btn_start.addActionListener(new ActionListener() {164. public void actionPerformed(ActionEvent e) { 165. if (isStart) {166. JOptionPane.showMessageDialog(frame, "服务器已处于启动状态，不要重复启动！",167. "错误", JOptionPane.ERROR_MESSAGE);168. return;169. }170. int max;171. int port;172. try {173. try {174.max = Integer.parseInt(txt_max.get Text());175. } catch (Exception e1) {176. throw new Exception("人数上限为正整数！");177. }178. if (max <= 0) {179. throw new Exception("人数上限为正整数！");180. }181. try {182.port = Integer.parseInt(txt_port.g etText());183. } catch (Exception e1) {184. throw new Exception("端口号为正整数！");185. }186. if (port <= 0) {187. throw new Exception("端口号为正整数！");188. }189. serverStart(max, port);190. contentArea.append("服务器已成功启动!人数上限：" + max + ",端口：" + port191. + "\r\n");192. JOptionPane.showMessageDialog(frame, "服务器成功启动!");193. btn_start.setEnabled(false);194. txt_max.setEnabled(false);195. txt_port.setEnabled(false);196. btn_stop.setEnabled(true);197. } catch (Exception exc) {198. JOptionPane.showMessageDialog(frame, e xc.getMessage(),199. "错误", JOptionPane.ERROR_MESSAGE);200. }201. }202. });203.204. // 单击停止服务器按钮时事件205. btn_stop.addActionListener(new ActionListener() {206. public void actionPerformed(ActionEvent e) { 207. if (!isStart) {208. JOptionPane.showMessageDialog(frame, "服务器还未启动，无需停止！", "错误",209. JOptionPane.ERROR_MESSAGE); 210. return;211. }212. try {213. closeServer();214. btn_start.setEnabled(true);215. txt_max.setEnabled(true);216. txt_port.setEnabled(true);217. btn_stop.setEnabled(false);218. contentArea.append("服务器成功停止!\r\n");219. JOptionPane.showMessageDialog(frame, "服务器成功停止！");220. } catch (Exception exc) {221. JOptionPane.showMessageDialog(frame, "停止服务器发生异常！", "错误",222. JOptionPane.ERROR_MESSAGE); 223. }224. }225. });226. }227.228. // 启动服务器229. public void serverStart(int max, int port) throws java .net.BindException {230. try {231.clients = new ArrayList<ClientThread>();232.serverSocket = new ServerSocket(port); 233.serverThread = new ServerThread(serverSocket, max);234. serverThread.start();235.isStart = true;236. } catch (BindException e) {237.isStart = false;238. throw new BindException("端口号已被占用，请换一个！");239. } catch (Exception e1) {240. e1.printStackTrace();241.isStart = false;242. throw new BindException("启动服务器异常！"); 243. }244. }245.246. // 关闭服务器247. @SuppressWarnings("deprecation")248. public void closeServer() {249. try {250. if (serverThread != null)251. serverThread.stop();// 停止服务器线程252.253. for (int i = clients.size() - 1; i >= 0; i--) {254. // 给所有在线用户发送关闭命令255. clients.get(i).getWriter().println("CLOSE");256. clients.get(i).getWriter().flush(); 257. // 释放资源258. clients.get(i).stop();// 停止此条为客户端服务的线程259. clients.get(i).reader.close();260. clients.get(i).writer.close();261. clients.get(i).socket.close();262. clients.remove(i);263. }264. if (serverSocket != null) {265. serverSocket.close();// 关闭服务器端连接266. }267. listModel.removeAllElements();// 清空用户列表268.isStart = false;269. } catch (IOException e) {270. e.printStackTrace();271.isStart = true;272. }273. }274.275. // 群发服务器消息276. public void sendServerMessage(String message) { 277. for (int i = clients.size() - 1; i >= 0; i--) { 278. clients.get(i).getWriter().println("服务器：" + message + "(多人发送)");279. clients.get(i).getWriter().flush();280. }281. }282.283. // 服务器线程284. class ServerThread extends Thread {285. private ServerSocket serverSocket;286. private int max;// 人数上限287.288. // 服务器线程的构造方法289. public ServerThread(ServerSocket serverSocket, int max) {290.this.serverSocket = serverSocket;291.this.max = max;292. }293.294. public void run() {295. while (true) {// 不停的等待客户端的链接296. try {297. Socket socket = serverSocket.accept();298. if (clients.size() == max) {// 如果已达人数上限299. BufferedReader r = new BufferedRea der(300. new InputStreamReader(sock et.getInputStream()));301. PrintWriter w = new PrintWriter(so cket302. .getOutputStream()); 303. // 接收客户端的基本用户信息304. String inf = r.readLine();305. StringTokenizer st = new StringTok enizer(inf, "@");306. User user = new User(st.nextToken( ), st.nextToken());307. // 反馈连接成功信息308. w.println("MAX@服务器：对不起，" + user.getName()309. + user.getIp() + "，服务器在线人数已达上限，请稍后尝试连接！");310. w.flush();311. // 释放资源312. r.close();313. w.close();314. socket.close();315. continue;316. }317. ClientThread client = new ClientThread (socket);318. client.start();// 开启对此客户端服务的线程319. clients.add(client);320. listModel.addElement(client.getUser().getName());// 更新在线列表321. contentArea.append(client.getUser().ge tName()322. + client.getUser().getIp() + "上线!\r\n");323. } catch (IOException e) {324. e.printStackTrace();325. }326. }327. }328. }329.330. // 为一个客户端服务的线程331. class ClientThread extends Thread {332. private Socket socket;333. private BufferedReader reader;334. private PrintWriter writer;335. private User user;336.337. public BufferedReader getReader() {338. return reader;339. }340.341. public PrintWriter getWriter() {342. return writer;343. }344.345. public User getUser() {346. return user;347. }348.349. // 客户端线程的构造方法350. public ClientThread(Socket socket) {351. try {352.this.socket = socket;353.reader = new BufferedReader(new InputStrea mReader(socket354. .getInputStream()));355.writer = new PrintWriter(socket.getOutputS tream());356. // 接收客户端的基本用户信息357. String inf = reader.readLine();358. StringTokenizer st = new StringTokenizer(i nf, "@");er = new User(st.nextToken(), st.nextTok en());360. // 反馈连接成功信息361. writer.println(user.getName() + user.getIp () + "与服务器连接成功!");362. writer.flush();363. // 反馈当前在线用户信息364. if (clients.size() > 0) {365. String temp = "";366. for (int i = clients.size() - 1; i >= 0; i--) {367. temp += (clients.get(i).getUser().getName() + "/" + clients368. .get(i).getUser().getIp())369. + "@";370. }371. writer.println("USERLIST@" + clients.s ize() + "@" + temp);372. writer.flush();373. }374. // 向所有在线用户发送该用户上线命令375. for (int i = clients.size() - 1; i >= 0; i --) {376. clients.get(i).getWriter().println( 377. "ADD@" + user.getName() + user .getIp());378. clients.get(i).getWriter().flush(); 379. }380. } catch (IOException e) {381. e.printStackTrace();382. }383. }384.385. @SuppressWarnings("deprecation")386. public void run() {// 不断接收客户端的消息，进行处理。
JavaSocket+多线程实现多人聊天室功能
JavaSocket+多线程实现多⼈聊天室功能本⽂实例为⼤家分享了Java Socket+多线程实现多⼈聊天室的具体代码，供⼤家参考，具体内容如下思路简介分为客户端和服务器两个类，所有的客户端将聊的内容发送给服务器，服务器接受后，将每⼀条内容发送给每⼀个客户端，客户端再显⽰在终端上。
客户端设计客户端包含2个线程，1个⽤来接受服务器的信息，再显⽰，1个⽤来接收键盘的输⼊，发送给服务器。
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import .Socket;import java.nio.charset.StandardCharsets;import java.util.Scanner;public class WeChatClient { //WeChat的客户端类private Socket client;private String name;private InputStream in;private OutputStream out;private MassageSenter massageSenter;private MassageGeter massageGeter;class MassageGeter extends Thread{ //⼀个⼦线程类，⽤于客户端接收消息MassageGeter() throws IOException{in = client.getInputStream();}@Overridepublic void run() {int len;byte[] bytes = new byte[1024];try {while ((len = in.read(bytes)) != -1) { //此函数是阻塞的System.out.println(new String(bytes,0,len, StandardCharsets.UTF_8));}}catch (IOException e){System.out.println(e.toString());}System.out.println("Connection interruption");}}class MassageSenter extends Thread{ //⼀个⼦线程类，⽤于发送消息给服务器MassageSenter() throws IOException{out = client.getOutputStream();}@Overridepublic void run() {Scanner scanner = new Scanner(System.in);try {while (scanner.hasNextLine()) { //此函数为阻塞的函数String massage = scanner.nextLine();out.write((name + " : " + massage).getBytes(StandardCharsets.UTF_8));if(massage.equals("//exit"))break;}}catch (IOException e){e.printStackTrace();}}}WeChatClient(String name, String host, int port) throws IOException {//初始化，实例化发送和接收2个线程 = name;client = new Socket(host,port);massageGeter = new MassageGeter();massageSenter = new MassageSenter();}void login() throws IOException{//登录时，先发送名字给服务器，在接收到服务器的正确回应之后，启动线程out.write(name.getBytes(StandardCharsets.UTF_8));byte[] bytes = new byte[1024];int len;len = in.read(bytes);String answer = new String(bytes,0,len, StandardCharsets.UTF_8);if(answer.equals("logined!")) {System.out.println("Welcome to WeChat! "+name);massageSenter.start();massageGeter.start();try {massageSenter.join();//join()的作⽤是等线程结束之后再继续执⾏主线程(main)massageGeter.join();}catch (InterruptedException e){System.err.println(e.toString());}}else{System.out.println("Server Wrong");}client.close();}public static void main(String[] args) throws IOException{//程序⼊⼝String host = "127.0.0.1";WeChatClient client = new WeChatClient("Uzi",host,7777);client.login();}}服务器设计服务器包含3个线程类，端⼝监听线程，客户端接收信息线程，发送信息线程。
使用Java和WebSocket实现网页聊天室实例代码
使⽤Java和WebSocket实现⽹页聊天室实例代码在没介绍正⽂之前，先给⼤家介绍下websocket的背景和原理：背景在浏览器中通过http仅能实现单向的通信,comet可以⼀定程度上模拟双向通信,但效率较低,并需要服务器有较好的⽀持; flash中的socket 和xmlsocket可以实现真正的双向通信,通过 flex ajax bridge,可以在javascript中使⽤这两项功能. 可以预见,如果websocket⼀旦在浏览器中得到实现,将会替代上⾯两项技术,得到⼴泛的使⽤.⾯对这种状况，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽并达到实时通讯。
在JavaEE7中也实现了WebSocket协议。
原理WebSocket protocol 。
现很多⽹站为了实现即时通讯，所⽤的技术都是轮询(polling)。
轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP request，然后由服务器返回最新的数据给客户端的浏览器。
这种传统的HTTP request 的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求，然⽽HTTP request 的header是⾮常长的，⾥⾯包含的有⽤数据可能只是⼀个很⼩的值，这样会占⽤很多的带宽。
⽽⽐较新的技术去做轮询的效果是Comet – ⽤了AJAX。
但这种技术虽然可达到全双⼯通信，但依然需要发出请求。
在 WebSocket API，浏览器和服务器只需要做⼀个握⼿的动作，然后，浏览器和服务器之间就形成了⼀条快速通道。
两者之间就直接可以数据互相传送。
在此WebSocket 协议中，为我们实现即时服务带来了两⼤好处：1. Header互相沟通的Header是很⼩的-⼤概只有 2 Bytes2. Server Push服务器的推送，服务器不再被动的接收到浏览器的request之后才返回数据，⽽是在有新数据时就主动推送给浏览器。
JavaWebSocket实现网络聊天室（群聊+私聊）
JavaWebSocket实现⽹络聊天室（群聊+私聊）1、简单说明谢谢博主的⽂章和项⽬，我是抱着学习的态度，若有理解错的地⽅，请指正。
2、项⽬内容项⽬的功能说明去原博主博客看吧，项⽬上改进的地⽅，我具体做以下说明。
（1）webSocket服务对于webSocket服务代码，我进⾏⼀部分的封装和优化，主要是消息内容的封装、⽤户信息封装。
页⾯显⽰⽤户的昵称，指定⽤户昵称进⾏消息发送。
ChatServer.javapackage q.webSocket;import er;import monDate;import net.sf.json.JSONObject;import org.apache.log4j.Logger;import javax.servlet.http.HttpSession;import javax.websocket.*;import javax.websocket.server.PathParam;import javax.websocket.server.ServerEndpoint;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/*** @author ccq* @Description webSocket服务* @date 2017/12/16 17:31*/@ServerEndpoint(value="/chatServer/{userid}", configurator = HttpSessionConfigurator.class)public class ChatServer {private static Logger logger = Logger.getLogger(ChatServer.class);private static int onlineCount = 0; // 记录连接数⽬// Map<⽤户id，⽤户信息>private static Map<String, OnlineUser> onlineUserMap = new ConcurrentHashMap<String, OnlineUser>(); //在线⽤户/*** 连接成功调⽤的⽅法*/@OnOpenpublic void onOpen(@PathParam("userid") String userid , Session session, EndpointConfig config){("[ChatServer] connection : userid = " + userid + " , sessionId = " + session.getId());// 增加⽤户数量addOnlineCount();// 获取当前⽤户的sessionHttpSession httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());User user = (User) httpSession.getAttribute("user"); // 获得当前⽤户信息// 将当前⽤户存到在线⽤户列表中OnlineUser onlineUser = new OnlineUser(user.getUserid(),user.getNickname(),session);onlineUserMap.put(user.getUserid(),onlineUser);// 通知所有在线⽤户，当前⽤户上线String content = "[" + CommonDate.getTime24() + " : " + user.getNickname() + "加⼊聊天室，当前在线⼈数为 " + getOnlineCount() + "位" + "]";JSONObject msg = new JSONObject();msg.put("content",content);String message = Message.getMessage(msg.toString(),Message.NOTICE,onlineUserMap.values());Message.broadcast(message,onlineUserMap.values());}/*** 连接关闭⽅法*/@OnClosepublic void onClose(@PathParam("userid") String userid,Session session,CloseReason closeReason){("[ChatServer] close : userid = " + userid + " , sessionId = " + session.getId() +" , closeCode = " + closeReason.getCloseCode().getCode() + " , closeReason = " +closeReason.getReasonPhrase());// 减少当前⽤户subOnlienCount();// 移除的⽤户信息OnlineUser removeUser = onlineUserMap.remove(userid);onlineUserMap.remove(userid);// 通知所有在线⽤户，当前⽤户下线String content = "["+ CommonDate.getTime24() + " : " + removeUser.getNickname() + " 离开聊天室，当前在线⼈数为 " + getOnlineCount() + "位" + "]";JSONObject msg = new JSONObject();msg.put("content",content);if(onlineUserMap.size() > 0){String message = Message.getMessage(msg.toString(), Message.NOTICE, onlineUserMap.values());Message.broadcast(message,onlineUserMap.values());}else{("content : ["+ CommonDate.getTime24() + " : " + removeUser.getNickname() + " 离开聊天室，当前在线⼈数为 " + getOnlineCount() + "位" + "]"); }}/*** 接收客户端的message，判断是否有接收⼈⽽选择进⾏⼴播还是指定发送* @param data 客户端发来的消息*/@OnMessagepublic void onMessage(@PathParam("userid") String userid,String data){("[ChatServer] onMessage : userid = " + userid + " , data = " + data);JSONObject messageJson = JSONObject.fromObject(data);JSONObject message = messageJson.optJSONObject("message");String to = message.optString("to");String from = message.optString("from");// 将⽤户id转换为名称to = erIdCastNickName(to);OnlineUser fromUser = onlineUserMap.get(from);String sendMessage = Message.getContent(fromUser,to,message.optString("content"),message.optString("time"));String returnData = Message.getMessage(sendMessage, messageJson.optString("type"),null);if(to == null || to.equals("")){ // 进⾏⼴播Message.broadcast(returnData.toString(),onlineUserMap.values());}else{Message.singleSend(returnData.toString(), onlineUserMap.get(from)); // 发送给⾃⼰String[] useridList = message.optString("to").split(",");for(String id : useridList){if(!id.equals(from)){Message.singleSend(returnData.toString(), onlineUserMap.get(id)); // 分别发送给指定的⽤户}}}}/*** 发⽣错误* @param throwable*/@OnErrorpublic void onError(@PathParam("userid") String userid,Session session,Throwable throwable){("[ChatServer] close : userid = " + userid + " , sessionId = " + session.getId() +" , throwable = " + throwable.getMessage() );}public static int getOnlineCount() {return onlineCount;}public synchronized void addOnlineCount(){onlineCount++;}public synchronized void subOnlienCount(){onlineCount--;}/*** 将⽤户id转换为名称* @param userIds* @return*/private String userIdCastNickName(String userIds){String niceNames = "";if(userIds != null && !userIds.equals("")){String[] useridList = userIds.split(",");String toName = "";for (String id : useridList){toName = toName + onlineUserMap.get(id).getNickname() + ",";}niceNames = toName.substring(0,toName.length() - 1);}return niceNames;}}OnlineUser.javapublic class OnlineUser {private String userid;private String nickname;private Session session;} Message.javapackage q.webSocket;import net.sf.json.JSONArray;import net.sf.json.JSONObject;import mons.collections.CollectionUtils;import org.apache.log4j.Logger;import javax.websocket.Session;import java.io.IOException;import java.util.ArrayList;import java.util.Collection;import java.util.List;/*** @author ccq* @Description 消息类* @date 2017/12/16 19:08*/public class Message {private static Logger logger = Logger.getLogger(Message.class);/*** 消息类型*/public static String NOTICE = "notice"; //通知public static String MESSAGE = "message"; //消息/*** 组装信息返回给前台* @param message 交互信息* @param type 信息类型* @param userList 在线列表* @return** "massage" : {* "from" : "xxx",* "to" : "xxx",* "content" : "xxx",* "time" : "xxxx.xx.xx"* },* "type" : {notice|message},* "list" : {[xx],[xx],[xx]}*/public static String getMessage(String message,String type,Collection<OnlineUser> userList){JSONObject msg = new JSONObject();msg.put("message",message);msg.put("type", type);if(CollectionUtils.isNotEmpty(userList)){List<String> propertys = new ArrayList<String>();propertys.add("session");JSONArray userListArray = JSONArray.fromObject(userList,JsonConfigUtils.getJsonConfig(propertys)); msg.put("list", userListArray);}return msg.toString();}/*** 消息内容* @param fromUser* @param to* @param content* @param time* @return* {* "from" : "xxx",* "to" : "xxx",* "content" : "xxx",* "time" : "xxxx.xx.xx"* }*/public static String getContent(OnlineUser fromUser,String to,String content,String time){JSONObject contentJson = new JSONObject();// 转化为json串时去掉session，⽤户session不能被序列化List<String> propertys = new ArrayList<String>();propertys.add("session");contentJson.put("from",JSONObject.fromObject(fromUser,JsonConfigUtils.getJsonConfig(propertys)));contentJson.put("to",to);contentJson.put("content",content);contentJson.put("time",time);return contentJson.toString();}/*** ⼴播消息* @param message 消息* @param onlineUsers 在线⽤户*/public static void broadcast(String message,Collection<OnlineUser> onlineUsers){/***************************在线⽤户***************************/StringBuffer userStr = new StringBuffer();for(OnlineUser user : onlineUsers){userStr.append(user.getNickname() + ",");}userStr.deleteCharAt(userStr.length()-1);("[broadcast] message = " + message + ", onlineUsers = " + userStr.toString());/***************************在线⽤户***************************/for(OnlineUser user : onlineUsers){try {user.getSession().getBasicRemote().sendText(message);} catch (IOException e) {e.printStackTrace();("消息发送失败！" + e.getMessage());continue;}}}/*** 对特定⽤户发送消息* @param message* @param onlineUser*/public static void singleSend(String message, OnlineUser onlineUser){("[singleSend] message = " + message + ", toUser = " + onlineUser.getNickname());try {onlineUser.getSession().getBasicRemote().sendText(message);} catch (IOException e) {e.printStackTrace();("消息发送失败！" + e.getMessage());}}}(2)⽤户头像上传确实⽐较好⽤，贴⼀下主要代码@RequestMapping(value = "{userid}/upload", method = RequestMethod.POST,produces = "application/json; charset=utf-8")@ResponseBodypublic String updateUserPassword(@PathVariable("userid") String userid,String image,HttpServletRequest request){JSONObject responseJson = new JSONObject();String filePath = "I:\\IDEA2017-02\\img\\";String PicName= UUID.randomUUID().toString()+".png";String header ="data:image";String[] imageArr=image.split(",");if(imageArr[0].contains(header)) {//是img的// 去掉头部image=imageArr[1];// 修改图⽚BASE64Decoder decoder = new BASE64Decoder();try {byte[] decodedBytes = decoder.decodeBuffer(image); // 将字符串格式的image转为⼆进制流（biye[])的decodedBytesString imgFilePath = filePath + PicName; //指定图⽚要存放的位File targetFile = new File(filePath);if(!targetFile.exists()){targetFile.mkdirs();}FileOutputStream out = new FileOutputStream(imgFilePath);//新建⼀个⽂件输出器，并为它指定输出位置imgFilePathout.write(decodedBytes); //利⽤⽂件输出器将⼆进制格式decodedBytes输出out.close();// 修改图⽚User user = userService.getUserById(userid);user.setProfilehead(PicName);int flag = userService.updateUser(user);if(flag > 0){Log log = LogUtil.setLog(userid, CommonDate.getTime24(), WordDefined.LOG_TYPE_UPDATE,WordDefined.LOG_DETAIL_UPDATE_PROFILEHEAD, NetUtil.getIpAddress(request)); logService.insertLog(log);}else{responseJson.put("result","error");responseJson.put("msg","上传失败！");}} catch (IOException e) {e.printStackTrace();}}responseJson.put("result","ok");responseJson.put("msg","上传成功！");responseJson.put("fileUrl","/pic/" + PicName);return responseJson.toString();}3、改进的图⽚4、源码地址（2017-12-17晚更新）由于⼩弟刚学会使⽤github，所以现在才把修改的代码地址放出来。
(完整word版)基于Java_Socket通信程序设计
摘要随着时代的发展，人们互相交流的方式也在逐渐变化，从原来的面对面，到电话、手机，然后到短信、E-mail，再到现在的QQ、微信，聊天变得越来越具有实时性和有效性。
但是现在聊天软件都必须连接到Internet后才能够让人们相互交流。
如果用户在工作时候连接网络，有可能因为网络的关系使得工作效率变低；也有可能因为网络的关系，让公司内部的资料被泄露出去，使公司收到损失。
因此进行一个在局域网下的聊天工具的设计是很有必要的。
本文介绍了在局域网内实现相互收发消息的基本流程，并且编写了一个基于Socket的聊天窗口。
这个简单的软件采用的是C/S结构模式，即客户端/服务器模式。
这个软件可以让客户端和客户端能够进行通信，服务器端也能够对客户端进行发消息，还能够进行监听客户端的所有消息。
不足之处是只能够启动一个服务器，所有的客户端只能够通过一个端口连接服务器进行通信。
如果让客户端不看到不属于这个端口的其它客户发的消息，必须重新定义Server 端，更改端口。
本文用到了Sock编程、多线程、TCP/IP协议还有图形界面设计的控件编程的知识。
通过对程序进行测试，发现程序能够在同一个局域网下实现多人通信。
我们也许通过路由器分配的IP，也可以利用现在流行的“免费WiFi”，让所有人连接WiFi，这样，也会给每个客户端分配IP地址，这样也就有了局域网，它并不需要外网的帮助。
关键词：局域网；Socket；多线程；TCP/IPAbstractWith the development of the times, the communication mode of people is changed gradually. Yesterday, we communicated with each other face to face, then we tell something to others using telephone, cellphone, and then using message, e-mail. Now we tell something to each other with QQ, MSN and wechat. Communication becomes more and more real-time and ephemeral. But the software we used should depend on the Internet. If not, they are nothing. If we connect the Internent during working, we may not devote ourself into our jobs. And also, the important information may be leaked to let the company lost money. So it is important to design a software about chating in the LAN but not on the Internet.This paper intruduce that people send messages to each other in the local area network. And Programming the chat window based on the Socket. This simple application use the C/S model. The C/S model is Client/Server model. This application can let the different client sends or receives messages. Server can send message to every client and it can get all messages of every client sends. There is a weak pointthat people can just start one server. All clients should use the port the server given. If we want to divide people, we should change the port and copy another “Server”code to start new server, then some people use this server and others use another server. This paper uses the knowledges about the Socket programming, multithreading, TCP/IP protocol and the control programming about the GUI.When tested, the application can let multi clients send or receive messages. We may use the IP that the router gives us, we can also use the “Free-WiFi” that is popular now to let everyone connect the WiFi, then everybody has one IP. People have a local area network and it does not need the Internet.Key words: Local Area Network; Socket; Multithreading; TCP/IP目录引言 (1)1 实现原理 (2)1.1 C/S结构 (3)1.2 TCP/IP协议 (5)1.3 套接字 (6)1.4 多线程 (8)1.5 Socket的同步和异步方式 (10)1.6 用Socket开发的C/S模型 (11)2 总体设计 (12)2.1 程序实现原理 (12)2.2 C/S架构设计 (13)2.3 数据流图 (14)3 模块设计 (15)3.1 系统的总体流程图 (15)3.3 上传文件 (17)3.4 下载文件 (19)3.5 服务器和客户端图形界面的的详细设计 (22)3.6 服务器等待连接的详细设计 (26)3.7 监听端的详细设计 (27)3.8 客户端发送消息内容以及连接服务器程序 (27)3.6 获得客户端ip (28)4 系统测试 (29)4.1 聊天程序测试 (30)4.2 上传与下载程序测试 (33)致谢 (35)参考文献 (36)附录A (38)附录B (58)引言近年来，随着科技的不断进步，网络也在快速向前发展着。
(完整word版)JAVA聊天室
基于JAVA的聊天室设计与实现一、设计目的：信息技术的高速发展给人类生产，生活带来了广泛而深远的影响。
“上网冲浪”、“数码相机”“PDA”、“彩屏手机”、“蓝牙技术”等新产品，新概念层出不穷，不断冲击着人们的视听。
这些高科技成果为人们带来便捷、快乐的同时，也促进了人机交互技术的发展。
人机交互是关于设计、评价和实现供人们使用的交互式计算机系统，并围绕相关的主要现象进行研究的科学。
它主要研究人与计算机之间的信息交换，涉及计算机科学，心理学，认知科学等诸多学科，是信息技术的一个重要组成部分，并将继续对信息技术的发展产生巨大影响。
聊天室是一项应用广泛，并且实用性强的一个非常典型的人机交互系统。
在信息世界里，聊天工具的使用是非常频繁的，如MSN、QQ、校内通，之类的聊天工具许多人都正在使用。
此次设计的聊天室系统虽然其功能简单，但是在开发技术和过程中，能够充分学习和使用JAVA的技术，进一步培养学生面向对象程序设计的思想，加深对面向对象程序设计四大特性的理解。
二、需求分析人们日常生活中越来越多地使用聊天室这项应用来为自己的工作和学习服务。
一个操作简单，界面友好、运行稳定的聊天室对于小型局域网的用户可以起到很好的交流作用。
所谓聊天室就是一个可以让许多用户同时互相通信的网上园地，个人用户可以通过聊天室将自己融入整个主流社会中。
根据目前使用聊天室的用户需求显示，用户对于聊天室主要有以下几点要求：（1）、聊天功能：可以实时接收和发送信息，并能支持公聊和私聊的的方式，能够查看聊天记录，聊天过程中能对字体、表情等进行设定等。
（2）、用户功能：可以随时注册和登录及注销，并能选择性加好友和删除好友以及查看对方的开放信息，还能看到对方的登录状态。
（3）、文件传输功能：用户可以共享资源，能发送及接收文件。
（4）、保密功能：用户可以设定自己的保密状态，使某些信息对于其他用户是不可见的。
（5）、系统稳定：客户端与服务端的连接稳定，不出现或者少出现连接不上的情况。
使用Socket、Java开发一个CS架构的多人聊天室
Flash 客户端发来的字符串，通过输出流（OutputStream）向 Flash 客户端写字符串： while (true) { // readLine() 方法也是阻塞式的，当客户端有消息发来就读取，否 则就一直等待 String msg = reader.readLine(); // 当客户端发送的字符串为 null 时，说明客户端已经关闭，此时退 出循环 if (msg == null) { System.out.println("客户端已离开"); break; } // 将读入的信息加工后再写回客户端 writer.writeUTF("写回客户端的" + msg); } 以上是ServerSocket 与 AS 3 Socket 通信的基本原理。在实际应 用中，会有多个客户端连接这个ServerSocket，因此要创建一个多线 程的 Socket 服务器。 下面简述一下多线程 Socket 服务器原理：当 socketServer.accept() 之后就需要实例化一个线程对象，在该对象 中持有 socketServer.accept() 返回的 Socket 对象，然后让线程 跑起来执行读写操作。如果再来一个客户端就再跑一个线程，同样执行 读写操作。同时，用一个 List 容器来管理这些对象。 最终服务器端的代码如下： import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import .ServerSocket; import .Socket; import java.util.ArrayList; import java.util.Iterator; import java.util.List;
(完整word版)JAVA聊天室实验报告
Java聊天室实验报告班级: **＊*＊*学号: ＊＊＊＊＊＊＊＊姓名：***目录：一、实验目的.。
.。
...。
.。
..。
..。
....。
..。
...。
...。
...。
..。
.。
.。
3二、所需技术 .。
.。
..。
.。
..。
..。
..。
.。
.。
.。
....。
.....。
.。
.。
.。
...。
3三、需求分析。
..。
.。
.。
..。
...。
.。
..。
.。
...。
..。
.。
.。
..。
3四、系统设计 .。
..。
.......。
...。
.。
....。
...。
.。
...。
....。
..。
.....。
.41、服务器结构 ..。
.。
..。
...。
.。
.。
.。
.。
...。
.....。
.。
.。
.。
42、客户端结构 ..。
.。
.....。
..。
...。
.。
..。
.。
.。
...。
.。
..。
.。
.。
4五、实现细节。
..。
...。
..。
...。
.....。
..。
..。
.。
....。
..。
..51、客户端细节。
.。
..。
.。
...。
..。
.。
..。
...。
..。
..。
.。
52、服务器细节 .。
.。
.。
....。
.。
.。
..。
.。
.。
..。
..。
..。
..。
.。
.。
..6六、系统展示。
...。
.。
.。
.。
.。
.。
.。
.。
.。
..。
..。
..。
..。
..。
.。
(7)七、实验小结。
.。
....。
..。
....。
.。
.。
...。
..。
...。
.。
.。
.。
..。
. (9)Rain153 WeChat 聊天室系统一、实验目的：1、使用Java技术完成聊天室系统，深入学习使用Java语言。
2、使用Java 的多线程机制，深入理解Java多线程技术的应用。
3、使用GUI,对JFrame的深入学习。
4、使用网络编程，掌握基于TCP协议的Socket编程，了解Socket编程的协议约定,掌握简单应用协议的开发.5、使用C/S架构,对网络编程有一定的了解。
二、所需技术本系统要求使用java技术开发。
所需知识包括java程序设计语言、swing基本GUI组件、多线程编程、socket编程、集成开发环境使用eclipse。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
北京邮电大学软件学院2010-2011 学年第 1学期实训项目文档（每个项目小组一份）课程名称：全日制研究生实训项目名称：通信软件实训项目完成人：姓名：学号：姓名：学号：姓名：学号：姓名：学号：姓名：学号：姓名：学号：指导教师：日期：2011年1月21日基于java socket的聊天室实现一 . 实训项目目的和要求（说明通过本项目希望达到的目的和要求）目的：熟练掌握socket编程原理，并用java socket实现聊天室要求：实现p2p和聊天室功能二 . 实训项目开发环境（说明本项目需要的环境）开发工具：Eclipse SDK Version: 3.5.2 和NetBeans 6.9.1 版本系统：win7三 . 实训项目内容（说明本项目的内容，如：问题分析、设计方案、算法、设计图等）1.问题分析网络编程中两个主要的问题一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。
在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。
而TCP层则提供面向应用的可靠（tcp）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。
目前较为流行的网络编程模型是客户机/服务器（C/S）结构。
即通信双方一方作为服务器等待客户提出请求并予以响应。
客户则在需要服务时向服务器提出申请。
服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也能及时得到服务。
两类传输协议：TCP；UDP。
TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。
通过TCP协议传输，得到的是一个顺序的无差错的数据流。
发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。
两类传输协议：TCP；UDP。
TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。
通过TCP协议传输，得到的是一个顺序的无差错的数据流。
发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。
UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。
比较：UDP：1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。
2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。
3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方TCP：1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接时间。
2，TCP传输数据大小限制，一旦连接建立起来，双方的socket 就可以按统一的格式传输大的数据。
3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。
应用：1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。
但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。
2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。
例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。
2.设计方案基于Socket的java网络编程。
网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。
Socket通常用来实现客户方和服务方的连接。
Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。
但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。
在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。
Socket通讯的过程。
Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client 端发回Accept（接受）消息。
一个连接就建立起来了。
Server端和Client 端都可以通过send，recv等方法与对方通信。
3.设计图图1：聊天室用例图用例说明文本：1、用户登录用例：客户端运行，用户可以用用户名和端口号登陆到服务器。
2、服务器注册用例：服务器根据用户输入的用户名和端口号和sip地址记录用户信息并把信息广播给所有的在线用户。
3、客户端发送消息用例：客户端县服务器带有关键字（群聊/私聊/登录/退出）的消息到服务器。
4、服务器转发消息用例：服务器解析收到的消息，提取目的端sip地址，并把消息转发到目的端。
5、客户端退出用例：客户端向服务器发送log on消息。
服务器把该客户信息从用户列表中删除，并更新在线列表。
图2聊天室领域模型图3登录顺序图图4聊天顺序图四 . 实训项目结果及分析项目分析：客户端实现：以服务方主机地址和端口号为参数调用 Socket 类的构造函数去创建一个 Socket 对象. 创建过程包含了向服务方请求建立通讯连接。
使用Socket 对象的 getInputStream() 和 getOutputStream() 方法创建用于网络传输的输入/输出流。
使用所得的网络流对象读写数据,网络流对象将读写转换成对 Socket 数据的接收和发送。
工作完毕, 关闭网络流对象服务器实现：以某端口号为参数调用 ServerSocket 类的构造函数去创建一个 ServerSocket 对象，作为服务器的Socket。
调用被创建的ServerSocket 对象的 accept() 方法在指定端口监听客户方的连接请求。
收到客户请求后,accept() 方法返回一个新建的 Socket 对象, 该对象代表和客户方建立起来的通讯连接在服务方的通讯端点。
使用 Socket 对象的getInputStream() 和 getOutputStream() 方法创建用于网络传输的输入/输出流。
使用所得的网络流对象读写数据,网络流对象将读写转换成对Socket 的数据的接收和发送。
工作完毕, 关闭网络流对象项目实现：五 . 实训项目人员、进度安排及完成过程小组一共六个人，在这一星期的实训中，每个人都认真学习了java socket的内容，并在此基础上进一步完成聊天室功能实现。
由于基础不同，我小组分工及人员完成情况如下：小组组长：在这个项目里主要负责协调各个组员之间的协作，进行项目分工，画用例模型，总结整理组员的工作。
技术经理：主要负责java socket的研究并回答小组其他成员的疑问，在聊天室的设计过程中，对一些功能实现提出了建设性的意见。
技术人员：主要负责几个聊天室程序的分析与设计，设计文档的撰写，聊天室程序编写的大部分工作。
测试人员：负责聊天室程序的测试工作，需求文档的撰写，负责文档的整理，资料的搜集以及小组PPT的制作。
六 . 实训项目心得及体会心得体会：理解了socket工作流程和实现方法，熟练掌握socket编程，实现了简单的聊天室功能，对多线程有了更进一步的理解。
通过老师对SIP协议的讲解，使我对SIP协议有了一个初步的认识，使我明白了SIP(Session Initiation Protocol)是一个应用层的信令控制协议。
用于创建、修改和释放一个或多个参与者的会话。
这些会话可以好似Internet多媒体会议、IP电话或多媒体分发。
会话的参与者可以通过组播（multicast）、网状单播（unicast）或两者的混合体进行通信。
在学习网络传输的过程中，对两种网络传输协议有了更进一步的理解和深刻的体会。
七 . 附录（附上实训项目其他文档，具体内容根据项目要求确定）1. 需求分析文档错误！未找到索引项。
2. 设计文档3. 项目PPT4. 源程序Linux操作系统下基于c语言的 socket聊天室实现一 . 实训项目目的和要求（说明通过本项目希望达到的目的和要求）基于Linux系统下的socket编程——P2P聊天系统1.掌握Linux环境下socket编程的基本过程；2.熟练掌握C语言编程方法；3.了解GCC编译器的编译过程，并能在Linux系统下熟练使用。
二 . 实训项目开发环境（说明本项目需要的环境）系统环境：Linux系统编译环境：GCC编译器三 . 实训项目内容（说明本项目的内容，如：问题分析、设计方案、算法、设计图等）问题分析：如何通过socket实现Linux环境下的点对点通信。
设计方案：1.目的：在Linux系统中实现点对点通信2.要求：使用socket、C语言编程3.步骤：（1）根据socket通信机制，编写C源程序；（2）对源程序进行反复测试、修改；（3）实现点对点通信功能。
设计图：四 . 实训项目结果及分析P2P网络聊天系统的测试结果如下：结果分析：该测试是在一台计算机上进行的，若要实现两台计算机间的点对点通信，只需修改相应的IP地址和端口号即可。
如图所示，该系统实现了P2P通信，即通信双方之间可以相互发送和接收消息，达到了预期目的，满足了用户需求。
五 . 实训项目人员、进度安排及完成过程小组一共六个人，在这一星期的实训中，每个人都认真学习了linux操作系统环境下的C socket的内容，及GCC的编译环境，并在此基础上进一步完成聊天室功能实现。
具体的分工如下：负责UDP通讯协议下聊天室的程序编写。
负责TCP通讯写一下的聊天室的程序编写。
同学，主要负责编写需求分析，绘制领域模型等工作。
六 . 实训项目心得及体会Linux环境对于我们都是一个陌生的环境，通过这个项目的联系，收获的不仅是C Socket的通信编程。