Java 日看一类（60）之net包中的AbstractPlainDatagramSocketImpl类

关注

原创最新推荐文章于 2026-08-05 17:41:51 发布 1k 阅读 AI 写同款· GEO 优化 ›

网络编程之三：java.net包的DatagramSocket和DatagramPacket 本博文主要简述TCP/UDP的比较和应用场景，继而java.net包下基于DatagramSocket/DatagramPacket的编程和源码分析 TCP与UDP作为传输层两个重要的协议，得到广泛的使用 TCP 1、面向连接，速度较慢，证明：连接双方的一方主动断开连接之后，另一方的recieve（）会立即作出响应 2、面向字节流，虽然应用程序和TCP的交互是一次一个数据块（大小不等），但TC 阅读详情

该类引入了如下包：

import java.io.FileDescriptor;
import java.io.IOException;
import java.security.AccessController;
import sun.net.ResourceManager;

该类继承自DatagramSocketImpl类

该类不是公共类

该类的类头注释如下：

/**
 * Abstract datagram and multicast socket implementation base class.
 * Note: This is not a public class, so that applets cannot call
 * into the implementation directly and hence cannot bypass the
 * security checks present in the DatagramSocket and MulticastSocket
 * classes.
 *
 * @author Pavani Diwanji
 */

大意如下：

该类是数据报和组播的基础实现类。

注意：该类不是公共类，所以applets不能直接调用该实现并且因此不能避过在DatagramSocket和MulticastSocket的即时安全性检查

该类含有如下的成员变量：

超时记录（等ack

int timeout = 0;

连接状态

boolean connected = false;

服务类型

private int trafficClass = 0;

目的地址

protected InetAddress connectedAddress = null;

目的端口

private int connectedPort = -1;

本地主机名

private static final String os = AccessController.doPrivileged(//跳过权限检查
    new sun.security.action.GetPropertyAction("os.name")
);

检测连接是否被禁用（看主机名里是不是有OS X，我本人用的Mac os，所以检测的是OS X），如果为false，native函数connect不能调用

private final static boolean connectDisabled = os.contains("OS X");

该类含有如下的成员方法：

默认构造函数

protected synchronized void create() throws SocketException {
    ResourceManager.beforeUdpCreate();//资源管理器检查创建UDP的资源
    fd = new FileDescriptor();//创建文件描述符
    try {
        datagramSocketCreate();//尝试创建DatagramSocket
    } catch (SocketException ioe) {
        ResourceManager.afterUdpClose();//出异常关闭的时候也需要进行资源检查，释放资源
        fd = null;
        throw ioe;
    }
}

绑定本地端口

protected synchronized void bind(int lport, InetAddress laddr)
    throws SocketException {
    bind0(lport, laddr);
}

绑定本地端口（native

protected abstract void bind0(int lport, InetAddress laddr)
    throws SocketException;

发送数据报包（需要后续完成，

protected abstract void send(DatagramPacket p) throws IOException;

连接远端的数据报套接字

protected void connect(InetAddress address, int port) throws SocketException {
    connect0(address, port);
    connectedAddress = address;
    connectedPort = port;
    connected = true;
}

断开已有的连接

protected void disconnect() {
    disconnect0(connectedAddress.holder().getFamily());
    connected = false;
    connectedAddress = null;
    connectedPort = -1;
}

窥探包来源（参数就是包来源，不是很懂，等到后面看到该类实例应该就清楚了，返回值肯定是IP地址一类的

protected abstract int peek(InetAddress i) throws IOException;

窥探包来源（返回值是包来源

protected abstract int peekData(DatagramPacket p) throws IOException;

接收数据报

protected synchronized void receive(DatagramPacket p)
    throws IOException {
    receive0(p);
}

接收数据报（native

protected abstract void receive0(DatagramPacket p)
    throws IOException;

设置发包过期时间（ttl

protected abstract void setTimeToLive(int ttl) throws IOException;

返回设置的过期时间（int

protected abstract int getTimeToLive() throws IOException;

设置发包过期时间（emmm，参数是byte类

protected abstract void setTTL(byte ttl) throws IOException;

返回设置的过期时间（byte

protected abstract byte getTTL() throws IOException;

加入组播团体

protected void join(InetAddress inetaddr) throws IOException {
    join(inetaddr, null);
}

离开组播团体

protected void leave(InetAddress inetaddr) throws IOException {
    leave(inetaddr, null);
}

加入组播团体（参数不同

protected void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf)
    throws IOException {
    if (mcastaddr == null || !(mcastaddr instanceof InetSocketAddress))
        throw new IllegalArgumentException("Unsupported address type");
    join(((InetSocketAddress)mcastaddr).getAddress(), netIf);
}

加入组播团体（基础方法

protected abstract void join(InetAddress inetaddr, NetworkInterface netIf)
    throws IOException;

离开组播团体

protected void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf)
    throws IOException {
    if (mcastaddr == null || !(mcastaddr instanceof InetSocketAddress))
        throw new IllegalArgumentException("Unsupported address type");
    leave(((InetSocketAddress)mcastaddr).getAddress(), netIf);
}

基础方法

protected abstract void leave(InetAddress inetaddr, NetworkInterface netIf)
    throws IOException;

关闭套接字

protected void close() {
    if (fd != null) {//文件描述符标志该套接字状态
        datagramSocketClose();
        ResourceManager.afterUdpClose();
        fd = null;
    }
}

判定当前套接字状态

protected boolean isClosed() {
    return (fd == null) ? true : false;
}

最终操作（关闭

protected void finalize() {
    close();
}

设置操作权限（object 根据设置操作不同而不同，该方法主要是检查，设置封装在另一个方法里

public void setOption(int optID, Object o) throws SocketException {
    if (isClosed()) {//检测当前套接字是否关闭
        throw new SocketException("Socket Closed");
    }
    switch (optID) {//常量声明在父类
       /* check type safety b4 going native.  These should never
        * fail, since only java.Socket* has access to
        * PlainSocketImpl.setOption().
        */
    case SO_TIMEOUT://设置超时
        if (o == null || !(o instanceof Integer)) {
            throw new SocketException("bad argument for SO_TIMEOUT");
        }
        int tmp = ((Integer) o).intValue();
        if (tmp < 0)
            throw new IllegalArgumentException("timeout < 0");
        timeout = tmp;
        return;
    case IP_TOS://IP服务类型设置
        if (o == null || !(o instanceof Integer)) {
            throw new SocketException("bad argument for IP_TOS");
        }
        trafficClass = ((Integer)o).intValue();
        break;
    case SO_REUSEADDR://地址端口重用
        if (o == null || !(o instanceof Boolean)) {
            throw new SocketException("bad argument for SO_REUSEADDR");
        }
        break;
    case SO_BROADCAST://设置广播
        if (o == null || !(o instanceof Boolean)) {
            throw new SocketException("bad argument for SO_BROADCAST");
        }
        break;
    case SO_BINDADDR://绑定地址
        throw new SocketException("Cannot re-bind Socket");
    case SO_RCVBUF://接收和发送的缓冲大小
    case SO_SNDBUF:
        if (o == null || !(o instanceof Integer) ||
            ((Integer)o).intValue() < 0) {
            throw new SocketException("bad argument for SO_SNDBUF or " +
                                      "SO_RCVBUF");
        }
        break;
    case IP_MULTICAST_IF://组播设置
        if (o == null || !(o instanceof InetAddress))
            throw new SocketException("bad argument for IP_MULTICAST_IF");
        break;
    case IP_MULTICAST_IF2:
        if (o == null || !(o instanceof NetworkInterface))
            throw new SocketException("bad argument for IP_MULTICAST_IF2");
        break;
    case IP_MULTICAST_LOOP:
        if (o == null || !(o instanceof Boolean))
            throw new SocketException("bad argument for IP_MULTICAST_LOOP");
        break;
    default:
        throw new SocketException("invalid option: " + optID);
    }
    socketSetOption(optID, o);
}

获得具体设置信息

public Object getOption(int optID) throws SocketException {
    if (isClosed()) {
        throw new SocketException("Socket Closed");
    }

    Object result;

    switch (optID) {
        case SO_TIMEOUT:
            result = new Integer(timeout);
            break;

        case IP_TOS:
            result = socketGetOption(optID);
            if ( ((Integer)result).intValue() == -1) {
                result = new Integer(trafficClass);
            }
            break;

        case SO_BINDADDR:
        case IP_MULTICAST_IF:
        case IP_MULTICAST_IF2:
        case SO_RCVBUF:
        case SO_SNDBUF:
        case IP_MULTICAST_LOOP:
        case SO_REUSEADDR:
        case SO_BROADCAST:
            result = socketGetOption(optID);
            break;

        default:
            throw new SocketException("invalid option: " + optID);
    }

    return result;
}

创建数据报套接字

protected abstract void datagramSocketCreate() throws SocketException;

关闭数据包套接字

protected abstract void datagramSocketClose();

具体设置

protected abstract void socketSetOption(int opt, Object val)
    throws SocketException;

具体设置获得

protected abstract Object socketGetOption(int opt) throws SocketException;

连接至目的地址和端口

protected abstract void connect0(InetAddress address, int port) throws SocketException;

断开连接

protected abstract void disconnect0(int family);

返回连接禁用状态

protected boolean nativeConnectDisabled() {
    return connectDisabled;
}

检测数据有效性（猜测是进行校验码校验

abstract int dataAvailable();

该类含有如下的静态代码块：

static {
    java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<Void>() {//加载运行时的net库
            public Void run() {
                System.loadLibrary("net");
                return null;
            }
        });
}