专栏首页Hadoop实操如何开发HBase Endpoint类型的Coprocessor以及部署使用

如何开发HBase Endpoint类型的Coprocessor以及部署使用

温馨提示:要看高清无码套图,请使用手机打开并单击图片放大查看。

Fayson的github:https://github.com/fayson/cdhproject

提示:代码块部分可以左右滑动查看噢

1.文档编写目的


Fayson在前面的文章介绍了HBase自带的Coprocessor调用示例《如何使用Java调用HBase的 Endpoint Coprocessor》,本篇文章Fayson主要介绍如何开发一个HBase Endpoint类型的协处理器。

本篇文章示例协处理器主要实现了对列的Count、Max、Min、Sum以及Average。前面的文章调用Coprocessor定义的全局的,在本篇文章Fayson介绍另一种实现方式通过代码的方式对指定的表添加Coprocessor。

  • 内容概述

1.环境准备

2.使用Protobuf生成序列化类

3.Endpoint Coprocessor服务端实现

4.Endpoint Coprocessor客户端实现

5.部署及调用

  • 测试环境

1.CM和CDH版本为5.14.3

2.集群未启用Kerberos

2.环境准备


在HMaster、RegionServer内部,创建了RpcServer实例,并与Client三者之间实现了Rpc调用,在HBase0.95版本引入了Google-Protobuf作为中间数据组织方式,并在Protobuf提供的Rpc接口之上,实现了基于服务的Rpc实现。

Protobuf Buffers是一种轻便高效的结构化数据存储格式,可以用于数据序列化。适合做数据存储或RPC数据交换格式。用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。

这里Fayson借助于Protobuf来生成HBase RPC数据交换格式类,在HBase中使用的Protobuf版本为2.5.0,所以选择安装相同版本的Protobuf。

1.下载Protobuf2.5.0版本的安装包,地址如下:

https://github.com/google/protobuf/releases/download/v2.5.0/protobuf-2.5.0.tar.gz

(可左右滑动)

2.选择一台服务器安装Protobuf

[root@ip-172-31-5-38 ~]# wget https://github.com/google/protobuf/releases/download/v2.5.0/protobuf-2.5.0.tar.gz

(可左右滑动)

3.执行如下命令安装Protobuf所需要的依赖包

yum install -y autoconf automake libtool curl make g++ unzip gcc-c++

(可左右滑动)

4.解压protobuf-2.5.0.tar.gz,并进入解压目录执行如下命令编译安装

[root@ip-172-31-5-38 ~]# tar -zxvf protobuf-2.5.0.tar.gz
[root@ip-172-31-5-38 ~]# cd protobuf-2.5.0
[root@ip-172-31-5-38 protobuf-2.5.0]# ./configure --prefix=/usr/local/protobuf
[root@ip-172-31-5-38 protobuf-2.5.0]# make && make install

(可左右滑动)

5.配置Protobuf环境变量

export PROTOBUF_HOME=/usr/local/protobuf
export PATH=$PROTOBUF_HOME/bin:$PATH

(可左右滑动)

执行命令使环境变量生效

[root@ip-172-31-5-38 protobuf-2.5.0]# source /etc/profile

(可左右滑动)

6.准备HBase测试表,建表脚本及测试数据如下

create 'fayson_coprocessor', {NAME => 'info'}
put 'fayson_coprocessor','001','info:sales',12.3
put 'fayson_coprocessor','002','info:sales',24.5
put 'fayson_coprocessor','003','info:sales',10.5
put 'fayson_coprocessor','004','info:sales',11.5
put 'fayson_coprocessor','005','info:sales',10.5
put 'fayson_coprocessor','001','info:age',22
put 'fayson_coprocessor','002','info:age',33
put 'fayson_coprocessor','003','info:age',26
put 'fayson_coprocessor','004','info:age',28
put 'fayson_coprocessor','005','info:age',56

(可左右滑动)

3.使用Protobuf生成序列化类


1.准备MyFirstCoprocessor.proto文件,内容如下

[root@ip-172-31-5-171 hbase-coprocessor]# vim MyFirstCoprocessor.proto 
syntax = "proto2";
option java_package = "com.cloudera.hbase.coprocessor.server";
option java_outer_classname = "MyFirstCoprocessor";
option java_generic_services = true;
option java_generate_equals_and_hash = true;
option optimize_for = SPEED;
message MyCoprocessRequest {
    required string family = 1;
    required string columns = 2;
}
message MyCoprocessResponse {
    required int64 count = 1;
    required double maxnum = 3;
    required double minnum = 4;
    required double sumnum = 5;
}
service AggregationService {
  rpc getAggregation(MyCoprocessRequest)
    returns (MyCoprocessResponse);
}

(可左右滑动)

2.在命令行执行如下命令生成Java类

[root@ip-172-31-5-38 hbase-coprocessor]# protoc --java_out=./ MyFirstCoprocessor.proto 
[root@ip-172-31-5-38 hbase-coprocessor]# ll
total 4
drwxr-xr-x 3 root root  22 May 14 16:34 com
-rw-r--r-- 1 root root 609 May 14 16:33 MyFirstCoprocessor.proto
[root@ip-172-31-5-38 hbase-coprocessor]# 

(可左右滑动)

在当前目录下根据java_package指定的目录生成Java类。

4.Endpoint Coprocessor服务端实现


1.使用Maven创建Java示例工程,pom.xml文件内容如下

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-client</artifactId>
    <version>2.6.0-cdh5.11.2</version>
</dependency>
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-common</artifactId>
    <version>2.6.0-cdh5.11.2</version>
</dependency>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>1.2.0-cdh5.11.2</version>
</dependency>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-examples</artifactId>
    <version>1.2.0-cdh5.11.2</version>
</dependency>
<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
    <version>2.5.0</version>
</dependency>

(可左右滑动)

2.将Protobuf生成的java类拷贝至指定的包目录下

与MyFirstCoprocessor.proto文件指定的java_package包目录一致。

3.在com.cloudera.hbase.coprocessor.server包下新建MyFirstCoprocessorEndpoint实现类,内容如下

package com.cloudera.hbase.coprocessor.server;
import com.google.protobuf.RpcCallback;
import com.google.protobuf.RpcController;
import com.google.protobuf.Service;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.Coprocessor;
import org.apache.hadoop.hbase.CoprocessorEnvironment;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.coprocessor.CoprocessorException;
import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
import org.apache.hadoop.hbase.protobuf.ResponseConverter;
import org.apache.hadoop.hbase.regionserver.InternalScanner;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
 * package: com.cloudera.hbase.coprocessor.server
 * describe: HBase RegionServer上Endpoint Coprocessor实现,主要实现对指定列的Count、MAX、MIN、SUM聚合操作
 * creat_user: Fayson
 * email: htechinfo@163.com
 * creat_date: 2018/5/13
 * creat_time: 下午11:11
 * 公众号:Hadoop实操
 */
public class MyFirstCoprocessorEndPoint extends MyFirstCoprocessor.AggregationService implements Coprocessor, CoprocessorService {
    protected static final Log log = LogFactory.getLog(MyFirstCoprocessorEndPoint.class);
    private RegionCoprocessorEnvironment env;
    @Override
    public void getAggregation(RpcController controller, MyFirstCoprocessor.MyCoprocessRequest request, RpcCallback<MyFirstCoprocessor.MyCoprocessResponse> done) {
        Scan scan = new Scan();
        scan.addFamily(Bytes.toBytes(request.getFamily()));
        //传入列的方式   sales:MAX,sales:MIN,sales:AVG,slaes:SUM,sales:COUNT
        String colums = request.getColumns();
        //记录所有要扫描的列
        Map<String, List<String>> columnMaps = new HashedMap();
        for (String columnAndType : colums.split(",")) {
            String column = columnAndType.split(":")[0];
            String type = columnAndType.split(":")[1];
            List<String> typeList = null;
            if (columnMaps.containsKey(column)) {
                typeList = columnMaps.get(column);
            } else {
                typeList = new ArrayList<>();
                //将column添加到Scan中
                scan.addColumn(Bytes.toBytes(request.getFamily()), Bytes.toBytes(column));
            }
            typeList.add(type);
            columnMaps.put(column, typeList);
        }
        InternalScanner scanner = null;
        MyFirstCoprocessor.MyCoprocessResponse response = null;
        Double max = null;
        Double min = null;
        Double sumVal = null;
        long counter = 0L;
        try {
            scanner = this.env.getRegion().getScanner(scan);
            List<Cell> results = new ArrayList<>();
            boolean hasMore = false;
            scanner = env.getRegion().getScanner(scan);
            do {
                hasMore = scanner.next(results);
                if (results.size() > 0) {
                    ++counter;
                }
                log.info("counter:" + counter);
                log.info("results size:" + results.size());
                for (Cell cell : results) {
                    String column = Bytes.toString(CellUtil.cloneQualifier(cell));
                    log.info("Column Name: " + column);
                    log.info("Cell Value:" + new String(CellUtil.cloneValue(cell)));
                    Double temp = Double.parseDouble(new String(CellUtil.cloneValue(cell)));
                    if (columnMaps.containsKey(column)) {
                        List<String> types = columnMaps.get(column);
                        for (String type : types) {
                            switch (type.toUpperCase()) {
                                case "MIN":
                                    min = min != null && (temp == null || compare(temp, min) >= 0) ? min : temp;
                                    log.info("MIN Value: " + min.doubleValue());
                                    break;
                                case "MAX":
                                    max = max != null && (temp == null || compare(temp, max) <= 0) ? max : temp;
                                    break;
                                case "SUM":
                                    if (temp != null) {
                                        sumVal = add(sumVal, temp);
                                    }
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                }
                results.clear();
            } while (hasMore);
            response = MyFirstCoprocessor.MyCoprocessResponse.newBuilder()
                    .setMaxnum(max!=null?max.doubleValue():Double.MAX_VALUE)
                    .setMinnum(min!=null?min.doubleValue():Double.MIN_NORMAL)
                    .setCount(counter)
                    .setSumnum(sumVal!=null?sumVal.doubleValue():Double.MIN_NORMAL).build();
        } catch (IOException e) {
            e.printStackTrace();
            ResponseConverter.setControllerException(controller, e);
        } finally {
            if (scanner != null) {
                try {
                    scanner.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        done.run(response);
    }
    public static int compare(Double l1, Double l2) {
        if (l1 == null ^ l2 == null) {
            return l1 == null ? -1 : 1; // either of one is null.
        } else if (l1 == null)
            return 0; // both are null
        return l1.compareTo(l2); // natural ordering.
    }
    public double divideForAvg(Double d1, Long l2) {
        return l2 != null && d1 != null?d1.doubleValue() / l2.doubleValue():0.0D / 0.0;
    }
    public Double add(Double d1, Double d2) {
        return d1 != null && d2 != null ? Double.valueOf(d1.doubleValue() + d2.doubleValue()) : (d1 == null ? d2 : d1);
    }
    @Override
    public void start(CoprocessorEnvironment coprocessorEnvironment) throws IOException {
        if (coprocessorEnvironment instanceof RegionCoprocessorEnvironment) {
            this.env = (RegionCoprocessorEnvironment) coprocessorEnvironment;
        } else {
            throw new CoprocessorException("Must be loaded on a table region!");
        }
    }
    @Override
    public void stop(CoprocessorEnvironment coprocessorEnvironment) throws IOException {
    }
    @Override
    public Service getService() {
        return this;
    }
}

(可左右滑动)

5.Endpoint Coprocessor客户端实现


1.编写MyFirstCoprocessExample.java类,代码如下:

package com.cloudera.hbase.coprocessor.client;
import com.cloudera.hbase.coprocessor.server.MyFirstCoprocessor;
import com.cloudera.hbase.coprocessor.server.MyFirstCoprocessorEndPoint;
import com.google.common.util.concurrent.AtomicDouble;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Coprocessor;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.client.coprocessor.Batch;
import org.apache.hadoop.hbase.client.coprocessor.DoubleColumnInterpreter;
import org.apache.hadoop.hbase.ipc.BlockingRpcCallback;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;
/**
 * package: com.cloudera.hbase.coprocessor.client
 * describe: 调用HBase RegionServer端的协处理器
 * creat_user: Fayson
 * email: htechinfo@163.com
 * creat_date: 2018/5/14
 * creat_time: 下午6:36
 * 公众号:Hadoop实操
 */
public class MyFirstCoprocessExample {
    public static void main(String[] args) {
        String table_name = "fayson_coprocessor";
        //初始化HBase配置
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.property.clientPort", "2181");
        configuration.setStrings("hbase.zookeeper.quorum", "ip-172-31-5-38.ap-southeast-1.compute.internal,ip-172-31-8-230.ap-southeast-1.compute.internal,ip-172-31-5-171.ap-southeast-1.compute.internal");
        try {
            //创建一个HBase的Connection
            Connection connection = ConnectionFactory.createConnection(configuration);
            TableName tableName = TableName.valueOf(table_name);
            if(!connection.getAdmin().tableExists(tableName)) {
                System.out.println(table_name + "does not exist....");
                System.exit(0);
            }
            Table table = connection.getTable(tableName);
            //删除表上的协处理器
            deleteCoprocessor(connection, table, MyFirstCoprocessorEndPoint.class);
            //为指定的表添加协处理器
            String hdfspath = "hdfs://nameservice3/hbase/coprocessor/hbase-demo-1.0-SNAPSHOT.jar";
            setupToExistTable(connection, table, hdfspath, MyFirstCoprocessorEndPoint.class);
            //客户端调用Region端的协处理器
            execFastEndpointCoprocessor(table, "info", "sales:MAX,sales:MIN,sales:AVG,sales:SUM,sales:COUNT");
            //关闭连接
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 删除HBase表上的协处理器
     * @param connection
     * @param table
     * @param cls
     */
    public static void deleteCoprocessor(Connection connection, Table table, Class<?>... cls) {
        System.out.println("begin delete " + table.getName().toString() + " Coprocessor......");
        try {
            HTableDescriptor hTableDescriptor = table.getTableDescriptor();
            for(Class cass : cls) {
                hTableDescriptor.removeCoprocessor(cass.getCanonicalName());
            }
            connection.getAdmin().modifyTable(table.getName(), hTableDescriptor);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("end delete " + table.getName().toString() + " Coprocessor......");
    }
    /**
     *
     * @param connection
     * @param table
     * @param jarPath
     * @param cls
     */
    public static void setupToExistTable(Connection connection, Table table, String jarPath, Class<?>... cls) {
        try {
            if(jarPath != null && !jarPath.isEmpty()) {
                Path path = new Path(jarPath);
                HTableDescriptor hTableDescriptor = table.getTableDescriptor();
                for(Class cass : cls) {
                    hTableDescriptor.addCoprocessor(cass.getCanonicalName(), path, Coprocessor.PRIORITY_USER, null);
                }
                connection.getAdmin().modifyTable(table.getName(), hTableDescriptor);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 效率最高的方式,在方式二的基础上优化
     * 通过HBase的coprocessorService(Class, byte[],byte[],Batch.Call,Callback<R>)方法获取表的总条数
     * @param table HBase表名
     * @return 返回表的总条数
     */
    public static long execFastEndpointCoprocessor(Table table, String family, String columns) {
        long start_t = System.currentTimeMillis();
        //定义总的 rowCount 变量
        AtomicLong totalRowCount = new AtomicLong();
        AtomicDouble maxValue = new AtomicDouble(Double.MIN_VALUE);
        AtomicDouble minValue = new AtomicDouble(Double.MAX_VALUE);
        AtomicDouble sumValue = new AtomicDouble();
        try {
            Batch.Callback<MyFirstCoprocessor.MyCoprocessResponse> callback = new Batch.Callback<MyFirstCoprocessor.MyCoprocessResponse>() {
                @Override
                public void update(byte[] bytes, byte[] bytes1, MyFirstCoprocessor.MyCoprocessResponse myCoprocessResponse) {
                    //更新Count值
                    totalRowCount.getAndAdd(myCoprocessResponse.getCount());
                    //更新最大值
                    if(myCoprocessResponse.getMaxnum() > maxValue.doubleValue()) {
                        maxValue.compareAndSet(maxValue.doubleValue(), myCoprocessResponse.getMaxnum());
                    }
                    //更新最小值
                    if(myCoprocessResponse.getMinnum() < minValue.doubleValue()) {
                        minValue.compareAndSet(minValue.doubleValue(), myCoprocessResponse.getMinnum());
                    }
                    //更新求和
                    sumValue.getAndAdd(myCoprocessResponse.getSumnum());
                }
            };
            table.coprocessorService(MyFirstCoprocessor.AggregationService.class, null, null, new Batch.Call<MyFirstCoprocessor.AggregationService, MyFirstCoprocessor.MyCoprocessResponse>() {
                @Override
                public MyFirstCoprocessor.MyCoprocessResponse call(MyFirstCoprocessor.AggregationService aggregationService) throws IOException {
                    MyFirstCoprocessor.MyCoprocessRequest requet = MyFirstCoprocessor.MyCoprocessRequest.newBuilder().setFamily(family).setColumns(columns).build();
                    BlockingRpcCallback<MyFirstCoprocessor.MyCoprocessResponse> rpcCallback = new BlockingRpcCallback<>();
                    aggregationService.getAggregation(null, requet, rpcCallback);
                    MyFirstCoprocessor.MyCoprocessResponse response = rpcCallback.get();
                    return response;
                }
            }, callback);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("耗时:" + (System.currentTimeMillis() - start_t));
        System.out.println("totalRowCount:" + totalRowCount.longValue());
        System.out.println("maxValue:" + maxValue.doubleValue());
        System.out.println("minValue:" + minValue.doubleValue());
        System.out.println("sumValue:" + sumValue.doubleValue());
        System.out.println("avg:" + new DoubleColumnInterpreter().divideForAvg(sumValue.doubleValue(), totalRowCount.longValue()));
        return totalRowCount.longValue();
    }
}

(可左右滑动)

6.部署及调用


1.使用mvn编译工程

mvn clean package

(可左右滑动)

2.将编译好的jar包,上传HDFS的/hbase/coprocessor目录下

[root@ip-172-31-5-38 ~]# export HADOOP_USER_NAME=hbase         
[root@ip-172-31-5-38 ~]# hadoop fs -mkdir -p /hbase/coprocessor
[root@ip-172-31-5-38 ~]# hadoop fs -put hbase-demo-1.0-SNAPSHOT.jar /hbase/coprocessor
[root@ip-172-31-5-38 ~]# hadoop fs -ls /hbase/coprocessor

(可左右滑动)

在客户端调用的示例代码中使用的是代码为指定的表添加Coprocessor操作,所以这里不需要在HBase中配置全局的Coprocessor。

3.运行MyFirstCoprocessorExample代码,查看运行结果

统计的值与我们写入的数据一致。

7.总结


  • 在开发HBase的Coprocessor借助于Protobuf生成RPC请求数据交互类,我们只需要在生成的类基础上实现业务即可。
  • 本篇文章主要介绍了怎么样通过代码的方式为指定的HBase表添加Coprocessor,这种方式使用更灵活,不需要重启HBase服务。
  • 将编写好的Coprocessor jar上传至HDFS,确保文件的目录属主。
  • HBase自带的也有AggregateImplementation类实现列的聚合,原生的不能同时对多个列进行聚合处理,如果需要多次聚合则需要多次调用RPC请求,HBase数据在不断的写入会出现每次聚合的结果有偏差,本示例将聚合放在一个RPC中处理可以减少RPC的请求次数并确保查询条件相同的情况下不会出现数据不一致问题。

GitHub地址:

https://github.com/fayson/cdhproject/blob/master/hbasedemo/proto/MyFirstCoprocessor.proto

https://github.com/fayson/cdhproject/blob/master/hbasedemo/src/main/java/com/cloudera/hbase/coprocessor/server/MyFirstCoprocessorEndPoint.java

https://github.com/fayson/cdhproject/blob/master/hbasedemo/src/main/java/com/cloudera/hbase/coprocessor/server/MyFirstCoprocessor.java

https://github.com/fayson/cdhproject/blob/master/hbasedemo/src/main/java/com/cloudera/hbase/coprocessor/client/MyFirstCoprocessExample.java

提示:代码块部分可以左右滑动查看噢

为天地立心,为生民立命,为往圣继绝学,为万世开太平。 温馨提示:要看高清无码套图,请使用手机打开并单击图片放大查看。

推荐关注Hadoop实操,第一时间,分享更多Hadoop干货,欢迎转发和分享。

原创文章,欢迎转载,转载请注明:转载自微信公众号Hadoop实操

本文分享自微信公众号 - Hadoop实操(gh_c4c535955d0f),作者:Fayson

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2018-05-15

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 如何在CDH中使用HBase的ACLs进行授权

    Fayson
  • 如何使用hadoop命令向CDH集群提交MapReduce作业

    在前面文章Fayson讲过《如何跨平台在本地开发环境提交MapReduce作业到CDH集群》,那对于部分用户来说,需要将打包好的jar包在CDH集群运行,可以使...

    Fayson
  • 0554-6.1.0-同一java进程中同时访问认证和非认证集群的问题(续)

    Fayson在前面的文章《0553-6.1.0-如何使用Java代码同时访问安全和非安全CDH集群》,本篇文章介绍在同一Java进程中,通过多线程同时访问Ker...

    Fayson
  • 劲爆ORACLE优化,你不必是专家

    性能优化可以从PLAN开始,但是不能以PLAN结束。对于一些优化需求,我们可以看看执行计划,不过加HINT一般不是办法,我们可以从应用、业务找突破口,甚至可以把...

    数据和云
  • Python 中那些令人拍案叫绝的功能!

    链接:www.oschina.net/translate/python-functions

    Rocky0429
  • 开源跨平台移动项目Ngui【视图与布局系统】

    这是一个GUI的排版显示引擎和跨平台的GUI应用程序开发框架,基于NodeJS/OpenGL,这也是第一个在移动端Android/iOS融合NodeJS的前端G...

    IMWeb前端团队
  • golang五周岁

    时间过得真是太快,一晃眼golang都五周岁了。五年,对于人生来讲也许有些漫长,但对于一门语言的发展来说,仅仅是沧海一粟。相对于它试图挑战的「系统级」语言:c,...

    tyrchen
  • 开源跨平台移动项目Ngui【视图与布局系统】

    Ngui简介 这是一个GUI的排版显示引擎和跨平台的GUI应用程序开发框架,基于NodeJS/OpenGL,这也是第一个在移动端Android/iOS融合Nod...

    IMWeb前端团队
  • Github标星19K+Star,10分钟自建对象存储服务!

    MinIO 是一款基于Go语言的高性能对象存储服务,在Github上已有19K+Star。它采用了Apache License v2.0开源协议,非常适合于存储...

    macrozheng
  • Spring中的测试类~简洁方便

    我们在src目录下新建一个test文件夹,并将其改成测试目录Test,标记为绿色:

    用户7544680

扫码关注云+社区

领取腾讯云代金券