linux解析配置文件的源码,源码解析Flask的配置文件

在flask里，我们常在主文件中定义某些配置，比如：

app.debug = True

app.secret_key = 'helloworld!!'

实际上，flask中默认可以进行可选的配置项有很多。

如果在开发的过程中，把所有需要的配置项都定义在主文件中，就会造成整个程序的目录结构不合理，

如果需要重写的flask配置项很多的时候，就可以把配置项用别的方式进行定义，然后导入使用

flask的配置文件是一个flask.config.Config对象

导入Config对象，可以发现Config对象继承字典，

Config默认的配置有：

default_config = ImmutableDict({

'DEBUG':                                get_debug_flag(default=False),

'TESTING':                              False,

'PROPAGATE_EXCEPTIONS':                None,

'PRESERVE_CONTEXT_ON_EXCEPTION':        None,

'SECRET_KEY':                          None,

'PERMANENT_SESSION_LIFETIME':          timedelta(days=31),

'USE_X_SENDFILE':                      False,

'LOGGER_NAME':                          None,

'LOGGER_HANDLER_POLICY':              'always',

'SERVER_NAME':                          None,

'APPLICATION_ROOT':                    None,

'SESSION_COOKIE_NAME':                  'session',

'SESSION_COOKIE_DOMAIN':                None,

'SESSION_COOKIE_PATH':                  None,

'SESSION_COOKIE_HTTPONLY':              True,

'SESSION_COOKIE_SECURE':                False,

'SESSION_REFRESH_EACH_REQUEST':        True,

'MAX_CONTENT_LENGTH':                  None,

'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),

'TRAP_BAD_REQUEST_ERRORS':              False,

'TRAP_HTTP_EXCEPTIONS':                False,

'EXPLAIN_TEMPLATE_LOADING':            False,

'PREFERRED_URL_SCHEME':                'http',

'JSON_AS_ASCII':                        True,

'JSON_SORT_KEYS':                      True,

'JSONIFY_PRETTYPRINT_REGULAR':          True,

'JSONIFY_MIMETYPE':                    'application/json',

'TEMPLATES_AUTO_RELOAD':                None,

})

通过查看Config对象的源码，可以知道flask的配置可以有以下几种方式

1.在主文件中定义(通常使用的方式)

app.debug = True

app.secret_key = 'helloworld!!'

由于Config对象继承了dict的方法和属性，所以还可以使用app.config.update(配置项)的方式导入配置项

2.从环境变量中导入配置项

导入配置项的方式：

app.config.from_envvar("环境变量名称")

from_envvar方法的源码：

def from_envvar(self, variable_name, silent=False):

rv = os.environ.get(variable_name)

if not rv:

if silent:

return False

raise RuntimeError('The environment variable %r is not set '

'and as such configuration could not be '

'loaded.  Set this variable and make it '

'point to a configuration file' %

variable_name)

return self.from_pyfile(rv, silent=silent)

可以看到,从环境变量中导入配置项的方法，就是从环境变量中找到并读取对应的py文件名称，然后内部调用from_pyfile方法处理读取到的内容得到配置

3.从Python文件中导入

从python文件中获取配置项的方式：

app.config.from_pyfile("python文件名称")

例如，创建一个名为setting.py的文件

setting.py文件的内容为：

DEBUG=True

然后使用app.config.from_pyfile("setting.py")的方式导入配置项

from_pyfile方法的源码：

def from_pyfile(self, filename, silent=False):

filename = os.path.join(self.root_path, filename)

d = types.ModuleType('config')

d.__file__ = filename

try:

with open(filename, mode='rb') as config_file:

exec(compile(config_file.read(), filename, 'exec'), d.__dict__)

except IOError as e:

if silent and e.errno in (errno.ENOENT, errno.EISDIR):

return False

e.strerror = 'Unable to load configuration file (%s)' % e.strerror

raise

self.from_object(d)

return True

从py文件中导入配置项的过程中，读取参数中的python文件的内容，进行编译后exec方法执行，就得到所需要的配置项

需要注意的是：

python文件可以是绝对路径或者相对路径，如果是相对路径，则py文件必须放在root_path目录下，

4.从对象中导入配置项

from_object方法的源码：

def from_object(self, obj):

if isinstance(obj, string_types):

obj = import_string(obj)

for key in dir(obj):

if key.isupper():

self[key] = getattr(obj, key)

从对象中导入配置项的过程中，首先判断所传入的对象名是否是字符串，然后调用import_string方法处理字符串形式的对象名

import_string方法的源码：

def import_string(import_name, silent=False):

import_name = str(import_name).replace(':', '.')

try:

try:

__import__(import_name)

except ImportError:

if '.' not in import_name:

raise

else:

return sys.modules[import_name]

module_name, obj_name = import_name.rsplit('.', 1)

try:

module = __import__(module_name, None, None, [obj_name])

except ImportError:

module = import_string(module_name)

try:

return getattr(module, obj_name)

except AttributeError as e:

raise ImportError(e)

except ImportError as e:

if not silent:

reraise(

ImportStringError,

ImportStringError(import_name, e),

sys.exc_info()[2])

可以看到，import_string方法，实际上是对字符串形式的对象名执行rsplit方法，得到模块名和对象名

在模块可以被正常导入之前，不停执行import_string方法,最后执行getattr方法从模块中获取对象名

5.from_json：从json字符串中获取配置项

from_json方法的源码：

def from_json(self, filename, silent=False):

filename = os.path.join(self.root_path, filename)

try:

with open(filename) as json_file:

obj = json.loads(json_file.read())

except IOError as e:

if silent and e.errno in (errno.ENOENT, errno.EISDIR):

return False

e.strerror = 'Unable to load configuration file (%s)' % e.strerror

raise

return self.from_mapping(obj)

从json文件中获取配置项，实际上就是对json文件执行json.loads方法，得到对象

然后内部调用from_mapping方法处理所得到的对象

6.from_mapping：从dict字典中获取配置项

from_mapping方法的源码：

def from_mapping(self, *mapping, **kwargs):

mappings = []

if len(mapping) == 1:

if hasattr(mapping[0], 'items'):

mappings.append(mapping[0].items())

else:

mappings.append(mapping[0])

elif len(mapping) > 1:

raise TypeError(

'expected at most 1 positional argument, got %d' % len(mapping)

)

mappings.append(kwargs.items())

for mapping in mappings:

for (key, value) in mapping:

if key.isupper():

self[key] = value

return True

把参数字典中的所有键值对添加到列表���，循环遍历列表，读取列表中每个元素的键和值

如果键为大写，则key为配置选项，value为配置选项的值

7.get_namespace：从名称空间中获取配置选项

get_namespace源码：

def get_namespace(self, namespace, lowercase=True, trim_namespace=True):

rv = {}

for k, v in iteritems(self):

if not k.startswith(namespace):

continue

if trim_namespace:

key = k[len(namespace):]

else:

key = k

if lowercase:

key = key.lower()

rv[key] = v

return rv

get_namespace方法，是从指定的名称空间或前缀中进行匹配，返回包含配置项的子集的字典

迭代当前对象，获取key和v,把key转换为小写格式，然后把key和v包含在一个字典中