安卓经过DHCP协议获取IP地址的过程

时间  2020-12-14
标签 java android 服务器 app dom socket ide 函数 this 栏目 Android 繁體版
原文   原文链接

安卓经过DHCP协议的DORA Discovery发现 Offer提供 Request请求 Ack确认 获取IP地址的过程
安卓N以前 5.0 6.0经过 android_net_utils_runDhcp 方法运行 /system/bin/dhcpcd 获取ip地址
安卓N以后 N不要了runDhcpcd(),而是经过DhcpClient
DhcpClient是经过framework发送dhcpcd协议的UDP请求包直接去拿IP，再也不使用开源的dhcpcd
google还用了一个状态机 IpManager 来管理dhcpcd成功仍是失败等状态，
将ip赋值给IpConfiguration和LinkProperties传递到上层的frameworkjava

/frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiStateMachine.javaandroid

// 当WifiStateMachine状态机进入状态ObtainingIpState时 获取IP地址
class ObtainingIpState extends State {
@Override
public void enter() {
mIpManager.startProvisioning(IpManager.ProvisioningConfiguration prov); //启动获取IP地址
}
}
ObtainingIpState所在状态机服务器

ObtainingIpState所在状态机

/frameworks/base/services/net/java/android/net/ip/IpManager.javaapp

class StartedState extends State {} IpManager中的三个状态机
class StoppedState extends State {}
class StoppingState extends State {}dom

public void startProvisioning(ProvisioningConfiguration req) {
    getNetworkInterface();

    mCallback.setNeighborDiscoveryOffload(true);
    // 给初始化的状态机 StoppedState 发送消息CMD_START
    sendMessage(CMD_START, new ProvisioningConfiguration(req));
}

========================================================================
class StoppedState extends State {
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
…..
case CMD_START:
mConfiguration = (ProvisioningConfiguration) msg.obj;
// 接收到 CMD_START 会进行状态的切换，调用 StartedState的enter()方法
transitionTo(mStartedState);
break;
…..
}socket

==========================================ide

class StartedState extends State {
void enter(){
if(startIPv4()) // 状态 StartedState 的enter 进入方法，调用startIPv4()函数
}
}函数

==========================================ui

private boolean startIPv4() {
    // If we have a StaticIpConfiguration attempt to apply it and handle the result accordingly.
    if (mConfiguration.mStaticIpConfig != null) { // 若是有静态IP
        if (setIPv4Address(mConfiguration.mStaticIpConfig.ipAddress)) {
            handleIPv4Success(new DhcpResults(mConfiguration.mStaticIpConfig));
        } else {
            if (VDBG) { Log.d(mTag, "onProvisioningFailure()"); }
            recordMetric(IpManagerEvent.PROVISIONING_FAIL);
            mCallback.onProvisioningFailure(new LinkProperties(mLinkProperties));
            return false;
        }
    } else {
        // Start DHCPv4.  建立DhcpClient
        mDhcpClient = DhcpClient.makeDhcpClient(mContext, IpManager.this, mInterfaceName);
        mDhcpClient.registerForPreDhcpNotification(); // mRegisteredForPreDhcpNotification = true

        //接收前面发过来的mDhcpClient.sendMessage(DhcpClient.CMD_START_DHCP);跟着跳转到DhcpInitState:
        mDhcpClient.sendMessage(DhcpClient.CMD_START_DHCP); // 发送CMD_START_DHCP消息

        if (mConfiguration.mProvisioningTimeoutMs > 0) {
            final long alarmTime = SystemClock.elapsedRealtime() +
                    mConfiguration.mProvisioningTimeoutMs;
            mProvisioningTimeoutAlarm.schedule(alarmTime); // 在36秒后启动timeout超时操做
        }
    }

    return true;
}


private boolean setIPv4Address(LinkAddress address) {
    final InterfaceConfiguration ifcg = new InterfaceConfiguration();
    ifcg.setLinkAddress(address);
    try {
    final INetworkManagementService mNwService.setInterfaceConfig(mInterfaceName, ifcg);
        if (VDBG) Log.d(mTag, "IPv4 configuration succeeded");
    } catch (IllegalStateException | RemoteException e) {
        Log.e(mTag, "IPv4 configuration failed: ", e);
        return false;
    }
    return true;
}

==========================================
//接收前面发过来的mDhcpClient.sendMessage(DhcpClient.CMD_START_DHCP);跟着跳转到 DhcpInitState:
mDhcpClient.sendMessage(DhcpClient.CMD_START_DHCP); // 发送CMD_START_DHCP消息this

/frameworks/base/services/net/java/android/net/dhcp/DhcpClient.java

class StoppedState extends LoggingState {
    @Override
    public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case CMD_START_DHCP:
                if (mRegisteredForPreDhcpNotification) {
                    transitionTo(mWaitBeforeStartState);
                } else {
                    transitionTo(mDhcpInitState);  // 状态跳转到 DhcpInitState
                }
                return HANDLED;
            default:
                return NOT_HANDLED;
        }
    }

}

class DhcpInitState extends PacketRetransmittingState {
    public DhcpInitState() {
        super();
    }

//进入状态时启动一次startNewTransaction
//DORA Discover发现 Offer提供 Request请求 ACK确认 开始Discovery 发现?
@Override
public void enter() {
super.enter(); // 调用父类的 enter 方法中
startNewTransaction();
}

protected boolean sendPacket() {
        return sendDiscoverPacket(); // 发送  DiscoverPacket 发现包
    }

    protected void receivePacket(DhcpPacket packet) {
        if (!isValidPacket(packet)) return;
        if (!(packet instanceof DhcpOfferPacket)) return;
        mOffer = packet.toDhcpResults();
        if (mOffer != null) {
            Log.d(TAG, "Got pending lease: " + mOffer);
            transitionTo(mDhcpRequestingState); // 接收到了 Offer包  接下来发送 Request 请求包
        }
    }
}

    private void startNewTransaction() {
    mTransactionId = mRandom.nextInt();  // 传输包的id号?
    mTransactionStartMillis = SystemClock.elapsedRealtime();
}
==================================================
PacketRetransmittingState

   abstract class PacketRetransmittingState extends LoggingState {

    private int mTimer;
    protected int mTimeout = 0;

    @Override
    public void enter() {
        super.enter();
        initTimer();
        maybeInitTimeout();
        sendMessage(CMD_KICK);  // 发送消息  CMD_KICK
    }

    @Override
    public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case CMD_KICK:

// 调用了 sendPacket()抽象方法 因此就是以前的DhcpInitState的具体的实现 sendPacket()
sendPacket();
scheduleKick();
return HANDLED;
case CMD_RECEIVED_PACKET:
receivePacket((DhcpPacket) message.obj);
return HANDLED;
case CMD_TIMEOUT:
timeout();
return HANDLED;
default:
return NOT_HANDLED;
}
}

public void exit() {
        mKickAlarm.cancel();
        mTimeoutAlarm.cancel();
    }

    }
    abstract protected boolean sendPacket();

abstract protected void receivePacket(DhcpPacket packet);

class DhcpInitState extends PacketRetransmittingState {

    protected boolean sendPacket() {
        return sendDiscoverPacket(); // 发送  DiscoverPacket 发现包
    }


private boolean sendDiscoverPacket() {
    ByteBuffer packet = DhcpPacket.buildDiscoverPacket(
            DhcpPacket.ENCAP_L2, mTransactionId, getSecs(), mHwAddr,
            DO_UNICAST, REQUESTED_PARAMS);  // 建立 ByteBuffer的UDP包

return transmitPacket(packet, “DHCPDISCOVER”, DhcpPacket.ENCAP_L2, INADDR_BROADCAST); // 发送
}

}

private boolean transmitPacket(ByteBuffer buf, String description, int encap, Inet4Address to) {
    try {
        if (encap == DhcpPacket.ENCAP_L2) {
            if (DBG) Log.d(TAG, "Broadcasting " + description);
            // 送这里发送出去
            Os.sendto(mPacketSock, buf.array(), 0, buf.limit(), 0, mInterfaceBroadcastAddr);
        } else if (encap == DhcpPacket.ENCAP_BOOTP && to.equals(INADDR_BROADCAST)) {
            if (DBG) Log.d(TAG, "Broadcasting " + description);
            // N.B.: We only need this codepath because DhcpRequestPacket
            // hardcodes the source IP address to 0.0.0.0. We could reuse
            // the packet socket if this ever changes.
            Os.sendto(mUdpSock, buf, 0, to, DhcpPacket.DHCP_SERVER);
        } else {
            if (DBG) Log.d(TAG, String.format("Unicasting %s to %s",description, Os.getpeername(mUdpSock)));
            Os.write(mUdpSock, buf);
        }
    } catch(ErrnoException|IOException e) {
        Log.e(TAG, "Can't send packet: ", e);
        return false;
    }
    return true;
}

==================================================================
另一边有一个接收线程ReceiveThread run()，一直在收dhcp server的的数据包。

class ReceiveThread extends Thread {

    private final byte[] mPacket = new byte[DhcpPacket.MAX_LENGTH];
    private volatile boolean mStopped = false;

    public void halt() {
        mStopped = true;
        closeSockets();  // Interrupts the read() call the thread is blocked in.
    }

    @Override
    public void run() {
        if (DBG) Log.d(TAG, "Receive thread started");
        while (!mStopped) {
            int length = 0;  // Or compiler can't tell it's initialized if a parse error occurs.
            try {

                //读取DHCP服务发出的OFFER提交包
                length = Os.read(mPacketSock 【FileDescriptor】, mPacket, 0, mPacket.length); 
                DhcpPacket packet = null;
                packet = DhcpPacket.decodeFullPacket(mPacket, length, DhcpPacket.ENCAP_L2);
                if (DBG) Log.d(TAG, "Received packet: " + packet);
                sendMessage(CMD_RECEIVED_PACKET, packet); // 发送接收到消息 CMD_RECEIVED_PACKET
            } catch (IOException|ErrnoException e) {
                if (!mStopped) {
                    Log.e(TAG, "Read error", e);
                    DhcpErrorEvent.logReceiveError(mIfaceName);
                }
            } catch (DhcpPacket.ParseException e) {
                Log.e(TAG, "Can't parse packet: " + e.getMessage());
                if (PACKET_DBG) {
                    Log.d(TAG, HexDump.dumpHexString(mPacket, 0, length));
                }
                DhcpErrorEvent.logParseError(mIfaceName, e.errorCode);
            }
        }
        if (DBG) Log.d(TAG, "Receive thread stopped");
    }

}

abstract class PacketRetransmittingState extends LoggingState {

    @Override
    public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case CMD_RECEIVED_PACKET:
                receivePacket((DhcpPacket) message.obj); // 调用子类具体实现的receivePacket 方法
                return HANDLED;
            default:
                return NOT_HANDLED;
        }
    }
}

class DhcpInitState extends PacketRetransmittingState {

class DhcpInitState extends PacketRetransmittingState {

    protected void receivePacket(DhcpPacket packet) {   // 完成 DORA 中的 Offer的阶段 
        if (!isValidPacket(packet)) return;
        if (!(packet instanceof DhcpOfferPacket)) return;
        mOffer = packet.toDhcpResults();
        if (mOffer != null) {
            Log.d(TAG, "Got pending lease: " + mOffer);
    // 接收到了来自DHCP服务器的OFFER包，切换状态到  DhcpRequestingState  并进入到 enter() 方法
            transitionTo(mDhcpRequestingState); 
        }
    }
}

}

===================================================================

class DhcpRequestingState extends PacketRetransmittingState { // 进入到父类的enter 方法
    public DhcpRequestingState() {
        mTimeout = DHCP_TIMEOUT_MS / 2;  
    }


    public void enter() {// 进入到父类的enter 方法
        super.enter();
        initTimer();
        maybeInitTimeout();
        sendMessage(CMD_KICK); // 再次发送 CMD_KICK 消息
    }

            public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case CMD_KICK:   //  收到 CMD_KICK 消息 
                sendPacket();  // 发送包方法，此时调用的是具体子类 DhcpRequestingState的发送方法
                scheduleKick();
                return HANDLED;
            default:
                return NOT_HANDLED;
        }
    }


     // 发送请求   完成  DORA中的  Request的阶段
     // 此时 继续在接收线程中等待接收来自服务器的ACK DHCP数据包
    protected boolean sendPacket() {
        return sendRequestPacket(
                INADDR_ANY,                                    // ciaddr
                (Inet4Address) mOffer.ipAddress.getAddress(),  // DHCP_REQUESTED_IP
                (Inet4Address) mOffer.serverAddress,           // DHCP_SERVER_IDENTIFIER
                INADDR_BROADCAST);                             // packet destination address
    }

    protected void receivePacket(DhcpPacket packet) {
        if (!isValidPacket(packet)) return;
        if ((packet instanceof DhcpAckPacket)) {
            DhcpResults results = packet.toDhcpResults();
            if (results != null) {
                setDhcpLeaseExpiry(packet);
                acceptDhcpResults(results, "Confirmed");
                transitionTo(mConfiguringInterfaceState);
            }
        } else if (packet instanceof DhcpNakPacket) {
            // TODO: Wait a while before returning into INIT state.
            Log.d(TAG, "Received NAK, returning to INIT");
            mOffer = null;
            transitionTo(mDhcpInitState);
        }
    }



private boolean sendRequestPacket(
        Inet4Address clientAddress, Inet4Address requestedAddress,
        Inet4Address serverAddress, Inet4Address to) {
    // TODO: should we use the transaction ID from the server?
    final int encap = INADDR_ANY.equals(clientAddress)
            ? DhcpPacket.ENCAP_L2 : DhcpPacket.ENCAP_BOOTP;

    ByteBuffer packet = DhcpPacket.buildRequestPacket(
            encap, mTransactionId, getSecs(), clientAddress,
            DO_UNICAST, mHwAddr, requestedAddress,
            serverAddress, REQUESTED_PARAMS, null);
    String serverStr = (serverAddress != null) ? serverAddress.getHostAddress() : null;
    String description = "DHCPREQUEST ciaddr=" + clientAddress.getHostAddress() +
                         " request=" + requestedAddress.getHostAddress() +
                         " serverid=" + serverStr;
    return transmitPacket(packet, description, encap, to);  // 发送数据包
}



return transmitPacket(packet, "DHCPDISCOVER", DhcpPacket.ENCAP_L2, INADDR_BROADCAST); // 发送
}

}

private boolean transmitPacket(ByteBuffer buf, String description, int encap, Inet4Address to) {
    try {
        if (encap == DhcpPacket.ENCAP_L2) {
            if (DBG) Log.d(TAG, "Broadcasting " + description);
            // 送这里发送出去  真正发送
            Os.sendto(mPacketSock, buf.array(), 0, buf.limit(), 0, mInterfaceBroadcastAddr);
        } else if (encap == DhcpPacket.ENCAP_BOOTP && to.equals(INADDR_BROADCAST)) {
            if (DBG) Log.d(TAG, "Broadcasting " + description);
            // N.B.: We only need this codepath because DhcpRequestPacket
            // hardcodes the source IP address to 0.0.0.0. We could reuse
            // the packet socket if this ever changes.
            Os.sendto(mUdpSock, buf, 0, to, DhcpPacket.DHCP_SERVER);
        } else {
            if (DBG) Log.d(TAG, String.format("Unicasting %s to %s",description, Os.getpeername(mUdpSock)));
            Os.write(mUdpSock, buf);
        }
    } catch(ErrnoException|IOException e) {
        Log.e(TAG, "Can't send packet: ", e);
        return false;
    }
    return true;
}

===========================================================

另一边有一个接收线程ReceiveThread run()，一直在收dhcp server的的数据包。

class ReceiveThread extends Thread {

    private final byte[] mPacket = new byte[DhcpPacket.MAX_LENGTH];
    private volatile boolean mStopped = false;

    public void halt() {
        mStopped = true;
        closeSockets();  // Interrupts the read() call the thread is blocked in.
    }

    @Override
    public void run() {
        if (DBG) Log.d(TAG, "Receive thread started");
        while (!mStopped) {
            int length = 0;  // Or compiler can't tell it's initialized if a parse error occurs.
            try {

                //读取DHCP服务发出的ACK确认包
                length = Os.read(mPacketSock 【FileDescriptor】, mPacket, 0, mPacket.length); 
                DhcpPacket packet = null;
                packet = DhcpPacket.decodeFullPacket(mPacket, length, DhcpPacket.ENCAP_L2);
                if (DBG) Log.d(TAG, "Received packet: " + packet);

                // 发送接收到消息 CMD_RECEIVED_PACKET  此时处理的状态是 DhcpRequestingState
                sendMessage(CMD_RECEIVED_PACKET, packet); 
            } catch (IOException|ErrnoException e) {
                if (!mStopped) {
                    Log.e(TAG, "Read error", e);
                    DhcpErrorEvent.logReceiveError(mIfaceName);
                }
            } catch (DhcpPacket.ParseException e) {
                Log.e(TAG, "Can't parse packet: " + e.getMessage());
                if (PACKET_DBG) {
                    Log.d(TAG, HexDump.dumpHexString(mPacket, 0, length));
                }
                DhcpErrorEvent.logParseError(mIfaceName, e.errorCode);
            }
        }
        if (DBG) Log.d(TAG, "Receive thread stopped");
    }

}

// 处理消息 CMD_RECEIVED_PACKET 对应的数据包是 ACK数据包 UDP
class DhcpRequestingState extends PacketRetransmittingState {

public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case CMD_RECEIVED_PACKET:
                receivePacket((DhcpPacket) message.obj);  //DhcpRequestingState处理接收到的数据包
                return HANDLED;
            default:
                return NOT_HANDLED;
        }
    }


        protected void receivePacket(DhcpPacket packet) {
        if (!isValidPacket(packet)) return;
        if ((packet instanceof DhcpAckPacket)) {
            DhcpResults results = packet.toDhcpResults();
            if (results != null) {
                setDhcpLeaseExpiry(packet);
//这里会调用notifySuccess，发送CMD去通知IpManager说，IP拿到了 分析 acceptDhcpResults
                acceptDhcpResults(results, "Confirmed");  // 分叉

//进入新的状态 ConfiguringInterfaceState enter方法  
                transitionTo(mConfiguringInterfaceState); 
            }
        } else if (packet instanceof DhcpNakPacket) { // 收到的是NACK 解决数据包的话
            // TODO: Wait a while before returning into INIT state.
            Log.d(TAG, "Received NAK, returning to INIT");
            mOffer = null;
            transitionTo(mDhcpInitState);
        }
    }

}

//这里会调用notifySuccess，发送CMD去通知IpManager说，IP拿到了 分析 acceptDhcpResults
acceptDhcpResults(results, “Confirmed”);

private void acceptDhcpResults(DhcpResults results, String msg) {
    mDhcpLease = results;
    mOffer = null;
    Log.d(TAG, msg + " lease: " + mDhcpLease);
    notifySuccess(); // 通知成功拿到IP地址了
}

private void notifySuccess() {
    mController【StateMachine】.sendMessage( CMD_POST_DHCP_ACTION, DHCP_SUCCESS, 0, new DhcpResults(mDhcpLease));
}



  class StartedState extends State {

    @Override
    public boolean processMessage(Message msg) {
        switch (msg.what) {
              case DhcpClient.CMD_POST_DHCP_ACTION:
                stopDhcpAction();

                switch (msg.arg1) {
                    case DhcpClient.DHCP_SUCCESS:
                        handleIPv4Success((DhcpResults) msg.obj); // 处理 handleIPv4Success IPV4地址
                        break;
                    case DhcpClient.DHCP_FAILURE:
                        handleIPv4Failure();
                        break;
                    default:
                        Log.e(mTag, "Unknown CMD_POST_DHCP_ACTION status:" + msg.arg1);
                }
                break;
  }
  }

}

private void handleIPv4Success(DhcpResults dhcpResults) {
    mDhcpResults = new DhcpResults(dhcpResults);
    final LinkProperties newLp = assembleLinkProperties();
    final ProvisioningChange delta = setLinkProperties(newLp);

    if (VDBG) {
        Log.d(mTag, "onNewDhcpResults(" + Objects.toString(dhcpResults) + ")");
    }
    mCallback.onNewDhcpResults(dhcpResults);
    dispatchCallback(delta, newLp);   //这里分发dhcpResults 把IPv4地址发出去
}




    private void dispatchCallback(ProvisioningChange delta, LinkProperties newLp) {
    switch (delta) {
        case GAINED_PROVISIONING:
            if (VDBG) { Log.d(mTag, "onProvisioningSuccess()"); }
            recordMetric(IpManagerEvent.PROVISIONING_OK);
            mCallback.onProvisioningSuccess(newLp); // 回调
            break;

    }
}

dispatchCallback 的结果最后会做用到 WaitForProvisioningCallback 


public static class WaitForProvisioningCallback extends Callback {
    private LinkProperties mCallbackLinkProperties;

    public LinkProperties waitForProvisioning() {
        synchronized (this) {
            try {
                wait();
            } catch (InterruptedException e) {}
            return mCallbackLinkProperties;
        }
    }

    @Override
    public void onProvisioningSuccess(LinkProperties newLp) {   // 回调
        synchronized (this) {
            mCallbackLinkProperties = newLp;  // 把当前的IPv4保存起来
            notify();
        }
    }

    @Override
    public void onProvisioningFailure(LinkProperties newLp) {
        synchronized (this) {
            mCallbackLinkProperties = null;
            notify();
        }
    }

} acceptDhcpResults 分析到此为止 开始分析新的状态

//进入新的状态 ConfiguringInterfaceState enter方法
ConfiguringInterfaceState 

class ConfiguringInterfaceState extends LoggingState {
    @Override
    public void enter() {
        super.enter();

// 发送消息 CMD_CONFIGURE_LINKADDRESS 被StartedState 处理
mController.sendMessage(CMD_CONFIGURE_LINKADDRESS, mDhcpLease.ipAddress);
}

@Override
    public boolean processMessage(Message message) {
        super.processMessage(message);
        switch (message.what) {
            case EVENT_LINKADDRESS_CONFIGURED:
                transitionTo(mDhcpBoundState);
                return HANDLED;
            default:
                return NOT_HANDLED;
        }
    }
}


========================

    class StartedState extends State {
    @Override
    public boolean processMessage(Message msg) {
        switch (msg.what) {
                   case DhcpClient.CMD_CONFIGURE_LINKADDRESS: {
                final LinkAddress ipAddress = (LinkAddress) msg.obj;
                if (setIPv4Address(ipAddress)) {  // 设置 IPv4地址
                    mDhcpClient.sendMessage(DhcpClient.EVENT_LINKADDRESS_CONFIGURED);
                } else {
                    Log.e(mTag, "Failed to set IPv4 address!");
                    dispatchCallback(ProvisioningChange.LOST_PROVISIONING,
                            new LinkProperties(mLinkProperties));
                    transitionTo(mStoppingState);
                }
                break;
    }
    }

=========================================
// 回到开头的 setIPv4Address 至此得到了IP地址
private boolean setIPv4Address(LinkAddress address) {
final InterfaceConfiguration ifcg = new InterfaceConfiguration();
ifcg.setLinkAddress(address);
try {
final INetworkManagementService mNwService.setInterfaceConfig(mInterfaceName, ifcg);
if (VDBG) Log.d(mTag, “IPv4 configuration succeeded”);
} catch (IllegalStateException | RemoteException e) {
Log.e(mTag, “IPv4 configuration failed: “, e);
return false;
}
return true;
}

NetworkManagementService.java
@Override
public void setInterfaceConfig(String iface, InterfaceConfiguration cfg) {
    mContext.enforceCallingOrSelfPermission(CONNECTIVITY_INTERNAL, TAG);
    LinkAddress linkAddr = cfg.getLinkAddress();
    if (linkAddr == null || linkAddr.getAddress() == null) {
        throw new IllegalStateException("Null LinkAddress given");
    }

    final Command cmd = new Command("interface", "setcfg", iface,
            linkAddr.getAddress().getHostAddress(),
            linkAddr.getPrefixLength());
    for (String flag : cfg.getFlags()) {
        cmd.appendArg(flag);
    }

    try {
        mConnector.execute(cmd);  //  执行命令
    } catch (NativeDaemonConnectorException e) {
        throw e.rethrowAsParcelableException();
    }
}

http://m.blog.csdn.net/xiaoxiangyuhai/article/details/75219357

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程