文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

面试官：Zookeeper了解吗？说说都有哪些使用场景？

2024-12-10 16:19

关注

 前言

前两篇讲了Zookeeper的特性、客户端使用和集群原理，因为 Zookeeper 是分布式系统中很常见的一个基础系统。 而且问的话常问的就是说 zookeeper 的使用场景是什么？ 看你知道不知道一些基本的使用场景。 但是其实 Zookeeper 挖深了自然是可以问的很深很深的。本文主要来聊聊 Zookeeper 主要的几个使用场景。

  1. 分布式集群管理
  2. 分布式注册中心
  3. 分布式JOB
  4. 分布式锁

分布式集群管理
分布式集群管理的需求

  1. 主动查看线上服务节点
  2. 查看服务节点资源使用情况
  3. 服务离线通知
  4. 服务资源（CPU、内存、硬盘）超出阀值通知

架构设计

节点结构

  1. niuh-manger // 根节点
  2. server00001 : //服务节点 1
  3. server00002 ://服务节点 2
  4. server........n ://服务节点 n

服务状态信息

  1. ip
  2. cpu
  3. memory
  4. disk

功能实现
数据生成与上报

  1. 创建临时节点：
  2. 定时变更节点状态信息：

主动查询

被动通知

关键示例代码

  1. package com.niuh.os; 
  2. import com.fasterxml.jackson.core.JsonProcessingException; 
  3. import com.fasterxml.jackson.databind.ObjectMapper; 
  4. import org.I0Itec.zkclient.ZkClient; 
  5. import java.lang.instrument.Instrumentation; 
  6. import java.lang.management.ManagementFactory; 
  7. import java.lang.management.MemoryUsage; 
  8. import java.net.InetAddress; 
  9. import java.net.UnknownHostException; 
  10. public class Agent { 
  11.     private static Agent ourInstance = new Agent(); 
  12.     private String server = "127.0.0.1:2181"; 
  13.     private ZkClient zkClient; 
  14.     private static final String rootPath = "/niuh-manger"; 
  15.     private static final String servicePath = rootPath + "/service"; 
  16.     private String nodePath; ///niuh-manger/service0000001 当前节点路径 
  17.     private Thread stateThread; 
  18.     public static Agent getInstance() { 
  19.         return ourInstance; 
  20.     } 
  21.     private Agent() { 
  22.     } 
  23.     // javaagent 数据监控 
  24.     public static void premain(String args, Instrumentation instrumentation) { 
  25.         Agent.getInstance().init(); 
  26.     } 
  27.     public void init() { 
  28.         zkClient = new ZkClient(server, 5000, 10000); 
  29.         System.out.println("zk连接成功" + server); 
  30.         // 创建根节点 
  31.         buildRoot(); 
  32.         // 创建临时节点 
  33.         createServerNode(); 
  34.         // 启动更新的线程 
  35.         stateThread = new Thread(() -> { 
  36.             while (true) { 
  37.                 updateServerNode(); 
  38.                 try { 
  39.                     Thread.sleep(5000); 
  40.                 } catch (InterruptedException e) { 
  41.                     e.printStackTrace(); 
  42.                 } 
  43.             } 
  44.         }, "zk_stateThread"); 
  45.         stateThread.setDaemon(true); 
  46.         stateThread.start(); 
  47.     } 
  48.     // 数据写到 当前的临时节点中去 
  49.     public void updateServerNode() { 
  50.         zkClient.writeData(nodePath, getOsInfo()); 
  51.     } 
  52.     // 生成服务节点 
  53.     public void createServerNode() { 
  54.         nodePath = zkClient.createEphemeralSequential(servicePath, getOsInfo()); 
  55.         System.out.println("创建节点:" + nodePath); 
  56.     } 
  57.     // 更新服务节点状态 
  58.     public String getOsInfo() { 
  59.         OsBean bean = new OsBean(); 
  60.         bean.lastUpdateTime = System.currentTimeMillis(); 
  61.         bean.ip = getLocalIp(); 
  62.         bean.cpu = CPUMonitorCalc.getInstance().getProcessCpu(); 
  63.         MemoryUsage memoryUsag = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(); 
  64.         bean.usedMemorySize = memoryUsag.getUsed() / 1024 / 1024; 
  65.         bean.usableMemorySize = memoryUsag.getMax() / 1024 / 1024; 
  66.         bean.pid = ManagementFactory.getRuntimeMXBean().getName(); 
  67.         ObjectMapper mapper = new ObjectMapper(); 
  68.         try { 
  69.             return mapper.writeValueAsString(bean); 
  70.         } catch (JsonProcessingException e) { 
  71.             throw new RuntimeException(e); 
  72.         } 
  73.     } 
  74.     public static String getLocalIp() { 
  75.         InetAddress addr = null; 
  76.         try { 
  77.             addr = InetAddress.getLocalHost(); 
  78.         } catch (UnknownHostException e) { 
  79.             throw new RuntimeException(e); 
  80.         } 
  81.         return addr.getHostAddress(); 
  82.     } 
  83.     public void buildRoot() { 
  84.         if (!zkClient.exists(rootPath)) { 
  85.             zkClient.createPersistent(rootPath); 
  86.         } 
  87.     } 
  88. } 

实现效果
启动参数设置

 

运行测试用例：

  1. package com.niuh.test; 
  2. import com.niuh.os.Agent; 
  3. import org.junit.Ignore; 
  4. import org.junit.Test; 
  5. public class AgentTest { 
  6.     @Test 
  7.     @Ignore 
  8.     public void initTest() { 
  9.         Agent.premain(null, null); 
  10.         runCPU(2); //20% 占用 
  11.         try { 
  12.             Thread.sleep(Long.MAX_VALUE); 
  13.         } catch (InterruptedException e) { 
  14.             e.printStackTrace(); 
  15.         } 
  16.     } 
  17.     // 
  18.     private void runCPU(int count) { 
  19.         for (int i = 0; i < count; i++) { 
  20.             new Thread(() -> { 
  21.                 while (true) { 
  22.                     long bac = 1000000; 
  23.                     bac = bac >> 1; 
  24.                 } 
  25.             }).start(); 
  26.             ; 
  27.         } 
  28.     } 
  29. } 

控制台输出：

  1. CPU 报警...22.55120088850181 
  2. CPU 报警...46.06592086097357CPU 报警...47.87206766163349CPU 报警...49.49176420213768CPU 报警...48.967942479969004CPU 报警...49.193921607021565CPU 报警...48.806604284784676CPU 报警...48.63229912951865CPU 报警...49.34509647972038CPU 报警...47.07551108884401CPU 报警...49.18489236134496CPU 报警...49.903007346777066CPU 报警...49.28868795953268// 关闭测试用例服务已下线:OsBean{ip='192.168.43.11', cpu=49.28868795953268, usedMemorySize=56, usableMemorySize=3641, pid='47192@hejianhui', lastUpdateTime=1602056208842} 

本Demo不适用在生产环境，示例Demo涉及组件zookeeper-agent、zookeeper-web。源代码提交在 github：https://github.com/Niuh-Frame/niuh-zookeeper。

分布式注册中心
在单体式服务中，通常是由多个客户端去调用一个服务，只要在客户端中配置唯一服务节点地址即可，当升级到分布式后，服务节点变多，像一线大厂服务节点更是上万之多，这么多节点不可能手动配置在客户端，这里就需要一个中间服务，专门用于帮助客户端发现服务节点，即许多技术书籍经常提到的服务发现。

一个完整的注册中心涵盖以下功能特性：

Dubbo 对 Zookeeper的使用
阿里著名的开源项目Dubbo 是一个基于JAVA的RCP框架，其中必不可少的注册中心可基于多种第三方组件实现，但其官方推荐的还是Zookeeper作为注册中心服务。

Dubbo Zookeeper注册中心存储结构

节点说明

流程说明

  1. 服务提供者启动时: 向 /dubbo/com.foo.BarService/providers 目录下写入自己的 URL 地址
  2. 服务消费者启动时: 订阅 /dubbo/com.foo.BarService/providers 目录下的提供者 URL 地址。并向 /dubbo/com.foo.BarService/consumers 目录下写入自己的 URL 地址
  3. 监控中心启动时: 订阅 /dubbo/com.foo.BarService 目录下的所有提供者和消费者 URL 地址。

示例Demo
服务端代码

  1. package com.niuh.zk.dubbo; 
  2. import com.alibaba.dubbo.config.ApplicationConfig; 
  3. import com.alibaba.dubbo.config.ProtocolConfig; 
  4. import com.alibaba.dubbo.config.RegistryConfig; 
  5. import com.alibaba.dubbo.config.ServiceConfig; 
  6. import java.io.IOException; 
  7. public class Server { 
  8.     public void openServer(int port) { 
  9.         // 构建应用 
  10.         ApplicationConfig config = new ApplicationConfig(); 
  11.         config.setName("simple-app"); 
  12.         // 通信协议 
  13.         ProtocolConfig protocolConfig = new ProtocolConfig("dubbo", port); 
  14.         protocolConfig.setThreads(200); 
  15.         ServiceConfig serviceConfig = new ServiceConfig(); 
  16.         serviceConfig.setApplication(config); 
  17.         serviceConfig.setProtocol(protocolConfig); 
  18.         serviceConfig.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181")); 
  19.         serviceConfig.setInterface(UserService.class); 
  20.         UserServiceImpl ref = new UserServiceImpl(); 
  21.         serviceConfig.setRef(ref); 
  22.         //开始提供服务  开张做生意 
  23.         serviceConfig.export(); 
  24.         System.out.println("服务已开启!端口:"+serviceConfig.getExportedUrls().get(0).getPort()); 
  25.         ref.setPort(serviceConfig.getExportedUrls().get(0).getPort()); 
  26.     } 
  27.     public static void main(String[] args) throws IOException { 
  28.         new Server().openServer(-1); 
  29.         System.in.read(); 
  30.     } 
  31. } 

客户端代码

  1. package com.niuh.zk.dubbo; 
  2. import com.alibaba.dubbo.config.ApplicationConfig; 
  3. import com.alibaba.dubbo.config.ReferenceConfig; 
  4. import com.alibaba.dubbo.config.RegistryConfig; 
  5. import java.io.IOException; 
  6. public class Client {    UserService service;    // URL 远程服务的调用地址    public UserService buildService(String url) {        ApplicationConfig config = new ApplicationConfig("young-app"); 
  7.         // 构建一个引用对象        ReferenceConfig referenceConfig = new ReferenceConfig();        referenceConfig.setApplication(config); 
  8.         referenceConfig.setInterface(UserService.class);        // referenceConfig.setUrl(url);        referenceConfig.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181")); 
  9.         referenceConfig.setTimeout(5000); 
  10.         // 透明化        this.service = referenceConfig.get();        return service; 
  11.     }    static int i = 0; 
  12.     public static void main(String[] args) throws IOException {        Client client1 = new Client();        client1.buildService(""); 
  13.         String cmd;        while (!(cmd = read()).equals("exit")) { 
  14.             UserVo u = client1.service.getUser(Integer.parseInt(cmd));            System.out.println(u);        }    }    private static String read() throws IOException { 
  15.         byte[] b = new byte[1024]; 
  16.         int size = System.in.read(b); 
  17.         return new String(b, 0, size).trim(); 
  18.     }} 

查询 zk 实际存储内容：

  1. /dubbo 
  2. /dubbo/com.niuh.zk.dubbo.UserService/dubbo/com.niuh.zk.dubbo.UserService/configurators/dubbo/com.niuh.zk.dubbo.UserService/routers/dubbo/com.niuh.zk.dubbo.UserService/providers/dubbo/com.niuh.zk.dubbo.UserService/providers/dubbo://192.168.43.11:20880/com.niuh.zk.dubbo.UserService?anyhost=true&application=simple-app&dubbo=2.6.2&generic=false&interface=com.niuh.zk.dubbo.UserService&methods=getUser&pid=48302&side=provider&threads=200×tamp=1602057895881/dubbo/com.niuh.zk.dubbo.UserService/consumers/dubbo/com.niuh.zk.dubbo.UserService/consumers/consumer://192.168.43.11com.niuh.zk.dubbo.UserService?application=young-app&category=consumers&check=false&dubbo=2.6.2&interface=com.niuh.zk.dubbo.UserService&methods=getUser&pid=49036&side=consumer&timeout=5000×tamp=1602075359549 

示例Demo涉及组件zookeeper-dubbo。源代码提交在 github：https://github.com/Niuh-Frame/niuh-zookeeper。

分布式JOB
分布式JOB需求
多个服务节点只允许其中一个主节点运行JOB任务。
当主节点挂掉后能自动切换主节点，继续执行JOB任务。
架构设计

node结构

  1. niuh-master
  2. server0001:master
  3. server0002:slave
  4. server000n:slave

选举流程
服务启动：

  1. 在niuh-maste下创建server子节点，值为slave
  2. 获取所有niuh-master 下所有子节点
  3. 判断是否存在master 节点
  4. 如果没有设置自己为master节点

子节点删除事件触发：

  1. 获取所有niuh-master 下所有子节点
  2. 判断是否存在master 节点
  3. 如果没有设置最小值序号为master 节点

示例Demo

  1. package com.niuh.zookeeper.master; 
  2. import org.I0Itec.zkclient.ZkClient; 
  3. import java.util.Map; 
  4. import java.util.stream.Collectors; 
  5. public class MasterResolve { 
  6.     private String server = "127.0.0.1:2181"; 
  7.     private ZkClient zkClient; 
  8.     private static final String rootPath = "/niuh-master"; 
  9.     private static final String servicePath = rootPath + "/service"; 
  10.     private String nodePath; 
  11.     private volatile boolean master = false; 
  12.     private static MasterResolve resolve; 
  13.     private MasterResolve() { 
  14.         zkClient = new ZkClient(server, 2000, 5000); 
  15.         buildRoot();        createServerNode();    }    public static MasterResolve getInstance() { 
  16.         if (resolve == null) { 
  17.             resolve= new MasterResolve(); 
  18.         }        return resolve; 
  19.     }    // 构建根节点 
  20.     public void buildRoot() { 
  21.         if (!zkClient.exists(rootPath)) { 
  22.             zkClient.createPersistent(rootPath); 
  23.         } 
  24.     } 
  25.     // 创建server节点 
  26.     public void createServerNode() { 
  27.         nodePath = zkClient.createEphemeralSequential(servicePath, "slave"); 
  28.         System.out.println("创建service节点:" + nodePath); 
  29.         initMaster(); 
  30.         initListener(); 
  31.     } 
  32.     private void initMaster() { 
  33.         boolean existMaster = zkClient.getChildren(rootPath) 
  34.                 .stream() 
  35.                 .map(p -> rootPath + "/" + p) 
  36.                 .map(p -> zkClient.readData(p)) 
  37.                 .anyMatch(d -> "master".equals(d)); 
  38.         if (!existMaster) { 
  39.             doElection(); 
  40.             System.out.println("当前当选master"); 
  41.         } 
  42.     } 
  43.     private void initListener() { 
  44.         zkClient.subscribeChildChanges(rootPath, (parentPath, currentChilds) -> { 
  45.             doElection();//  执行选举 
  46.         }); 
  47.     } 
  48.     // 执行选举 
  49.     public void doElection() { 
  50.         Map childData = zkClient.getChildren(rootPath) 
  51.                 .stream() 
  52.                 .map(p -> rootPath + "/" + p) 
  53.                 .collect(Collectors.toMap(p -> p, p -> zkClient.readData(p))); 
  54.         if (childData.containsValue("master")) { 
  55.             return; 
  56.         } 
  57.         childData.keySet().stream().sorted().findFirst().ifPresent(p -> { 
  58.             if (p.equals(nodePath)) { // 设置最小值序号为master 节点 
  59.                 zkClient.writeData(nodePath, "master"); 
  60.                 master = true; 
  61.                 System.out.println("当前当选master" + nodePath); 
  62.             } 
  63.         }); 
  64.     } 
  65.     public static boolean isMaster() { 
  66.         return getInstance().master; 
  67.     } 
  68. } 

示例Demo涉及组件zookeeper-master。源代码提交在 github ：https://github.com/Niuh-Frame/niuh-zookeeper。

分布式锁
锁的的基本概念
开发中锁的概念并不陌生，通过锁可以实现在多个线程或多个进程间在争抢资源时，能够合理的分配置资源的所有权。在单体应用中我们可以通过 synchronized 或 ReentrantLock 来实现锁。但在分布式系统中，仅仅是加synchronized 是不够的，需要借助第三组件来实现。比如一些简单的做法是使用关系型数据行级锁来实现不同进程之间的互斥，但大型分布式系统的性能瓶颈往往集中在数据库操作上。为了提高性能得采用如Redis、Zookeeper之内的组件实现分布式锁。

共享锁：也称作只读锁，当一方获得共享锁之后，其它方也可以获得共享锁。但其只允许读取。在共享锁全部释放之前，其它方不能获得写锁。

排它锁：也称作读写锁，获得排它锁后，可以进行数据的读写。在其释放之前，其它方不能获得任何锁。

锁的获取
某银行账户，可以同时进行帐户信息的读取，但读取期间不能修改帐户数据。其账户ID为:888

获得读锁流程

  1. 基于资源ID创建临时序号读锁节点 /lock/888.R0000000002 Read
  2. 获取 /lock 下所有子节点，判断其最小的节点是否为读锁，如果是则获锁成功
  3. 最小节点不是读锁，则阻塞等待。添加lock/ 子节点变更监听。
  4. 当节点变更监听触发，执行第2步

数据结构

获得写锁

  1. 基于资源ID创建临时序号写锁节点 /lock/888.R0000000002 Write
  2. 获取 /lock 下所有子节点，判断其最小的节点是否为自己，如果是则获锁成功
  3. 最小节点不是自己，则阻塞等待。添加lock/ 子节点变更监听。
  4. 当节点变更监听触发，执行第2步

释放锁
读取完毕后，手动删除临时节点，如果获锁期间宕机，则会在会话失效后自动删除。

关于羊群效应
在等待锁获得期间，所有等待节点都在监听 Lock节点，一但lock 节点变更所有等待节点都会被触发，然后在同时反查Lock 子节点。如果等待对例过大会使用Zookeeper承受非常大的流量压力。

为了改善这种情况，可以采用监听链表的方式，每个等待队列只监听前一个节点，如果前一个节点释放锁的时候，才会被触发通知。这样就形成了一个监听链表。

示例Demo

  1. package com.niuh.zookeeper.lock; 
  2. import org.I0Itec.zkclient.IZkDataListener; 
  3. import org.I0Itec.zkclient.ZkClient; 
  4. import java.util.List; 
  5. import java.util.stream.Collectors; 
  6. public class ZookeeperLock { 
  7.     private String server = "127.0.0.1:2181"; 
  8.     private ZkClient zkClient; 
  9.     private static final String rootPath = "/niuh-lock1"; 
  10.     public ZookeeperLock() { 
  11.         zkClient = new ZkClient(server, 5000, 20000); 
  12.         buildRoot();    }    // 构建根节点 
  13.     public void buildRoot() { 
  14.         if (!zkClient.exists(rootPath)) { 
  15.             zkClient.createPersistent(rootPath); 
  16.         } 
  17.     } 
  18.     // 获取锁 
  19.     public Lock lock(String lockId, long timeout) { 
  20.         // 创建临时节点 
  21.         Lock lockNode = createLockNode(lockId); 
  22.         lockNode = tryActiveLock(lockNode);// 尝试激活锁 
  23.         if (!lockNode.isActive()) { 
  24.             try { 
  25.                 synchronized (lockNode) { 
  26.                     lockNode.wait(timeout); // 线程锁住 
  27.                 } 
  28.             } catch (InterruptedException e) { 
  29.                 throw new RuntimeException(e); 
  30.             } 
  31.         } 
  32.         if (!lockNode.isActive()) { 
  33.             throw new RuntimeException(" lock  timeout"); 
  34.         } 
  35.         return lockNode; 
  36.     } 
  37.     // 释放锁 
  38.     public void unlock(Lock lock) { 
  39.         if (lock.isActive()) { 
  40.             zkClient.delete(lock.getPath()); 
  41.         } 
  42.     } 
  43.     // 尝试激活锁 
  44.     private Lock tryActiveLock(Lock lockNode) { 
  45.         // 获取根节点下面所有的子节点 
  46.         List list = zkClient.getChildren(rootPath) 
  47.                 .stream() 
  48.                 .sorted() 
  49.                 .map(p -> rootPath + "/" + p) 
  50.                 .collect(Collectors.toList());      // 判断当前是否为最小节点 
  51.         String firstNodePath = list.get(0); 
  52.         // 最小节点是不是当前节点 
  53.         if (firstNodePath.equals(lockNode.getPath())) { 
  54.             lockNode.setActive(true); 
  55.         } else { 
  56.             String upNodePath = list.get(list.indexOf(lockNode.getPath()) - 1); 
  57.             zkClient.subscribeDataChanges(upNodePath, new IZkDataListener() { 
  58.                 @Override 
  59.                 public void handleDataChange(String dataPath, Object data) throws Exception { 
  60.                 } 
  61.                 @Override 
  62.                 public void handleDataDeleted(String dataPath) throws Exception { 
  63.                     // 事件处理 与心跳 在同一个线程，如果Debug时占用太多时间，将导致本节点被删除，从而影响锁逻辑。 
  64.                     System.out.println("节点删除:" + dataPath); 
  65.                      Lock lock = tryActiveLock(lockNode); 
  66.                     synchronized (lockNode) { 
  67.                         if (lock.isActive()) { 
  68.                             lockNode.notify(); // 释放了 
  69.                         } 
  70.                     } 
  71.                     zkClient.unsubscribeDataChanges(upNodePath, this); 
  72.                 } 
  73.             }); 
  74.         } 
  75.         return lockNode; 
  76.     } 
  77.     public Lock createLockNode(String lockId) { 
  78.         String nodePath = zkClient.createEphemeralSequential(rootPath + "/" + lockId, "w"); 
  79.         return new Lock(lockId, nodePath); 
  80.     } 
  81. } 

示例Demo涉及组件zookeeper-lock。源代码提交在 github ：https://github.com/Niuh-Frame/niuh-zookeeper。

 

来源：今日头条内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

面试官：Zookeeper了解吗？说说都有哪些使用场景？

后端开发Zookeeper2024-12-10

面试官：说说对 Node 中的 Process 的理解？有哪些常用方法？

后端开发NodeProcess2024-12-03

说说面试官：说说对Redux中间件的理解？常用的中间件有哪些？实现原理？

后端开发Redux中间件2024-12-03

面试官：说说对 Node 中的 Fs 模块的理解? 有哪些常用方法?

后端开发Node2024-12-03

面试官：说说你对版本管理的理解？常用的版本管理工具有哪些？

后端开发版本管理2024-12-02
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯