devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python开发——logging模块详解

作者：很楠不爱3 | 2024-05-19 00:43:26

赞

踩

valueerror: dictionary doesn't specify a version

logging模块详解

logging简介

logging是python的内置库，主要用于进行格式化内容输出，可将格式化内容输出到文件，也可输出到屏幕。我们在开发过程中常用print函数来进行调试，但是实际应用部署时我们要将日志的信息要输出到文件中，方便后续查找以及备份。在我们使用日志管理时，我们还可以将日志格式化成json对象转存到ELK中方便图形化查看及管理。前面说的这些，我们都可以通过logging所包含的功能以及提供扩展的方式来完成。

logging工作流程

这是从网上查到一个关于python logging模块的工作流程图，非常遗憾没有找到出处。

可以看到图中，几个关键的类

Logger

用于记录日志的对象。

通过流程图可以看到

  1. 判断是否enabled，实质就是看记录的level（logger.info，logger.debug等）和当前logger对象设置的level是否满足（比如logger设置的lever是Info，记录时使用的logger.debug，那么就会不满足，所以不会记录日志）
  2. 查看logger的过滤器是否满足。filter通过之后，交给logger的handler来记录日志，一个logger是可以设置多个handler。
  3. 交给Handlers实际记录日志

注：在整个应用中可以有多个logger，使用logging.getLogger时通过指定name来获取对象，实际logging中还存在一个Manager类，由Manager来进行多logger的单例模式管理。

Handler

用于记录日志到具体的文件或者输出流或其他的管道。

  1. 查看记录日志是否满足过滤器
  2. 满足过滤器，按照设置的Formatter生成字符串
  3. 将内容写入到具体的文件或者输出流

不同的Handler可能有不同的处理，但是底层原理还是做这三件事情。

Filter

用于过滤用户记录日志时，是否满足记录标准

Formatter

用于格式化，输出的字符串格式

这是原生自带的格式

  1. %(name)s            Name of the logger (logging channel)
  2.     %(levelno)s         Numeric logging level for the message (DEBUG, INFO,
  3.                         WARNING, ERROR, CRITICAL)
  4.     %(levelname)s       Text logging level for the message ("DEBUG", "INFO",
  5.                         "WARNING", "ERROR", "CRITICAL")
  6.     %(pathname)s        Full pathname of the source file where the logging
  7.                         call was issued (if available)
  8.     %(filename)s        Filename portion of pathname
  9.     %(module)s          Module (name portion of filename)
  10.     %(lineno)d          Source line number where the logging call was issued
  11.                         (if available)
  12.     %(funcName)s        Function name
  13.     %(created)f         Time when the LogRecord was created (time.time()
  14.                         return value)
  15.     %(asctime)s         Textual time when the LogRecord was created
  16.     %(msecs)d           Millisecond portion of the creation time
  17.     %(relativeCreated)d Time in milliseconds when the LogRecord was created,
  18.                         relative to the time the logging module was loaded
  19.                         (typically at application startup time)
  20.     %(thread)d          Thread ID (if available)
  21.     %(threadName)s      Thread name (if available)
  22.     %(process)d         Process ID (if available)
  23.     %(message)s         The result of record.getMessage(), computed just as
  24.                         the record is emitted
  25. 复制代码

LogRecord

我们每一次的 logger.info logger.debug logger.error等实际上都是进行一次LogRecord的处理

包含一些基本的输出日志内容，以及内容中参数，还有附带的函数名称，行数等信息

logging源码阅读

这是我这边基于字典的一个logging配置

  1. import logging
  2. import logging.config
  3. import os
  4.  
  5. basedir = os.path.abspath(os.path.dirname(__file__))
  6. log_path = os.path.join(basedir, '..', 'logs')
  7. service_name = "test_log"
  8. if not os.path.isdir(log_path):
  9.     os.mkdir(log_path)
  10.     
  11. class InfoFilter(logging.Filter):
  12.     def filter(self, record):
  13.         """
  14.         只筛选出INFO级别的日志
  15.         """
  16.         if logging.INFO <= record.levelno < logging.ERROR:
  17.             return super().filter(record)
  18.         else:
  19.             return 0
  20.  
  21.  
  22. class ErrorFilter(logging.Filter):
  23.     def filter(self, record):
  24.         """
  25.         只筛选出ERROR级别的日志
  26.         """
  27.         if logging.ERROR <= record.levelno < logging.CRITICAL:
  28.             return super().filter(record)
  29.         else:
  30.             return 0
  31.  
  32. LOG_CONFIG_DICT = {
  33.     'version': 1,
  34.     'disable_existing_loggers': False,
  35.     'formatters': {
  36.         'simple': {
  37.             'class': 'logging.Formatter',
  38.             'format': '%(asctime)s %(levelname)s %(name)s %(filename)s %(module)s %(funcName)s '
  39.                       '%(lineno)d %(thread)d %(threadName)s %(process)d %(processName)s %(message)s'
  40.         },
  41.         # json模式, 方便ELK收集处理
  42.         'json': {
  43.             'class': 'logging.Formatter',
  44.             'format': '{"time:":"%(asctime)s","level":"%(levelname)s","logger_name":"%(name)s",'
  45.                       '"file_name":"%(filename)s","module":"%(module)s","func_name":"%(funcName)s",'
  46.                       '"line_number":"%(lineno)d","thread_id":"%(thread)d","thread_name":"%(threadName)s",'
  47.                       '"process_id":"%(process)d","process_name":"%(processName)s","message":"%(message)s"}'}
  48.     },
  49.     # 过滤器
  50.     'filters': {
  51.         'info_filter': {
  52.             '()': InfoFilter
  53.         },
  54.         'error_filter': {
  55.             '()': ErrorFilter
  56.         }
  57.     },
  58.     # 处理器
  59.     'handlers': {
  60.         # 控制台输出
  61.         'console': {
  62.             'class': 'logging.StreamHandler',
  63.             'level': 'INFO',
  64.             'formatter': 'simple'
  65.         },
  66.         # info文件输出
  67.         'info_file': {
  68.             'level': 'INFO',
  69.             'formatter': 'json',
  70.             'class': 'logging.handlers.TimedRotatingFileHandler',
  71.             'filename': '{0}/{1}_info.log'.format(log_path, service_name),
  72.             'when': "d",
  73.             'interval': 1,
  74.             'encoding': 'utf8',
  75.             'backupCount': 30,
  76.             'filters': ['info_filter']
  77.         },
  78.         # error文件输出
  79.         'error_file': {
  80.             'level': 'ERROR',
  81.             'formatter': 'json',
  82.             'class': 'logging.handlers.TimedRotatingFileHandler',
  83.             'filename': '{0}/{1}_error.log'.format(log_path, service_name),
  84.             'when': "d",
  85.             'interval': 1,
  86.             'encoding': 'utf8',
  87.             'backupCount': 30,
  88.             'filters': ['error_filter']
  89.         }
  90.     },
  91.     # 记录器
  92.     'loggers': {
  93.         'full_logger': {
  94.             'handlers': ['console', 'info_file', 'error_file'],
  95.             'level': 'INFO'
  96.         },
  97.         'only_console_logger': {
  98.             'handlers': ['console'],
  99.             'level': 'INFO'
  100.         },
  101.         'only_file_logger': {
  102.             'handlers': ['info_file', 'error_file']
  103.         }
  104.     }
  105. }
  106.  
  107. logging.config.dictConfig(LOG_CONFIG_DICT)
  108. 复制代码

下面我们就基于config第一次配置时整个logging的工作原理。结合代码进行分析logging的工作之路。

我的python版本是Python3.6

从logging.config开始

  1. dictConfigClass = DictConfigurator
  2.  
  3. def dictConfig(config):
  4.     """Configure logging using a dictionary."""
  5.     dictConfigClass(config).configure()
  6. 复制代码

实质上是实例化logging.config.DictConfigurator类的对象，然后执行其configure方法。

  1. class DictConfigurator(BaseConfigurator):
  2.     """
  3.     Configure logging using a dictionary-like object to describe the
  4.     configuration.
  5.     """
  6.  
  7.     def configure(self):
  8.         """Do the configuration."""
  9.  
  10.         config = self.config
  11.         if 'version' not in config:
  12.             raise ValueError("dictionary doesn't specify a version")
  13.         if config['version'] != 1:
  14.             raise ValueError("Unsupported version: %s" % config['version'])
  15.         incremental = config.pop('incremental', False)
  16.         EMPTY_DICT = {}
  17.         logging._acquireLock()
  18.         try:
  19.             if incremental:
  20.                 handlers = config.get('handlers', EMPTY_DICT)
  21.                 for name in handlers:
  22.                     if name not in logging._handlers:
  23.                         raise ValueError('No handler found with '
  24.                                          'name %r'  % name)
  25.                     else:
  26.                         try:
  27.                             handler = logging._handlers[name]
  28.                             handler_config = handlers[name]
  29.                             level = handler_config.get('level', None)
  30.                             if level:
  31.                                 handler.setLevel(logging._checkLevel(level))
  32.                         except Exception as e:
  33.                             raise ValueError('Unable to configure handler '
  34.                                              '%r: %s' % (name, e))
  35.                 loggers = config.get('loggers', EMPTY_DICT)
  36.                 for name in loggers:
  37.                     try:
  38.                         self.configure_logger(name, loggers[name], True)
  39.                     except Exception as e:
  40.                         raise ValueError('Unable to configure logger '
  41.                                          '%r: %s' % (name, e))
  42.                 root = config.get('root', None)
  43.                 if root:
  44.                     try:
  45.                         self.configure_root(root, True)
  46.                     except Exception as e:
  47.                         raise ValueError('Unable to configure root '
  48.                                          'logger: %s' % e)
  49.             else:
  50.                 disable_existing = config.pop('disable_existing_loggers', True)
  51.  
  52.                 logging._handlers.clear()
  53.                 del logging._handlerList[:]
  54.  
  55.                 # Do formatters first - they don't refer to anything else
  56.                 formatters = config.get('formatters', EMPTY_DICT)
  57.                 for name in formatters:
  58.                     try:
  59.                         formatters[name] = self.configure_formatter(
  60.                                                             formatters[name])
  61.                     except Exception as e:
  62.                         raise ValueError('Unable to configure '
  63.                                          'formatter %r: %s' % (name, e))
  64.                 # Next, do filters - they don't refer to anything else, either
  65.                 filters = config.get('filters', EMPTY_DICT)
  66.                 for name in filters:
  67.                     try:
  68.                         filters[name] = self.configure_filter(filters[name])
  69.                     except Exception as e:
  70.                         raise ValueError('Unable to configure '
  71.                                          'filter %r: %s' % (name, e))
  72.                 handlers = config.get('handlers', EMPTY_DICT)
  73.                 deferred = []
  74.                 for name in sorted(handlers):
  75.                     try:
  76.                         handler = self.configure_handler(handlers[name])
  77.                         handler.name = name
  78.                         handlers[name] = handler
  79.                     except Exception as e:
  80.                         if 'target not configured yet' in str(e):
  81.                             deferred.append(name)
  82.                         else:
  83.                             raise ValueError('Unable to configure handler '
  84.                                              '%r: %s' % (name, e))
  85.  
  86.                 # Now do any that were deferred
  87.                 for name in deferred:
  88.                     try:
  89.                         handler = self.configure_handler(handlers[name])
  90.                         handler.name = name
  91.                         handlers[name] = handler
  92.                     except Exception as e:
  93.                         raise ValueError('Unable to configure handler '
  94.                                          '%r: %s' % (name, e))
  95.  
  96.                 root = logging.root
  97.                 existing = list(root.manager.loggerDict.keys())
  98.  
  99.                 existing.sort()
  100.  
  101.                 child_loggers = []
  102.                 #now set up the new ones...
  103.                 loggers = config.get('loggers', EMPTY_DICT)
  104.                 for name in loggers:
  105.                     if name in existing:
  106.                         i = existing.index(name) + 1 # look after name
  107.                         prefixed = name + "."
  108.                         pflen = len(prefixed)
  109.                         num_existing = len(existing)
  110.                         while i < num_existing:
  111.                             if existing[i][:pflen] == prefixed:
  112.                                 child_loggers.append(existing[i])
  113.                             i += 1
  114.                         existing.remove(name)
  115.                     try:
  116.                         self.configure_logger(name, loggers[name])
  117.                     except Exception as e:
  118.                         raise ValueError('Unable to configure logger '
  119.                                          '%r: %s' % (name, e))
  120.  
  121.                 _handle_existing_loggers(existing, child_loggers,
  122.                                          disable_existing)
  123.  
  124.                 # And finally, do the root logger
  125.                 root = config.get('root', None)
  126.                 if root:
  127.                     try:
  128.                         self.configure_root(root)
  129.                     except Exception as e:
  130.                         raise ValueError('Unable to configure root '
  131.                                          'logger: %s' % e)
  132.         finally:
  133.             logging._releaseLock()
  134. 复制代码

我们对incremental不进行设置，即使用全量的方式进行配置，对于所有的handler重置并处理

看下来基本上分为4步来走。

  1. 配置Formatter
  2. 配置Filter
  3. 配置Handler
  4. 配置Logger

Formatter配置

源码部分

  1.     def configure_formatter(self, config):
  2.         """Configure a formatter from a dictionary."""
  3.         if '()' in config:
  4.             factory = config['()'] # for use in exception handler
  5.             try:
  6.                 result = self.configure_custom(config)
  7.             except TypeError as te:
  8.                 if "'format'" not in str(te):
  9.                     raise
  10.                 config['fmt'] = config.pop('format')
  11.                 config['()'] = factory
  12.                 result = self.configure_custom(config)
  13.         else:
  14.             fmt = config.get('format', None)
  15.             dfmt = config.get('datefmt', None)
  16.             style = config.get('style', '%')
  17.             cname = config.get('class', None)
  18.             if not cname:
  19.                 c = logging.Formatter
  20.             else:
  21.                 c = _resolve(cname)
  22.             result = c(fmt, dfmt, style)
  23.         return result
  24. 复制代码

可以使用自己的Formatter，默认使用logging.Formatter

Filter配置

  1.     def configure_filter(self, config):
  2.         """Configure a filter from a dictionary."""
  3.         if '()' in config:
  4.             result = self.configure_custom(config)
  5.         else:
  6.             name = config.get('name', '')
  7.             result = logging.Filter(name)
  8.         return result
  9. 复制代码

设置filter,可以参考我上面配置的字典，可以自己定义Filter也可以使用系统内置Filter

Handler配置

  1.     def configure_handler(self, config):
  2.         """Configure a handler from a dictionary."""
  3.         config_copy = dict(config)  # for restoring in case of error
  4.         formatter = config.pop('formatter', None)
  5.         if formatter:
  6.             try:
  7.                 formatter = self.config['formatters'][formatter]
  8.             except Exception as e:
  9.                 raise ValueError('Unable to set formatter '
  10.                                  '%r: %s' % (formatter, e))
  11.         level = config.pop('level', None)
  12.         filters = config.pop('filters', None)
  13.         if '()' in config:
  14.             c = config.pop('()')
  15.             if not callable(c):
  16.                 c = self.resolve(c)
  17.             factory = c
  18.         else:
  19.             cname = config.pop('class')
  20.             klass = self.resolve(cname)
  21.             #Special case for handler which refers to another handler
  22.             if issubclass(klass, logging.handlers.MemoryHandler) and\
  23.                 'target' in config:
  24.                 try:
  25.                     th = self.config['handlers'][config['target']]
  26.                     if not isinstance(th, logging.Handler):
  27.                         config.update(config_copy)  # restore for deferred cfg
  28.                         raise TypeError('target not configured yet')
  29.                     config['target'] = th
  30.                 except Exception as e:
  31.                     raise ValueError('Unable to set target handler '
  32.                                      '%r: %s' % (config['target'], e))
  33.             elif issubclass(klass, logging.handlers.SMTPHandler) and\
  34.                 'mailhost' in config:
  35.                 config['mailhost'] = self.as_tuple(config['mailhost'])
  36.             elif issubclass(klass, logging.handlers.SysLogHandler) and\
  37.                 'address' in config:
  38.                 config['address'] = self.as_tuple(config['address'])
  39.             factory = klass
  40.         props = config.pop('.', None)
  41.         kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
  42.         try:
  43.             result = factory(**kwargs)
  44.         except TypeError as te:
  45.             if "'stream'" not in str(te):
  46.                 raise
  47.             kwargs['strm'] = kwargs.pop('stream')
  48.             result = factory(**kwargs)
  49.         if formatter:
  50.             result.setFormatter(formatter)
  51.         if level is not None:
  52.             result.setLevel(logging._checkLevel(level))
  53.         if filters:
  54.             self.add_filters(result, filters)
  55.         if props:
  56.             for name, value in props.items():
  57.                 setattr(result, name, value)
  58.         return result
  59. 复制代码

可以看到，前面顺序先配置formatter和filter是因为这里需要引用的到

值得注意的是，我们初始化时传递的一个字典，在整个配置过程中，字典里面的值会随着我们每次的配置变化而变化，所以我们在每个元素配置之后，在使用上一个字典元素时，就是配置完成之后的元素，为了方便理解，将配置filter之前和配置filter之后，config中的filter变化列出来

  1. config == > before filters {'info_filter': {'()': <class 'utils.log.InfoFilter'>}, 'error_filter': {'()': <class 'utils.log.ErrorFilter'>}} 
  2. config == > after filters {'info_filter': <utils.log.InfoFilter object at 0x00000000028EB208>, 'error_filter': <utils.log.ErrorFilter object at 0x00000000028EB240>}
  3. 复制代码

配置前是我们配置文件中的内容，配置完成之后filter已经是一组对象了，所以在配置handler时我们就可以直接使用对象add_filter了。

Logger配置

  1.     def common_logger_config(self, logger, config, incremental=False):
  2.         level = config.get('level', None)
  3.         if level is not None:
  4.             logger.setLevel(logging._checkLevel(level))
  5.         if not incremental:
  6.             #Remove any existing handlers
  7.             for h in logger.handlers[:]:
  8.                 logger.removeHandler(h)
  9.             handlers = config.get('handlers', None)
  10.             if handlers:
  11.                 self.add_handlers(logger, handlers)
  12.             filters = config.get('filters', None)
  13.             if filters:
  14.                 self.add_filters(logger, filters)
  15.  
  16.     def configure_logger(self, name, config, incremental=False):
  17.         """Configure a non-root logger from a dictionary."""
  18.         logger = logging.getLogger(name)
  19.         self.common_logger_config(logger, config, incremental)
  20.         propagate = config.get('propagate', None)
  21.         if propagate is not None:
  22.             logger.propagate = propagate
  23. 复制代码

这就比较容易理解了，将我们上面配置过的filters和handlers添加到我们的logger中。

这里需要注意的一点是logger = logging.getLogger(name)，看下logger.getLogger源码

  1. root = RootLogger(WARNING)
  2. Logger.root = root
  3. Logger.manager = Manager(Logger.root)
  4. def getLogger(name=None):
  5.     if name:
  6.         return Logger.manager.getLogger(name)
  7.     else:
  8.         return root
  9. class Manager(object):
  10.     def __init__(self, rootnode):
  11.         self.root = rootnode
  12.         self.disable = 0
  13.         self.emittedNoHandlerWarning = False
  14.         self.loggerDict = {}
  15.         self.loggerClass = None
  16.         self.logRecordFactory = None
  17.  
  18.     def getLogger(self, name):
  19.         rv = None
  20.         if not isinstance(name, str):
  21.             raise TypeError('A logger name must be a string')
  22.         _acquireLock()
  23.         try:
  24.             if name in self.loggerDict:
  25.                 rv = self.loggerDict[name]
  26.                 if isinstance(rv, PlaceHolder):
  27.                     ph = rv
  28.                     rv = (self.loggerClass or _loggerClass)(name)
  29.                     rv.manager = self
  30.                     self.loggerDict[name] = rv
  31.                     self._fixupChildren(ph, rv)
  32.                     self._fixupParents(rv)
  33.             else:
  34.                 rv = (self.loggerClass or _loggerClass)(name)
  35.                 rv.manager = self
  36.                 self.loggerDict[name] = rv
  37.                 self._fixupParents(rv)
  38.         finally:
  39.             _releaseLock()
  40.         return rv
  41. 复制代码

可以看到，logging使用Mangaer进行logger的单例管理

截止到这里，基本上我们使用前的准备，logging都替我们准备好了，下面就是我们的使用

获取logger并记录日志

  1. class Logger(Filterer):
  2. 	
  3. 	def info(self, msg, *args, **kwargs):
  4.         if self.isEnabledFor(INFO):
  5.             self._log(INFO, msg, args, **kwargs)
  6.     
  7.     def error(self, msg, *args, **kwargs):
  8.         if self.isEnabledFor(ERROR):
  9.             self._log(ERROR, msg, args, **kwargs)
  10.     
  11.     def isEnabledFor(self, level):
  12.         if self.manager.disable >= level:
  13.             return False
  14.         return level >= self.getEffectiveLevel()
  15. 	
  16.     def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
  17.         sinfo = None
  18.         if _srcfile:
  19.             try:
  20.                 fn, lno, func, sinfo = self.findCaller(stack_info)
  21.             except ValueError: # pragma: no cover
  22.                 fn, lno, func = "(unknown file)", 0, "(unknown function)"
  23.         else: # pragma: no cover
  24.             fn, lno, func = "(unknown file)", 0, "(unknown function)"
  25.         if exc_info:
  26.             if isinstance(exc_info, BaseException):
  27.                 exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
  28.             elif not isinstance(exc_info, tuple):
  29.                 exc_info = sys.exc_info()
  30.         record = self.makeRecord(self.name, level, fn, lno, msg, args,
  31.                                  exc_info, func, extra, sinfo)
  32.         self.handle(record)
  33.  
  34.     def handle(self, record):
  35.         if (not self.disabled) and self.filter(record):
  36.             self.callHandlers(record)
  37.             
  38.     def callHandlers(self, record):
  39.         c = self
  40.         found = 0
  41.         while c:
  42.             for hdlr in c.handlers:
  43.                 found = found + 1
  44.                 if record.levelno >= hdlr.level:
  45.                     hdlr.handle(record)
  46.             if not c.propagate:
  47.                 c = None    #break out
  48.             else:
  49.                 c = c.parent
  50.         if (found == 0):
  51.             if lastResort:
  52.                 if record.levelno >= lastResort.level:
  53.                     lastResort.handle(record)
  54.             elif raiseExceptions and not self.manager.emittedNoHandlerWarning:
  55.                 sys.stderr.write("No handlers could be found for logger"
  56.                                  " \"%s\"\n" % self.name)
  57.                 self.manager.emittedNoHandlerWarning = True
  58. class StreamHandler(Handler):
  59.  
  60.     terminator = '\n'
  61.  
  62.     def __init__(self, stream=None):
  63.         """
  64.         Initialize the handler.
  66.         If stream is not specified, sys.stderr is used.
  67.         """
  68.         Handler.__init__(self)
  69.         if stream is None:
  70.             stream = sys.stderr
  71.         self.stream = stream
  72.  
  73.     def flush(self):
  74.         self.acquire()
  75.         try:
  76.             if self.stream and hasattr(self.stream, "flush"):
  77.                 self.stream.flush()
  78.         finally:
  79.             self.release()
  80.  
  81.     def emit(self, record):
  82.         try:
  83.             msg = self.format(record)
  84.             stream = self.stream
  85.             stream.write(msg)
  86.             stream.write(self.terminator)
  87.             self.flush()
  88.         except Exception:
  89.             self.handleError(record)
  90.  
  91.     def __repr__(self):
  92.         level = getLevelName(self.level)
  93.         name = getattr(self.stream, 'name', '')
  94.         if name:
  95.             name += ' '
  96.         return '<%s %s(%s)>' % (self.__class__.__name__, name, level)
  97. 复制代码

根据代码可以看到符合我们流程图看到的流程，我们细化一下就是

  1. 查看记录日志是否满足过滤器，然后准备logrecord中的信息并生成logrecord
  2. 将logrecord交给所有handlers处理
  3. 在handler中确定是否满足handler过滤器，满足的话按照配置的Formatter生成字符串
  4. 将内容写入到具体的文件或者输出流
  1. logger = logging.getLogger("full_logger")
  2.  
  3. logger.info("111")
  4. # 根据我们的配置 这里会输出到流中，以及记录到test_log_info.log文件中
  5.  
  6. logger.error("error")
  7. # 根据我们的配置 这里会输出到流中，以及记录到test_log_error.info文件中
  8.  
  9. 复制代码

有兴趣的同学可以继续试试其他好玩的处理

也可以关注我的公众号共同学习。

转载于:https://juejin.im/post/5cee61d86fb9a07eff006b2c

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/590639
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号