Java中Socket实现消息传输（传输原型）

为什么80%的码农都做不了架构师？>>>   

项目已经做的差不多了，其中做了一个消息的转发功能，所以自己也写一个简单的例子看看

 

先一步步的来吧，先写好一个Socket的消息传输的原型来，再一步步的改进吧。

 

其实在这个基础上要中的东西还是很多的

1.客户端的登陆

2.客户端与服务端的断连后重连

3.消息的编解码

4.将传输改成由接收，发送，处理队列与接收，发送，处理线程来做

5.队列的超时机制

6.多线程安全

7.服务端收到消息可以进行群发或是转发

.....

 

问题还是很多，先放个简单的东西来做吧

 

Server原型

   服务端主要是为了接收客户端发来的消息并把这个消息群发到每一个客户端去。所以设置了一个List以存入Socket

   这里主要做的是在start()方法中开一个线程，让服务端通过这个线程进行进行监听客户端发来的消息并拿到这个Socket对像，其实这东西本不需要开一个线程去做，但是为了不在ss.accept()的时候让整个调用这个方法的主线程在那里等待，所以开了个线程去做，一但接到客户端的消息就把接收线程拉起

Java代码   

1. package demo;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.ServerSocket;  
9. import java.net.Socket;  
10. import java.util.LinkedList;  
11. import java.util.List;  
12.   
13. public class Server {  
14.     private ServerSocket ss = null;  
15.   
16.     private List<Socket> list = new LinkedList<Socket>();  
17.   
18.     private class ReceiveThread extends Thread {  
19.         private Socket socket = null;  
20.   
21.         public ReceiveThread(Socket socket) {  
22.             super("ReceiveThread");  
23.             this.socket = socket;  
24.         }  
25.   
26.         @Override  
27.         public void run() {  
28.             InputStream in = null;  
29.             DataInputStream dis = null;  
30.             while (true) {  
31.                 try {  
32.                     sleep(50);  
33.                 } catch (InterruptedException e1) {  
34.                     e1.printStackTrace();  
35.                 }  
36.   
37.                 if (socket == null || socket.isClosed()  
38.                         || !socket.isConnected()) {  
39.                     continue;  
40.                 }  
41.                 try {  
42.                     in = socket.getInputStream();  
43.                     dis = new DataInputStream(in);  
44.                     String readUTF = dis.readUTF();  
45.                     System.out.println("receive client message :" + socket  
46.                             + " " + readUTF);  
47.                     send(readUTF);  
48.                 } catch (IOException e) {  
49.                     try {  
50.                         in.close();  
51.                         dis.close();  
52.                     } catch (IOException e1) {  
53.                         e1.printStackTrace();  
54.                     }  
55.                     list.remove(socket);  
56.                     e.printStackTrace();  
57.                 }  
58.             }  
59.   
60.         }  
61.     }  
62.   
63.     public void send(String msg) throws IOException {  
64.         for (int i = ; i < list.size(); i++) {  
65.             Socket groupSocket = list.get(i);  
66.             OutputStream out = groupSocket.getOutputStream();  
67.             DataOutputStream dout = new DataOutputStream(out);  
68.             dout.writeUTF(msg);  
69.             dout.flush();  
70.             out.flush();  
71.         }  
72.     }  
73.   
74.     public class AcceptSocketThread extends Thread {  
75.         public AcceptSocketThread() {  
76.             super("AcceptSocketThread");  
77.         }  
78.   
79.         public void run() {  
80.             try {  
81.                 ss = new ServerSocket(7788);  
82.   
83.                 while (true) {  
84.                     Socket socket = ss.accept();  
85.                     list.add(socket);  
86.                     new ReceiveThread(socket).start();  
87.                 }  
88.             } catch (IOException e) {  
89.                 e.printStackTrace();  
90.             }  
91.   
92.         }  
93.     }  
94.   
95.     private void start() throws IOException {  
96.         new AcceptSocketThread().start();  
97.     }  
98.   
99.     public static void main(String[] args) throws Exception {  
100.         System.out.println("Server start ....");  
101.         new Server().start();  
102.     }  
103.   
104. }  

 

 

2.客户端Client

    这个就比较简单了，只是为了发送消息和接收消息

Java代码   

1. package demo;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.InetAddress;  
9. import java.net.Socket;  
10. import java.util.Scanner;  
11.   
12. public class Client {  
13.     private Socket socket = null;  
14.   
15.     private class ReceiveThread extends Thread {  
16.         @Override  
17.         public void run() {  
18.             while (true) {  
19.                 try {  
20.                     InputStream in = socket.getInputStream();  
21.                     DataInputStream din = new DataInputStream(in);  
22.                     String readUTF = din.readUTF();  
23.                     System.out.println("Server Send Message: " + readUTF);  
24.   
25.                 } catch (IOException e) {  
26.                     // TODO Auto-generated catch block  
27.                     e.printStackTrace();  
28.                 }  
29.             }  
30.         }  
31.     }  
32.   
33.     public void start() throws IOException {  
34.         socket = new Socket(InetAddress.getByName("127.0.0.1"), 7788);  
35.   
36.         new ReceiveThread().start();  
37.         System.out.println("Client start ....\nPlease input message : ");  
38.         while (true) {  
39.             Scanner scaner = new Scanner(System.in);  
40.             String next = scaner.next();  
41.             OutputStream out = socket.getOutputStream();  
42.             DataOutputStream dout = new DataOutputStream(out);  
43.             dout.writeUTF(next);  
44.             // scaner.close();  
45.             dout.flush();  
46.         }  
47.     }  
48.   
49.     public static void main(String[] args) throws IOException {  
50.         System.out.println("client ...");  
51.         Client client = new Client();  
52.         client.start();  
53.     }  
54.   
55. }  

转载于:https://my.oschina.net/kyo153/blog/41830