039.JAVA Socket网络编程概要

JAVA中的网络支持

针对网络通信的不同层次，JAVA提供的网络功能有四大类：

• InetAddress：用于标识网络上的硬件资源。
• URL：统一资源定位符，通过URL可以直接读取或写入网络上的数据。
• Sockets：使用TCP协议实现网络通信的Socket相关的类。
• Datagram：使用UDP协议，将数据保存在数据报中，通过网络进行通信。

InetAddress类使用示例

获取主机的软硬件信息。

import java.net.InetAddress;
import java.net.UnknownHostException;

public class SocketDome {
    public static void main(String[] args) {
        try {
            InetAddress address = InetAddress.getLocalHost();   //获取本机的InetAddress实例
            
            System.out.println("计算机名："+address.getHostName());
            System.out.println("IP地址："+address.getHostAddress());
            System.out.println("获取的本地InerAddress对象："+address);
        } catch (UnknownHostException e) {
            e.printStackTrace();
            System.out.println("程序异常："+e);
        }
    }
}

URL类使用示例

通过URL对象的openStream()方法可以得到指定的输入流，通过输入流可以读取、访问网络上的数据。

/**
     * 获取URL对应的资源
     */
    public void urlDome(){
        try {
            URL baidu = new URL("http://www.baidu.com");   //创建一个URL实例
            InputStream is = baidu.openStream();                //获取URL对象所表示资源的字节输入流
            InputStreamReader isr = new InputStreamReader(is);  //将字节输入流转换为字符输入流
            BufferedReader br = new BufferedReader(isr);        //为字符输入流添加缓冲
            int i=0;
            while (br.readLine()!=null){
                System.out.println(br.readLine());      //按行输出获取到的字符
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Socket通信原理及步骤

​ Socket是基于TCP协议实现网络通信的类。TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据。

​ 客户端封装Socket类，服务端封装ServerSocket类。

Socket通信实现步骤：

• 创建ServerSocket和Socket。
• 打开连接到Socket的输入/输出流。
• 按照协议对Socket进行读/写操作。
• 关闭输入输出流，关闭Socket。

服务器端：

1、创建ServerSocket对象，绑定监听端口。

2、通过accept()方法监听客户端连接请求。

3、连接建立后，通过输入流读取客户端发送的请求消息。

4、通过输出流向客户端发送响应消息。

5、关闭相关资源。

客户端：

1、创建Socket对象，指明需要连接的服务器的地址和端口号。

2、连接建立后，通过输出流向服务器端发送请求信息。

3、通过输入流获取服务器响应的信息。

4、关闭相关资源。

Socket会话实例：

服务端：

package com.example.demo;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public void serverImpl(){
        try {
            //创建服务端Socket
            ServerSocket listenSocket = new ServerSocket(2024); //创建一个服务端Socket，并绑定监听端口
            System.out.println("***服务器即将启动，等待客户端的连接***");

            //处理客户端发来的连接请求，生成客户端Socket对象
            Socket clientSocket =  listenSocket.accept();   //服务器阻塞等待，直到获取并接受到客户端的连接请求
            System.out.println("客户端连接成功！客户机地址为："+clientSocket.getRemoteSocketAddress());

            //获取输入流，以获取客户端发来的数据
            InputStream input = clientSocket.getInputStream();    //从clientSocket生成输入流。
            InputStreamReader inputReader = new InputStreamReader(input);   //将字节流转换为对中文兼容好的字符流
            BufferedReader bufferedReader = new BufferedReader(inputReader);    //创建与字符流配套的缓冲流

            //读取客户端发来的数据
            String clientInfo = null;
            while ((clientInfo = bufferedReader.readLine()) != null)  //循环读取文本行
            System.out.println("客户端数据说："+clientInfo);

            //获取输出流
            OutputStream output = clientSocket.getOutputStream();   //获取输出流
            OutputStreamWriter outputWriter = new OutputStreamWriter(output);   //将字节流转换为字符流
            BufferedWriter bufferedWriter = new BufferedWriter(outputWriter);   //为字符流添加缓冲

            //响应客户端会话
            String replayData = "你好！我是服务器，很高兴认识你";
            bufferedWriter.write(replayData);   //写入回复的数据
            bufferedWriter.flush();     //刷新该流的缓冲
            System.out.println("已回复客户端会话："+replayData);

            //关闭相关资源
            if (bufferedReader != null)
                bufferedReader.close();
            if (clientSocket != null)
                clientSocket.close();
            if (listenSocket != null)
                listenSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.serverImpl();
    }
}

客户端：

package com.example.demo;

import java.io.*;
import java.net.Socket;

public class Client {
    public void clientImpl(){
        try {
            //创建客户端Socket，并指定要连接的服务器地址和端口
            Socket clientSocket = new Socket("127.0.0.1",2024);
            //获取输出流
            OutputStream output = clientSocket.getOutputStream();   //从socket生成字节输出流
            OutputStreamWriter outputWriter = new OutputStreamWriter(output);   //将字节流转换为字符流
            BufferedWriter bufferedWriter = new BufferedWriter(outputWriter);   //为字符流添加配套的缓冲

            //向服务器端发送消息
            String Data = "服务器你好，我是客户端！";
            bufferedWriter.write(Data);   //写入数据
            bufferedWriter.flush();     //向服务器发送数据
            System.out.println("已对服务器说："+Data);

            clientSocket.shutdownOutput();  //关闭输出流

            //获取输入流
            InputStream input = clientSocket.getInputStream();
            InputStreamReader inputReader = new InputStreamReader(input);
            BufferedReader bufferedReader = new BufferedReader(inputReader);

            //读取服务端响应的数据
            String result = null;
            while ((result = bufferedReader.readLine()) != null)
                System.out.println("服务器回复的消息："+result);

            //关闭相关资源
            if (bufferedReader != null)
                bufferedReader.close();
            if (bufferedWriter != null)
                bufferedWriter.close();
            if (clientSocket != null)
                clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Client client = new Client();
        client.clientImpl();
    }
}

应用多线程实现服务端与多客户端通信

大多数场景下，服务端都需与多客户端进行通信，由此便需要用到多线程技术，实现与多客户端的通信。

基本步骤：

1、服务器端创建ServerSocket，循环调用accept()等待客户端连接。

2、客户端创建一个socket并请求和服务器端连接。

3、服务器端接受客户端请求，创建socket与该客户建立专线连接。

4、建立连接的两个socket在一个单独的线程上对话。

5、服务器端继续等待新连接。

实现多线程只需在上面例子的基础上修改服务端代码即可。

修改后的Server类代码为：

package com.example.demo;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public void serverImpl(){
        try {
            //创建服务端Socket
            ServerSocket listenSocket = new ServerSocket(2024); //创建一个服务端Socket，并绑定监听端口
            System.out.println("***服务器即将启动，等待客户端的连接***");

            //处理客户端发来的连接请求，生成客户端Socket对象
            Socket clientSocket = null;

            //设置一个死循环，调用accpet方法循环监听，等待客户端连接
            while (true){
                clientSocket =  listenSocket.accept();   //服务器阻塞等待，直到获取并接受到客户端的连接请求
                ServerThread serverThread = new ServerThread(clientSocket);    //收到连接请求创建一个新的服务线程
                serverThread.setPriority(4);    //设置线程的优先级，范围为1-10，默认为5
                serverThread.start();   //启动线程

                System.out.println("已收到一条客户端连接请求，创建一条客户连接线程，线程ID为"+serverThread.getId());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.serverImpl();
    }
}

创建服务线程类，继承Thread类重写run方法。将原来Server类中，获取输入输出流以读取响应客户端请求的代码，迁移至重写的run方法中。

ServerThread类的代码为：

package com.example.demo;

import java.io.*;
import java.net.Socket;

/**
 * 服务器线程处理类
 */
public class ServerThread extends Thread{
    Socket socket = null;   //与本线程相关的Socket
    
    //构造方法初始化Socket
    public ServerThread(Socket socket){
        this.socket = socket;
    }
    
    //重写run方法，自定义线程执行的操作，响应客户端请求
    public void run(){
        try {
            //获取输入流，以获取客户端发来的数据
            InputStream input = socket.getInputStream();    //从clientSocket生成输入流。
            InputStreamReader inputReader = new InputStreamReader(input);   //将字节流转换为对中文兼容好的字符流
            BufferedReader bufferedReader = new BufferedReader(inputReader);    //创建与字符流配套的缓冲流

            //读取客户端发来的数据
            String clientInfo = null;
            while ((clientInfo = bufferedReader.readLine()) != null)  //循环读取文本行
                System.out.println("客户端数据说：" + clientInfo);

            //获取输出流
            OutputStream output = socket.getOutputStream();   //获取输出流
            OutputStreamWriter outputWriter = new OutputStreamWriter(output);   //将字节流转换为字符流
            BufferedWriter bufferedWriter = new BufferedWriter(outputWriter);   //为字符流添加缓冲

            //响应客户端会话
            String replayData = "你好！我是服务器，很高兴认识你";
            bufferedWriter.write(replayData);   //写入回复的数据
            bufferedWriter.flush();     //刷新该流的缓冲
            System.out.println("已回复客户端会话：" + replayData);

            //关闭相关资源
            if (bufferedReader != null)
                bufferedReader.close();
            if (socket != null)
                socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

基于UDP的Socket编程

​ UDP协议（用户数据报协议）是无连接、不可靠的、无序的。UDP协议以数据报作为数据传输的载体。

​ 进行数据传输时，首先需要将要传输的数据定义成数据报（Datagram），在数据报中指明数据所要到达的Socket（主机地址和端口号），然后再将数据报发送出去。

• DatagramPacket：表示数据报包
• DatagramSocket：进行端到端通信的类

服务器端实现步骤：

1、创建DatagramSocket，指定端口号。

2、创建DatagramPacket。

3、接受客户端发送的数据信息。

4、读取数据。

客户端实现步骤：

1、定义发送信息。

2、创建DatagramPacket，包含将要发送的信息。

3、创建DatagramSocket。

4、发送数据

基于UDP的Socket通信实例如下（多线程实现逻辑跟上面的例子差不多，这里就不重复操作了）：

服务器端：

package com.example.demo;

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

/**
 * 服务端，基于UDP的用户登录
 */
public class UDPServer {
    public void serverImpl(){
        try {
            int port = 8800;
            DatagramSocket socket = new DatagramSocket(port);   //创建服务器端DatagramSocket，指定监听端口

            //接受数据
            byte[] data = new byte[1024];   //创建字节数组，指定接收的数据包大小
            DatagramPacket packet = new DatagramPacket(data,data.length);   //创建数据报，用于接收客户端发送的数据
            System.out.println("***服务器端已经启动，等待客户端连接***");

            socket.receive(packet);  //接受客户端发送的数据报，此方法在接收到数据报之前会一直阻塞
            String info = new String(data,0,packet.getLength());    //读取数据
            System.out.println("我是服务器，客户端说："+info);

            //响应消息
            InetAddress clientAddress = packet.getAddress();  //获取客户端地址
            int clientPort = packet.getPort();  //获取客户端端口
            byte[] replayData = "登录成功，欢迎您！".getBytes();    //定义响应数据，并转换为字节类型
            DatagramPacket replayPacket = new DatagramPacket(replayData,replayData.length,clientAddress,clientPort);  //创建数据包，并绑定客户端地址
            socket.send(replayPacket); //向客户端响应数据报
            System.out.println("已向客户端响应数据："+new String(replayData));

            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        UDPServer server = new UDPServer();
        server.serverImpl();
    }
}

客户端：

package com.example.demo;

import java.io.IOException;
import java.net.*;

public class UDPClient {
    public void clientImpl(){
        try {
            DatagramSocket socket = new DatagramSocket();   //创建DatagramSocket对象

            //发送数据
            InetAddress address = InetAddress.getByName("localhost");   //定义服务器地址
            int port = 8800;    //定义服务器端口
            byte[] data = "用户名：admin;密码：123".getBytes();    //定义发送数据，并转换为字节类型
            DatagramPacket packet = new DatagramPacket(data,data.length,address,port);  //创建数据包，并绑定服务器地址
            socket.send(packet); //向服务器发送数据报
            System.out.println("已向服务器发送数据："+new String(data));

            //接受响应消息
            byte[] replayData = new byte[1024];   //创建字节数组，指定接收的数据包大小
            DatagramPacket serverPacket = new DatagramPacket(replayData,replayData.length);   //创建数据报，用于接收服务器响应的数据

            socket.receive(serverPacket);  //接受服务器响应的数据报，此方法在接收到数据报之前会一直阻塞
            String info = new String(replayData,0,serverPacket.getLength());    //读取数据
            System.out.println("我是客户端，服务端回复说："+info);

            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        UDPClient client = new UDPClient();
        client.clientImpl();
    }
}

重点总结

本章主要内容

• Socket通信的主要步骤。

• 基于TCP的Socket通信。

• 基于UDP的Socket通信。

• 基于多线程的服务器与多客户端通信。

多线程的优先级：

serverThread.setPriority(4);    //设置线程的优先级，范围为1-10，默认为5

未设置优先级可能会导致运行时速度非常慢，可降低优先级。

是否关闭输出流和输入流：

​ 程序未执行结束时，不能关闭输出流。对于同一个socket的输出流，如果关闭了输出流，则与该输出流关联的Socket也会被关闭，所以一般不用关闭流，最后直接关闭socket即可。

关于数据传输格式：

​ 上面例子使用TCP通信传输数据，是通过字符串的形式传输的，而实际的应用中，更多是通过将数据封装成对象进行传输的。

2020年10月27日 完结

---