Java 网络编程之 Socket

========================UDP=============================

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。

UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。

由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPServer {
    public static void main(String[] args) {
        try {
            System.out.println("**服务器已经启动**");

            // 指定服务端口号、数据包大小
            int serverPort = 8800;
            byte[] data = new byte[1024];
            // 创建服务端DatagramSocket，并指定端口号
            DatagramSocket socket = new DatagramSocket(serverPort);

            /* UDP数据传输 */
            while (true) {

                /* 处理客户端的请求 */
                // 创建数据报DatagramPacket，用于接收客户端发送的数据
                DatagramPacket packet = new DatagramPacket(data, data.length);
                // 等待客户端的连接请求
                socket.receive(packet);
                // 获取客户端发送的数据
                String content = new String(data, 0, packet.getLength());

                /* 服务器处理任务 */
                System.out.println("处理需要转置的字符串：" + content);
                StringBuffer temp = new StringBuffer().append(content);
                // 倒置字符串
                content = new String(temp.reverse());

                /* 发送服务端响应 */
                // 定义客户端的地址、端口号、数据
                InetAddress address = packet.getAddress();
                int clientPort = packet.getPort();
                byte[] reply = content.getBytes();
                // 创建数据报，含响应的数据信息
                DatagramPacket packet2 = new DatagramPacket(reply, reply.length, address, clientPort);
                // 响应客户端
                socket.send(packet2);
            }
            // 关闭资源
//             socket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UDPClient {
    public static void main(String[] args) {
        try {

            /* 获取用户需要处理的字符串 */
            Scanner scanner = new Scanner(System.in);
            System.out.print("输入需要倒转的字符串：");
            String content = scanner.nextLine();

            /* 向服务器发送数据 */
            // 定义服务器的地址、端口号、数据
            InetAddress address = InetAddress.getByName("localhost");
            int clientPort = 8800;
            // 将字符串转换为字节数组
            byte[] data = content.getBytes();
            // 创建数据报，包含发送的数据
            DatagramPacket packet = new DatagramPacket(data, data.length, address, clientPort);
            // 创建DatagramSocket对象
            DatagramSocket socket = new DatagramSocket();
            // 向服务器发送数据报
            socket.send(packet);

            /* 从服务器获得数据 */
            // 创建数据报，用于接收服务器端响应的数据
            byte[] reply = new byte[1024];
            DatagramPacket packet2 = new DatagramPacket(reply, reply.length);
            // 接收服务器相应的数据
            socket.receive(packet2);
            // 读取字节数组中的数据
            content = new String(reply, 0, packet2.getLength());
            System.out.println("转置后的结果为：" + content);

            /* 关闭资源 */
            socket.close();
            scanner.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端输出：
                 **服务器已经启动**
                 处理需要转置的字符串：JavaScript

客户端输出：
                 输入需要倒转的字符串：JavaScript
                 转置后的结果为：tpircSavaJ

========================TCP==============================

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。

当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。

TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) {
        try {
            System.out.println("**服务器已经启动**");

            // 创建服务器Socket，并填写端口号
            ServerSocket serverSocket = new ServerSocket(8888);

            /* TCP数据传输 */
            while (true) {

                /* 处理客户端的请求 */
                // 调用accept()方法监听客户端连接
                Socket socket = serverSocket.accept();
                // 从客户端接收内容
                InputStream is = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader reader = new BufferedReader(isr);
                // 将响应内容存入字符串中
                String data = null;
                StringBuffer content = new StringBuffer();
                do {
                    if (data != null) {
                        content.append(data);
                    }
                } while ((data = reader.readLine()) != null);
                // 关闭输入流
                socket.shutdownInput();

                /* 服务器处理任务 */
                System.out.println("处理需要转置的字符串：" + content);
                // 倒置字符串
                content = content.reverse();

                /* 发送服务端响应 */
                OutputStream os = socket.getOutputStream();
                PrintWriter writer = new PrintWriter(os);
                writer.write(new String(content));
                writer.flush();
                // 关闭输出流
                socket.shutdownOutput();

                /* 关闭资源 */
                reader.close();
                isr.close();
                is.close();
                writer.close();
                os.close();
                socket.close();
            }

            /* 关闭Socket */
            // serverSocket.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TCPClient {
    public static void main(String[] args) {
        try {

            // 创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("localhost", 8888);

            /* 获取用户需要处理的字符串 */
            Scanner scanner = new Scanner(System.in);
            System.out.print("输入需要倒转的字符串：");
            String content = scanner.nextLine();

            /* 向服务器发送数据 */
            // 将数据以输出流形式发送
            OutputStream os = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(os);
            writer.write(content); // 写入数据
            writer.flush(); // 刷新缓存
            // 关闭输出流
            socket.shutdownOutput();

            /* 从服务器获得数据 */
            // 将数据以输入流形式获取
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader reader = new BufferedReader(isr);
            /* 将响应内容存入字符串中 */
            String data = null;
            StringBuffer buffer = new StringBuffer();
            do {
                if (data != null) {
                    buffer.append(data);
                }
            } while ((data = reader.readLine()) != null);
            // 关闭输入流
            socket.shutdownInput();
            System.out.println("转置后的结果为：" + buffer);

            /* 关闭资源 */
            writer.close();
            os.close();
            socket.close();
            reader.close();
            isr.close();
            is.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端输出：
                 **服务器已经启动**
                 处理需要转置的字符串：Android

客户端输出：
                 输入需要倒转的字符串：Android
                 转置后的结果为：diordnA