Android：这是一份很详细的Socket使用攻略

Android：这是一份很详细的Socket使用攻略
1.网络基础

1.1 计算机网络分层

计算机网络分为五层：物理层、数据链路层、网络层、运输层、应用层

其中：
- 网络层：负责根据IP找到目的地址的主机
- 运输层：通过端口把数据传到目的主机的目的进程，来实现进程与进程之间的通信
1.2 端口号（PORT）

端口号规定为16位，即允许一个IP主机有2的16次方65535个不同的端口。其中：
- 0~1023：分配给系统的端口号
  
  我们不可以乱用
- 1024~49151：登记端口号，主要是让第三方应用使用
  
  但是必须在IANA（互联网数字分配机构）按照规定手续登记，
- 49152~65535：短暂端口号，是留给客户进程选择暂时使用，一个进程使用完就可以供其他进程使用。
在Socket使用时，可以用1024~65535的端口号

1.3 C/S结构
- 定义：即客户端/服务器结构，是软件系统体系结构
- 作用：充分利用两端硬件环境的优势，将任务合理分配到Client端和Server端来实现，降低了系统的通讯开销。
  
  Socket正是使用这种结构建立连接的，一个套接字接客户端，一个套接字接服务器。
如图：
可以看出，Socket的使用可以基于TCP或者UDP协议。

1.4 TCP协议
- 定义：Transmission Control Protocol，即传输控制协议，是一种传输层通信协议
  
  基于TCP的应用层协议有FTP、Telnet、SMTP、HTTP、POP3与DNS。
- 特点：面向连接、面向字节流、全双工通信、可靠
  - 面向连接：指的是要使用TCP传输数据，必须先建立TCP连接，传输完成后释放连接，就像打电话一样必须先拨号建立一条连接，打完后挂机释放连接。
  - 全双工通信：即一旦建立了TCP连接，通信双方可以在任何时候都能发送数据。
  - 可靠的：指的是通过TCP连接传送的数据，无差错，不丢失，不重复，并且按序到达。
  - 面向字节流：流，指的是流入到进程或从进程流出的字符序列。简单来说，虽然有时候要传输的数据流太大，TCP报文长度有限制，不能一次传输完，要把它分为好几个数据块，但是由于可靠性保证，接收方可以按顺序接收数据块然后重新组成分块之前的数据流，所以TCP看起来就像直接互相传输字节流一样，面向字节流。
- TCP建立连接
  必须进行三次握手：若A要与B进行连接，则必须
  - 第一次握手：建立连接。客户端发送连接请求报文段，将SYN位置为1，Sequence Number为x；然后，客户端进入SYN_SEND状态，等待服务器的确认。即A发送信息给B
  - 第二次握手：服务器收到客户端的SYN报文段，需要对这个SYN报文段进行确认。即B收到连接信息后向A返回确认信息
  - 第三次握手：客户端收到服务器的（SYN+ACK）报文段，并向服务器发送ACK报文段。即A收到确认信息后再次向B返回确认连接信息
  此时，A告诉自己上层连接建立；B收到连接信息后告诉上层连接建立。
这样就完成TCP三次握手 = 一条TCP连接建立完成 = 可以开始发送数据
1. 三次握手期间任何一次未收到对面回复都要重发。
2. 最后一个确认报文段发送完毕以后，客户端和服务器端都进入ESTABLISHED状态。
为什么TCP建立连接需要三次握手？

答：防止服务器端因为接收了早已失效的连接请求报文从而一直等待客户端请求，从而浪费资源
- “已失效的连接请求报文段”的产生在这样一种情况下：Client发出的第一个连接请求报文段并没有丢失，而是在某个网络结点长时间的滞留了，以致延误到连接释放以后的某个时间才到达server。
- 这是一个早已失效的报文段。但Server收到此失效的连接请求报文段后，就误认为是Client再次发出的一个新的连接请求。
- 于是就向Client发出确认报文段，同意建立连接。
- 假设不采用“三次握手”：只要Server发出确认，新的连接就建立了。
- 由于现在Client并没有发出建立连接的请求，因此不会向Server发送数据。
- 但Server却以为新的运输连接已经建立，并一直等待Client发来数据。>- 这样，Server的资源就白白浪费掉了。
采用“三次握手”的办法可以防止上述现象发生：
- Client不会向Server的确认发出确认
- Server由于收不到确认，就知道Client并没有要求建立连接
- 所以Server不会等待Client发送数据，资源就没有被浪费
- TCP释放连接
  TCP释放连接需要四次挥手过程，现在假设A主动释放连接：（数据传输结束后，通信的双方都可释放连接）
  - 第一次挥手：A发送释放信息到B；（发出去之后，A->B发送数据这条路径就断了）
  - 第二次挥手：B收到A的释放信息之后，回复确认释放的信息：我同意你的释放连接请求
  - 第三次挥手：B发送“请求释放连接“信息给A
  - 第四次挥手：A收到B发送的信息后向B发送确认释放信息：我同意你的释放连接请求
    
    B收到确认信息后就会正式关闭连接；
    A等待2MSL后依然没有收到回复，则证明B端已正常关闭，于是A关闭连接
为什么TCP释放连接需要四次挥手？

为了保证双方都能通知对方“需要释放连接”，即在释放连接后都无法接收或发送消息给对方
- 需要明确的是：TCP是全双工模式，这意味着是双向都可以发送、接收的
- 释放连接的定义是：双方都无法接收或发送消息给对方，是双向的
- 当主机1发出“释放连接请求”（FIN报文段）时，只是表示主机1已经没有数据要发送 / 数据已经全部发送完毕；
  
  但是，这个时候主机1还是可以接受来自主机2的数据。
- 当主机2返回“确认释放连接”信息（ACK报文段）时，表示它已经知道主机1没有数据发送了
  但此时主机2还是可以发送数据给主机1
- 当主机2也发送了FIN报文段时，即告诉主机1我也没有数据要发送了
  此时，主机1和2已经无法进行通信：主机1无法发送数据给主机2，主机2也无法发送数据给主机1，此时，TCP的连接才算释放
1.5 UDP协议
- 定义：User Datagram Protocol，即用户数据报协议，是一种传输层通信协议。
  
  基于UDP的应用层协议有TFTP、SNMP与DNS。
- 特点：无连接的、不可靠的、面向报文、没有拥塞控制
  - 无连接的：和TCP要建立连接不同，UDP传输数据不需要建立连接，就像写信，在信封写上收信人名称、地址就可以交给邮局发送了，至于能不能送到，就要看邮局的送信能力和送信过程的困难程度了。
  - 不可靠的：因为UDP发出去的数据包发出去就不管了，不管它会不会到达，所以很可能会出现丢包现象，使传输的数据出错。
  - 面向报文：数据报文，就相当于一个数据包，应用层交给UDP多大的数据包，UDP就照样发送，不会像TCP那样拆分。
  - 没有拥塞控制：拥塞，是指到达通信子网中某一部分的分组数量过多，使得该部分网络来不及处理，以致引起这部分乃至整个网络性能下降的现象，严重时甚至会导致网络通信业务陷入停顿，即出现死锁现象，就像交通堵塞一样。TCP建立连接后如果发送的数据因为信道质量的原因不能到达目的地，它会不断重发，有可能导致越来越塞，所以需要一个复杂的原理来控制拥塞。而UDP就没有这个烦恼，发出去就不管了。
- 应用场景
  很多的实时应用（如IP电话、实时视频会议、某些多人同时在线游戏等）要求源主机以很定的速率发送数据，并且允许在网络发生拥塞时候丢失一些数据，但是要求不能有太大的延时，UDP就刚好适合这种要求。所以说，只有不适合的技术，没有真正没用的技术。
1.6 HTTP协议

详情请看我写的另外一篇文章你需要了解的HTTP知识都在这里了！

2. Socket定义
- 即套接字，是一个对 TCP / IP协议进行封装的编程调用接口（API）
  即通过Socket，我们才能在Andorid平台上通过 TCP/IP协议进行开发
  
  Socket不是一种协议，而是一个编程调用接口（API），属于传输层（主要解决数据如何在网络中传输）
- 成对出现，一对套接字：
```
Socket ={(IP地址1:PORT端口号)，(IP地址2:PORT端口号)}
```
- 1
3. 原理

Socket的使用类型主要有两种：
- 流套接字（streamsocket）：基于 TCP协议，采用流的方式提供可靠的字节流服务
- 数据报套接字(datagramsocket)：基于 UDP协议，采用数据报文提供数据打包发送的服务
具体原理图如下：

4. Socket 与 Http 对比
- Socket属于传输层，因为 TCP / IP协议属于传输层，解决的是数据如何在网络中传输的问题
- HTTP协议属于应用层，解决的是如何包装数据
由于二者不属于同一层面，所以本来是没有可比性的。但随着发展，默认的Http里封装了下面几层的使用，所以才会出现Socket & HTTP协议的对比：（主要是工作方式的不同）：
- Http：采用请求—响应方式。
  即建立网络连接后，当客户端向服务器发送请求后，服务器端才能向客户端返回数据。
  
  可理解为：是客户端有需要才进行通信
- Socket：采用服务器主动发送数据的方式
  即建立网络连接后，服务器可主动发送消息给客户端，而不需要由客户端向服务器发送请求
  
  可理解为：是服务器端有需要才进行通信
5. 使用步骤
- Socket可基于TCP或者UDP协议，但TCP更加常用
- 所以下面的使用步骤 & 实例的Socket将基于TCP协议
  // 步骤1：创建客户端 & 服务器的连接 // 创建Socket对象 & 指定服务端的IP及端口号 Socket socket = new Socket("192.168.1.32", 1989); // 判断客户端和服务器是否连接成功 socket.isConnected()); // 步骤2：客户端 & 服务器通信 // 通信包括：客户端接收服务器的数据 & 发送数据到服务器 <-- 操作1：接收服务器的数据 --> // 步骤1：创建输入流对象InputStream InputStream is = socket.getInputStream() // 步骤2：创建输入流读取器对象并传入输入流对象 // 该对象作用：获取服务器返回的数据 InputStreamReader isr = new InputStreamReader(is); BufferedReader br = new BufferedReader(isr); // 步骤3：通过输入流读取器对象接收服务器发送过来的数据 br.readLine()； <-- 操作2：发送数据到服务器 --> // 步骤1：从Socket 获得输出流对象OutputStream // 该对象作用：发送数据 OutputStream outputStream = socket.getOutputStream(); // 步骤2：写入需要发送的数据到输出流对象中 outputStream.write（（"Carson_Ho"+" "）.getBytes("utf-8")）； // 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞 // 步骤3：发送数据到服务端 outputStream.flush(); // 步骤3：断开客户端 & 服务器连接 os.close(); // 断开客户端发送到服务器的连接，即关闭输出流对象OutputStream br.close(); // 断开服务器发送到客户端的连接，即关闭输入流读取器对象BufferedReader socket.close(); // 最终关闭整个Socket连接
6. 具体实例
- 实例 Demo 代码包括：客户端 & 服务器
- 本文着重讲解客户端，服务器仅采用最简单的写法进行展示
6.1 客户端实现

步骤1：加入网络权限
```
<uses-permission android:name="android.permission.INTERNET" />
```
- 1
步骤2：主布局界面设置

包括创建Socket连接、客户端 & 服务器通信的按钮
1. <Button
2. android:id="@+id/connect"
3. android:layout_width="match_parent"
4. android:layout_height="wrap_content"
5. android:text="connect" />
7. <Button
8. android:id="@+id/disconnect"
9. android:layout_width="match_parent"
10. android:layout_height="wrap_content"
11. android:text="disconnect" />
13. <TextView
14. android:id="@+id/receive_message"
15. android:layout_width="match_parent"
16. android:layout_height="wrap_content" />
18. <Button
19. android:id="@+id/Receive"
20. android:layout_width="match_parent"
21. android:layout_height="wrap_content"
22. android:text="Receive from message" />
24. <EditText
25. android:id="@+id/edit"
26. android:layout_width="match_parent"
27. android:layout_height="wrap_content" />
29. <Button
30. android:id="@+id/send"
31. android:layout_width="match_parent"
32. android:layout_height="wrap_content"
33. android:text="send"/>
步骤3：创建Socket连接、客户端 & 服务器通信

具体请看注释

MainActivity.java
1. package scut.carson_ho.socket_carson;
3. import android.os.Bundle;
4. import android.os.Handler;
5. import android.os.Message;
6. import android.support.v7.app.AppCompatActivity;
7. import android.view.View;
8. import android.widget.Button;
9. import android.widget.EditText;
10. import android.widget.TextView;
12. import java.io.BufferedReader;
13. import java.io.IOException;
14. import java.io.InputStream;
15. import java.io.InputStreamReader;
16. import java.io.OutputStream;
17. import java.net.Socket;
18. import java.util.concurrent.ExecutorService;
19. import java.util.concurrent.Executors;
21. public class MainActivity extends AppCompatActivity {
23. /**
24. * 主变量
25. */
27. // 主线程Handler
28. // 用于将从服务器获取的消息显示出来
29. private Handler mMainHandler;
31. // Socket变量
32. private Socket socket;
34. // 线程池
35. // 为了方便展示,此处直接采用线程池进行线程管理,而没有一个个开线程
36. private ExecutorService mThreadPool;
37. /**
38. * 接收服务器消息变量
39. */
40. // 输入流对象
41. InputStream is;
42. // 输入流读取器对象
43. InputStreamReader isr ;
44. BufferedReader br ;
46. // 接收服务器发送过来的消息
47. String response;
50. /**
51. * 发送消息到服务器变量
52. */
53. // 输出流对象
54. OutputStream outputStream;
56. /**
57. * 按钮变量
58. */
60. // 连接断开连接发送数据到服务器的按钮变量
61. private Button btnConnect, btnDisconnect, btnSend;
63. // 显示接收服务器消息按钮
64. private TextView Receive,receive_message;
66. // 输入需要发送的消息输入框
67. private EditText mEdit;
69. @Override
70. protected void onCreate(Bundle savedInstanceState) {
71. super.onCreate(savedInstanceState);
72. setContentView(R.layout.activity_main);
74. /**
75. * 初始化操作
76. */
78. // 初始化所有按钮
79. btnConnect = (Button) findViewById(R.id.connect);
80. btnDisconnect = (Button) findViewById(R.id.disconnect);
81. btnSend = (Button) findViewById(R.id.send);
82. mEdit = (EditText) findViewById(R.id.edit);
83. receive_message = (TextView) findViewById(R.id.receive_message);
84. Receive = (Button) findViewById(R.id.Receive);
86. // 初始化线程池
87. mThreadPool = Executors.newCachedThreadPool();
90. // 实例化主线程,用于更新接收过来的消息
91. mMainHandler = new Handler() {
92. @Override
93. public void handleMessage(Message msg) {
94. switch (msg.what) {
95. case 0:
96. receive_message.setText(response);
97. break;
98. }
99. }
100. };
103. /**
104. * 创建客户端 & 服务器的连接
105. */
106. btnConnect.setOnClickListener(new View.OnClickListener() {
107. @Override
108. public void onClick(View v) {
110. // 利用线程池直接开启一个线程 & 执行该线程
111. mThreadPool.execute(new Runnable() {
112. @Override
113. public void run() {
115. try {
117. // 创建Socket对象 & 指定服务端的IP 及端口号
118. socket = new Socket("192.168.1.172", 8989);
120. // 判断客户端和服务器是否连接成功
121. System.out.println(socket.isConnected());
123. } catch (IOException e) {
124. e.printStackTrace();
125. }
127. }
128. });
130. }
131. });
133. /**
134. * 接收服务器消息
135. */
136. Receive.setOnClickListener(new View.OnClickListener() {
137. @Override
138. public void onClick(View v) {
140. // 利用线程池直接开启一个线程 & 执行该线程
141. mThreadPool.execute(new Runnable() {
142. @Override
143. public void run() {
145. try {
146. // 步骤1：创建输入流对象InputStream
147. is = socket.getInputStream();
149. // 步骤2：创建输入流读取器对象并传入输入流对象
150. // 该对象作用：获取服务器返回的数据
151. isr = new InputStreamReader(is);
152. br = new BufferedReader(isr);
154. // 步骤3：通过输入流读取器对象接收服务器发送过来的数据
155. response = br.readLine();
157. // 步骤4:通知主线程,将接收的消息显示到界面
158. Message msg = Message.obtain();
159. msg.what = 0;
160. mMainHandler.sendMessage(msg);
162. } catch (IOException e) {
163. e.printStackTrace();
164. }
166. }
167. });
169. }
170. });
173. /**
174. * 发送消息给服务器
175. */
176. btnSend.setOnClickListener(new View.OnClickListener() {
177. @Override
178. public void onClick(View v) {
180. // 利用线程池直接开启一个线程 & 执行该线程
181. mThreadPool.execute(new Runnable() {
182. @Override
183. public void run() {
185. try {
186. // 步骤1：从Socket 获得输出流对象OutputStream
187. // 该对象作用：发送数据
188. outputStream = socket.getOutputStream();
190. // 步骤2：写入需要发送的数据到输出流对象中
191. outputStream.write((mEdit.getText().toString()+" ").getBytes("utf-8"));
192. // 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞
194. // 步骤3：发送数据到服务端
195. outputStream.flush();
197. } catch (IOException e) {
198. e.printStackTrace();
199. }
201. }
202. });
204. }
205. });
208. /**
209. * 断开客户端 & 服务器的连接
210. */
211. btnDisconnect.setOnClickListener(new View.OnClickListener() {
212. @Override
213. public void onClick(View v) {
215. try {
216. // 断开客户端发送到服务器的连接，即关闭输出流对象OutputStream
217. outputStream.close();
219. // 断开服务器发送到客户端的连接，即关闭输入流读取器对象BufferedReader
220. br.close();
222. // 最终关闭整个Socket连接
223. socket.close();
225. // 判断客户端和服务器是否已经断开连接
226. System.out.println(socket.isConnected());
228. } catch (IOException e) {
229. e.printStackTrace();
230. }
232. }
233. });
236. }
237. }
6.2 服务器实现
- 因本文主要讲解客户端，所以服务器仅仅是为了配合客户端展示；
- 为了简化服务器使用，此处采用Mina框架
1. 服务器代码请在eclipse平台运行
2. 按照我的步骤一步步实现就可以无脑运行了
步骤1：导入Mina包

请直接移步到百度网盘：下载链接（密码: q73e）

步骤2：创建服务器线程
TestHandler.java
1. package mina;
2. // 导入包
4. public class TestHandler extends IoHandlerAdapter {
6. @Override
7. public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
8. System.out.println("exceptionCaught: " + cause);
9. }
11. @Override
12. public void messageReceived(IoSession session, Object message) throws Exception {
13. System.out.println("recieve : " + (String) message);
14. session.write("hello I am server");
15. }
17. @Override
18. public void messageSent(IoSession session, Object message) throws Exception {
20. }
22. @Override
23. public void sessionClosed(IoSession session) throws Exception {
24. System.out.println("sessionClosed");
25. }
27. @Override
28. public void sessionOpened(IoSession session) throws Exception {
29. System.out.println("sessionOpen");
30. }
32. @Override
33. public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
34. }
36. }
步骤3：创建服务器主代码
TestHandler.java
1. package mina;
3. import java.io.IOException;
4. import java.net.InetSocketAddress;
6. import org.apache.mina.filter.codec.ProtocolCodecFilter;
7. import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
8. import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
10. public class TestServer {
11. public static void main(String[] args) {
12. NioSocketAcceptor acceptor = null;
13. try {
14. acceptor = new NioSocketAcceptor();
15. acceptor.setHandler(new TestHandler());
16. acceptor.getFilterChain().addLast("mFilter", new ProtocolCodecFilter(new TextLineCodecFactory()));
17. acceptor.setReuseAddress(true);
18. acceptor.bind(new InetSocketAddress(8989));
19. } catch (Exception e) {
20. e.printStackTrace();
21. }
22. }
23. }
至此，客户端 & 服务器的代码均实现完毕。

6.3 测试结果
- 点击 Connect按钮：连接成功
- 输入发送的消息，点击 Send 按钮发送
- 服务器接收到客户端发送的消息
- 点击 Receive From Message按钮，客户端读取服务器返回的消息
- 点击 DisConnect按钮，断开客户端 & 服务器的连接
6.4 源码地址

Carson_Ho的Github地址：Socket具体实例

 7. 总结
- 相信大家已经非常了解关于Socket的使用
- 下面我将继续对 Android 的网络编程进行讲解，有兴趣可以继续关注Carson_Ho的安卓开发笔记
Android之Socket的基于UDP传输

接收方创建步骤：

1.  创建一个DatagramSocket对象，并指定监听的端口号

DatagramSocket socket = new  DatagramSocket (4567);

2. 创建一个byte数组用于接收

byte data[] = new byte[1024];

3. 创建一个空的DatagramPackage对象

DatagramPackage package = new DatagramPackage(data , data.length);

4. 使用receive方法接收发送方所发送的数据,同时这也是一个阻塞的方法

socket.receive(package);

5. 得到发送过来的数据

new String(package.getData() , package.getOffset() , package.getLength());

发送方创建步骤：

1.  创建一个DatagramSocket对象

DatagramSocket socket = new  DatagramSocket (4567);

2. 创建一个 InetAddress ，相当于是地址

InetAddress serverAddress = InetAddress.getByName("想要发送到的那个IP地址");

3. 这是随意发送一个数据

String str = "hello";

4. 转为byte类型

byte data[] = str.getBytes();

5. 创建一个DatagramPacket 对象，并指定要讲这个数据包发送到网络当中的哪个地址，以及端口号

DatagramPacket  package = new DatagramPacket (data , data.length , serverAddress , 4567);

6. 调用DatagramSocket对象的send方法发送数据

socket . send(package);

http://www.cnblogs.com/lee0oo0/archive/2012/04/04/2431907.html

一、有的手机不能直接接收UDP包，可能是手机厂商在定制Rom的时候把这个功能给关掉了。

1、可先在oncreate()方法里面实例化一个WifiManager.MulticastLock 对象lock；具体如下：
```
WifiManager manager = (WifiManager) this
                .getSystemService(Context.WIFI_SERVICE);
WifiManager.MulticastLock lock= manager.createMulticastLock("test wifi");
```
2、在调用广播发送、接收报文之前先调用lock.acquire()方法；

3、用完之后及时调用lock.release()释放资源，否决多次调用lock.acquire()方法，程序可能会崩，详情请见

Caused by: java.lang.UnsupportedOperationException: Exceeded maximum number of wifi locks

注；记得在配置文件里面添加如下权限：
```
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
```
经过这样处理后，多数手机都能正常发送接收到广播报文。

本小点转载自Android手机接收不到UDP报文

二、在UDP通信中，android端发送UDP广播包没有问题。至于接收的话，有时候不能接收到包。

在UDP通信中，Android端发送UDP广播包没有问题。至于接收的话，有时候不能接收到包。但是如果UDP包中指定了目标主机的地址的话，那么android端就能正常接收。

下面上一段代码，大家可用这段代码进行测试。

1、在一个Service里面，我们创建一个线程
```
public void onCreate() {//用于创建线程
        WifiManager manager = (WifiManager) this
                .getSystemService(Context.WIFI_SERVICE);
        udphelper = new UdpHelper(manager);
        
        //传递WifiManager对象，以便在UDPHelper类里面使用MulticastLock
        udphelper.addObserver(MsgReceiveService.this);
        tReceived = new Thread(udphelper);
        tReceived.start();
        super.onCreate();
    }
```
2、弄一个UDP帮助类，这个类主要用于发送和接收数据
```
package com.example.com.ihome.bang.util;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Observable;
import com.example.com.ihome.bang.tool.SendThread;
import android.net.wifi.WifiManager;
import android.util.Log;

/**
 * 
 * UdpHelper帮助类
 * 
 * @author 陈喆榕
 * 
 */
public class UdpHelper  implements Runnable {
    public    Boolean IsThreadDisable = false;//指示监听线程是否终止
    private static WifiManager.MulticastLock lock;
    InetAddress mInetAddress;
    public UdpHelper(WifiManager manager) {
         this.lock= manager.createMulticastLock("UDPwifi"); 
    }
    public void StartListen()  {
        // UDP服务器监听的端口
        Integer port = 8903;
        // 接收的字节大小，客户端发送的数据不能超过这个大小
        byte[] message = new byte[100];
        try {
            // 建立Socket连接
            DatagramSocket datagramSocket = new DatagramSocket(port);
            datagramSocket.setBroadcast(true);
            DatagramPacket datagramPacket = new DatagramPacket(message,
                    message.length);
            try {
                while (!IsThreadDisable) {
                    // 准备接收数据
                    Log.d("UDP Demo", "准备接受");
                     this.lock.acquire();
                     
                    datagramSocket.receive(datagramPacket);
                    String strMsg=new String(datagramPacket.getData()).trim();
                    Log.d("UDP Demo", datagramPacket.getAddress()
                            .getHostAddress().toString()
                            + ":" +strMsg );this.lock.release();
                }
            } catch (IOException e) {//IOException
                e.printStackTrace();
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }
    public static void send(String message) {
        message = (message == null ? "Hello IdeasAndroid!" : message);
        int server_port = 8904;
        Log.d("UDP Demo", "UDP发送数据:"+message);
        DatagramSocket s = null;
        try {
            s = new DatagramSocket();
        } catch (SocketException e) {
            e.printStackTrace();
        }
        InetAddress local = null;
        try {
            local = InetAddress.getByName("255.255.255.255");
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        int msg_length = message.length();
        byte[] messageByte = message.getBytes();
        DatagramPacket p = new DatagramPacket(messageByte, msg_length, local,
                server_port);
        try {

            s.send(p);
            s.close();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
            StartListen();
    }
}
```
最后，添加个人的实例：
```
package com.example.android.helloactivity;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.example.andriod.udp.UDPClient;
import com.example.andriod.udp.UDPServer;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainAct extends Activity {
    EditText msg_et = null;
    Button send_bt = null;
    TextView info_tv = null;
    private static final String TAG ="MainAct";
    private UDPClient client;
    private String sendInfo;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.udp_test);
        msg_et = (EditText) findViewById(R.id.edit_msg);
        send_bt = (Button) findViewById(R.id.send_bt);
        info_tv = (TextView) findViewById(R.id.receive_msg);
        info_tv.setText("source");
        // 开启服务器
        ExecutorService exec = Executors.newCachedThreadPool();
        UDPServer server = new UDPServer();
        exec.execute(server);
        // 发送消息
        send_bt.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {

                myThread1 thread = new myThread1("22");
                new Thread(thread).start();

            }
        });
    }

    final Handler mHander = new Handler() {

        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            //super.handleMessage(msg);
            info_tv.setText(sendInfo);
            
            Log.d(TAG, "client.send()=");
        }
    };

    class myThread1 implements Runnable {

        private String threadName;

        public myThread1(String name) {
            this.threadName = name;
        }

        public void run() {
            Log.d(TAG, "MyThread  execu"+msg_et.getText().toString());
            client = new UDPClient(msg_et.getText().toString());
            sendInfo=client.send();
            
            Message msg = mHander.obtainMessage();
            msg.arg1=1;
            mHander.sendMessage(msg);
            Log.d(TAG, "client.send()=");
        }
    }
}
```
```
package com.example.andriod.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

import android.util.Log;

public class UDPServer implements Runnable {
    private static final int PORT = 6000;
    private byte[] msg = new byte[2048];
    private boolean life = true;

    public UDPServer() {
    }

    public boolean isLife() {
        return life;
    }

    public void setLife(boolean life) {
        this.life = life;
    }

    @Override
    public void run() {
        DatagramSocket dSocket = null;
        DatagramPacket dPacket = new DatagramPacket(msg, msg.length);
        try {
            dSocket = new DatagramSocket(PORT);
            while (life) {
                try {
                    dSocket.receive(dPacket);
                    Log.d("tian msg sever received",
                            new String(dPacket.getData(), dPacket.getOffset(),
                                    dPacket.getLength())
                                    + "dPacket.getLength()="
                                    + dPacket.getLength());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}
```
```
package com.example.andriod.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

import android.util.Log;

public class UDPClient {
    private static final int SERVER_PORT = 6000;
    private DatagramSocket dSocket = null;
    private String msg;

    public UDPClient(String msg) {
        super();
        this.msg = msg;
    }

    public String send() {
        StringBuilder sb = new StringBuilder();
        InetAddress local = null;
        try {
            local = InetAddress.getByName("localhost"); // 本机测试
            sb.append("已找到服务器,连接中...").append("/n");
        } catch (UnknownHostException e) {
            sb.append("未找到服务器.").append("/n");
            e.printStackTrace();
        }
        try {
            dSocket = new DatagramSocket(); // 注意此处要先在配置文件里设置权限,否则会抛权限不足的异常
            sb.append("正在连接服务器...").append("/n");
        } catch (SocketException e) {
            e.printStackTrace();
            sb.append("服务器连接失败.").append("/n");
        }
        int msg_len = msg == null ? 0 : msg.length();
        DatagramPacket dPacket = new DatagramPacket(msg.getBytes(), msg_len,
                local, SERVER_PORT);
        try {
            dSocket.send(dPacket);
            Log.d("tian", "msg=="+msg+"dpackage="+dPacket.getData()+"dPacket.leng="+dPacket.getLength());
            sb.append("消息发送成功!").append("/n");
        } catch (IOException e) {
            e.printStackTrace();
            sb.append("消息发送失败.").append("/n");
        }
        dSocket.close();
        return sb.toString();
    }
}
```
相关阅读:
获取指定目录下的所有文件
 char码值对应列表大全
 烂记性不如好笔头㈠㈢㈥
 SQL Server中的Image数据类型的操作
 企业信息化与标准化的纠结（二）
企业信息化的前世今生
 企业信息化与标准化的纠结（一）
关于 EOM（Enterprise Operating Model）企业经营模型（1）转自n216
《优秀程序员应该具备哪些素质》（ZT）
谈谈MIS建设与职能架构的问题
原文地址：https://www.cnblogs.com/chenxibobo/p/14108963.html

Android：这是一份很详细的Socket使用攻略

1.网络基础

1.1 计算机网络分层

1.2 端口号（PORT）

1.3 C/S结构

1.4 TCP协议

为什么TCP建立连接需要三次握手？

为什么TCP释放连接需要四次挥手？

1.5 UDP协议

1.6 HTTP协议

2. Socket定义

3. 原理

4. Socket 与 Http 对比

5. 使用步骤

6. 具体实例

6.1 客户端 实现

6.2 服务器 实现

6.3 测试结果

6.4 源码地址

7. 总结

Android之Socket的基于UDP传输

一、有的手机不能直接接收UDP包，可能是手机厂商在定制Rom的时候把这个功能给关掉了。

二、在UDP通信中，android端发送UDP广播包没有问题。至于接收的话，有时候不能接收到包。

6.1 客户端实现

6.2 服务器实现