目录

1.准备工作

2.创建项目启动文件manage.py

3.构建全局初始化函数并在函数内创建app应用对象

4.通过终端脚本启动项目

5.项目加载配置

6.数据库初始化

　　1.SQLAlchemy初始化

　　2.Redis初始化

　　3.session存储到redis数据库中

　　4.数据迁移初始化

7.日志初始化

8.蓝图初始化

　　1.通过终端命令创建蓝图,并在蓝图中生成view/model/url等文件

　　2.将蓝图注册到APP应用对象下

　　3.注册路由和视图之间的关系

　　4.自动注册蓝图下的所有模型

1.准备工作

1.新建项目目录mofangapi,并创建虚拟环境

  1. mkvirtualenv mofang

2.安装开发中使用的依赖模块

  1. pip install flask==0.12.4
  2. pip install flask-redis
  3. pip install flask-session
  4. pip install flask-script
  5. pip install flask-mysqldb
  6. pip install flask-sqlalchemy
  7. pip install flask-migrate

接下来，在pycharm中打开项目目录mofangapi编写manage.py启动项目的文件

2.创建项目启动文件manage.py

  1. from flask import Flask
  2.  
  3. app = Flask(__name__)
  4.  
  5. @app.route('/')
  6. def index():
  7.     return 'index'
  8.  
  9. if __name__ == '__main__':
  10.     app.run()

manage.py终不能存放大量的开发代码, 在开发中应该体现的是一种分工精神,所以我们可以把flask中各种功能代码进行分类分文件存储.

现在项目的目录结构如下所示:

  1. 项目根目录/
  2. ├── application/            # 项目主要逻辑代码保存目录
  3. |   ├── settings/           # 项目配置存储目录
  4. │   │   ├ dev.py            # 开发阶段的配置文件
  5. │   │   ├ prod.py           # 生产阶段的配置文件
  6. |   |   ├ __init__.py       # 项目公共配置文件
  7. │   ├── __init__.py         # 项目初始化文件
  8. ├── manage.py               # 项目的终端管理脚本文件

3.构建全局初始化函数并在函数内创建app应用对象

1.把引导整个项目启动的全局初始化代码,保存到application/__init__py,代码:

  1. from flask import Flask
  2.  
  3. def init_app():
  4.     """全局初始化"""
  5.     app = Flask(__name__) # 创建APP应用对象
  6.     return app

2.在manage.py,中调用初始化函数,创建app应用对象,代码:

  1. from application import init_app
  2.  
  3. app = init_app() # 创建app应用对象
  4.  
  5. @app.route('/')
  6. def index():
  7.     return 'index'
  8.  
  9. if __name__ == '__main__':
  10.     app.run()

4.通过终端脚本启动项目

applicatiion/__init__py,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3.  
  4. manager = Manager() # 引入终端脚本管理对象 ***
  5.  
  6. def init_app():
  7.     """全局初始化"""
  8.  
  9.     # 创建app应用对象
  10.     app = Flask(__name__)
  11.  
  12.     # 初始化终端脚本工具 ***
  13.     manager.app = app
  14.  
  15.     return manager

将manage.py的app改为manage，代码:

  1. from application import init_app
  2.  
  3. manage = init_app()
  4.  
  5. @manage.app.route('/')
  6. def index():
  7.     return 'index'
  8.  
  9. if __name__ == '__main__':
  10.     manage.run()

运行项目的方式就要修改如下:

此时我们就可以通过如下指令去运行项目了

  1. python manage.py runserver -h0.0.0.0 -p5000

5.项目加载配置

1.在application/utils/config.py中准备加载配置的函数代码:

  1. from importlib import import_module
  2. def load_config(config_path):
  3.     """自动加载配置"""
  4.     module = import_module(config_path)
  5.     name = config_path.split(".")[-1]
  6.     if name == "settings":
  7.         return module.InitConfig
  8.     else:
  9.         return module.Config

2.编写项目默认配置文件, application/settings/__init__.py代码:

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     DEBUG = True

当然, 项目开发过程完成以后肯定会项目上线,所以针对配置文件,我们可以准备不同环境下的配置

application/settings/dev.py,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目开发环境下的配置"""
  4.     DEBUG = True

application/settings/prod.py,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目运营环境下的配置"""
  4.     DEBUG = False

3.在项目引导文件application/__init__py中加载配置,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3. from application.utils.config import load_config
  4. manager = Manager()
  5.  
  6. def init_app(config_path):
  7.     """全局初始化"""
  8.     # 创建app应用对象
  9.     app = Flask(__name__)
  10.  
  11.     # 设置项目根目录
  12.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  13.  
  14.     # 加载配置 ****
  15.     Config = load_config(config_path) # 调用utils里自己已经写好的load_config方法
  16.     app.config.from_object(Config) # 将配置类注册到APP上
  17.  
  18.     # 初始化终端脚本工具
  19.     manager.app = app
  20.  
  21.     return manager

4.在创建app对象的项目启动文件manage.py中,设置配置

  1. from application import init_app
  2.  
  3. manage = init_app("application.settings.dev") # 设置默认项目使用的配置文件是dev.py
  4.  
  5. @manage.app.route('/')
  6. def index():
  7.     return 'index'
  8.  
  9. if __name__ == '__main__':
  10.     manage.run()

6.数据库初始化

1.SQLAlchemy初始化

1.默认项目配置文件中增加配置选项,application/settings/__init__.py,代码:

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True

2.开发配置dev.py中,配置数据库连接信息,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目开发环境下的配置"""
  4.     DEBUG = True
  5.     # 数据库
  6.     SQLALCHEMY_DATABASE_URI = "mysql://mofang_user:mofang@127.0.0.1:3306/mofang?charset=utf8mb4"
  7.     SQLALCHEMY_ECHO = True

3.在mysql终端下, 创建数据库用户,命令如下:

  1. create database mofang charset=utf8mb4;
  2. # 针对当前数据库配置账户信息
  3. create user mofang_user identified by 'mofang';
  4. grant all privileges on mofang.* to 'mofang_user'@'%';
  5. flush privileges;

4.在项目全局引导文件中,对数据库功能进行初始化,application/__init__.py,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3. from flask_sqlalchemy import SQLAlchemy
  4. from application.utils.config import load_config
  5.  
  6. # 创建终端脚本管理对象
  7. manager = Manager()
  8.  
  9. # 创建数据库链接对象 ***
  10. db = SQLAlchemy()
  11.  
  12. def init_app(config_path):
  13.     """全局初始化"""
  14.  
  15.     # 创建app应用对象
  16.     app = Flask(__name__)
  17.     # 项目根目录
  18.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  19.  
  20.     # 加载配置
  21.     Config = load_config(config_path)
  22.     app.config.from_object(Config)
  23.  
  24.     # 数据库初始化 ***
  25.     db.init_app(app)
  26.  
  27.     # 初始化终端脚本工具
  28.     manager.app = app
  29.  
  30.     return manager

2.Redis初始化

1.默认配置文件,application/settings/__init__py,代码:

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True
  12.     # Redis
  13.     REDIS_URL = "redis://@127.0.0.1:6379/0"

2.在全局引导文件中, 对redis进行初始化,applicaiton/__init__.py,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3. from flask_sqlalchemy import SQLAlchemy
  4. from flask_redis import FlaskRedis
  5.  
  6. from application.utils.config import load_config
  7.  
  8. # 创建终端脚本管理对象
  9. manager = Manager()
  10.  
  11. # 创建数据库链接对象
  12. db = SQLAlchemy()
  13.  
  14. # redis链接对象 ***
  15. redis = FlaskRedis()
  16.  
  17. def init_app(config_path):
  18.     """全局初始化"""

  19.     # 创建app应用对象
  20.     app = Flask(__name__)
  21.     # 项目根目录
  22.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  23.  
  24.     # 加载配置
  25.     Config = load_config(config_path)
  26.     app.config.from_object(Config)
  27.  
  28.     # 数据库初始化
  29.     db.init_app(app)
  30.     redis.init_app(app) # redis数据库初始化 ***
  31.  
  32.     # 初始化终端脚本工具
  33.     manager.app = app
  34.  
  35.     return manager

3.session存储到redis数据库中

1.因为需要单独设置一个数据库存放session,所以我们再次单独配置一个关于session加载配置的函数init_session,

application/utils/session.py,代码:

  1. from redis import Redis
  2. def init_session(app):
  3.     host = app.config.get("SESSION_REDIS_HOST","127.0.0.1")
  4.     port = app.config.get("SESSION_REDIS_PORT",6379)
  5.     db = app.config.get("SESSION_REDIS_DB",0)
  6.     print(db)
  7.     app.config["SESSION_REDIS"] = Redis(host=host,port=port,db=db)

2.默认配置文件application/settings/__init__.py中, 添加配置项:

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True
  12.     # Redis
  13.     REDIS_URL = ""
  14.  
  15.     # 设置密钥，可以通过 base64.b64encode(os.urandom(48)) 来生成一个指定长度的随机字符串 ***
  16.     SECRET_KEY = "y58Rsqzmts6VCBRHes1Sf2DHdGJaGqPMi6GYpBS4CKyCdi42KLSs9TQVTauZMLMw"
  17.  
  18.     '''session存储配置''' ***
  19.     # session存储方式配置 ***
  20.     SESSION_TYPE = "redis"
  21.     # 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效 ***
  22.     SESSION_PERMANENT = False
  23.     # 设置session_id在浏览器中的cookie有效期 ***
  24.     PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒 ***
  25.     # 是否对发送到浏览器上session的cookie值进行加密 ***
  26.     SESSION_USE_SIGNER = True
  27.     # 保存到redis的session数的名称前缀 ***
  28.     SESSION_KEY_PREFIX = "session:"
  29.     # session保存数据到redis时启用的链接对象 ***
  30.     SESSION_REDIS = None   # 用于连接redis的配置 ***
  31.  
  32.     SESSION_REDIS_HOST = "127.0.0.1"
  33.     SESSION_REDIS_PORT = 6379
  34.     SESSION_REDIS_DB = 0

3.在本地开发配置中,设置session存储指定的redis库中,application/settings/dev.py,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目开发环境下的配置"""
  4.     DEBUG = True
  5.     # 数据库
  6.     SQLALCHEMY_DATABASE_URI = "mysql://mofang_user:mofang@127.0.0.1:3306/mofang?charset=utf8mb4"
  7.     SQLALCHEMY_ECHO = True
  8.  
  9.     # redis ***
  10.     REDIS_URL = "redis://@127.0.0.1:6379/0" # 0号redis库用来存redis缓存
  11.  
  12.     # session存储配置 ***
  13.     SESSION_REDIS_HOST = "127.0.0.1"
  14.     SESSION_REDIS_PORT = 6379
  15.     SESSION_REDIS_DB = 1 # 1号redis库用来存session

4.在项目全局引导文件application/__init__.py中对session存储进行初始化,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3. from flask_sqlalchemy import SQLAlchemy
  4. from flask_redis import FlaskRedis
  5. from flask_session import Session
  6.  
  7. from application.utils.config import load_config
  8. from application.utils.session import init_session
  9. # 创建终端脚本管理对象
  10. manager = Manager()
  11.  
  12. # 创建数据库链接对象
  13. db = SQLAlchemy()
  14.  
  15. # redis链接对象
  16. redis = FlaskRedis()
  17.  
  18. # Session存储对象 ***
  19. session_store = Session()
  20.  
  21. def init_app(config_path):
  22.     """全局初始化"""
  23.     # 创建app应用对象
  24.     app = Flask(__name__)
  25.     # 项目根目录
  26.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  27.  
  28.     # 加载配置
  29.     Config = load_config(config_path)
  30.     app.config.from_object(Config)
  31.  
  32.     # 数据库初始化
  33.     db.init_app(app)
  34.     redis.init_app(app)
  35.  
  36.     # session存储初始化 ***
  37.     init_session(app) # 加载session配置
  38.     session_store.init_app(app) # session存储初始化
  39.  
  40.     # 初始化终端脚本工具
  41.     manager.app = app
  42.  
  43.     return manager

4.数据迁移初始化

1.项目全局引导文件application/__init__py,代码:

  1. from flask import Flask
  2. from flask_script import Manager
  3. from flask_sqlalchemy import SQLAlchemy
  4. from flask_redis import FlaskRedis
  5. from flask_session import Session
  6. from flask_migrate import Migrate,MigrateCommand # ***
  7.  
  8. from application.utils.config import load_config
  9. from application.utils.session import init_session
  10.  
  11. # 创建终端脚本管理对象
  12. manager = Manager()
  13.  
  14. # 创建数据库链接对象
  15. db = SQLAlchemy()
  16.  
  17. # redis链接对象
  18. redis = FlaskRedis()
  19.  
  20. # Session存储对象
  21. session_store = Session()
  22.  
  23. # 数据迁移实例对象 ***
  24. migrate = Migrate()
  25.  
  26. def init_app(config_path):
  27.     """全局初始化"""
  28.     # 创建app应用对象
  29.     app = Flask(__name__)
  30.     # 项目根目录
  31.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  32.  
  33.     # 加载配置
  34.     Config = load_config(config_path)
  35.     app.config.from_object(Config)
  36.  
  37.     # 数据库初始化
  38.     db.init_app(app)
  39.     redis.init_app(app)
  40.  
  41.     # session存储初始化
  42.     init_session(app)
  43.     session_store.init_app(app)
  44.  
  45.     # 数据迁移初始化 ***
  46.     migrate.init_app(app,db)
  47.     # 添加数据迁移的命令到终端脚本工具中 ***
  48.     manager.add_command('db', MigrateCommand)
  49.  
  50.     # 初始化终端脚本工具
  51.     manager.app = app
  52.  
  53.     return manager

完成上面的项目构建步骤以后,此时目录结构如下:

  1. 项目根目录/
  2. ├── docs/                   # 项目开发文档/接口等备份资料存储目录
  3. ├── logs/                   # 项目日志存储目录
  4. ├── application/            # 项目主要逻辑代码保存目录
  5. |   ├── settings/           # 项目配置存储目录
  6. │   │   ├ dev.py            # 开发阶段的配置文件
  7. │   │   ├ prod.py           # 生产阶段的配置文件
  8. |   |   ├ __init__.py       # 项目公共配置文件
  9. |   ├── utils/              # 工具函数库/类库
  10. │   │   ├ session.py        # session相关的辅助函数
  11. │   │   ├ config.py         # 配置相关的辅助函数
  12. │   ├── __init__.py         # 项目初始化文件
  13. └── manage.py               # 项目的终端管理脚本文件

7.日志初始化

flask中没有内置的日志功能,我们在使用的时候, 一般日志如果不是核心重点,则通过由python内置的logging模块进行配置集成使用即可, 如果项目中日志发挥作用比较重要, 则一般安装部署 ELK日志分析系统.

1.日志的等级

  1. FATAL/CRITICAL = 致命的，危险的
  2. ERROR = 错误
  3. WARNING = 警告
  4. INFO = 信息
  5. DEBUG = 调试

2.构建日志模块

1.把日志初始化相关的代码封装成一个函数，application/utils/logger.py，代码：

  1. import logging
  2. from logging.handlers import RotatingFileHandler
  3.  
  4. class Log():
  5.     """日志模块"""
  6.  
  7.     def __init__(self, app=None):
  8.         if app is not None:
  9.             self.init_app(app)
  10.  
  11.     def init_app(self,app):
  12.         self.app = app
  13.         return self.setup()
  14.  
  15.     def setup(self):
  16.         """安装日志功能到flask中"""
  17.         # 设置日志的记录等级
  18.         logging.basicConfig(level=self.app.config.get("LOG_LEVEL"))  # 调试debug级
  19.  
  20.         # 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
  21.         file_log_handler = RotatingFileHandler(
  22.             self.app.BASE_DIR+self.app.config.get("LOG_DIR"),
  23.             maxBytes=self.app.config.get("LOG_MAX_BYTES"),
  24.             backupCount=self.app.config.get("LOG_BACKPU_COUNT")
  25.         )
  26.  
  27.         # 创建日志记录的格式 日志等级 输入日志信息的文件名 行数 日志信息
  28.         formatter = logging.Formatter('%(name)s: %(levelname)s %(asctime)s %(filename)s:%(lineno)d %(message)s')
  29.         # 为刚创建的日志记录器设置日志记录格式
  30.         file_log_handler.setFormatter(formatter)
  31.  
  32.         # 为全局的日志工具对象（flaskapp使用的）添加日志记录器
  33.         logging.getLogger(self.app.config.get("LOG_NAME")).addHandler(file_log_handler)
  34.         # 返回日志器对象提供给业务开发
  35.         logger = logging.getLogger(self.app.config.get("LOG_NAME"))
  36.         return logger

2.application/settings/__init__.py代码：

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True
  12.     # Redis
  13.     REDIS_URL = ""
  14.  
  15.     # 设置密钥，可以通过 base64.b64encode(os.urandom(48)) 来生成一个指定长度的随机字符串
  16.     SECRET_KEY = "y58Rsqzmts6VCBRHes1Sf2DHdGJaGqPMi6GYpBS4CKyCdi42KLSs9TQVTauZMLMw"
  17.  
  18.     # session存储配置
  19.     # session存储方式配置
  20.     SESSION_TYPE = "redis"
  21.     # 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效
  22.     SESSION_PERMANENT = False
  23.     # 设置session_id在浏览器中的cookie有效期
  24.     PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒
  25.     # 是否对发送到浏览器上session的cookie值进行加密
  26.     SESSION_USE_SIGNER = True
  27.     # 保存到redis的session数的名称前缀
  28.     SESSION_KEY_PREFIX = "session:"
  29.     # session保存数据到redis时启用的链接对象
  30.     SESSION_REDIS = None   # 用于连接redis的配置
  31.  
  32.     SESSION_REDIS_HOST = "127.0.0.1"
  33.     SESSION_REDIS_PORT = 6379
  34.     SESSION_REDIS_DB = 1
  35.  
  36.     # 调整json数据转换中文的配置
  37.     JSON_AS_ASCII=False
  38.  
  39.     # 日志相关配置 ***
  40.     LOG_LEVEL        = "INFO"              # 日志输出到文件中的最低等级
  41.     LOG_DIR          = "logs/0.log"        # 日志存储目录
  42.     LOG_MAX_BYTES    = 300 * 1024 * 1024   # 单个日志文件的存储上限[单位: b]
  43.     LOG_BACKPU_COUNT = 20                  # 日志文件的最大备份数量
  44.     LOG_NAME         = "flask"             # 日志器的名字

3.开发环境配置文件dev.py中配置具体的日志相关信息,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目开发环境下的配置"""
  4.     DEBUG = True
  5.     # 数据库
  6.     SQLALCHEMY_DATABASE_URI = "mysql://mofang_user:mofang@127.0.0.1:3306/mofang?charset=utf8mb4"
  7.     SQLALCHEMY_ECHO = True
  8.  
  9.     # redis
  10.     REDIS_URL = "redis://@127.0.0.1:6379/0"
  11.  
  12.     # session存储配置
  13.     SESSION_REDIS_HOST = "127.0.0.1"
  14.     SESSION_REDIS_PORT = 6379
  15.     SESSION_REDIS_DB = 1
  16.  
  17.     # 日志配置 ***
  18.     LOG_LEVEL        = "DEBUG"             # 日志输出到文件中的最低等级
  19.     LOG_DIR          = "/logs/mofang.log"  # 日志存储目录
  20.     LOG_MAX_BYTES    = 300 * 1024 * 1024   # 单个日志文件的存储上限[单位: b]
  21.     LOG_BACKPU_COUNT = 20                  # 日志文件的最大备份数量
  22.     LOG_NAME = "mofang"                    # 日志器名称

4.在 application/__init__.py文件中的init_app 方法中调用日志初始化。

  1. import os,logging
  2.  
  3. from flask import Flask
  4. from flask_script import Manager
  5. from flask_sqlalchemy import SQLAlchemy
  6. from flask_redis import FlaskRedis
  7. from flask_session import Session
  8. from flask_migrate import Migrate,MigrateCommand
  9.  
  10. from application.utils.config import load_config
  11. from application.utils.session import init_session
  12. from application.utils.logger import Log
  13. # 创建终端脚本管理对象
  14. manager = Manager()
  15.  
  16. # 创建数据库链接对象
  17. db = SQLAlchemy()
  18.  
  19. # redis链接对象
  20. redis = FlaskRedis()
  21.  
  22. # Session存储对象
  23. session_store = Session()
  24.  
  25. # 数据迁移实例对象
  26. migrate = Migrate()
  27.  
  28. # 日志对象 ***
  29. log = Log()
  30.  
  31. def init_app(config_path):
  32.     """全局初始化"""
  33.     # 创建app应用对象
  34.     app = Flask(__name__)
  35.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  36.  
  37.     # 加载配置
  38.     Config = load_config(config_path)
  39.     app.config.from_object(Config)
  40.  
  41.     # 数据库初始化
  42.     db.init_app(app)
  43.     redis.init_app(app)
  44.  
  45.     # session存储初始化
  46.     init_session(app)
  47.     session_store.init_app(app)
  48.  
  49.     # 数据迁移初始化
  50.     migrate.init_app(app,db)
  51.     # 添加数据迁移的命令到终端脚本工具中
  52.     manager.add_command('db', MigrateCommand)
  53.  
  54.     # 日志初始化 ***
  55.     app.log = log.init_app(app)
  56.  
  57.     # 初始化终端脚本工具
  58.     manager.app = app
  59.  
  60.     return manager

新增日志的项目目录结构如下所示

  1. ├── application
  2. │   ├── __init__.py
  3. │   ├── settings
  4. │   │   ├── dev.py
  5. │   │   ├── __init__.py
  6. │   │   ├── prod.py
  7. │   └── utils
  8. │       ├── config.py
  9. │       ├── __init__.py
  10. │       ├── logger.py      # 日志相关模块代码库
  11. │       └── session.py
  12. ├── docs
  13. ├── logs                    # 日志文件存储目录
  14. │   └── mofang.log
  15. └── manage.py

经过上面的改造，我们接下来就可以开始创建蓝图了。

8.蓝图初始化

1.通过终端命令创建蓝图,并在蓝图中生成view/model/url等文件

1.在application下创建apps目录，apps以后专门用于保存每一个项目的蓝图,并在apps创建home蓝图目录,并在__init__.py文件中创建蓝图对象

通过自定义终端命令, 创建一个自动生成蓝图目录的命令.application/utils/commands.py,代码:

  1. from flask_script import Command, Option
  2.  
  3. class BlueprintCommand(Command):
  4.     """蓝图生成命令"""
  5.     name = "blue"
  6.     option_list = [
  7.         Option('--name', '-n', dest='name'),
  8.     ]
  9.     def run(self, name):
  10.         # 生成蓝图名称对象的目录
  11.         os.mkdir(name)
  12.         open("%s/__init__.py" % name, "w")
  13.         open("%s/views.py" % name, "w")
  14.         open("%s/models.py" % name, "w")
  15.         with open("%s/urls.py" % name, "w") as f:
  16.             content = """from . import views
  17. from application.utils import path
  18. urlpatterns = [
  19.  
  20. ]"""
  21.             f.write(content)
  22.         print("蓝图%s创建完成...." % name)

2.上面的命令就可以帮我们完成项目中生成蓝图的功能,接下来我们就可以直接把命令注册到manage对象中就可以使用了.

但是, 我们往后的开发中肯定还会继续的需要进行自定义终端命令,所以我们声明一个load_command的函数,让自动帮我们完成加载注册自定义终端命令的过程.

application/utils/commands.py,代码:

  1. import os
  2. from importlib import import_module
  3. from flask_script import Command, Option
  4. import inspect
  5.  
  6. def load_command(manager,command_path=None):
  7.     """自动加载自定义终端命令"""
  8.     if command_path is None:
  9.         command_path = "application.utils.commands"
  10.  
  11.     module = import_module(command_path)
  12.     class_list = inspect.getmembers(module,inspect.isclass)
  13.     for class_item in class_list:
  14.         if issubclass(class_item[1],Command) and class_item[0] != "Command":
  15.             manager.add_command(class_item[1].name,class_item[1])
  16.  
  17. class BlueprintCommand(Command):
  18.     """蓝图生成命令"""
  19.     name = "blue"
  20.     option_list = [
  21.         Option('--name', '-n', dest='name'),
  22.     ]
  23.     def run(self, name):
  24.         # 生成蓝图名称对象的目录
  25.         os.mkdir(name)
  26.         open("%s/__init__.py" % name, "w")
  27.         open("%s/views.py" % name, "w")
  28.         open("%s/models.py" % name, "w")
  29.         with open("%s/urls.py" % name, "w") as f:
  30.             content = """from . import views
  31. from application.utils import path
  32. urlpatterns = [
  33.  
  34. ]"""
  35.             f.write(content)
  36.         print("蓝图%s创建完成...." % name)

3.在项目全局引导文件application/__init__.py中, 调用load_command函数注册命令

  1. import os,logging
  2.  
  3. from flask import Flask
  4. from flask_script import Manager
  5. from flask_sqlalchemy import SQLAlchemy
  6. from flask_redis import FlaskRedis
  7. from flask_session import Session
  8. from flask_migrate import Migrate,MigrateCommand
  9.  
  10. from application.utils.config import load_config
  11. from application.utils.session import init_session
  12. from application.utils.logger import Log
  13. from application.utils.commands import load_command
  14. # 创建终端脚本管理对象
  15. manager = Manager()
  16.  
  17. # 创建数据库链接对象
  18. db = SQLAlchemy()
  19.  
  20. # redis链接对象
  21. redis = FlaskRedis()
  22.  
  23. # Session存储对象
  24. session_store = Session()
  25.  
  26. # 数据迁移实例对象
  27. migrate = Migrate()
  28.  
  29. # 日志对象
  30. log = Log()
  31.  
  32. def init_app(config_path):
  33.     """全局初始化"""
  34.     # 创建app应用对象
  35.     app = Flask(__name__)
  36.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  37.  
  38.     # 加载配置
  39.     Config = load_config(config_path)
  40.     app.config.from_object(Config)
  41.  
  42.     # 数据库初始化
  43.     db.init_app(app)
  44.     redis.init_app(app)
  45.  
  46.     # session存储初始化
  47.     init_session(app)
  48.     session_store.init_app(app)
  49.  
  50.     # 数据迁移初始化
  51.     migrate.init_app(app,db)
  52.     # 添加数据迁移的命令到终端脚本工具中
  53.     manager.add_command('db', MigrateCommand)
  54.  
  55.     # 日志初始化
  56.     app.log = log.init_app(app)
  57.  
  58.     # 初始化终端脚本工具
  59.     manager.app = app
  60.  
  61.     # 注册自定义命令 ***
  62.     load_command(manager)
  63.  
  64.     return manager

4.接下来就可以在终端下,通过命令生成蓝图目录了.

命令:

  1. cd application/apps
  2. python ../../manage.py blue -nhome

效果:

2.将蓝图注册到APP应用对象下

有了蓝图以后,接下来我们就可以视图代码,模型代码,路由代码等存储到蓝图目录下了,但是我们需要把蓝图注册到app应用对象下.所以我们注册蓝图这块代码也可以封装到一个函数中.让程序自动识别并注册.

项目中可以有多个蓝图,但是有些蓝图可能并不能提供给客户端访问,所以我们需要在配置文件中声明一个蓝图注册列表, 在init_blueprint函数中只注册配置列表的蓝图

1.application/settings/__init__.py,代码:

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True
  12.     # Redis
  13.     REDIS_URL = ""
  14.  
  15.     # 设置密钥，可以通过 base64.b64encode(os.urandom(48)) 来生成一个指定长度的随机字符串
  16.     SECRET_KEY = "y58Rsqzmts6VCBRHes1Sf2DHdGJaGqPMi6GYpBS4CKyCdi42KLSs9TQVTauZMLMw"
  17.  
  18.     # session存储配置
  19.     # session存储方式配置
  20.     SESSION_TYPE = "redis"
  21.     # 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效
  22.     SESSION_PERMANENT = False
  23.     # 设置session_id在浏览器中的cookie有效期
  24.     PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒
  25.     # 是否对发送到浏览器上session的cookie值进行加密
  26.     SESSION_USE_SIGNER = True
  27.     # 保存到redis的session数的名称前缀
  28.     SESSION_KEY_PREFIX = "session:"
  29.     # session保存数据到redis时启用的链接对象
  30.     SESSION_REDIS = None   # 用于连接redis的配置
  31.  
  32.     SESSION_REDIS_HOST = "127.0.0.1"
  33.     SESSION_REDIS_PORT = 6379
  34.     SESSION_REDIS_DB = 1
  35.  
  36.     # 调整json数据转换中文的配置
  37.     JSON_AS_ASCII=False
  38.  
  39.     # 日志相关配置
  40.     LOG_LEVEL        = "INFO"              # 日志输出到文件中的最低等级
  41.     LOG_DIR          = "logs/0.log"        # 日志存储目录
  42.     LOG_MAX_BYTES    = 300 * 1024 * 1024   # 单个日志文件的存储上限[单位: b]
  43.     LOG_BACKPU_COUNT = 20                  # 日志文件的最大备份数量
  44.     LOG_NAME         = "flask"             # 日志器的名字
  45.  
  46.     # 蓝图注册列表 ***
  47.     INSTALLED_APPS = [
  48.  
  49.     ]

application/settings/dev.py,代码:

  1. from . import InitConfig
  2. class Config(InitConfig):
  3.     """项目开发环境下的配置"""
  4.     DEBUG = True
  5.     # 数据库
  6.     SQLALCHEMY_DATABASE_URI = "mysql://mofang_user:mofang@127.0.0.1:3306/mofang?charset=utf8mb4"
  7.     SQLALCHEMY_ECHO = True
  8.  
  9.     # redis
  10.     REDIS_URL = "redis://@127.0.0.1:6379/0"
  11.  
  12.     # session存储配置
  13.     SESSION_REDIS_HOST = "127.0.0.1"
  14.     SESSION_REDIS_PORT = 6379
  15.     SESSION_REDIS_DB = 1
  16.  
  17.     # 日志配置
  18.     LOG_LEVEL        = "DEBUG"             # 日志输出到文件中的最低等级
  19.     LOG_DIR          = "/logs/mofang.log"  # 日志存储目录
  20.     LOG_MAX_BYTES    = 300 * 1024 * 1024   # 单个日志文件的存储上限[单位: b]
  21.     LOG_BACKPU_COUNT = 20                  # 日志文件的最大备份数量
  22.     LOG_NAME = "mofang"                    # 日志器名称
  23.  
  24.     # 注册蓝图  ***
  25.     INSTALLED_APPS = [
  26.         "application.apps.home",
  27.     ]

2.在init_blueprint函数中,针对注册的蓝图列表注册到app应用对象里面,

application/utils/__init__.py,代码:

  1. def init_blueprint(app):
  2.     """自动注册蓝图"""
  3.     blueprint_path_list = app.config.get("INSTALLED_APPS")
  4.     for blueprint_path in blueprint_path_list:
  5.         blueprint_name = blueprint_path.split(".")[-1]
  6.         # 自动创建蓝图对象
  7.         blueprint = Blueprint(blueprint_name,blueprint_path)
  8.  
  9.         # 注册蓝图对象到app应用对象中
  10.         app.register_blueprint(blueprint,url_prefix="")

3.项目全局引导文件中, 调用init_blueprint方法, 自动注册蓝图.application/__init__.py,代码:

  1. import os,logging
  2.  
  3. from flask import Flask
  4. from flask_script import Manager
  5. from flask_sqlalchemy import SQLAlchemy
  6. from flask_redis import FlaskRedis
  7. from flask_session import Session
  8. from flask_migrate import Migrate,MigrateCommand
  9.  
  10. from application.utils import init_blueprint
  11. from application.utils.config import load_config
  12. from application.utils.session import init_session
  13. from application.utils.logger import Log
  14. from application.utils.commands import load_command
  15. # 创建终端脚本管理对象
  16. manager = Manager()
  17.  
  18. # 创建数据库链接对象
  19. db = SQLAlchemy()
  20.  
  21. # redis链接对象
  22. redis = FlaskRedis()
  23.  
  24. # Session存储对象
  25. session_store = Session()
  26.  
  27. # 数据迁移实例对象
  28. migrate = Migrate()
  29.  
  30. # 日志对象
  31. log = Log()
  32.  
  33. def init_app(config_path):
  34.     """全局初始化"""
  35.     # 创建app应用对象
  36.     app = Flask(__name__)
  37.     app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
  38.  
  39.     # 加载配置
  40.     Config = load_config(config_path)
  41.     app.config.from_object(Config)
  42.  
  43.     # 数据库初始化
  44.     db.init_app(app)
  45.     redis.init_app(app)
  46.  
  47.     # session存储初始化
  48.     init_session(app)
  49.     session_store.init_app(app)
  50.  
  51.     # 数据迁移初始化
  52.     migrate.init_app(app,db)
  53.     # 添加数据迁移的命令到终端脚本工具中
  54.     manager.add_command('db', MigrateCommand)
  55.  
  56.     # 日志初始化
  57.     app.log = log.init_app(app)
  58.  
  59.     # 蓝图注册 ***
  60.     init_blueprint(app)
  61.  
  62.     # 初始化终端脚本工具
  63.     manager.app = app
  64.  
  65.     # 注册自定义命令
  66.     load_command(manager)
  67.  
  68.     return manager

3.注册路由和视图之间的关系

1.注册子路由和视图之间的关系

注册了蓝图对象以后,蓝图下面的视图方法和视图对应的路由关系也要进行注册!

所以, 在蓝图home下面的urls.py文件中,通过path方法把url地址和视图方法进行处理成字典,然后把字典作为成员返回到变量urlpatterns列表中.

1.application/utils/__init__.py,生成path函数,代码:

  1. from flask import Blueprint
  2. from importlib import import_module
  3. def path(rule,func_view):
  4.     # 把蓝图下视图和路由之间的映射关系处理成字典结构，方便后面注册蓝图的时候，直接传参
  5.     return {"rule":rule,"view_func":func_view}

2.在蓝图下的urls.py中,注册视图和路由的关系,home/urls.py,代码:

  1. from . import views
  2. from application.utils import path
  3. urlpatterns = [
  4.     path("/",views.index),
  5. ]

视图代码:

  1. def index():
  2.     return 'index'

3.在init_blueprint初始化蓝图的函数中, 生成蓝图对象以后自动加载并注册蓝图和视图

application/utils/__init__.py,代码:

  1. from flask import Blueprint
  2. from importlib import import_module
  3. def path(rule,func_view):
  4.     # 把蓝图下视图和路由之间的映射关系处理成字典结构，方便后面注册蓝图的时候，直接传参
  5.     return {"rule":rule,"view_func":func_view}
  6.  
  7. def init_blueprint(app):
  8.     """自动注册蓝图"""
  9.     blueprint_path_list = app.config.get("INSTALLED_APPS")
  10.     for blueprint_path in blueprint_path_list:
  11.         blueprint_name = blueprint_path.split(".")[-1]
  12.         # 自动创建蓝图对象
  13.         blueprint = Blueprint(blueprint_name,blueprint_path)
  14.         # 蓝图自动注册和绑定视图和子路由
  15.         url_module = import_module(blueprint_path+".urls") # 加载蓝图下的子路由文件
  16.         for url in url_module.urlpatterns: # 遍历子路由中的所有路由关系
  17.             blueprint.add_url_rule(**url)  # 注册到蓝图下
  18.         # 注册蓝图对象到app应用对象中
  19.         app.register_blueprint(blueprint,url_prefix="")

2.注册总路由和蓝图之间的关系

4.此时, 运行项目,就允许蓝图中视图通过url地址提供给客户端访问了.

上面蓝图注册到app时, 没有设置url_prefix路由前缀, 接下来我们可以单独设置一个总路由application/urls.py,进行路由前缀的设置.

在项目默认配置文件中,application/settings/__init__.py,新增总路由的配置项

  1. class InitConfig():
  2.     """项目默认初始化配置"""
  3.     # 调试模式
  4.     DEBUG = True
  5.  
  6.     # 数据库相关配置
  7.     SQLALCHEMY_DATABASE_URI = ""
  8.     # 动态追踪修改设置
  9.     SQLALCHEMY_TRACK_MODIFICATIONS = False
  10.     # 查询时会显示原始SQL语句
  11.     SQLALCHEMY_ECHO= True
  12.     # Redis
  13.     REDIS_URL = ""
  14.  
  15.     # 设置密钥，可以通过 base64.b64encode(os.urandom(48)) 来生成一个指定长度的随机字符串
  16.     SECRET_KEY = "y58Rsqzmts6VCBRHes1Sf2DHdGJaGqPMi6GYpBS4CKyCdi42KLSs9TQVTauZMLMw"
  17.  
  18.     # session存储配置
  19.     # session存储方式配置
  20.     SESSION_TYPE = "redis"
  21.     # 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效
  22.     SESSION_PERMANENT = False
  23.     # 设置session_id在浏览器中的cookie有效期
  24.     PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒
  25.     # 是否对发送到浏览器上session的cookie值进行加密
  26.     SESSION_USE_SIGNER = True
  27.     # 保存到redis的session数的名称前缀
  28.     SESSION_KEY_PREFIX = "session:"
  29.     # session保存数据到redis时启用的链接对象
  30.     SESSION_REDIS = None   # 用于连接redis的配置
  31.  
  32.     SESSION_REDIS_HOST = "127.0.0.1"
  33.     SESSION_REDIS_PORT = 6379
  34.     SESSION_REDIS_DB = 1
  35.  
  36.     # 调整json数据转换中文的配置
  37.     JSON_AS_ASCII=False
  38.  
  39.     # 日志相关配置
  40.     LOG_LEVEL        = "INFO"              # 日志输出到文件中的最低等级
  41.     LOG_DIR          = "logs/0.log"        # 日志存储目录
  42.     LOG_MAX_BYTES    = 300 * 1024 * 1024   # 单个日志文件的存储上限[单位: b]
  43.     LOG_BACKPU_COUNT = 20                  # 日志文件的最大备份数量
  44.     LOG_NAME         = "flask"             # 日志器的名字
  45.  
  46.     # 蓝图注册列表
  47.     INSTALLED_APPS = [
  48.  
  49.     ]
  50.  
  51.     # 总路由 ***
  52.     URL_PATH = "application.urls"

5.创建总路由文件并注册蓝图和路由前缀的关系, application/urls.py,代码:

  1. from application.utils import include
  2. urlpatterns = [
  3.     include("","home.urls"),
  4. ]

6.接下来,在init_blueprint蓝图初始化函数中新增判断识别路由前缀的代码; 同时, 把路由前缀和蓝图映射关系的处理代码封装成include方法,方便以后需求变化时可以直接调整.

application/utils/__init__.py,代码:

  1. from flask import Blueprint
  2. from importlib import import_module
  3. def path(rule,func_view):
  4.     # 把蓝图下视图和路由之间的映射关系处理成字典结构，方便后面注册蓝图的时候，直接传参
  5.     return {"rule":rule,"view_func":func_view}
  6.  
  7. def include(url_prefix, blueprint_path):
  8.     """把路由前缀和蓝图进行关系映射"""
  9.     return {"url_prefix":url_prefix,"blueprint_path":blueprint_path}
  10.  
  11. def init_blueprint(app):
  12.     """自动注册蓝图"""
  13.     blueprint_path_list = app.config.get("INSTALLED_APPS")
  14.     for blueprint_path in blueprint_path_list:
  15.         blueprint_name = blueprint_path.split(".")[-1]
  16.         # 自动创建蓝图对象
  17.         blueprint = Blueprint(blueprint_name,blueprint_path)
  18.         # 蓝图自动注册和绑定视图和子路由
  19.         url_module = import_module(blueprint_path+".urls") # 加载蓝图下的子路由文件
  20.         for url in url_module.urlpatterns: # 遍历子路由中的所有路由关系
  21.             blueprint.add_url_rule(**url)  # 注册到蓝图下
  22.  
  23.         # 读取总路由文件
  24.         url_path = app.config.get("URL_PATH")
  25.         urlpatterns = import_module(url_path).urlpatterns  # 加载蓝图下的子路由文件
  26.         url_prefix = "" # 蓝图路由前缀
  27.         for urlpattern in urlpatterns:
  28.             if urlpattern["blueprint_path"] == blueprint_name+".urls":
  29.                 url_prefix = urlpattern["url_prefix"]
  30.                 break
  31.         # 注册蓝图对象到app应用对象中,  url_prefix 蓝图的路由前缀
  32.         app.register_blueprint(blueprint,url_prefix=url_prefix)

4.自动注册蓝图下的所有模型

1.在蓝图下的models.py中声明模型,例如:

  1. from application import db
  2. class User(db.Model):
  3.     __tablename__ = "mf_user"
  4.     id = db.Column(db.Integer, primary_key=True, comment="主键ID")
  5.     name = db.Column(db.String(255), unique=True, comment="账户名")
  6.     password = db.Column(db.String(255), comment="登录密码")
  7.     ip_address = db.Column(db.String(255), index=True, comment="登录IP")
  8.  
  9.     def __repr__(self):
  10.         return self.name

2.然后在终端下执行数据迁移

  1. cd ../..
  2. python manage.py db init
  3. python manage.py db migrate -m "text"

3.上面的命令执行以后, 我们可以发现模型根本被flask进行识别到.所以我们需要把模型注册到flask项目中.

application/utils/__init__.py,代码:

  1. from flask import Blueprint
  2. from importlib import import_module
  3. def path(rule,func_view):
  4.     # 把蓝图下视图和路由之间的映射关系处理成字典结构，方便后面注册蓝图的时候，直接传参
  5.     return {"rule":rule,"view_func":func_view}
  6.  
  7. def include(url_prefix, blueprint_path):
  8.     """把路由前缀和蓝图进行关系映射"""
  9.     return {"url_prefix":url_prefix,"blueprint_path":blueprint_path}
  10.  
  11. def init_blueprint(app):
  12.     """自动注册蓝图"""
  13.     blueprint_path_list = app.config.get("INSTALLED_APPS")
  14.     for blueprint_path in blueprint_path_list:
  15.         blueprint_name = blueprint_path.split(".")[-1]
  16.         # 自动创建蓝图对象
  17.         blueprint = Blueprint(blueprint_name,blueprint_path)
  18.         # 蓝图自动注册和绑定视图和子路由
  19.         url_module = import_module(blueprint_path+".urls") # 加载蓝图下的子路由文件
  20.         for url in url_module.urlpatterns: # 遍历子路由中的所有路由关系
  21.             blueprint.add_url_rule(**url)  # 注册到蓝图下
  22.  
  23.         # 读取总路由文件
  24.         url_path = app.config.get("URL_PATH")
  25.         urlpatterns = import_module(url_path).urlpatterns  # 加载蓝图下的子路由文件
  26.         url_prefix = "" # 蓝图路由前缀
  27.         for urlpattern in urlpatterns:
  28.             if urlpattern["blueprint_path"] == blueprint_name+".urls":
  29.                 url_prefix = urlpattern["url_prefix"]
  30.                 break
  31.  
  32.         # 注册模型 ***
  33.         import_module(blueprint_path+".models")
  34.  
  35.         # 注册蓝图对象到app应用对象中,  url_prefix 蓝图的路由前缀
  36.         app.register_blueprint(blueprint,url_prefix=url_prefix)

项目能自动加载总路由和蓝图路由以后的项目目录结构,如下:

  1. 项目根目录/
  2. ├── application/            # 项目主要逻辑代码保存目录
  3. |   ├── settings/           # 项目配置存储目录
  4. │   │   ├ __init__.py       # 项目默认初始化配置文件
  5. │   │   ├ dev.py            # 开发阶段的配置文件
  6. │   │   └ prod.py           # 生产阶段的配置文件
  7. │   ├── __init__.py         # 项目初始化全局引导文件
  8. |   ├── utils/              # 项目工具类库目录
  9. │   │   ├ commands.py       # 自定义命令和加载命令的相关函数
  10. │   │   ├ config.py         # 项目配置加载的辅助函数
  11. │   │   ├ session.py        # 项目存储session相关的函数
  12. │   │   └ logger.py         # 日志模块
  13. │   ├── apps/               # 保存项目中所有蓝图的存储目录
  14. │   │   ├── home            # 蓝图目录【这里是举例而已】
  15. │   │   │   ├── __init__.py # 蓝图的初始化文件
  16. │   │   │   ├── urls.py     # 蓝图的子路由文件
  17. │   │   │   ├── models.py   # 蓝图的模型文件
  18. │   │   │   └── views.py    # 蓝图的视图文件
  19. │   │   ├── __init__.py
  20. │   └── urls.py              # 总路由
  21. ├── manage.py               # 项目的终端管理脚本文件

day98:MoFang:服务端项目搭建的更多相关文章

  1. day97:MoFang:移动端APP开发准备&移动端项目搭建&APICloud前端框架

    目录 1.移动端开发相关概念 1.APP类型 2.移动端屏幕介绍 3.移动端自适配方案 4.元信息(meta) 2.APP开发准备 1.注册APPCLoud账号 2.下载APP开发编辑器 3.下载AP ...

  2. spring-oauth-server实践：客户端和服务端环境搭建

    客户端:http://localhost:8080/spring-oauth-client/index.jsp 服务端:http://localhost:8080/spring-oauth-serve ...

  3. 如何实现从Java入门到服务端项目开发的进阶?

    对于打算入门或者刚刚入门学习Java的人来说,刚开始接触这门学科,往往会觉得不知所措,也会觉得很迷茫.结合前人经验,就从入门到进阶对于Java的学习而言,应该对于学习时间.目标和内容规划有一个清晰的定 ...

  4. Vue+koa2开发一款全栈小程序(5.服务端环境搭建和项目初始化）

    1.微信公众平台小程序关联腾讯云 腾讯云的开发环境是给免费的一个后台,但是只能够用于开发,如果用于生产是需要花钱的,我们先用开发环境吧 1.用小程序开发邮箱账号登录微信公众平台 2.[设置]→[开发者 ...

  5. Redis服务端的搭建（初级）

    前方低能,仅适合入门级菜鸟阅读,大神大牛通通闪开! 前言:redis经常被用来做缓存(原因自行科普),基于学习的需要自己搭建了一个redis服务器,考虑到项目的分布式部署,所以前期开始的时候,redi ...

  6. Node服务端极速搭建 － nvmhome

    本文意在让你掌握极速搭建Node服务端(任何Project) $ whoami name: kelvin email: kelvv@outlook.com homepage: www.kelvv.co ...

  7. Node服务端极速搭建 －－ nvmhome

    > 本文意在让你掌握极速搭建Node服务端(任何Project) ```$ whoaminame: kelvinemail: kelvv@outlook.comhomepage: www.kel ...

  8. Android中直播视频技术探究之---视频直播服务端环境搭建(Nginx+RTMP)

    一.前言 前面介绍了Android中视频直播中的一个重要类ByteBuffer,不了解的同学可以 点击查看 到这里开始,我们开始动手开发了,因为我们后续肯定是需要直播视频功能,然后把视频推流到服务端, ...

  9. Netty入门一：服务端应用搭建 & 启动过程源码分析

    最近周末也没啥事就学学Netty,同时打算写一些博客记录一下(写的过程理解更加深刻了) 本文主要从三个方法来呈现:Netty核心组件简介.Netty服务端创建.Netty启动过程源码分析 如果你对Ne ...

随机推荐

  1. laravel 验证码 auth方式登录 中间件判断session是否存在

    首先下载laravel的插件 composer下载  实现验证码       composer require mews/captcha 在config/app.php进行配置 'providers' ...

  2. MONGODB01 - Prematurely reached end of stream 错误定位及修复

    最近项目在运行过程,当一段时间没有操作mongo,再次访问报错,如下 org.springframework.data.mongodb.UncategorizedMongoDbException: P ...

  3. import tensorflow 出现非法指令(核心已转储)

    使用 conda install -c conda-forge tensorflow 或者 conda install -c conda-forge tensorflow-gpu 试下.

  4. SQL SERVER级联查询及数据结构《存储过程-递归树形查询》

    --创建表,插入数据 create table tb(id varchar(3) , pid varchar(3) , name varchar(10))insert into tb values(' ...

  5. Java 将JSON反射到实体类

    通过服务间调用拿到的数据返回的格式是JSON,如果你当前这个服务有实体数据类型可以对应上,那么就可以轻松愉快的搞定. 如果数据格式对不上,例如这个JSON里面有些数据是我们不想要的,这样我们实体的数据 ...

  6. 【KataDaily 191015】Sort the Gift Code

    题目: Happy Holidays fellow Code Warriors! Santa's senior gift organizer Elf developed a way to repres ...

  7. 白话科普系列——最好用的浏览器 Chrome，你用了么？

    市面上的浏览器多种多样,而浏览器的王者--IE 浏览器,它在 2002 年市场份额高达 95.4%.直到后续 Firefox,Safari,Chrome 相继问世才动摇了 IE 浏览器的地位,其中 C ...

  8. layui表单提交

    关于layui表单提交  只是简单用一个文本框记录一下提交过程    其他的如下拉框选择框样式可以参考官网 下面直接开始.首 一:前台页面 <!DOCTYPE html><html& ...

  9. MyBatis源码解析

    在讲解MyBatis之前,先说下传统JDBC连接数据库的弊端: 1.JDBC底层没有实现连接池,从而导致操作数据库需要频繁的创建和释放,影响性能: 2.JDBC的代码散落在Java代码中,如果需要修改 ...

  10. Module Federation原理剖析

    [转自团队掘金原文: https://juejin.im/post/6895324456668495880] 为什么需要学习webpack5 module Federation原理呢?因为EMP微前端 ...