android log机制——输出log【转】-低调大师

android log机制——输出log【转】

2016-08-22 784

转自：http://blog.csdn.net/tdstds/article/details/19084327

转自： http://my.oschina.net/wolfcs/blog/164624

Android log系统。

在android Java code中输出log

android系统有4种类型、6个优先级的log，有一些常量用于标识这些信息，相关的定义在frameworks/base/core/Java/android/util/Log.java中可以看到：

 
       01 
       /** 
      
       02 
         * Priority constant for the println method; use Log.v.  
      
       03 
         */  
      
       04 
        public static final int VERBOSE = 2;  
      
       05 
         
       06 
       /** 
      
       07 
         * Priority constant for the println method; use Log.d.  
      
       08 
         */  
      
       09 
        public static final int DEBUG = 3;  
      
       10 
         
       11 
       /** 
      
       12 
         * Priority constant for the println method; use Log.i.  
      
       13 
         */  
      
       14 
        public static final int INFO = 4;  
      
       15 
         
       16 
       /** 
      
       17 
         * Priority constant for the println method; use Log.w.  
      
       18 
         */  
      
       19 
        public static final int WARN = 5;  
      
       20 
         
       21 
       /** 
      
       22 
         * Priority constant for the println method; use Log.e.  
      
       23 
         */  
      
       24 
        public static final int ERROR = 6;  
      
       25 
         
       26 
       /** 
      
       27 
         * Priority constant for the println method.  
      
       28 
         */  
      
       29 
        public static final int ASSERT = 7;  
      
       30 
         
       31 
        /** @hide */ public static final int LOG_ID_MAIN = 0;  
      
       32 
        /** @hide */ public static final int LOG_ID_RADIO = 1;  
      
       33 
        /** @hide */ public static final int LOG_ID_EVENTS = 2;  
      
       34 
        /** @hide */ public static final int LOG_ID_SYSTEM = 3;

Java层可以通过三个class来输出其中三种类型的log，三种类型分别为MAIN、RADIO和SYSTEM，三个class分别为Log、Rlog和Slog，其package则分别为android.util、android.telephony和 android.util。这些用于打印log的classes，其构造函数都为private，因而都不能创建其对象，但它们都提供了静态方法来给用户打印log。各个log打印class的实现都大同小异，可以看一下Log这个class中的一些：

 
       01 
        public static int v(String tag, String msg, Throwable tr) {  
      
       02 
            return println_native(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));  
      
       03 
       } 
      
       04 
         
       05 
       /** 
      
       06 
         * Send a {@link #DEBUG} log message.  
      
       07 
         * @param tag Used to identify the source of a log message.  It usually identifies  
      
       08 
         *        the class or activity where the log call occurs.  
      
       09 
         * @param msg The message you would like logged.  
      
       10 
         */  
      
       11 
        public static int d(String tag, String msg) {  
      
       12 
            return println_native(LOG_ID_MAIN, DEBUG, tag, msg);  
      
       13 
       }

最终都会是调用Log.println_native()静态native方法来打印log，各个类中各个方法的不同之处也仅在于参数的差异。

Log.println_native()方法

这个方法的code在/frameworks/base/core/jni/android_util_Log.cpp，为：

 
       01 
        static jint android_util_Log_println_native(JNIEnv* env, jobject clazz,  
      
       02 
                jint bufID, jint priority, jstring tagObj, jstring msgObj)  
      
       03 
       { 
      
       04 
            const char* tag = NULL;  
      
       05 
            const char* msg = NULL;  
      
       06 
         
       07 
            if (msgObj == NULL) {  
      
       08 
                jniThrowNullPointerException(env, "println needs a message");  
      
       09 
                return -1;  
      
       10 
            }  
      
       11 
         
       12 
            if (bufID < 0 || bufID >= LOG_ID_MAX) {  
      
       13 
                jniThrowNullPointerException(env, "bad bufID");  
      
       14 
                return -1;  
      
       15 
            }  
      
       16 
         
       17 
            if (tagObj != NULL)  
      
       18 
                tag = env->GetStringUTFChars(tagObj, NULL);  
      
       19 
            msg = env->GetStringUTFChars(msgObj, NULL);  
      
       20 
         
       21 
            int res = __android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);  
      
       22 
         
       23 
            if (tag != NULL)  
      
       24 
                env->ReleaseStringUTFChars(tagObj, tag);  
      
       25 
            env->ReleaseStringUTFChars(msgObj, msg);  
      
       26 
         
       27 
            return res;  
      
       28 
       } 
      
       29 
         
       30 
       /* 
      
       31 
         * JNI registration.  
      
       32 
         */  
      
       33 
        static JNINativeMethod gMethods[] = {  
      
       34 
            /* name, signature, funcPtr */  
      
       35 
            { "isLoggable",      "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable },  
      
       36 
            { "println_native",  "(IILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println_native },  
      
       37 
       };

可以看到，干的都是转换参数的事情，最终再call到__android_log_buf_write()函数，这个函数的定义在system/core/liblog/logd_write.c，为：

 
       01 
        int __android_log_buf_write(int bufID, int prio, const char *tag, const char *msg)  
      
       02 
       { 
      
       03 
            struct iovec vec[3];  
      
       04 
            char tmp_tag[32];  
      
       05 
         
       06 
            if (!tag)  
      
       07 
                tag = "";  
      
       08 
         
       09 
            /* XXX: This needs to go! */  
      
       10 
            if ((bufID != LOG_ID_RADIO) &&  
      
       11 
                 (!strcmp(tag, "HTC_RIL") ||  
      
       12 
                !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */  
      
       13 
                !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */  
      
       14 
                !strcmp(tag, "AT") ||  
      
       15 
                !strcmp(tag, "GSM") ||  
      
       16 
                !strcmp(tag, "STK") ||  
      
       17 
                !strcmp(tag, "CDMA") ||  
      
       18 
                !strcmp(tag, "PHONE") ||  
      
       19 
                !strcmp(tag, "SMS"))) {  
      
       20 
                    bufID = LOG_ID_RADIO;  
      
       21 
                    // Inform third party apps/ril/radio.. to use Rlog or RLOG  
      
       22 
                    snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag);  
      
       23 
                    tag = tmp_tag;  
      
       24 
            }  
      
       25 
         
       26 
            vec[0].iov_base   = (unsigned char *) &prio;  
      
       27 
            vec[0].iov_len    = 1;  
      
       28 
            vec[1].iov_base   = (void *) tag;  
      
       29 
            vec[1].iov_len    = strlen(tag) + 1;  
      
       30 
            vec[2].iov_base   = (void *) msg;  
      
       31 
            vec[2].iov_len    = strlen(msg) + 1;  
      
       32 
         
       33 
            return write_to_log(bufID, vec, 3);  
      
       34 
       }

做了三件事情，一是根据log的tag，转换bufID，二是用传进来的参数构造一个struct iovec数组，三是将前一步构造的数组作为参数调用write_to_log()。write_to_log()是一个函数指针，在开始时，它指向了__write_to_log_init()：

 
       1 
        static int (*write_to_log)(log_id_t, struct iovec *vec, size_t nr) = __write_to_log_init;

__write_to_log_init()的实现如下：

 
       01 
        static int __write_to_log_init(log_id_t log_id, struct iovec *vec, size_t nr)  
      
       02 
       { 
      
       03 
       #ifdef HAVE_PTHREADS 
      
       04 
            pthread_mutex_lock(&log_init_lock);  
      
       05 
       #endif 
      
       06 
         
       07 
            if (write_to_log == __write_to_log_init) {  
      
       08 
                log_fds[LOG_ID_MAIN] = log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY);  
      
       09 
                log_fds[LOG_ID_RADIO] = log_open("/dev/"LOGGER_LOG_RADIO, O_WRONLY);  
      
       10 
                log_fds[LOG_ID_EVENTS] = log_open("/dev/"LOGGER_LOG_EVENTS, O_WRONLY);  
      
       11 
                log_fds[LOG_ID_SYSTEM] = log_open("/dev/"LOGGER_LOG_SYSTEM, O_WRONLY);  
      
       12 
         
       13 
                write_to_log = __write_to_log_kernel;  
      
       14 
         
       15 
                if (log_fds[LOG_ID_MAIN] < 0 || log_fds[LOG_ID_RADIO] < 0 ||  
      
       16 
                        log_fds[LOG_ID_EVENTS] < 0) {  
      
       17 
                    log_close(log_fds[LOG_ID_MAIN]);  
      
       18 
                    log_close(log_fds[LOG_ID_RADIO]);  
      
       19 
                    log_close(log_fds[LOG_ID_EVENTS]);  
      
       20 
                    log_fds[LOG_ID_MAIN] = -1;  
      
       21 
                    log_fds[LOG_ID_RADIO] = -1;  
      
       22 
                    log_fds[LOG_ID_EVENTS] = -1;  
      
       23 
                    write_to_log = __write_to_log_null;  
      
       24 
                }  
      
       25 
         
       26 
                if (log_fds[LOG_ID_SYSTEM] < 0) {  
      
       27 
                    log_fds[LOG_ID_SYSTEM] = log_fds[LOG_ID_MAIN];  
      
       28 
                }  
      
       29 
            }  
      
       30 
         
       31 
       #ifdef HAVE_PTHREADS 
      
       32 
            pthread_mutex_unlock(&log_init_lock);  
      
       33 
       #endif 
      
       34 
         
       35 
            return write_to_log(log_id, vec, nr);  
      
       36 
       }

这个地方，会检查write_to_log是否指向了__write_to_log_init，也就是是否是第一次打印log，如果是，则打开几个用于输出log的设备文件，然后使write_to_log函数指针指向__write_to_log_kernel，或者在打开输出log设备文件出现异常时，使write_to_log指向__write_to_log_null，最后再次调用经过了重定向的write_to_log，也就是__write_to_log_kernel或者__write_to_log_null函数。我们可以看一下那几个设备文件究竟是什麽(在system/core/include/cutils/logger.h)：

 
       1 
       #define LOGGER_LOG_MAIN     "log/main" 
      
       2 
       #define LOGGER_LOG_RADIO    "log/radio" 
      
       3 
       #define LOGGER_LOG_EVENTS   "log/events" 
      
       4 
       #define LOGGER_LOG_SYSTEM   "log/system"

接着继续来看__write_to_log_kernel或者__write_to_log_null函数：

 
       01 
        static int __write_to_log_null(log_id_t log_fd, struct iovec *vec, size_t nr)  
      
       02 
       { 
      
       03 
            return -1;  
      
       04 
       } 
      
       05 
         
       06 
        static int __write_to_log_kernel(log_id_t log_id, struct iovec *vec, size_t nr)  
      
       07 
       { 
      
       08 
            ssize_t ret;  
      
       09 
            int log_fd;  
      
       10 
         
       11 
            if (/*(int)log_id >= 0 &&*/ (int)log_id < (int)LOG_ID_MAX) {  
      
       12 
                log_fd = log_fds[(int)log_id];  
      
       13 
            } else {  
      
       14 
                return EBADF;  
      
       15 
            }  
      
       16 
         
       17 
            do {  
      
       18 
                ret = log_writev(log_fd, vec, nr);  
      
       19 
            } while (ret < 0 && errno == EINTR);  
      
       20 
         
       21 
            return ret;  
      
       22 
       }

由log_id获取到对应的log_fd，然后调用log_writev()打印log。可以看一下log_writev()的定义，它是一个宏：

 
       01 
       #if FAKE_LOG_DEVICE 
      
       02 
       // This will be defined when building for the host. 
      
       03 
       #define log_open(pathname, flags) fakeLogOpen(pathname, flags) 
      
       04 
       #define log_writev(filedes, vector, count) fakeLogWritev(filedes, vector, count) 
      
       05 
       #define log_close(filedes) fakeLogClose(filedes) 
      
       06 
       #else 
      
       07 
       #define log_open(pathname, flags) open(pathname, (flags) | O_CLOEXEC) 
      
       08 
       #define log_writev(filedes, vector, count) writev(filedes, vector, count) 
      
       09 
       #define log_close(filedes) close(filedes) 
      
       10 
       #endif

这些就都是标准的unix系统调用了。

本地层代码Log输出

以一些比较典型的native代码打印log的case为例。先来看一下，在JNI的code中打印log的方法。在JNI中，比较常见到用ALOGx这一组宏来打印log，比如在frameworks/base/core/jni/android/graphics/TextLayoutCache.cpp这个文件中的dumpCacheStats()函数：

 
       01 
        void TextLayoutCache::dumpCacheStats() {  
      
       02 
            float remainingPercent = 100 * ((mMaxSize - mSize) / ((float)mMaxSize));  
      
       03 
            float timeRunningInSec = (systemTime(SYSTEM_TIME_MONOTONIC) - mCacheStartTime) / 1000000000;  
      
       04 
         
       05 
            size_t cacheSize = mCache.size();  
      
       06 
         
       07 
            ALOGD("------------------------------------------------");  
      
       08 
            ALOGD("Cache stats");  
      
       09 
            ALOGD("------------------------------------------------");  
      
       10 
            ALOGD("pid       : %d", getpid());  
      
       11 
            ALOGD("running   : %.0f seconds", timeRunningInSec);  
      
       12 
            ALOGD("entries   : %d", cacheSize);  
      
       13 
            ALOGD("max size  : %d bytes", mMaxSize);  
      
       14 
            ALOGD("used      : %d bytes according to mSize", mSize);  
      
       15 
            ALOGD("remaining : %d bytes or %2.2f percent", mMaxSize - mSize, remainingPercent);  
      
       16 
            ALOGD("hits      : %d", mCacheHitCount);  
      
       17 
            ALOGD("saved     : %0.6f ms", mNanosecondsSaved * 0.000001f);  
      
       18 
            ALOGD("------------------------------------------------");  
      
       19 
       }

使用这组宏，需要定义另外一个宏来作为所打印log的tag：

 
       1 
       #define LOG_TAG "TextLayoutCache"

此外，还要include头文件<cutils/log.h>。来看一下这些宏中的一些的定义：

 
       01 
       /* 
      
       02 
         * Simplified macro to send a debug log message using the current LOG_TAG.  
      
       03 
         */  
      
       04 
       #ifndef ALOGD 
      
       05 
       #define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) 
      
       06 
       #endif 
      
       07 
         
       08 
       /* 
      
       09 
         * Simplified macro to send a warning log message using the current LOG_TAG.  
      
       10 
         */  
      
       11 
       #ifndef ALOGW 
      
       12 
       #define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) 
      
       13 
       #endif 
      
       14 
         
       15 
       /* 
      
       16 
         * Basic log message macro.  
      
       17 
         *  
      
       18 
         * Example:  
      
       19 
         *  ALOG(LOG_WARN, NULL, "Failed with error %d", errno);  
      
       20 
         *  
      
       21 
         * The second argument may be NULL or "" to indicate the "global" tag.  
      
       22 
         */  
      
       23 
       #ifndef ALOG 
      
       24 
       #define ALOG(priority, tag, ...) \ 
      
       25 
            LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)  
      
       26 
       #endif 
      
       27 
         
       28 
       /* 
      
       29 
         * Log macro that allows you to specify a number for the priority.  
      
       30 
         */  
      
       31 
       #ifndef LOG_PRI 
      
       32 
       #define LOG_PRI(priority, tag, ...) \ 
      
       33 
            android_printLog(priority, tag, __VA_ARGS__)  
      
       34 
       #endif 
      
       35 
         
       36 
       #define android_printLog(prio, tag, fmt...) \ 
      
       37 
            __android_log_print(prio, tag, fmt)

先来看一下，在native层中定义的priority(在system/core/include/android/log.h中)：

 
       01 
       /* 
      
       02 
         * Android log priority values, in ascending priority order.  
      
       03 
         */  
      
       04 
        typedef enum android_LogPriority {  
      
       05 
            ANDROID_LOG_UNKNOWN = 0,  
      
       06 
            ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */  
      
       07 
            ANDROID_LOG_VERBOSE,  
      
       08 
            ANDROID_LOG_DEBUG,  
      
       09 
            ANDROID_LOG_INFO,  
      
       10 
            ANDROID_LOG_WARN,  
      
       11 
            ANDROID_LOG_ERROR,  
      
       12 
            ANDROID_LOG_FATAL,  
      
       13 
            ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */  
      
       14 
       } android_LogPriority;

另外，这些宏最终都会call到__android_log_print()，也是在system/core/liblog/logd_write.c中：

 
       01 
        int __android_log_print(int prio, const char *tag, const char *fmt, ...)  
      
       02 
       { 
      
       03 
            va_list ap;  
      
       04 
            char buf[LOG_BUF_SIZE];  
      
       05 
         
       06 
            va_start(ap, fmt);  
      
       07 
            vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);  
      
       08 
            va_end(ap);  
      
       09 
         
       10 
            return __android_log_write(prio, tag, buf);  
      
       11 
       }

先是格式化参数，然后就是调用__android_log_write()函数。这个函数的code如下：

 
       01 
        int __android_log_write(int prio, const char *tag, const char *msg)  
      
       02 
       { 
      
       03 
            struct iovec vec[3];  
      
       04 
            log_id_t log_id = LOG_ID_MAIN;  
      
       05 
            char tmp_tag[32];  
      
       06 
         
       07 
            if (!tag)  
      
       08 
                tag = "";  
      
       09 
         
       10 
            /* XXX: This needs to go! */  
      
       11 
            if (!strcmp(tag, "HTC_RIL") ||  
      
       12 
                !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */  
      
       13 
                !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */  
      
       14 
                !strcmp(tag, "AT") ||  
      
       15 
                !strcmp(tag, "GSM") ||  
      
       16 
                !strcmp(tag, "STK") ||  
      
       17 
                !strcmp(tag, "CDMA") ||  
      
       18 
                !strcmp(tag, "PHONE") ||  
      
       19 
                !strcmp(tag, "SMS")) {  
      
       20 
                    log_id = LOG_ID_RADIO;  
      
       21 
                    // Inform third party apps/ril/radio.. to use Rlog or RLOG  
      
       22 
                    snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag);  
      
       23 
                    tag = tmp_tag;  
      
       24 
            }  
      
       25 
         
       26 
            vec[0].iov_base   = (unsigned char *) &prio;  
      
       27 
            vec[0].iov_len    = 1;  
      
       28 
            vec[1].iov_base   = (void *) tag;  
      
       29 
            vec[1].iov_len    = strlen(tag) + 1;  
      
       30 
            vec[2].iov_base   = (void *) msg;  
      
       31 
            vec[2].iov_len    = strlen(msg) + 1;  
      
       32 
         
       33 
            return write_to_log(log_id, vec, 3);  
      
       34 
       }

这个函数与我们前面看到的__android_log_buf_write()非常相似。所不同的就是这个函数没有log_id参数，因而它默认是输出MAIN log，当log的TAG为某些特殊字串时，则输出RADIO log。最后同样是调用write_to_log这个函数指针来输出log。

我们再来看一个skia里面打log的SkDebugf()函数的实现：

 
       1 
       #include <android/log.h> 
      
       2 
         
       3 
        void SkDebugf(const char format[], ...) {  
      
       4 
            va_list args;  
      
       5 
            va_start(args, format);  
      
       6 
            __android_log_vprint(ANDROID_LOG_DEBUG, LOG_TAG, format, args);  
      
       7 
            va_end(args);  
      
       8 
       }

call到了__android_log_vprint()来输出log，__android_log_vprint()的定义也在system/core/liblog/logd_write.c中：

 
       1 
        int __android_log_vprint(int prio, const char *tag, const char *fmt, va_list ap)  
      
       2 
       { 
      
       3 
            char buf[LOG_BUF_SIZE];  
      
       4 
         
       5 
            vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);  
      
       6 
         
       7 
            return __android_log_write(prio, tag, buf);  
      
       8 
       }

一样是__android_log_write()函数。

Done.

【作者】张昺华

【出处】 http://www.cnblogs.com/sky-heaven/

【博客园】 http://www.cnblogs.com/sky-heaven/

【新浪博客】 http://blog.sina.com.cn/u/2049150530

【知乎】 http://www.zhihu.com/people/zhang-bing-hua

【我的作品---旋转倒立摆】 http://v.youku.com/v_show/id_XODM5NDAzNjQw.html?spm=a2hzp.8253869.0.0&from=y1.7-2

【我的作品---自平衡自动循迹车】 http://v.youku.com/v_show/id_XODM5MzYyNTIw.html?spm=a2hzp.8253869.0.0&from=y1.7-2

【新浪微博】张昺华--sky

【twitter】 @sky2030_

【facebook】张昺华 zhangbinghua

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.

微信关注我们

原文链接：https://yq.aliyun.com/articles/375257

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

从零学React Native之10Text

在React Native开发中,所有需要显示的字符串文本都需要放置在Text或者Text的子组件中。虽然在之前的文章中多次使用了Text组件，但是Text组件还是值得专门学习的, 并没有想象中的那么简单。任何一个组件，都有样式和属性，样式一般约束控件的样式和位置，定义在style属性中。属性就是直接声明在控件上。 Text样式 Text组件支持View的所有样式键。但是需要注意的是，Text内部的元素不再使用flexBox布局,而是采用文本布局。这意味着Text组件内部的元素不再是一个个的矩形,组件内部元素排列出组件末端时会自动另起一行。所以开发者可以不用设定Text控件的高度,一般情况也没有必要设定，Text组件的高度将由Text组件的宽度，需要显示的字符串长度，字体大小共同来决定。 Text组件中显示的字符串只有一行,并且我们设置了Text组件的高度,这个高度比字体大很多,字符串会贴着组件上边显示, 因为不支持flexBox布局, 无法让它调整到垂直方向居中显示. 我们只能通过在字符串前面加{\r\n} 让字符串前加空行的形式凑到居中显示. 了解了上面的特性, 后面我们会...

2016-08-23

653

Android 动态注册亮屏、息屏广播

/***************************************************************************** * Android 动态注册亮屏、息屏广播 * 说明： * 今天遇到需求是亮屏、息屏广播，程梦真验证了在有些手机上可行，有些不行， * 这个功能看来是要看情况的。 * * 2016-8-23 深圳南山平山村曾剑锋 ****************************************************************************/ 一、参考文档： 1. Android中不能静态注册的广播 http://blog.sina.com.cn/s/blog_6f1361e50102vnln.html 2. Android应用程序--获取待机、唤醒、关机、网络状态变化消息 http://blog.csdn.net/myarrow/article/details/8174912 3. Android - how to receive broadcast intents ACTION_SCREEN_ON...

2016-08-23

632

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。