Go语言视频零基础入门到精通

admin

1.开篇简介
　　Socket本质上就是java封装了传输层上的TCP协议（注：UDP用的是DatagramSocket类）。要实现Socket的传输，需要构建客户端和服务器端。另外，传输的数据可以是字符串和字节。字符串传输主要用于简单的应用，比较复杂的应用(比如Java和C++进行通信)，往往需要构建自己的应用层规则(类似于应用层协议)，并用字节来传输。
2.基于字符串传输的Socket案例
　　1）服务器端代码(基于控制台的应用程序，模拟)

1. import java.io.BufferedReader;
2. import java.io.BufferedWriter;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. import java.io.OutputStreamWriter;
6. import java.io.PrintWriter;
7. import java.net.ServerSocket;
8. import java.net.Socket;
9. import java.util.ArrayList;
10. import java.util.List;
11. import java.util.concurrent.ExecutorService;
12. import java.util.concurrent.Executors;
15. public class Main {
16.     private static final int PORT = 9999;
17.     private List<Socket> mList = new ArrayList<Socket>();
18.     private ServerSocket server = null;
19.     private ExecutorService mExecutorService = null; //thread pool
20.    
21.     public static void main(String[] args) {
22.         new Main();
23.     }
24.     public Main() {
25.         try {
26.             server = new ServerSocket(PORT);
27.             mExecutorService = Executors.newCachedThreadPool();  //create a thread pool
28.             System.out.println("服务器已启动...");
29.             Socket client = null;
30.             while(true) {
31.                 client = server.accept();
32.                 //把客户端放入客户端集合中
33.                 mList.add(client);
34.                 mExecutorService.execute(new Service(client)); //start a new thread to handle the connection
35.             }
36.         }catch (Exception e) {
37.             e.printStackTrace();
38.         }
39.     }
40.     class Service implements Runnable {
41.             private Socket socket;
42.             private BufferedReader in = null;
43.             private String msg = "";
44.             
45.             public Service(Socket socket) {
46.                 this.socket = socket;
47.                 try {
48.                     in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
49.                     //客户端只要一连到服务器，便向客户端发送下面的信息。
50.                     msg = "服务器地址：" +this.socket.getInetAddress() + "come toal:"
51.                         +mList.size()+"（服务器发送）";
52.                     this.sendmsg();
53.                 } catch (IOException e) {
54.                     e.printStackTrace();
55.                 }
56.                
57.             }
59.             @Override
60.             public void run() {
61.                 try {
62.                     while(true) {
63.                         if((msg = in.readLine())!= null) {
64.                             //当客户端发送的信息为：exit时，关闭连接
65.                             if(msg.equals("exit")) {
66.                                 System.out.println("ssssssss");
67.                                 mList.remove(socket);
68.                                 in.close();
69.                                 msg = "user:" + socket.getInetAddress()
70.                                     + "exit total:" + mList.size();
71.                                 socket.close();
72.                                 this.sendmsg();
73.                                 break;
74.                                 //接收客户端发过来的信息msg，然后发送给客户端。
75.                             } else {
76.                                 msg = socket.getInetAddress() + ":" + msg+"（服务器发送）";
77.                                 this.sendmsg();
78.                             }
79.                         }
80.                     }
81.                 } catch (Exception e) {
82.                     e.printStackTrace();
83.                 }
84.             }
85.           /**
86.            * 循环遍历客户端集合，给每个客户端都发送信息。
87.            */
88.            public void sendmsg() {
89.                System.out.println(msg);
90.                int num =mList.size();
91.                for (int index = 0; index < num; index ++) {
92.                    Socket mSocket = mList.get(index);
93.                    PrintWriter pout = null;
94.                    try {
95.                        pout = new PrintWriter(new BufferedWriter(
96.                                new OutputStreamWriter(mSocket.getOutputStream())),true);
97.                        pout.println(msg);
98.                    }catch (IOException e) {
99.                        e.printStackTrace();
100.                    }
101.                }
102.            }
103.         }   
104. }

复制代码

　　2）Android客户端代码

1. package com.amaker.socket;
3. import java.io.BufferedReader;
4. import java.io.BufferedWriter;
5. import java.io.IOException;
6. import java.io.InputStreamReader;
7. import java.io.OutputStreamWriter;
8. import java.io.PrintWriter;
9. import java.net.Socket;
10. import android.app.Activity;
11. import android.app.AlertDialog;
12. import android.content.DialogInterface;
13. import android.os.Bundle;
14. import android.os.Handler;
15. import android.os.Message;
16. import android.view.View;
17. import android.widget.Button;
18. import android.widget.EditText;
19. import android.widget.TextView;
21. public class SocketDemo extends Activity implements Runnable {
22.     private TextView tv_msg = null;
23.     private EditText ed_msg = null;
24.     private Button btn_send = null;
25.     // private Button btn_login = null;
26.     private static final String HOST = "10.0.2.2";
27.     private static final int PORT = 9999;
28.     private Socket socket = null;
29.     private BufferedReader in = null;
30.     private PrintWriter out = null;
31.     private String content = "";
32.     //接收线程发送过来信息，并用TextView显示
33.     public Handler mHandler = new Handler() {
34.         public void handleMessage(Message msg) {
35.             super.handleMessage(msg);
36.             tv_msg.setText(content);
37.         }
38.     };
40.     @Override
41.     public void onCreate(Bundle savedInstanceState) {
42.         super.onCreate(savedInstanceState);
43.         setContentView(R.layout.main);
45.         tv_msg = (TextView) findViewById(R.id.TextView);
46.         ed_msg = (EditText) findViewById(R.id.EditText01);
47.         btn_send = (Button) findViewById(R.id.Button02);
49.         try {
50.             socket = new Socket(HOST, PORT);
51.             in = new BufferedReader(new InputStreamReader(socket
52.                     .getInputStream()));
53.             out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
54.                     socket.getOutputStream())), true);
55.         } catch (IOException ex) {
56.             ex.printStackTrace();
57.             ShowDialog("login exception" + ex.getMessage());
58.         }
59.         btn_send.setOnClickListener(new Button.OnClickListener() {
61.             @Override
62.             public void onClick(View v) {
63.                 // TODO Auto-generated method stub
64.                 String msg = ed_msg.getText().toString();
65.                 if (socket.isConnected()) {
66.                     if (!socket.isOutputShutdown()) {
67.                         out.println(msg);
68.                     }
69.                 }
70.             }
71.         });
72.         //启动线程，接收服务器发送过来的数据
73.         new Thread(SocketDemo.this).start();
74.     }
75.     /**
76.      * 如果连接出现异常，弹出AlertDialog！
77.      */
78.     public void ShowDialog(String msg) {
79.         new AlertDialog.Builder(this).setTitle("notification").setMessage(msg)
80.                 .setPositiveButton("ok", new DialogInterface.OnClickListener() {
82.                     @Override
83.                     public void onClick(DialogInterface dialog, int which) {
85.                     }
86.                 }).show();
87.     }
88.     /**
89.      * 读取服务器发来的信息，并通过Handler发给UI线程
90.      */
91.     public void run() {
92.         try {
93.             while (true) {
94.                 if (!socket.isClosed()) {
95.                     if (socket.isConnected()) {
96.                         if (!socket.isInputShutdown()) {
97.                             if ((content = in.readLine()) != null) {
98.                                 content += "\n";
99.                                 mHandler.sendMessage(mHandler.obtainMessage());
100.                             } else {
102.                             }
103.                         }
104.                     }
105.                 }
106.             }
107.         } catch (Exception e) {
108.             e.printStackTrace();
109.         }
110.     }
112. }

复制代码

　　解析：除了isClose方法，Socket类还有一个isConnected方法来判断Socket对象是否连接成功。  看到这个名字，也许读者会产生误解。  其实isConnected方法所判断的并不是Socket对象的当前连接状态，  而是Socket对象是否曾经连接成功过，如果成功连接过，即使现在isClose返回true， isConnected仍然返回true。因此，要判断当前的Socket对象是否处于连接状态， 必须同时使用isClose和isConnected方法， 即只有当isClose返回false，isConnected返回true的时候Socket对象才处于连接状态。 虽然在大多数的时候可以直接使用Socket类或输入输出流的close方法关闭网络连接，但有时我们只希望关闭OutputStream或InputStream，而在关闭输入输出流的同时，并不关闭网络连接。这就需要用到Socket类的另外两个方法：shutdownInput和shutdownOutput，这两个方法只关闭相应的输入、输出流，而它们并没有同时关闭网络连接的功能。和isClosed、isConnected方法一样，Socket类也提供了两个方法来判断Socket对象的输入、输出流是否被关闭，这两个方法是isInputShutdown()和isOutputShutdown()。 shutdownInput和shutdownOutput并不影响Socket对象的状态。

2.基于字节的传输
  基于字节传输的时候，只需要把相应的字符串和整数等类型转换为对应的网络字节进行传输即可。具体关于如何把其转换为网络字节，请参《网路搜集：java整型数与网络字节序的 byte[] 数组转换关系》。

PS： 欢迎关注公众号"Devin说"，会不定期更新Java相关技术知识。