Java整理（七）网络编程Socket

java.net 包中提供了两种常见的网络协议的支持：

TCP：是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。

UDP：是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。

端口：用于区分不同应用程序，0~65535，其中0~1023为系统保留

http:80 ftp:21 telnet:23

 

Socket编程

服务器实例化ServerSocket对象，表示通过服务器上的端口通信。

服务调用ServerSocket类的accept()方法，等待客户端请求。

客户端实例化一个Socket对象，指定服务器。

服务器accept()返回一个新socket引用，连接到客户端。

连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。

java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

ServerSocket 类

服务器应用程序通过使用java.net.ServerSocket 类以获取一个端口,并且侦听客户端请求。

ServerSocket 类有四个构造方法：

1     publicServerSocket(int port) throws IOException

创建绑定到特定端口的服务器套接字。

2     publicServerSocket(int port, int backlog) throws IOException

利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。

3     publicServerSocket(int port, int backlog, InetAddress address) throws IOException

使用指定的端口、侦听backlog 和要绑定到的本地 IP 地址创建服务器。

4     publicServerSocket() throws IOException

创建非绑定服务器套接字。

ServerSocket 类的常用方法：

1     publicint getLocalPort()

  返回此套接字在其上侦听的端口。

2     publicSocket accept() throws IOException

侦听并接受到此套接字的连接。

3     publicvoid setSoTimeout(int timeout)

 通过指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位。

4     publicvoid bind(SocketAddress host, int backlog)

将 ServerSocket绑定到特定地址（IP 地址和端口号）。

Socket 类

Java.net.Socket 类代表客户端和服务器都用来互相沟通的套接字。客户端要获取一个Socket 对象通过实例化 ，而服务器获得一个Socket对象则通过 accept()方法的返回值。

Socket 类有五个构造方法：

1     publicSocket(String host, int port) throws UnknownHostException, IOException.

创建一个流套接字并将其连接到指定主机上的指定端口号。

2     publicSocket(InetAddress host, int port) throws IOException

创建一个流套接字并将其连接到指定 IP 地址的指定端口号。

3     publicSocket(String host, int port, InetAddress localAddress, int localPort) throwsIOException.

创建一个套接字并将其连接到指定远程主机上的指定远程端口。

4     publicSocket(InetAddress host, int port, InetAddress localAddress, int localPort)throws IOException.

创建一个套接字并将其连接到指定远程地址上的指定远程端口。

5     publicSocket()

通过系统默认类型的SocketImpl 创建未连接套接字

当 Socket 构造方法返回，并没有简单的实例化了一个 Socket 对象，它实际上会尝试连接到指定的服务器和端口。

Socket常用方法：

1     publicvoid connect(SocketAddress host, int timeout) throws IOException

将此套接字连接到服务器，并指定一个超时值。

2     publicInetAddress getInetAddress()

 返回套接字连接的地址。

3     publicint getPort()

返回此套接字连接到的远程端口。

4     publicint getLocalPort()

返回此套接字绑定到的本地端口。

5     publicSocketAddress getRemoteSocketAddress()

返回此套接字连接的端点的地址，如果未连接则返回 null。

6     publicInputStream getInputStream() throws IOException

返回此套接字的输入流。

7     publicOutputStream getOutputStream() throws IOException

返回此套接字的输出流。

8     publicvoid close() throws IOException

关闭此套接字。

InetAddress 类

表示互联网协议(IP)地址，包括IPv4和IPv6。

无构造方法，根据静态方法返回实例。

1     staticInetAddress getByAddress(byte[] addr)

在给定原始 IP 地址的情况下，返回 InetAddress 对象。

2     staticInetAddress getByAddress(String host, byte[] addr)

根据提供的主机名和 IP 地址创建 InetAddress。

3     staticInetAddress getByName(String host)

在给定主机名的情况下确定主机的 IP 地址。这个方法不只是设置InetAddress类中一个私有字段String，而是会建立与本地DNS服务器的一个连接，来查找名字和数字地址。如：

InetAddress address = InetAddress.getByName("www.google.com");
System.out.println(address);

输出：www.google.com/67.15.100.252

4     StringgetHostAddress()

返回 IP 地址字符串（以文本表现形式）。

5     StringgetHostName()

 获取此 IP 地址的主机名。

6     staticInetAddress getLocalHost()

返回本地主机。

DatagramSocket和DatagramPacket

DatagramPacket：表示数据报包

DatagramSocket：进行端到端通信的类

使用UDP协议，将数据保存在数据报中，通过网络进行通信。

接收端：

DatagramSocket serverSocket = newDatagramSocket(port);

byte[] data = new byte[1024];//创建数据报，用于接收客户端发送的数据

DatagramPacket packet = newDatagramPacket(data,data.length);

serverSocket.receive(packet);//接收，阻塞

发送端：

InetAddress address =InetAddress.getByName(serverName);

byte[] data = "发送的消息".getBytes();

DatagramPacket packet = newDatagramPacket(data,data.length,address,port);

DatagramSocket socket = newDatagramSocket();

socket.send(packet);

Demo

TCP

服务端：

importjava.net.*;
import java.io.*;
public class Test_SocketServer_TCP extends Thread {

    private ServerSocketserverSocket;

    public Test_SocketServer_TCP(int port) throws IOException
    {
        serverSocket = new ServerSocket(port);
        serverSocket.setSoTimeout(100000);//指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位
    }

    public void run()
    {
        while(true)
        {
            try
            {
                System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
                Socket server = serverSocket.accept();//等待连接，阻塞，返回一个Socket对象
                System.out.println("远程主机地址：" + server.getRemoteSocketAddress());
                DataInputStream in = new DataInputStream(server.getInputStream());
                System.out.println(in.readUTF());
                DataOutputStream out = new DataOutputStream(server.getOutputStream());
                out.writeUTF("服务器发送的消息：" + server.getLocalSocketAddress() + "\nGoodbye!");
                server.close();
            }catch(SocketTimeoutException s)
            {
                System.out.println("Socket timed out!");
                break;
            }catch(IOException e)
            {
                e.printStackTrace();
                break;
            }
        }
    }

    public static void main(String[] args) {
        int port = 10009;
        try
        {
            Thread t = new Test_SocketServer_TCP(port);
            t.run();
        }catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

客户端：

public static void socket_tcp(){
    String serverName = "localhost";
    int port = 10009;
    try
    {
        System.out.println("连接到主机：" + serverName + " ，端口号：" + port);
        Socket client = new Socket(serverName, port);
        System.out.println("远程主机地址：" + client.getRemoteSocketAddress());
        OutputStream outToServer = client.getOutputStream();
        DataOutputStream out = new DataOutputStream(outToServer);

        out.writeUTF("客户端发送的消息。。。" + client.getLocalSocketAddress());
        InputStream inFromServer = client.getInputStream();
        DataInputStream in = new DataInputStream(inFromServer);
        System.out.println("服务器响应： " + in.readUTF());
        client.close();
    }catch(IOException e)
    {
        e.printStackTrace();
    }
}

 

UDP

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

服务端：

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

public class Test_SocketServer_UDP extends Thread {
    private DatagramSocket serverSocket;

    public Test_SocketServer_UDP(int port) throws IOException
    {
        serverSocket = new DatagramSocket(port);
        serverSocket.setSoTimeout(100000);//指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位
    }

    public void run()
    {
        while(true)
        {
            try
            {
                System.out.println("等待接收数据，端口号为：" + serverSocket.getLocalPort() + "...");
                byte[] data = new byte[1024];//创建数据报，用于接收客户端发送的数据
                DatagramPacket packet = new DatagramPacket(data,data.length);
                serverSocket.receive(packet);//接收，阻塞
                String info = new String(data,0,data.length);
                System.out.println(info);
//                serverSocket.close();
            }catch(SocketTimeoutException s)
            {
                System.out.println("Socket timed out!");
                break;
            }catch(IOException e)
            {
                e.printStackTrace();
                break;
            }
        }
    }
    public static void main(String[] args) {
        int port = 10010;
        try
        {
            Thread t = new Test_SocketServer_UDP(port);
            t.run();
        }catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

客户端：

public static void socket_udp() throws UnknownHostException {
    String serverName = "localhost";
    InetAddress address = InetAddress.getByName(serverName);
    int port = 10010;
    try {
        byte[] data = "客户端发送的消息。。。".getBytes();
        DatagramPacket packet = new DatagramPacket(data,data.length,address,port);
        DatagramSocket socket = new DatagramSocket();
        socket.send(packet);
        socket.close();
    }catch(IOException e)
    {
        e.printStackTrace();
    }
}