【使用zookpeer】模拟 hadoop的 datenode与namenode 的master-slaves的 关系

已于 2022-05-08 23:49:23 修改
阅读量627 收藏
点赞数
文章标签： hadoop java 大数据
于 2022-05-08 23:47:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49032728/article/details/124656918
版权

一：功能需求

总结

用到的知识点 ：
1.序列化和反序列化
2.zookpeer监听机制
3.对象流完成 datanode的 信息的注册.

1.功能:

  1. 当 datanode上线时，namenode中可以感知到.
  2. 当datanode下线时，namenode中可以感知到.
    2.分析：
  3. 当datanode上线时，datanode在zk中创建的节点类型为 瞬时的顺序节点．　
    ２．　namenode临听节点的变化情况，一旦有一个datanode下线，则这个节点会删除，namenode会自动回调》
  4. 请用对象流完成 datanode的 信息的注册.
  5. datanode的节点信息: System中获取 properties.

二： 前提:

利用zk完成,请先在zk中创建一个 servers 节点.

三 .模拟代码实现

3.1 DataNodeServer类

DataNodeServer该类用于提供外界访问，我把他在maven中pom.xml中加入 指定的主类build 配置 ，这个配置 在jar包中 manidest 文件中加入Main-class指定，就可通过java -Defile.encoding = utf-8 -jar xxx.jar包执行了

public class DataNodeServer {

private String parentNode="/servers";//这是整个集群的根节点
private static ZkHelper zkHelper;
private static ZooKeeper zk;
private static Logger logger = Logger.getLogger(DataNodeServer.class);
private static Scanner sc = new Scanner(System.in);
private static String zkUrl;

/**
 * 客户端与zk服务器连接方法
 * @throws IOException
 * @throws InterruptedException
 */
private void getConnect() throws IOException, InterruptedException {
    if(zkUrl!=null){
        zkHelper.connectString = zkUrl;
    }
    zkHelper = new ZkHelper();
    zk = zkHelper.connect();
}
/**
 * datanode客户端要将自己的信息打包装成一个Object，将对象序列化成byte[],
 * 然后再传给 zk 保存到节点的内容中 转化为对象流
 *
 * @param obj  必须实现java,io,Serilalizable
 *
 * @return
 */
private byte[]  toByteArray(Object obj){
    byte[] bs = null;
    ByteArrayOutputStream bos = new ByteArrayOutputStream(); //将数据以byte[]写出（输出）到内存
      ObjectOutputStream oos = null;
    try{
          oos = new ObjectOutputStream(bos);//将可以序列化的对象序列化写出到bos中   obj必须实现java.io.Serializable
          oos.writeObject(obj);
          oos.flush();

          //obj中的数据变成 byte[] 存到内存
          bs = bos.toByteArray();
    }catch (IOException e){
        e.printStackTrace();
    }finally {
          try{
              if(oos!=null){
                  oos.close();
              }
              if(bos!=null){
                  bos.close();
              }
          }catch (IOException e){
              e.printStackTrace();
          }
    }
    return bs;
}

/**
 * 将客户端的数据注册到zk中
 */
private void registerServer(){
    Properties p = getLocalHostInfo();
    byte[] data = toByteArray(p);  //将序列化的byte数组 赋给 data数组
    String ip = (String) p.get("ip");
    try {
        /**
         *    brokers/idss/1   broker/ids/2  borkers/ids/3
         *    myid : 1 myid :2
         *    带序号的临时节点 /server/server_192.168.176.200 _000000001   data:P序列化后的byte[]  /servers/server_192.168.76.200_0000
         *    acl :world:anyone
         *CreateMode类型分为4种
         * 1.PERSISTENT--持久型
         * 2.PERSISTENT_SEQUENTIAL--持久顺序型
         * 3.EPHEMERAL--临时型  下线既可以删除
         * 4.EPHEMERAL_SEQUENTIAL--临时顺序型
         */
        String resultPath = zk.create(parentNode+"/server_"+ip+"_",data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        logger.info("在服务器创建节点成功,路径为:"+resultPath);
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

/**
 * 获取当前系统的信息包装成一个Proerties
 *
 * @return
 */
private static Properties getLocalHostInfo() {

      Runtime r = Runtime.getRuntime(); //jvm信息   ： jvm内存
      Properties props = System.getProperties();  //操作系统信息
       InetAddress addr = null;

    try {
        addr = InetAddress.getLocalHost();//IP地址
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }

    String ip = addr.getHostAddress();   //取地址


    props.setProperty("ip",ip);
    props.setProperty("hostname", addr.getHostName());
    props.setProperty("totalMem",r.freeMemory()+"");
    props.setProperty("availableProcessors",r.availableProcessors()+"");

    System.out.println("ip: " + ip);
    System.out.println("hostname: "+addr.getHostName());
    System.out.println("jvm可以使用的总内存: "+ r.totalMemory());
    System.out.println("JVM可以使用的剩余内存: "+r.freeMemory());
    System.out.println("JVM可以使用的处理器个数: "+r.availableProcessors());


    System.out.println("Java的运行环境版本："+props.getProperty("java.version"));
    System.out.println("Java的运行环境供应商："+props.getProperty("java.vendor"));
    System.out.println("Java供应商的URL："+props.getProperty("java.vendor.url"));
    System.out.println("Java的安装路径："+props.getProperty("java.home"));
    System.out.println("Java的虚拟机规范版本："+props.getProperty("java.vm.specification.version"));
    System.out.println("Java的虚拟机规范供应商："+props.getProperty("java.vm.specification.vendor"));
    System.out.println("Java的虚拟机规范名称："+props.getProperty("java.vm.specification.name"));
    System.out.println("Java的虚拟机实现版本："+props.getProperty("java.vm.version"));
    System.out.println("Java的虚拟机实现供应商："+props.getProperty("java.vm.vendor"));
    System.out.println("Java的虚拟机实现名称："+props.getProperty("java.vm.name"));
    System.out.println("Java运行时环境规范版本："+props.getProperty("java.specification.version"));
    System.out.println("Java运行时环境规范供应商："+props.getProperty("java.specification.vender"));
    System.out.println("Java运行时环境规范名称："+props.getProperty("java.specification.name"));
    System.out.println("Java的类格式版本号："+props.getProperty("java.class.version"));
    System.out.println("Java的类路径："+props.getProperty("java.class.path"));
    System.out.println("加载库时搜索的路径列表："+props.getProperty("java.library.path"));
    System.out.println("默认的临时文件路径："+props.getProperty("java.io.tmpdir"));
    System.out.println("一个或多个扩展目录的路径："+props.getProperty("java.ext.dirs"));
    System.out.println("操作系统的名称："+props.getProperty("os.name"));
    System.out.println("操作系统的构架："+props.getProperty("os.arch"));
    System.out.println("操作系统的版本："+props.getProperty("os.version"));
    System.out.println("文件分隔符："+props.getProperty("file.separator")); //在 unix 系统中是＂／＂
    System.out.println("路径分隔符："+props.getProperty("path.separator")); //在 unix 系统中是＂:＂
    System.out.println("行分隔符："+props.getProperty("line.separator")); //在 unix 系统中是＂/n＂
    System.out.println("用户的账户名称："+props.getProperty("user.name"));
    System.out.println("用户的主目录："+props.getProperty("user.home"));
    System.out.println("用户的当前工作目录："+props.getProperty("user.dir"));



    return props;
}


/**
 * 业务方法：用于耗时
 */

private void business(){
    System.out.println("请输入割圆次数: ");
    int n = sc.nextInt();
      double y = 1.0;
      for (int i = 0; i < n; i++) {
          double π   =  3 * Math.pow( 2 , i) * y;
        System.out.println("第"+i+"次切割,为正"+(6 + 6*i) + "边形，圆周率π = " + π);
        y = Math.sqrt( 2 - Math.sqrt( 4 - y*y));
    }
}

/**
 * 主程序
 * @param args
 * @throws InterruptedException
 * @throws IOException
 */
public static void main(String[] args) throws InterruptedException, IOException {
    if(args != null && args.length >0){
        zkUrl = args[0];
    }

    DataNodeServer server = new DataNodeServer();
    server.getConnect();
    server.registerServer(); //第一次datanode后注册到zk

    boolean flag = false;
    int choice = 2;
    while (!flag){
        System.out.println("请输入你要的操作:\n1.执行计算任务  \n2.退出\n");
        choice = sc.nextInt();
        switch (choice){
            case 1:
                 server.business();
                 break;
            case 2:
                zkHelper.close();
                flag = true;
                sc.close();
                break;
            default:
                System.out.println("没有这个操作....");
        }
    }
    System.out.println("客户端退出");
}

}

3.2 NameNodeServer

该类用于监视datanodeserve的心跳，可以通过zookpeer的watch来监听上线节点数目，只需要实现Watcher接口再传入

public class NameNodeServer {

    private static ZkHelper zkHelper;
    private static ZooKeeper zk;
    private static Logger logger = Logger.getLogger(NameNodeServer.class);
    private String parentNode = "/servers";


    //初始化节点parentdate节点
    private void initMainNode()throws  Exception{
        zkHelper = new ZkHelper();
        zk = zkHelper.connect();
        if(zk==null || zk.getState()!= ZooKeeper.States.CONNECTED){
            logger.error("没有建立起与zookpeer服务器"+zkHelper.getConnectString()+"的连接");
            throw new Exception("没有建立起与zookpeer服务器"+zkHelper.getConnectString()+"的连接");
        }
        try{
            zk.exists(parentNode,true);
        }catch (Exception e){
            zk.create(parentNode,"this is yc datanode cluster".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    /**
     * 获取服务器列表哦
     * @throws KeeperException
     * @throws InterruptedException
     */
    private void getServerList() throws KeeperException,InterruptedException{
        CountDownLatch countDownLatch = new CountDownLatch(Integer.MAX_VALUE);

         MyMatch nm = new MyMatch(zk,parentNode,countDownLatch);
        List<String> servers = zk.getChildren(parentNode,nm);//*****第一次取/servers节点的列表后，绑定了监听...
        logger.info("主线程启动,得到当前datanode列表: ");
        for (String child : servers) {
            byte[] data = zk.getData(parentNode+"/"+child,false,null);//这个data就是客户端存入的 Properties对象

            logger.info(child);
        }
        countDownLatch.await();//阻塞
    }

    /**
     * 关闭服务器
     */
    public void closeZookpeer(){
        logger.info("关闭zookpeer的连接....");
        if(zk!=null && zk.getState() == ZooKeeper.States.CONNECTED){
            try {
                zk.close();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
//start-all.sh   stop.all.sh
    public static void main(String[] args) throws Exception {
        //1.实例化服务器
        NameNodeServer server = new NameNodeServer();
        //2.建立连接 NameNodeServer -> zk;
        //3.判断/servers是否存在 如果不存在 则创建 -》init
        server.initMainNode();;

        //绑定监听 /servers下的/子节点变化
        // * ls path [watch] ->getChildren
        //*创建，删除子节点事件起作用
        //countdownloach
        server.getServerList();//阻塞式
        //5.关闭服务器 释放资源
        server.closeZookpeer();
    }

}


/**
 * 监听子节点的列表发生变化
 */
class MyMatch implements Watcher {

    private ZooKeeper zk;
    private String path;
    private CountDownLatch countDownLatch;
    private Logger logger = Logger.getLogger(MyMatch.class);

    private void showChildNodeInfo(List<String> children) {
        //1.循环子节点列表
        logger.info("当前在线的datanode有:" + children.size());
        logger.info("他们是:");
        logger.info(children); //[xx,xx,xxx]
        logger.info("各节点的详情:");
        for (String sonPath : children) {

            logger.info("*****" + sonPath + "*********");

            try {
                byte[] data = zk.getData(path + "/" + sonPath, false, null);//byte[]->反序列化
                Properties p = (Properties) deserilizable(data);
                logger.info(p);
                logger.info("**************");

            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //2.根据子节点 路径 显示信息
        }
    }
序列化转为byte数组
    private Object deserilizable(byte[] data) {

        Object obj = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            bis = new ByteArrayInputStream(data);
            ois = new ObjectInputStream(bis);
            obj = ois.readObject();
        } catch (ClassNotFoundException | IOException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return obj;
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == NodeChildrenChanged) {
            //实现子节点列表变化的代码
            logger.info("监听到了子节点的变化...");
            try {
                 //重新绑定
                List<String> children = zk.getChildren(path,MyMatch.this);
                showChildNodeInfo(children);
            } catch (KeeperException | InterruptedException e) {

                e.printStackTrace();
                logger.error(e.getMessage());
            }
        } else if (event.getType() == NodeDataChanged) {
            try {
                Stat stat = new Stat();
           //画龙点睛之笔
                byte[] data = zk.getData(path, MyMatch.this, stat);//异常不能抛出
                String dataString = new String(data,"utf-8");
                logger.info("监听程序中获取节点:"+path+"更新后的数据为:"+dataString);
                logger.info("节点最新的信息stat为:");

                String info = YcZnodeUtil.printZnodeInfo(stat);
                logger.info(info);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        countDownLatch.countDown();  //递减
        //重新设置countdown 的初始值 让他循环
        if (countDownLatch.getCount() == 1) {
            countDownLatch = new CountDownLatch(Integer.MAX_VALUE);
        }
        System.out.println("当前  connectedsignal为：   " + countDownLatch.getCount());


    }
    public MyMatch(ZooKeeper zk,String path,CountDownLatch countDownLatch){
        super();
        this.zk = zk;
        this.path = path;
        this.countDownLatch = countDownLatch;
    }

    public MyMatch(){
        super();
    }

    public void setZk(ZooKeeper zk){
        this.zk = zk;
    }
    public void setPath(String path){
        this.path = path;
    }
}


# pom文件配置
<build>

        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
             </plugin>
<!--借助assembly插件完成包含项目依赖的jar包-->
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                  <appendAssemblyId>false</appendAssemblyId>
                    <descriptorRefs>
<!--                        设置将所有的依赖的打进jar包中-->
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                  <archive>
                      <manifest>
<!--                          此处main方法入口的class-->
                          <mainClass>com.yc.Zookpeek.program2.NameNodeServer</mainClass>
                      </manifest>
                  </archive>
<!--                    //指定输出路径-->
<!--                    <outputDirectory>D://a</outputDirectory>-->
             </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
<!--                        将assembly插件绑定了package中到时候只需要双击package指令即可-->
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
         </plugin>

        </plugins>
    </build>


    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>



    </dependencies>

</project>
一枚扁舟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hadoop-2.7.5-with-centos7.6.tar.gz
08-24
然后，在Master节点上启动NameNode和ResourceManager，其他节点启动DataNode和NodeManager，形成Hadoop集群。 五、Hadoop应用 1. MapReduce编程模型：理解Map函数和Reduce函数的工作原理，编写自定义的Mapper和...
Hadoop服务和Zookeeper服务中的各个交互流程
LI_dreamit的博客
10-13 594
1、ResourceManager和NameManager的交互 流程 1）由客户端向RM发送计算任务的请求， 2）RM的APPlocationManager接收计算的任务，然后在namemanager中生成一个applocationmaster 3）applocationmaster接收请求后，向RM中的ResourceScheduler申请计算资源，申请成功后告知applocationmaster 4）applocationmaster接收到申请成功的消息后，通知NM
ZooKeeper数据存储与数据同步机制
张普的专栏
07-05 1495
ZooKeeper中，数据存储分为两部分，内存数据(ZKDatabase)与磁盘数据(事务日志 + 事务快照)。ZKDatabaseZooKeeper的数据模型是一棵树。而从使用角度看，ZooKeeper就像一个内存数据库一样，在内存数据库中，存储了整棵树的内容，包括所有的节点路径、节点数据以及ACL信息等。ZKDatabaseZKDatabase是ZooKeeper的内...
Zookeeper介绍及实战（一）
yaya_jn的博客
05-17 5068
一、ZooKeeper介绍 ZooKeeper 是一个开源的分布式协调框架，是Apache Hadoop 的一个子项目，主要用来解决分布式集群中应用系统的一致性问题。Zookeeper 的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来，构成一个高效可靠的原语集，并以一系列简单易用的接口提供给用户使用。 官方：Apache ZooKeeper ZooKeeper本质上是一个分布式的小文件存储系统（Zookeeper=文件系统+监听机制）。提供基于类似于文件系统的目录树方式的数据存.
使用ZooKeeper实现Java跨JVM的分布式锁
大新博客
06-03 9380
说明：本文是使用Curator框架进行讲解及演示，Curator是对Zookeeper客户端的一个封装，因为Zookeeper的客户端实现偏底层，如果想要实现锁或其他功能都需要自己封装，实现一些简单的功能还可以，如果想要实现锁这种高并发下的东西，不建议自己封装，除非你自信你写的东西比国外大神写的还好~ 如果是研究学习到是可以自己写一下，同时也可以看看开源的代码，那里面还是有很多值得学习的东西。
hadoop学习笔记
chuan的专栏
09-25 467
hadoop的集群是基于master/slave模式，namenode和jobtracker属于master，datanode和tasktracker属于slave，master只有一个，而slave有多个。 ·分布式存储（hdfs）角度：集群中的节点由一个namenode和多个datanode组成。namenode是中心服务器，负责管理文件系统的名字空间（namespace）以及客户端对文件的
hadoop-2.7-spark-2.1-搭建
01-09
在这个过程中，我们需要对Linux操作系统有基本的了解，掌握用户管理和文件权限控制，同时还需要熟悉Hadoop和Spark的安装与配置流程。 1. **Linux操作** - **增加用户**：在Linux中，可以通过`useradd`命令创建新...
Hadoop_Hive安装--自己整理
11-14
1. 在主节点（master）上生成公钥私钥对，运行`ssh-keygen -t rsa`，然后将公钥（默认为`~/.ssh/id_rsa.pub`）复制到所有从节点（slaves）的`~/.ssh/authorized_keys`文件中。 2. 确保所有节点的SSH服务都在运行，...
hadoop-管理
03-07
在分布式计算领域，Hadoop 是一个广泛使用的开源框架，它为大数据处理提供了高效、可靠的解决方案。本篇文章将详细探讨在 Hadoop 和 HBase 集群管理中的几个关键知识点，包括处理各种节点宕机问题、添加新节点以及...
Hadoop2.X集群安装与配置
07-24
5. 修改`etc/hadoop/slaves`文件，列出所有工作节点的主机名。 六、格式化NameNode 在主节点上执行`hadoop namenode -format`命令初始化NameNode。 七、启动Hadoop服务 在主节点上依次启动DataNode、NameNode、...
DataNode寻找NameNode
高毅的博客
07-02 460
DataNode启动时是怎样寻找它所属的NameNode的呢？ 原来在它的块数据存储在它所在主机的本地文件系统中，比如我的是在如下的目录中 在current目录下有BP-987952527-192.168.220.129-1498325297029，这个文件夹的名字是NameNode赋予它的，也可以说是NameNode给它打的一个标签，以表明该DataNode属于某个NameNode。
Hadoop系列-HDFS架构和简介（八）
Toby的博客
11-21 655
Hadoop系列之HDFS架构
hadoop中的RPC, namenode和datanode通信原理
想~ai抽
03-09 1953
1. JobClient（题外话，自己翻译了一下JobClient的运行机制）: JobClient是用户提交的信息与JobTracker交互的主要接口。它提供的功能有：提交作业，跟踪作业进度，访问作业报告和进度，获取MR集群的状态等。 作业提交过程： a. 检查作业的输入输出是否合乎规范； b. 为作业计算出InputSplit（单个Mapper需要执行的部分）； c. 如有需要，为D
Hadoop源码分析---Namenode和Datanode
u012361112的博客
06-22 624
1. 使用hadoop FileSystem类读取文件系统代码如下： public static void main(String[] args) { Configuration conf = new Configuration(); try { FileSystem fs = FileSystem.get(conf); ...
HDFS的运行原理,NameNode,DataNode,client介绍
最长的电影
03-18 908
HDFS（Hadoop Distributed File System ）Hadoop分布式文件系统。是根据google发表的论文翻版的。论文为GFS（Google File System）Google 文件系统（中文，英文）。 HDFS有很多特点：     ① 保存多个副本，且提供容错机制，副本丢失或宕机自动恢复。默认存3份。     ② 运行在廉价的机器上。（商用机）     ③ ...
DataNode与Namenode的互动
weixin_33802505的博客
11-01 433
2019独角兽企业重金招聘Python工程师标准>>> ...
HadoopRPC框架-----模拟NameNode和Client通信
BDLng的博客
12-19 589
Hadoop中datanode和namenode之间的通信是通过他们内部实现的一个RPC框架实现的，一般这个RPC框架，应用于纯后台交互系统中。 下面对其API进行一下NameNode和Client之间通信的Demo。 代码：（jar自己引） HDFS客户端： import java.net.InetSocketAddress; import org.apache.hadoop.conf.
5节点 Hadoop +zookeeper 完全分布式集群（HA）
wjl7813的博客
01-28 532
主机 信息规划  master slave1 slave2 slave3 slave4 namenode 是 是 否 否 否 datanode 否 否 是 是 是 resourcemanager 是 是 否 否 否 journalnode 是 是 是 是 是 zookeeper 是 是 是 是 是 软件规划  软件 版本
hadoop+Zookeeper集群安装配置高可用-HadoopHA
sxj的专栏
01-05 4480
1、请看：https://blog.csdn.net/sunxiaoju/article/details/85222290，此处只是配置系统的：硬件配置以及操作系统、节点需要安装的工具、安装JDK环境、创建hadoop用户、建立ssh无密码登录本机前五部分，第6部分的hadoop安装在此博文中需要重新配置，所以不需要查看，在此处博文中需要添加一个master1的namenode节点要结合前五部分一...
grep hadoop-hadoop-namenode-master.log
最新发布
04-23
在这个例子中，我们要在hadoop-hadoop-namenode-master.log文件中查找特定的字符串。具体使用方法为：在终端中输入以下命令： grep "hadoop-hadoop-namenode-master.log" 文件名 这将在指定的文件中搜索包含...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值