Java Socket

1. 套接字介绍

　　套接字是介于传输层(TCP/UDP)和应用层(HTTP/FTP)之间的一个抽象，被应用程序调用;

　　在java环境中套接字编程主要使用TCP/IP协议，但是套接字支持的协议族远不止这些；

　　在java套接字编程中有Socket和ServerSocket两个核心类，ServerSocket位于服务器端监听连接，Socket位于客户端发起连接，服务器端监听到连接后也会产生一个Socket实例来完成与对端Socket的通信，并且服务器端的Socket和客户端的Socket没有任何区别，也就是说进程间通信需要一对套接字完成；

2. API介绍

　　Socket和ServerSocket是java提供网络编程的门面接口，实际上都是通过SocketImpl及子类完成的；

 2.1 重要类关系图

 

 2.2 重要类介绍

  1. InetAddress

　　InetAddress是java对IP地址的封装，包括IP设备的名称、ip地址，有Inet4Address和Inet6Address两个子类；

　　没有公开的构造方法，只能通过公开的静态方法实例化对象

   方法介绍

　　1）getByName：实例化一个InetAddress对象，getByName的参数可以是ip地址字符串，也可以是主机名

　　2）anyLocalAddress：实例化一个表示任何本地地址的网络地址，通常是0.0.0.0

　　3）getHostAddress一般通过InetAddress的获取主机ip地址串，通过获取主机名

　　4）getHostName

  2. SocketAddress/InetSocketAddress

　　套接字地址，用来表示一个套接字在网络中的位置；

　　SocketAddress不依赖任何协议的套接字地址；

　　InetSocketAddress表示一个IP套接字地址，由套接字地址的 IP地址(InetAddress)、主机名和端口号组成

  3. ServerSocket

　　服务器套接字，在服务器端用于监听网络传入

    构造方法

　　1）ServerSocket()：创建一个不绑定任何ip和端口的服务器套接字

　　创建一个SocksSocketImpl赋值给ServerSocket的SocketImpl，并把自己赋值给SocketImpl的ServerSocket

　　2）ServerSocket(port, backlog, InetAddress)：用指定的端口、连接大小、ip地址创建一个服务器套接字

　　　　同无参构造，创建SocksSocketImpl并相互赋值

　　　　根据port和InetAddress创建套接字地址InetSocketAddress（InetAddress, port），如果InetAddress为null则通过InetAddress的anyLocalAddress实例化一个IP地址，如果port不合法则抛出异常；

　　　　通过调用bind(SocketAddress, backlog)将服务器套接字和套接字地址进行绑定；

　　　　backlog说明https://blog.csdn.net/oyueyang1/article/details/80451535

    方法介绍

　　1）bind(SocketAddress, backlog)：将服务器套接字和套接字地址进行绑定，tcp accept队列大小为backlog

　　　　如果SocketAddress为null则新建一个InetSocketAddress(InetAddress.anyLocalAddress, 0),0表示让系统随机分配端口号

　　　　实际上通过SocketImpl的bind(InetAddress, port)绑定的，SocketImpl是在构造函数中创建并绑定到当前类的

　　　　有参构造方法在构造过程都进行了bind操作，所以此方法一般与无参构造方法同时使用

　　2）isBound、getInetAddress、getLocalPort、getLocalSocketAddress查询bind方法的绑定信息

　　3）accept：阻塞式的监听到此服务器套接字连接，监听到连接后会创建一个Socket套接字，服务端和客户端各有一个Socket，2个套接字可以完成不同进程间通信；

　　4）implAccept(Socket)：为保护方法，当我们自定义ServerSocket需要复写accept方法时，需要新建一个Socket然后通过implAccept加工，accept的阻塞其实是阻塞在implAccept的加工过程

　　5）getChannel：获取ServerSocketChannel通道

　　6）close/isClose：关闭套接字/判断套接字是否已关闭

　　　　关闭服务器套接字后，阻塞在accept的线程会抛出SocketException；

　　　　ServerSocketChannel通道关闭；

　　　　注意：没有直接方法判断对端套接字是否关闭

　　7）getSoTimeout/setSoTimeout： 设置accept的阻塞时间，0时表示无穷大，如果超时抛出SocketTimeOutException；

　　　　间接调用SocketImple的getOption(capId)/setOption(capId,Object), capId为SO_TIMEOUT(SocketOption中定义)；

　　8）setSocketFactory(SocketImplFactory)：设置套接字实现工厂

　　　　构造方法中会创建一个SocketImpl，默认是创建SocksSocketImpl，如果已设置SocketImplFactory则会调用工厂方法创建一个

  4. Socket

　　套接字或客户端套接字，不同进程通信的端点，服务器端会有n多个客户端套接字

   构造方法

　　1）Socket()：创建一个不绑定任何套接字地址，不连接任务服务器套接字的套接字

　　　　创建一个SocksSocketImpl赋值给Socket的SocketImpl，并把自己赋值给SocketImpl的Socket, 同ServerSocket的无参构造方法

　　2）Socket(SocketAddress serverAddress, SocketAddress localAddress, boolean stream)：创建套接并绑定和连接到指定套接字地址

　　　　绑定到本地套接字地址localAddress，连接的服务器套接字地址为serverAddress；

　　　　如果localAddress为null则内核随机选择一个本地ip地址和端口进行绑定；

　　　　stream表示流套接字（tcp），负责数据包datagram套接字（udp，每个包有大小限制）

　　3）Socket(InetAddress server, int serverPort, InetAddress local, int localPort)：创建套接并绑定和连接到指定套接字地址

　　　　将server和serverPort封装成服务器套接字SocketAddress，local和localPort封装成客户端套接字SocketAddress，然后调用Socket(SocketAddress, SocketAddress, stream)创建流式套接字

　　4）Socket(String host, int port)：

　　　　将host和port封装成服务器端套接字地址SocketAddress；

　　　　本地SocketAddress为null则，本地端口随机，任意一本机ip；

　　　　调用Socket（SocketAddress， SocketAddress， stream）创建流式Socket；

   方法介绍

　　1）connect(SocketAddress)/connect(SocketAddress, timeout)： 连接到套接字地址指定的服务器套接字

　　　　有参数构造方法中都会调用connect方法，所以此方法一般与无参构造方法同时使用

　　2）bind(SocketAddress) ：将套接字和套接字地址进行绑定

　　　　如果已绑定则异常；

　　　　如果没有绑定在connect方法中会进行绑定，所以如果要调用bind方法需要在connect前调用；

　　3）getInetAddress()/getPort()/getRemoteSocketAddress()： 获取 对端 套接字的IP地址、端口号、套接字地址，没有连接则返回null

　　4）getLocalAddress()/getLocalPort()/getLocalSocketAddress()：获 此 套接字的IP地址、端口号、套接字地址

　　5）getChannel()：返回此套接字的SocketChannel通道

　　6）getInputStream()：返回套接字的输入流

　　　　如果连接正常，inputstream的read会一直阻塞；

　　　　关闭输入流会关闭对应的套接字；

　　　　当Socket底层的连接中断时，套接字已缓存的字节可以通过read读取，如果已经消耗了所有缓存的字节，read操作会抛出IOException，套接字上没有任何缓存字节，并且套接字没有关闭调用 available返回0

　　7）getOutputStream()：返回套接字的输出流

　　　　关闭输出流会关闭对应的套接字

　　8）setSoTimeout(timeout)：Socket关联的InputStream的read操作默认是阻塞的，如果设置超时值，read操作超时引发SocketTimeoutException

　　　　 实际上通过SocketImpl的setOption(optId)实现， optId为SO_TIMEOUT（SocketOptions中定义）

　　9）close：关闭套接字

　　　　阻塞于当前套接字的IO操作会抛出SocketException;

　　　　关闭后不能重新连接和重新绑定（已建立的连接不能用），只能通过新建；

　　　　会关闭此套接字的输入输出流；

　　　　关闭关联的通道；

　　10）shutdownInput：丢弃发送到输入流的所有字节，读取内容返回EOF

　　11）shutdownOutput：禁用输出流，以前发送的字节都会被底层发送，如果关闭后执行写入会抛出IOException

　　12）isBound/isClose/isConnect/isInputShutdown/isOutputSHutdown：用于判断相应的操作是否结束

　　13）setSocketImplFactory：设置套接字实现的工厂，构造方法默认会创建一个SocksSocketImpl，如果指定工厂会通过工厂创建

3. 实例

 工具类：SocketUtil

import java.net.InetSocketAddress;
import java.net.SocketAddress;

/**
 * 工具类
 */
public class SocketUtil {

    /**
     * 解析套接字地址中的ip和端口
     */
    public static String getSocketAddress(SocketAddress socketAddress) {

        if (socketAddress instanceof InetSocketAddress) {
            InetSocketAddress inetSocketAddress = ((InetSocketAddress) socketAddress);
            int port = inetSocketAddress.getPort();
            String hostName = inetSocketAddress.getHostName();
            return String.format("%s:%s", hostName, port);
        }

        return null;
    }
}

 服务器类：DemoTcpServer

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 群聊服务器：启动服务器套接字，监听并处理连接
 */
public class DemoTcpServer {

    static final List<Socket> ONLINE_SOCKET = new ArrayList();

    public static void main(String[] args) throws IOException {

        // 创建服务器套接字，并绑定到本机的41440端口监听
        ServerSocket serverSocket = new ServerSocket(41440, 50, InetAddress.getByName("192.168.1.101"));
        System.out.println("服务器started...");

        // 创建线程池用于处理已连接的socket
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        while (true) {
            // 等待socket接入，有连接接入后会创建一个Socket与对端Socket通信，此Socket地址ip为本机、端口随机
            Socket socket = serverSocket.accept();
            String socketAddress = SocketUtil.getSocketAddress(socket.getRemoteSocketAddress());
            System.out.println(socketAddress + " 上线了...");
            // 加入到在线的socket列表，用于群发消息
            ONLINE_SOCKET.add(socket);
            // 单独起一个线程监听消息，可以改成nio的Selectors实现
            executorService.submit(new SocketHandler(socket));
        }
    }
}

/**
 * 处理Socket的任务
 */
class SocketHandler implements Runnable {

    private Socket socket;

    public SocketHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            String clientFlag = SocketUtil.getSocketAddress(this.socket.getRemoteSocketAddress());
            byte[] input = new byte[1024];
            // 循环监听消息
            while (true) {
                // 阻塞式读取消息
                int read = this.socket.getInputStream().read(input);
                // 服务器记录发送的所有消息
                System.out.println(clientFlag + " " + new String(input, 0, read, "utf-8"));
                // 群发消息
                sendMsg(this.socket, clientFlag, new String(input, 0, read, "utf-8"));
            }
        } catch (IOException e) {
            System.out.println(SocketUtil.getSocketAddress(socket.getRemoteSocketAddress()) + "下线...");
            DemoTcpServer.ONLINE_SOCKET.remove(socket);
        }
    }

    /**
     * 群发消息
     */
    private void sendMsg(Socket ignoreSocket, String clientFlag, String msg) {

        Iterator<Socket> iterator = DemoTcpServer.ONLINE_SOCKET.iterator();
        while (iterator.hasNext()) {

            Socket currentSocket = iterator.next();

            // 不需要向此Socket对端发送消息，只有一个客户端时需要注解此判断
            if (currentSocket.equals(ignoreSocket)) {
                continue;
            }

            // 发送消息到客户端
            try {
                currentSocket.getOutputStream().write((clientFlag + System.lineSeparator() + msg).getBytes("utf-8"));
            } catch (Exception e) {
                System.out.println(SocketUtil.getSocketAddress(currentSocket.getRemoteSocketAddress()) + "下线...");
                iterator.remove();
            }
        }
    }
}

 客户端类：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端
 */
public class DemoTcpClient {
    public static void main(String[] args) throws Exception {

        //以下3步可以通过有参构造方法一次指定
        // 创建客户端socket
        Socket socket = new Socket();
        // 绑定到本地的ip和端口号
        socket.bind(new InetSocketAddress("192.168.1.101", 41441));
        // 连接到远程的套接字服务器
        socket.connect(new InetSocketAddress("192.168.1.101", 41440), 0);
        System.out.println("已上线...");

        // 新启动线程用于回显消息
        new Thread(() -> {
            try {
                byte[] input = new byte[1024];
                while (true) {
                    int read = socket.getInputStream().read(input);
                    System.out.println(new String(input, 0, read, "utf-8"));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        //处理输入
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            socket.getOutputStream().write(scanner.nextLine().getBytes("utf-8"));
            socket.getOutputStream().flush();
        }
    }
}

 

---

 

 参考文献：

　　1. https://droidyue.com/blog/2015/03/08/sockets-programming-in-java/
　　2. https://my.oschina.net/leejun2005/blog/104955
　　3. https://www.cnblogs.com/w-wfy/p/6415840.html