Flask入门一（介绍、Flask安装、Flask运行方式及使用、虚拟环境、调试模式、配置文件、路由系统）

一、Flask介绍

Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用

Flask depends on the Werkzeug WSGI toolkit, the Jinja template engine, and the Click CLI toolkit

	-Werkzeug WSGI：接收请求   django 中得 wsgiref
    -jinja2模板     :渲染模板的  django中得dtl
    -Click CLI      ：命令定制工具   django 的 manage.py runserver/migrate...

常用Python Web框架区别

	'Python Web框架,本质都是一样的'
	1.Django：大而全，内置的app多，第三方app也多，django3.x也支持异步操作了
		-自带的应用：admin后台管理、auth身份鉴权、sessions会话管理....
		-第三方app:Django Rest Framework、Django CORS Headers 、Django Bootstrap....
		
	2.Flask：小而精，没有过多的内置组件，只有完整的web框架最基本的功能，需要借助于第三方完成更丰富的功能
		-众多第三方：比如orm咱们会用sqlalchemy，peewee....
	
	3.fastapi：python的异步web框架，跟flask相似，也只保留了web开发的核心功能，其他需要借助第三方实现
		-异步框架
		-更方便的使用ppython async和await关键字来实现异步操作
	
	4.sanic：python的异步web框架，供支持异步高并发请求的 web 服务

同步框架和异步框架的区别

	   1.djagno是同步框架还是异步框架，djagno 3.x以后支持异步
	   2.同步框架：一个线程只处理一个请求
	   3.异步框架：一个线程可以处理多个请求
	   4.异步框架可以很显著的提高并发量
	   
	   django的并发量是指usgi的线程数，线程的并发量就是协程，同步框架和异步框架对于用户来说，
	   消耗的时间是一个样的。但异步框架的效率提高了。

二、Flask创建和运行

1.安装

	pip install flask
	'安装完成后，会在script目录下多flask.exe 命令，后期运行flask需要使用它'

2.快速使用

	from flask import Flask
	
	1.实例化得到对象
	app = Flask(__name__)
	
	2.注册路由，写视图函数
	@app.route('/')  # 根路径
	def index():
	    return 'hello world'
	
	
	if __name__ == '__main__':
	    # 运行app，默认运行在5000
	    # 默认是host='127.0.0.1', port=5000端口
	    app.run()

	'运行后http://127.0.0.1:5000访问这个地址，即可看到hello，world了'

3.Flask小知识

	1.注册路由
    	app.route(路径，method=[请求方式get,post])
	2.新手四件套：
	    -render_template   渲染模板  跟django有区别
	    -redirect    重定向
	    -return  字符串 返回字符串---jsonify格式字符串
	3.请求的request对象，是全局的request对象，直接导入使用即可，在不同的视图函数不会混乱
	    request.method   请求方式
	    request.form     post请求的body体的内容转换成了字典
	4.session  全局的直接导入使用即可，一定要指定秘钥app.secret_key='shashoashofisj'
	     放值：session['name']='kimi'
	     取值: session.get('name')
	5.模板的渲染
	    -兼容django的dtl
	    -更强大，可以加括号，字典取值多样(dict.get('')/dict['']/dict./dict.items()),而django只能dict.
	    -{% for %}
	6.转换器@app.route('/detail/<int:pk>')

4.flask的运行方式

	'运行项目方式'
	-方式一（pycharm配置）：
    	-新建一个flask-server---》配置选中 script---》有app的文件
        
   	-方式二：命令（推荐这种）
    	flask --app py文件名字  run
        flask --app 5-flask再体验.py run
        
     -方式三：命令
    	python38 -m flask --app py文件名字 run
        python38 -m flask --app 5-flask再体验.py run
    	
     -方式四，右键运行
         if __name__ == '__main__':
            app.run()
        
     -方式五：命令运行（跟右键运行一样）
    	python38 5-app.py
        
	 - 方式六：少用（pip install python-dotenv）
    	flask app run

三、Werkzeug介绍

Werkzeug是一个WSGI工具包，他可以作为一个Web框架的底层库。这里稍微说一下， werkzeug 不是一个web服务器，也不是一个web框架，而是一个工具包，官方的介绍说是一个 WSGI 工具包，它可以作为一个 Web 框架的底层库，因为它封装好了很多 Web 框架的东西，例如 Request，Response 等等

Werkzeug is a comprehensive WSGI web application library. It began as a simple collection of various utilities for WSGI applications and has become one of the most advanced WSGI utility libraries.
Werkzeug 是一个综合性 WSGI Web 应用程序库。它最初是 WSGI 应用程序的各种实用程序的简单集合，现已成为最先进的 WSGI 实用程序库之一。

Werkzeug doesn’t enforce any dependencies. It is up to the developer to choose a template engine, database adapter, and even how to handle requests
Werkzeug 不强制执行任何依赖关系。由开发人员选择模板引擎、数据库适配器，甚至如何处理请求

官方网址：https://werkzeug.palletsprojects.com/en/3.0.x/

	django--->wsgiref ,uwsgi
	flask---->Werkzeug
	django或flask--》都需要有web服务器---》web服务器需要符合 wsgi协议
		-规定了，框架是一个可调用对象，请求来了，wsgi服务器调用这个对象的时候，会传入 两个参数environ，start_response
	    -flask中能找到这两个参数，django中也能找到这两个参数

	后期：
		测试django项目，使用wsgiref，上线djagno项目，使用uwsgi，gunicorn
	    测试flask项目，使用werkzeug，上线flask项目，使用uwsgi，gunicorn

	1 写了一个可调用对象，可以使用符合wsig协议的web服务器来调用，执行它
	def application(environ, start_response):
	    start_response('200 OK', [('Content-Type', 'text/plain')])
	    return ['Hello World!'.encode('utf-8')]
	
	
	2 使用符合wsgi协议的web服务器调用它
	from wsgiref.simple_server import make_server
	# 咱们这个application 函数,它就是 django框架或flask框架
	def application(environ,start_response):
	    print(environ)
	    start_response('200 OK', [('Content-Type', 'text/html')])
	    # 只有是html的才会把代码渲染，否则就是当成字符串展示到页面
	    if environ.get('PATH_INFO') == '/index':
	        with open('index.html', 'rb') as f:
	            data = f.read()
	
	    elif environ.get('PATH_INFO') == '/login':
	        with open('login.html', 'rb') as f:
	            data = f.read()
	    else:
	        data = b'<h1>Hello, web!</h1>'
	    return [data]
	
	
	
	if __name__ == '__main__':
	    myserver = make_server('',8011,application)
	    print('监听8011端口')
	    myserver.serve_forever()
	    
	    
	    
	3 使用werkzeug 运行 application
	# 有了 Request和Response，路由分发，可以获取静态文件，可以返回html页面
	from werkzeug.wrappers import Request, Response
	from werkzeug.serving import run_simple
	def application(environ, start_response):
	    request = Request(environ)
	    text = f"Hello {request.args.get('name', 'World')}!"
	    response = Response(text, mimetype='text/plain')
	    return response(environ, start_response)
	
	
	if __name__ == '__main__':
	    run_simple('localhost', 4000, application)

四、Jinja2介绍

Jinja is a fast, expressive, extensible templating engine. Special placeholders in the template allow writing code similar to Python syntax. Then the template is passed data to render the final document
Jinja
是一个快速、富有表现力、可扩展的模板引擎。模板中的特殊占位符允许编写类似于 Python 语法的代码。然后向模板传递数据以渲染最终文档

语法完全支持 dtl，但比dtl更强大

官方网址：https://jinja.palletsprojects.com/en/3.1.x/

五、Click CLI 介绍

Click is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary. It’s the “Command Line Interface Creation Kit”. It’s highly configurable but comes with sensible defaults out of the box
Click 是一个 Python 包，用于以可组合的方式使用尽可能少的代码创建漂亮的【命令行界面】。它是“命令行界面创建工具包”。它具有高度可配置性，但具有开箱即用的合理默认值

It aims to make the process of writing command line tools quick and fun while also preventing any frustration caused by the inability to implement an intended CLI API
它的目的是使编写命令行工具的过程变得快速而有趣，同时也防止因无法实现预期的 CLI API 而造成的任何挫败感

	Click in three points:
	  arbitrary nesting of commands	
	  automatic help page generation
	  supports lazy loading of subcommands at runtime 
	  
	Click三点：
	  命令的任意嵌套
	  自动生成帮助页面
	  支持运行时延迟加载子命令

官方网址：https://click.palletsprojects.com/en/8.1.x/

	# pip3 install click
	import click
	@click.command()
	@click.option('--count', default=1, help='Number of greetings.')
	@click.option('--name', prompt='Your name',help='The person to greet.')
	def hello(count, name):
	    for x in range(count):
	        click.echo(f"Hello {name}!")
	
	if __name__ == '__main__':
	    hello()
	
	1  python app.py --count=3  # app.py是当前运行页py的名称
	# count=3循环三次
	2  python app.py --help
	3  python app.py --count=3 --name=jack

六、Flask安装

介绍

	'最新版本，最低支持 python3.8'
	1 安装flask时，会自动安装一些其他模块
	    1.Werkzeug implements WSGI, the standard Python interface between applications and servers. 运行服务
	    2.Jinja is a template language that renders the pages your application serves. 模板
	    MarkupSafe comes with Jinja. It escapes untrusted input when rendering templates to avoid injection attacks. 防止xss攻击
	    3.ItsDangerous securely signs data to ensure its integrity. This is used to protect Flask’s session cookie. cookie加密
	    4.Click is a framework for writing command line applications. It provides the flask command and allows adding custom management commands. 制定命令
	    5.Blinker provides support for Signals.  信号

	2 这些依赖不会自动安装。如果您安装它们，Flask 将检测并使用它们
		# python-dotenv enables support for Environment Variables From dotenv when running flask commands.
		可以把key和value放到环境变量---》使用这个模块可以操作
		
		# Watchdog provides a faster, more efficient reloader for the development server
		flask修改了代码，他会检测到并重新运行---》最新代码

watchdog使用

	# pip install watchdog
	'当前目录下文件修改会被监控到，打印日志'
	'例如创建新文件，删除，修改等都会记录日志'
	
	import sys
	import time
	import logging
	from watchdog.observers import Observer
	from watchdog.events import LoggingEventHandler
	
	if __name__ == '__main__':
	    logging.basicConfig(level=logging.INFO,
	                        format='%(asctime)s - %(message)s',
	                        datefmt='%Y-%m-%d %H:%M:%S')
	
	    path = sys.argv[1] if len(sys.argv) > 1 else '.'
	    event_handler = LoggingEventHandler()
	    observer = Observer()
	    observer.schedule(event_handler, path, recursive=True)
	    observer.start()
	
	    try:
	        while True:
	            time.sleep(1)
	    except KeyboardInterrupt:
	        observer.stop()
	    observer.join()

python–dotenv使用（操作环境变量）

官方网址：https://saurabh-kumar.com/python-dotenv/

	# pip install python-dotenv
	import os
	from dotenv import load_dotenv
	from dotenv import dotenv_values
	
	1 加载配置文件
	# 必须在根路径下新建一个 .env 的文件，并写入配置才能返回True,会把.env下的配置文件设置进环境变量
	# 配置按照key：value的形式  USERNAME=JACK
	res=load_dotenv()  # take environment variables from .env
	print(res)
	print(os.environ.get('DOMAIN'))
	print(os.environ.get('USERNAME'))
	print(os.environ.get('AGE'))
	# You will probably want to add .env to your .gitignore, especially if it contains secrets like a password.
	
	
	2 获取环境变量字典
	config = dotenv_values(".env")
	print(config)
	print(config.get('DOMAIN'))

七、虚拟环境

介绍

之前咱们学过适应第三方模块创建虚拟环境，python内置（venv）可以直接创建虚拟环境

Use a virtual environment to manage the dependencies for your project, both in development and in production.
在开发和生产中,使用虚拟环境来管理项目的依赖关系

What problem does a virtual environment solve? The more Python projects you have, the more likely it is that you need to work with different versions of Python libraries, or even Python itself. Newer versions of libraries for one project can break compatibility in another project.
虚拟环境解决什么问题？您拥有的 Python 项目越多，您就越有可能需要使用不同版本的 Python 库，甚至是 Python 本身。一个项目的较新版本的库可能会破坏另一项目的兼容性。

Virtual environments are independent groups of Python libraries, one for each project. Packages installed for one project will not affect other projects or the operating system’s packages.
虚拟环境是一组独立的 Python 库，每个项目对应一个。为一个项目安装的软件包不会影响其他项目或操作系统的软件包

Python comes bundled with the venv module to create virtual environments.
Python 使用 venv 模块来创建虚拟环境

Mac/linux创建虚拟环境

	'创建虚拟环境'
	mkdir myproject
	cd myproject
	python3 -m venv .venv
	# 激活虚拟环境
	. .venv/bin/activate

Win创建虚拟环境

	'创建虚拟环境'
	mkdir myproject
	cd myproject
	py -3 -m venv .venv
	# 激活虚拟环境
	.venv\Scripts\activate

八、Flask的debug模式(调试)

	flask --app xxxx.py run --debug
	1 浏览器显示错误信息
	2 改了代码自动重启

九、fastapi小案例(快速了解)

官方网址：https://fastapi.tiangolo.com/zh/

	安装：
		pip install fastapi
		pip install uvicorn
	'具体查看官方文档即可'
	
	# from typing import Union  # python 的内置--》数据校验
	import time
	
	from fastapi import FastAPI
	import asyncio
	app = FastAPI()
	
	@app.get("/")
	async def read_root():
	    # 如果有io
	    await asyncio.sleep(2)
	    # time.sleep(10)
	    return {"Hello": "World"}
	
	
	@app.get("/items/{item_id}")
	def read_item(item_id, q=None):
	    return {"item_id": item_id, "q": q}
	
	# 天生自带接口文档----》方便我们快速写前后端分离的接口
	
	'运行：uvicorn fastapi快速了解.py:app'
	# 针对于io多的web后端，使用 异步框架，会提高性能
	# 咱们项目，基本都是io多，查询数据库，redis 都是io操作
	# 使用fastapi能提高并发量

十、显示用户小案例

app.py

from flask import Flask, render_template, request, redirect,session
app = Flask(__name__)
app.secret_key = 'dsakjfkls.fldsjalkfj.lksfjdal'



# 常量--》写死用户信息
USERS = {
    1: {'name': '刘亦菲', 'age': 18, 'gender': '男', 'text': "刘亦菲，1987年8月25日出生于湖北省武汉市，华语影视女演员、歌手，毕业于北京电影学院2002级表演系本科",
        'img': 'https://img2.woyaogexing.com/2021/10/16/e3ccba623848430ba83209c0621a2256!400x400.jpeg'},
    2: {'name': '彭于晏', 'age': 28, 'gender': '男', 'text': "彭于晏，1982年3月24日出生于中国台湾省澎湖县，毕业于不列颠哥伦比亚大学，华语影视男演员。。。。。。。。",
        'img': 'https://img2.woyaogexing.com/2021/10/16/e71aa35728c34313bccb4c371192990f!400x400.jpeg'},
    3: {'name': '迪丽热巴', 'age': 38, 'gender': '女', 'text': "迪丽热巴（Dilraba），1992年6月3日出生于中国新疆乌鲁木齐市，毕业于上海戏剧学院，中国内地影视女演员",
        'img': 'https://img2.woyaogexing.com/2021/10/30/6a34146dde2d4f1c832463a5be1ed027!400x400.jpeg'},
    4: {'name': '亚瑟', 'age': 38, 'gender': '男', 'text': "亚瑟，是腾讯手游《王者荣耀》中一名战士型英雄角色，也是《王者荣耀》的新手英雄之一，既可攻又可守",
        'img': 'https://img2.woyaogexing.com/2021/10/30/371b2aa7a03c4f53b7b1bc86f877d7d1!400x400.jpeg'},
}



@app.route('/login',methods=['GET','POST'])
def login():
    if request.method == 'GET':
        # 返回模板
        return render_template('login.html')
    else:
        # 取出用户名密码，判断
        # flask的request 没有POST，GET
        # request.form  就是 post
        # request.args  就是 GET
        username = request.form.get('username')
        password = request.form.get('password')
        if username == 'jack' and password == '123':
            # 登录成功跳转到首页,并把登录信息写入到session中
            # 一旦使用session就必须指定密钥，secret_key
            session['name']=username
            # return redirect('https://www.baidu.com')
            return redirect('/')  # 重定向到首页
        else:
            return render_template('login.html', error='用户名密码错误')


# 首页及其他分支页面需要登录后，才能访问，如果没有登录需跳转至登录页面
@app.route('/')
def index():
    if session.get('name'):
        return render_template('index.html',users=USERS)
    else:
        return redirect('/login')


@app.route('/detail/<int:id>')
def detail(id):
    if session.get('name'):
        info = USERS.get(id)
        return render_template('detail.html',info=info)
    else:
        return redirect('/login')


if __name__ == '__main__':
    app.run(debug=True)

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<form method="post">
    <p>用户名： <input type="text" name="username"></p>
    <p>密码： <input type="password" name="password"></p>
    <p><input type="submit" value="登录"><span>{{ errors }}</span></p>
</form>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

{% for k,v in users.items() %}
        <div>id:{{ k }}</div>
        <div><a href="/detail/{{ k }}">{{ v.name }}</a></div>
        <div>{{ v['age'] }}</div>
        <div>{{ v.get('gender') }}</div>
        <div><img src="{{v.img}}" alt="" width="100px" height="100px"></div>
        <hr>
{% endfor %}
</body>
</html>

detail.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h2>用户名称：{{ info.name }}</h2>       <!--支持Django中的Dtl语法-->
<h2>用户年龄：{{ info.age }}</h2>
<h2>用户性别：{{ info.gender }}</h2>
<h3>用户信息：{{ info.text }}</h3>

</body>
</html>

登录装饰器

	def auth(func):
	    def inner(*args,**kwargs):
	        if session.get('name'):
	            res = func(*args,**kwargs)
	            return res
	        else:
	            return redirect('/login')
	    return inner

	# 首页及其他分支页面需要登录后，才能访问，如果没有登录需跳转至登录页面
	# 使用登录装饰器
	# 必须路由匹配完---》执行视图函数之前，做判断--》路由的装饰器是控制路由匹配的--》需要先执行，所以登录认证装饰器，放在下面
	# 这样加了会报错---》每个路由，都会有个别名，如果不写，默认以函数名作为别名
	# 如果视图函数加了装饰器---》函数名就变成了 inner？--》所有视图函数，都叫inner，导致 路由别名冲突了
	# 1 装饰器加装饰器---wrapper装饰器--》改掉真正被装饰函数的名字
	# 2 直接指定路由别名
	@app.route('/',endpoint='index')
	@auth
	def index():
	    return render_template('index.html',users=USERS)

十一、Flask配置文件

配置方式

	from flask import Flask,jsonify
	app = Flask(__name__)
	
	1 方式一:放在app对象上，本质会放在 app.config 里面
	app.debug = False
	app.secret_key = 'xxkjl.xxxlxkj.xxljafsdkljfs'
	print(app.config)
	
	2 方式二：放在app对象的config参数上
	app.config['DEBUG'] = True  # key需要全大写
	app.config['HOST'] = '127.0.0..1' # 自己设置的配置
	app.config['DEBUG'] = True  # 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
	app.config.from_pyfile('python文件名称')  # 使用本地配置文件
	app.config.from_envvar('环境变量名称')  # 使用环境变量里面的信息
	app.config.from_json('json文件名称')  # 必须为Json格式 因为内部会执行json.loads
	app.config.from_mapping({'DEBUG': True})  # 字典格式
	app.config.from_object('object / path')  # python类或类的路径
	print(app.config)
	
	3 方式三：通过py文件设置  settings.py
	app.config.from_pyfile('./settings.py')
	# 会加载settings中得大写的配置，都放在config中
	# settings文件中 ， 使用 例如 DEBUG=True形式
	print(app.config)
	
	4 方式四：了解，使用环境变量----需要dotenv使用
	# 需要有.env文件，配置和上面settings一样形式
	app.config.from_envvar("环境变量名称")
	
	5 方式五，常用，通过类
	# 通过在settings中写类，在类中配置即可，可配置多个类，也就可以实现多套配置
	app.config.from_object('settings.ProductionConfig')
	app.config.from_object('settings.DevelopmentConfig')
	print(app.config)
	
	
	6 其他
	app.config.from_json("json文件名称")
	# JSON文件名称，必须是json格式，因为内部会执行json.loads
	app.config.from_mapping({'DEBUG': True})


	'settings.py'
	# DEBUG = True
	# HOST = '192.168.255.1'
	
	class Config(object):
	    DEBUG = False
	    TESTING = False
	    SECRET_KEY='123'
	    DATABASE_URI = '127.0.0.1'
	
	
	class ProductionConfig(Config):  # 例如上线配置
	    DEBUG = False
	    SECRET_KEY = 'asfasfd.ea33435asfasf'
	    DATABASE_URI = '192.168.1.23'
	
	
	class DevelopmentConfig(Config):  # 例如开发配置
	    DEBUG = True
	    DATABASE_URI = '127.0.0.1'

默认配置文件

	{
        'DEBUG':                                get_debug_flag(default=False),  是否开启Debug模式
        'TESTING':                              False,                          是否开启测试模式
        'PROPAGATE_EXCEPTIONS':                 None,                          
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,  #秘钥
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31), #sessio过期时间
        'USE_X_SENDFILE':                       False,
        'LOGGER_NAME':                          None,
        'LOGGER_HANDLER_POLICY':               'always',
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     None,
        'SESSION_COOKIE_NAME':                  'session', # 操作session--》成cookie到浏览器--》key值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,
    }

补充

	'后期项目中，可能使用配置中心'
	本地项目从配置中心获取配置信息--》写入到项目中
    以后只需要改配置中心，所有项目配置都会变化

	
	'配置中心：'
	-携程的阿波罗(Apollo)
	携程阿波罗(Apollo)：构建环境非常复杂–底层架构的颗粒度拆分的非常细
	文档：https://www.apolloconfig.com/#/zh/README
	git地址：https://github.com/apolloconfig/apollo
	
	-Spring Cloud Config
	SpringCloud Config：属于spring体系,没有界面，配置文件内容存放在git上面
	
	-Nacos(阿里)轻量级的配置中心
	Nacos即可以作为注册中心，也可以作为分布式配置中心，轻量级的
	git地址：https://github.com/alibaba/nacos/
	文档地址：https://nacos.io/zh-cn/docs/what-is-nacos.html

十二、路由系统

路由的典型写法

	@app.route('/detail/<int:id>', methods=['GET', 'POST'], endpoint='detail')	# int转换器
	def detail():
		return 'hello'
	"""
		methods:  列表规定了请求方式 如果列表中没有请求方式不被允许
		endpoint: 路由别名 如果不写会被装饰的函数名作为别名 
	"""

路由中的默认转换器

	DEFAULT_CONVERTERS = {
		'default':          UnicodeConverter,		# 默认
	    'string':           UnicodeConverter,		# 字符串
	    'any':              AnyConverter,			# 任何类型
	    'path':             PathConverter,			# 路径
	    'int':              IntegerConverter,		# 数字
	    'float':            FloatConverter,			# 小数
	    'uuid':             UUIDConverter,			# asdad-asdda-asdaa
	}

from flask import Flask
app = Flask(__name__)
app.debug=True


# @app.route('/<int:number>')  # 数字类型
# @app.route('/<name>')  # 默认
# @app.route('/<string:name>')  # 字符串
@app.route('/<path:path>')  # 路径，路由后面带斜杠 http://127.0.0.1:5000/name=jack
def index(path):
    return 'hello'+str(path)



if __name__ == '__main__':
    app.run()

路由本质

1. decorator = app.route('/',methods=['GET','POST'],endpoint='n1')	# 如果没有传endpoint，这个地方就是None
    def route(self, rule, **options):
        # app对象	# rule= /	# options = {methods=['GET','POST'], endpoint='n1'}
        def decorator(f):
            endpoint = options.pop('endpoint', None)
            self.add_url_rule(rule, endpoint, f, **options)
            # self是Flask的对象 app:rule路由 endpoint:别名，是None 其他的打散了传入了(methods..)
            return f
        return decorator
        
2. @decorator
    decorator(index)
    # 加了装饰器最终，返回的还是index，只不过执行了 self.add_url_rule(rule, endpoint, f, **options)

"""
	Flask类中的add_url_rule方法最终意思：
		rule就是装饰器传入的路径与路由
		endpoint别名
		view_func视图函数不加括号
	
	最终结论“现在不需要使用装饰器来注册路由”
	app.add_url_rule('/home', view_func=home, endpoint='home')
	...
	(最终的结果就像Django中的SimpleRouter自动生成路由 可以写多个)
"""

Add_url_rule的参数

	@app.route和app.add_url_rule参数：
	rule == url
	view_func == 视图函数名称
	defaluts == None 默认值 需要穿值就是 defaluts = {'K': 'v'}
	endpoint == None 名称 用于反向生成url 
	methods = None 允许请求的方式
	
	strict_slashes = None 	对url最后的/符号是否严格要求 
		# @app.route('/index', strict_slashes=False）	如果是True的话那就需要严格添加/否则匹配失败
	redirect_to = None  重定向到指定地址
		#  @app.route('/index/<int:id>', redirect_to='/home/<id>')		当访问起那么这个路径直接跳转到后面这个路径