Android网络编程基础

Android网络编程只TCP通信

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

服务器端：

package com.jiao.socketdemo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.InterruptedIOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Main {
    public static int TCP_SERVER_PORT = 5556;

    // 声明一个socket来接受客户端连接

    public static void main(String[] args) {

        start();
    }

    private static void start() {
        ServerSocket serverSocket = null;
        try {
            // TCP_SERVER_PORT 为指定的绑定端口，为int 类型
            serverSocket = new ServerSocket(TCP_SERVER_PORT);
            // 监听连接请求
            Socket socket = serverSocket.accept();
            // 写入读Buffer 中 // 获取输入流
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    socket.getInputStream()));

            // 放到写Buffer 中 // 获取输出流
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
                    socket.getOutputStream()));

            // 读取接收信息，转换为字符串
            String incomingMsg = in.readLine()
                    + System.getProperty("line.separator");

            System.out.println("接受到的信息：" + incomingMsg);
            // 生成发送字符串
            String outgoingMsg = "goodbye from port " + TCP_SERVER_PORT
                    + System.getProperty("line.separator");
            // 将发送字符串写入上面定义的BufferedWriter 中
            out.write(outgoingMsg);

            System.out.println("发送出去的信息" + outgoingMsg);
            // 刷新，发送
            out.flush();
            // 关闭
            socket.close();
        } catch (InterruptedIOException e) {
            // 超时错误
            e.printStackTrace();
            // IO 异常
        } catch (IOException e) {
            // 打印错误
            e.printStackTrace();
        } finally {
            // 判定是否初始化ServerSocket 对象，如果初始化则关闭serverSocket
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

客户端：

package com.example.socketclient;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import android.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {
    public static int TCP_SERVER_PORT = 5556;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread() {
            public void run() {
                actStart();
            };
        }.start();
    }

    private void actStart() {
        try {
            // 初始化Socket，TCP_SERVER_PORT 为指定的端口，int 类型r
            Socket socket = new Socket("这里为服务器的ip", TCP_SERVER_PORT);
            // 获取输入流
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 生成输出流
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            // 生成输出内容
            String outMsg = "Jiao_Test" + TCP_SERVER_PORT+ System.getProperty("line.separator");
            // 写入
            out.write(outMsg);
            // 刷新，发送
            out.flush();
            // 获取输入流
            String inMsg = in.readLine() + System.getProperty("line.separator");
            // Log.i("TcpClient", "received: " + inMsg);
            System.out.println("接收服务器返回："+inMsg);
            // 关闭连接
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

二：UDP传输方式

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

服务端代码

package com.example.socketudp;

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

import android.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {
    private final static int MAX_UDP_DATAGRAM_LEN = 1024;
    private final static int UDP_SERVER_PORT = 5556;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread() {
            public void run() {
                actStart();
            }
        }.start();
    }

    private void actStart() {
        // 接收的字节大小，客户端发送的数据不能超过MAX_UDP_DATAGRAM_LEN
        byte[] lMsg = new byte[MAX_UDP_DATAGRAM_LEN];
        // 实例化一个DatagramPacket 类
        DatagramPacket dp = new DatagramPacket(lMsg, lMsg.length);
        // 新建一个DatagramSocket 类
        DatagramSocket ds = null;
        try {
            // UDP 服务器监听的端口
            ds = new DatagramSocket(UDP_SERVER_PORT);
            // 准备接收数据
            ds.receive(dp);
        } catch (SocketException e) {
            e.printStackTrace();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 如果ds 对象不为空，则关闭ds 对象
            if (ds != null) {
                ds.close();
            }

        }
    }
}

客户端代码：

package com.example.socketclient;

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.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {
    public static int UDP_SERVER_PORT = 5556;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread() {
            public void run() {
                actStart();
            };
        }.start();
    }

    private void actStart() {
        // 定义需要发送的信息
        String udpMsg = "jiao udp test" + UDP_SERVER_PORT;
        // 新建一个DatagramSocket 对象
        DatagramSocket ds = null;
        try {
            // 初始化DatagramSocket 对象
            ds = new DatagramSocket();
            // 初始化InetAddress 对象
            InetAddress serverAddr = InetAddress.getByName("服务器的ip");
            DatagramPacket dp;
            // 初始化DatagramPacket 对象
            dp = new DatagramPacket(udpMsg.getBytes(), udpMsg.length(),serverAddr, UDP_SERVER_PORT);
            // 发送
            ds.send(dp);
        }
        // 异常处理
        // Socket 连接异常
        catch (SocketException e) {
            e.printStackTrace();
            // 不能连接到主机
        } catch (UnknownHostException e) {
            e.printStackTrace();
            // 数据流异常
        } catch (IOException e) {
            e.printStackTrace();
            // 其他异常
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 如果DatagramSocket 已经实例化，则需要将其关闭
            if (ds != null) {
                ds.close();
            }
        }
    }
}