Android网络编程基础

Android网络编程只TCP通信

 

TCP 服务器端工作的主要步骤如下。
步骤1　调用ServerSocket（int port）创建一个ServerSocket，并绑定到指定端口上。
步骤2　调用accept()，监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字。
步骤3　调用Socket 类的getOutputStream() 和getInputStream() 获取输出和输入流，开始网络数据的发送和接收。
步骤4　关闭通信套接字。

服务器端：

 1 package com.jiao.socketdemo;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.InterruptedIOException;
 8 import java.io.OutputStreamWriter;
 9 import java.net.ServerSocket;
10 import java.net.Socket;
11 
12 public class Main {
13     public static int TCP_SERVER_PORT = 5556;
14 
15     // 声明一个socket来接受客户端连接
16 
17     public static void main(String[] args) {
18 
19         start();
20     }
21 
22     private static void start() {
23         ServerSocket serverSocket = null;
24         try {
25             // TCP_SERVER_PORT 为指定的绑定端口，为int 类型
26             serverSocket = new ServerSocket(TCP_SERVER_PORT);
27             // 监听连接请求
28             Socket socket = serverSocket.accept();
29             // 写入读Buffer 中 // 获取输入流
30             BufferedReader in = new BufferedReader(new InputStreamReader(
31                     socket.getInputStream()));
32 
33             // 放到写Buffer 中 // 获取输出流
34             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
35                     socket.getOutputStream()));
36 
37             // 读取接收信息，转换为字符串
38             String incomingMsg = in.readLine()
39                     + System.getProperty("line.separator");
40 
41             System.out.println("接受到的信息：" + incomingMsg);
42             // 生成发送字符串
43             String outgoingMsg = "goodbye from port " + TCP_SERVER_PORT
44                     + System.getProperty("line.separator");
45             // 将发送字符串写入上面定义的BufferedWriter 中
46             out.write(outgoingMsg);
47 
48             System.out.println("发送出去的信息" + outgoingMsg);
49             // 刷新，发送
50             out.flush();
51             // 关闭
52             socket.close();
53         } catch (InterruptedIOException e) {
54             // 超时错误
55             e.printStackTrace();
56             // IO 异常
57         } catch (IOException e) {
58             // 打印错误
59             e.printStackTrace();
60         } finally {
61             // 判定是否初始化ServerSocket 对象，如果初始化则关闭serverSocket
62             if (serverSocket != null) {
63                 try {
64                     serverSocket.close();
65                 } catch (IOException e) {
66                     e.printStackTrace();
67                 }
68             }
69         }
70 
71     }
72 
73 }

客户端：

 1 package com.example.socketclient;
 2 
 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.net.Socket;
 9 import java.net.UnknownHostException;
10 import android.app.Activity;
11 import android.os.Bundle;
12 
13 public class MainActivity extends Activity {
14     public static int TCP_SERVER_PORT = 5556;
15 
16     @Override
17     protected void onCreate(Bundle savedInstanceState) {
18         super.onCreate(savedInstanceState);
19         setContentView(R.layout.activity_main);
20 
21         new Thread() {
22             public void run() {
23                 actStart();
24             };
25         }.start();
26     }
27 
28     private void actStart() {
29         try {
30             // 初始化Socket，TCP_SERVER_PORT 为指定的端口，int 类型r
31             Socket socket = new Socket("这里为服务器的ip", TCP_SERVER_PORT);
32             // 获取输入流
33             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
34             // 生成输出流
35             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
36             // 生成输出内容
37             String outMsg = "Jiao_Test" + TCP_SERVER_PORT+ System.getProperty("line.separator");
38             // 写入
39             out.write(outMsg);
40             // 刷新，发送
41             out.flush();
42             // 获取输入流
43             String inMsg = in.readLine() + System.getProperty("line.separator");
44             // Log.i("TcpClient", "received: " + inMsg);
45             System.out.println("接收服务器返回："+inMsg);
46             // 关闭连接
47             socket.close();
48         } catch (UnknownHostException e) {
49             e.printStackTrace();
50         } catch (IOException e) {
51             e.printStackTrace();
52         }
53 
54     }
55 
56 }

二：UDP传输方式

步骤1　调用DatagramSocket(int port) 创建一个数据报套接字，并绑定到指定端口上。
步骤2　调用DatagramPacket（byte[]buf,int length），建立一个字节数组以接收UDP 包。
步骤3　调用DatagramSocket 类的receive()，接受UDP 包。
步骤4　关闭数据报套接字。

服务端代码

 1 package com.example.socketudp;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.SocketException;
 7 
 8 import android.app.Activity;
 9 import android.os.Bundle;
10 
11 public class MainActivity extends Activity {
12     private final static int MAX_UDP_DATAGRAM_LEN = 1024;
13     private final static int UDP_SERVER_PORT = 5556;
14 
15     @Override
16     protected void onCreate(Bundle savedInstanceState) {
17         super.onCreate(savedInstanceState);
18         setContentView(R.layout.activity_main);
19 
20         new Thread() {
21             public void run() {
22                 actStart();
23             }
24         }.start();
25     }
26 
27     private void actStart() {
28         // 接收的字节大小，客户端发送的数据不能超过MAX_UDP_DATAGRAM_LEN
29         byte[] lMsg = new byte[MAX_UDP_DATAGRAM_LEN];
30         // 实例化一个DatagramPacket 类
31         DatagramPacket dp = new DatagramPacket(lMsg, lMsg.length);
32         // 新建一个DatagramSocket 类
33         DatagramSocket ds = null;
34         try {
35             // UDP 服务器监听的端口
36             ds = new DatagramSocket(UDP_SERVER_PORT);
37             // 准备接收数据
38             ds.receive(dp);
39         } catch (SocketException e) {
40             e.printStackTrace();
41 
42         } catch (IOException e) {
43             e.printStackTrace();
44         } finally {
45             // 如果ds 对象不为空，则关闭ds 对象
46             if (ds != null) {
47                 ds.close();
48             }
49 
50         }
51     }
52 }

 

客户端代码：

 1 package com.example.socketclient;
 2 
 3 import java.io.IOException;
 4 import java.net.DatagramPacket;
 5 import java.net.DatagramSocket;
 6 import java.net.InetAddress;
 7 import java.net.SocketException;
 8 import java.net.UnknownHostException;
 9 import android.app.Activity;
10 import android.os.Bundle;
11 
12 public class MainActivity extends Activity {
13     public static int UDP_SERVER_PORT = 5556;
14 
15     @Override
16     protected void onCreate(Bundle savedInstanceState) {
17         super.onCreate(savedInstanceState);
18         setContentView(R.layout.activity_main);
19 
20         new Thread() {
21             public void run() {
22                 actStart();
23             };
24         }.start();
25     }
26 
27     private void actStart() {
28         // 定义需要发送的信息
29         String udpMsg = "jiao udp test" + UDP_SERVER_PORT;
30         // 新建一个DatagramSocket 对象
31         DatagramSocket ds = null;
32         try {
33             // 初始化DatagramSocket 对象
34             ds = new DatagramSocket();
35             // 初始化InetAddress 对象
36             InetAddress serverAddr = InetAddress.getByName("服务器的ip");
37             DatagramPacket dp;
38             // 初始化DatagramPacket 对象
39             dp = new DatagramPacket(udpMsg.getBytes(), udpMsg.length(),serverAddr, UDP_SERVER_PORT);
40             // 发送
41             ds.send(dp);
42         }
43         // 异常处理
44         // Socket 连接异常
45         catch (SocketException e) {
46             e.printStackTrace();
47             // 不能连接到主机
48         } catch (UnknownHostException e) {
49             e.printStackTrace();
50             // 数据流异常
51         } catch (IOException e) {
52             e.printStackTrace();
53             // 其他异常
54         } catch (Exception e) {
55             e.printStackTrace();
56         } finally {
57             // 如果DatagramSocket 已经实例化，则需要将其关闭
58             if (ds != null) {
59                 ds.close();
60             }
61         }
62     }
63 }