1//服务端
 2ServerSocket serverSocket = null;
 3public final int port = 2022;
 4try {
 5    InetAddress addr = InetAddress.getLocalHost();
 6    System.out.println("local host:"+addr);
 7    serverSocket = new ServerSocket(port);
 8    Log.d(TAG,"->>>serverSocket success");
 9} catch (IOException e) {
10    e.printStackTrace();
11}

 1//服务端
 2//考虑到不只有一个客户端连接，所以需要一个循环
 3try {
 4    Socket socket = null;
 5    //等待连接，每建立一个连接，就新建一个线程
 6    while(true){
 7        //等待一个客户端的连接，在连接之前，此方法是阻塞的
 8        socket = serverSocket.accept();
 9        Log.d(TAG, "->>>connect to"+socket.getInetAddress()+":"+socket.getLocalPort());
10    }
11} catch (IOException e) {
12    e.printStackTrace();
13}

 1//客户端
 2public static String IP_ADDRESS = "";
 3public static int PORT = 2022;
 4
 5IP_ADDRESS = tv_adress.getText().toString();
 6//这里的message为自己手动输入的字符串
 7new ConnectionThread(message).start();
 8
 9//新建一个子线程，实现socket通信
10class ConnectionThread extends Thread {
11    String message = null;
12
13    public ConnectionThread(String msg) {
14        Log.d(TAG, "->>>ConnectionThread|msg = " + msg);
15        message = msg;
16    }
17
18    @Override
19    public void run() {
20        if (soc == null) {
21            try {
22                Log.d(TAG,"->>>new socket");
23                if ("".equals(IP_ADDRESS)) {
24                    return;
25                }
26                //这个是阻塞的方法，连接成功后才会执行后面的语句
27                soc = new Socket(IP_ADDRESS, PORT);
28            } catch (IOException e) {
29                e.printStackTrace();
30            }
31        }
32    }
33}

 1//服务端
 2try {
 3    Socket socket = null;
 4    while(true){
 5        socket = serverSocket.accept();
 6        //每次连接都开启一个线程，最好使用JDK的线程池
 7        new ConnectThread(socket).start();
 8    }
 9} catch (IOException e) {
10    e.printStackTrace();
11}
12
13//向客户端发送信息
14class ConnectThread extends Thread{
15    Socket socket = null;
16    //socket变量注入
17    public ConnectThread(Socket socket){
18        super();
19        this.socket = socket;
20    }
21
22    @Override
23    public void run(){
24        try {
25            //这里通过socket来获取二进制的输入输出流用于传递数据
26            DataInputStream dis = new DataInputStream(socket.getInputStream());
27            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
28            while(true){
29                i++;
30                String msgRecv = dis.readUTF();
31                Log.d(TAG, "->>>msg from client: " + msgRecv);
32                //服务端的消息，只是在客户端的基本上加了一个符号
33                dos.writeUTF(msgRecv + i);
34                dos.flush();
35            }
36        } catch (IOException e) {
37            e.printStackTrace();
38        }
39    }
40}

 1//客户端
 2public static String IP_ADDRESS = "";
 3public static int PORT = 2022;
 4String messageRecv = null;
 5
 6IP_ADDRESS = tv_adress.getText().toString();
 7//这里的message为自己手动输入的字符串
 8new ConnectionThread(message).start();
 9
10//新建一个子线程，实现socket通信
11class ConnectionThread extends Thread {
12    @Override
13    public void run() {
14        if (soc == null) {
15            try {
16                soc = new Socket(IP_ADDRESS, PORT);
17                //这里通过socket来获取二进制的输入输出流用于传递数据
18                dis = new DataInputStream(soc.getInputStream());
19                dos = new DataOutputStream(soc.getOutputStream());
20            } catch (IOException e) {
21                e.printStackTrace();
22            }
23        }
24        try {
25            //客户端发送消息
26            dos.writeUTF(message);
27            dos.flush();
28            //客户端接收消息
29            messageRecv = dis.readUTF();//如果没有收到数据，会阻塞
30            Message msg = new Message();
31            Bundle b = new Bundle();
32            b.putString("data", messageRecv);
33            msg.setData(b);
34            handler.sendMessage(msg);
35        } catch (IOException e) {
36            e.printStackTrace();
37        }
38    }
39}

 1public void StartService() throws IOException {
 2    //1.创建服务器端DatagramSocket，指定端口号
 3    InetAddress addr = InetAddress.getLocalHost();
 4    datagramSocket = new DatagramSocket(PORT, addr);
 5    //2.创建数据报，用于接收客户端发送的数据
 6    byte[] data = new byte[1024];
 7    datagramPacket = new DatagramPacket(data, data.length);
 8    Log.d(TAG, "->>>UDP server is start ,wait client connected... ");
 9    //3.接收客户端发送的数据
10    //receive方法是阻塞方法
11    datagramSocket.receive(datagramPacket);
12    //4.读取数据
13    String info = new String(data, 0, datagramPacket.getLength());
14    Log.d(TAG, "->>>UDP server : info = " + info);
15
16    //响应客户端
17    //1.定于客户端地址、端口号、数据
18    InetAddress address = datagramPacket.getAddress();
19    int port = datagramPacket.getPort();
20    byte[] data2 = "hello".getBytes();
21    //2.创建数据报，包含响应的数据信息
22    DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
23    datagramSocket.send(packet2);
24    //4.关闭资源
25    //datagramSocket.close();
26}

 1public void StartClient() throws IOException {
 2    //1.创建服务器端DatagramSocket，指定端口号
 3    addr = InetAddress.getLocalHost();
 4    String IP_ADDRESS = addr.toString().split("/")[1];
 5    Log.d(TAG, "->>>addr = " + addr + " , IP_ADDRESS = " + IP_ADDRESS);
 6    //2.创建数据报，包含发送的数据信息
 7    byte[] data = "username:yangyang48;passwd:2023-01-01".getBytes();
 8    datagramPacket = new DatagramPacket(data, data.length, addr, PORT);
 9    //3.创建DatagramSocket对象
10    datagramSocket = new DatagramSocket();
11    //4.向服务器端发送数据报
12    datagramSocket.send(datagramPacket);
13
14    //接收服务端信息
15    //1.创建数据报，用于接收服务器端响应的数据
16    byte[] data2 = new byte[1024];
17    DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
18    //2.接收服务器响应的数据
19    datagramSocket.receive(packet2);
20    //3.读取数据
21    String reply = new String(data2, 0, packet2.getLength());
22    Log.d(TAG, "->>>UDP client reply = " + reply);
23    //4.关闭资源
24    datagramSocket.close();
25}