1 创建模型类

1.1 创建等级典表orm 实体类

common/models/level.py

from . import db

class Level(db.Model):        # 创建的模型类继承了db.Model 模型类与数据库就绑定了
    """
    等级典表
    """
    __tablename__ = 'level_scale'
    level_id=db.Column(db.Integer,primary_key=True,doc='主键ID');
    level_name = db.Column(db.String, doc='等级名称')
    system_id=db.Column(db.Integer,default='01', doc='系统ID')

1.2. 创建超限告警明细表实体类

common/models/overlimit.py

from . import db
from datetime import datetime

class Overlimit(db.Model):
    """
    超限告警明细表
    """
    __tablename__='overlimit_alarm_details'
    class STATUS:
        health=101
        mild=111
        moderate=121
        severe=131

    id=db.Column('overlimit_alarm_id',db.Integer,primary_key=True, doc='主键ID')
    system_id=db.Column(db.Integer,doc='系统ID')
    system_name=db.Column(db.String,doc='系统名称')
    object_id=db.Column(db.Integer,doc='对象ID')
    object_name=db.Column(db.String,doc='对象名称')
    measuring_point_id=db.Column(db.Integer,doc='测点ID')
    measuring_point_name=db.Column(db.String,doc='测点名称')
    value_type=db.Column(db.String,doc='数值类型')
    level_id=db.Column(db.Integer,default='111', doc='等级ID')
    level_name=db.Column(db.String,default='轻度',doc='等级名称')
    overlimit_code = db.Column(db.Integer, default='0100010000', doc='超限编码')
    overlimit_name = db.Column(db.String, default='轻度', doc='等级名称')
    min_value=db.Column(db.String,doc='最小值')
    max_value = db.Column(db.String, doc='最大值')
    average_value = db.Column(db.String, doc='平均值')
    value = db.Column(db.String, doc='当前值')
    indicator_value = db.Column(db.String, doc='指标值')
    alarm_time= db.Column(db.DateTime, default=datetime.now,doc='告警时间')
    trigger_number = db.Column(db.String, doc='触发次数')
    create_time= db.Column(db.DateTime, default=datetime.now,doc='记录创建时间')

2 创建缓存工具类

2.1 app实体类中添加redis的配置 ：monitor/__init__.py

    #4 redis 配置
    # redis 哨兵的配置，用于存储数据
    from redis.sentinel import Sentinel
    _sentinel = Sentinel(app.config['REDIS_SENTINELS'])
    app.redis_master = _sentinel.master_for(app.config['REDIS_SENTINEL_SERVICE_NAME'])
    app.redis_slave = _sentinel.slave_for(app.config['REDIS_SENTINEL_SERVICE_NAME'])
    # redis 集群的配置，用于存储缓存数据
    from rediscluster import StrictRedisCluster
    app.redis_cluster = StrictRedisCluster(startup_nodes=app.config['REDIS_CLUSTER'])

2.2 创建查询健康状态等级的缓存工具类

from flask import current_app
import json
from models.level import Level
from redis.exceptions import RedisError, ConnectionError
from sqlalchemy.exc import SQLAlchemyError, DatabaseError
from flask import jsonify

class SafetyMonitor(object):
    """
    安全监测  等级缓存工具类
    """
    key="safetymonitor:level"

    @classmethod
    def save(cls):
        """
        查询数据库
        保存缓存记录
        :return:
        """
        r = current_app.redis_cluster
        # db=current_app.db
        try:
            status = Level.query.all()
            # status=db.session.query(Status).all()
        except DatabaseError as e:
            current_app.logger.error(e)
            # 对于这个数据库异常，我们自己封装的get方法无法为调用者做决定，决定返回什么值，所以抛出异常给调用者，由调用者决定
            raise e

        if status is None:
            # 数据库不存在
            # redis将该key缓存设置为-1
            try:
                r.setex(cls.key, 2 * 60 * 60, -1)
            except RedisError as e:
                current_app.logger.error(e)
            return None
        else:
            # 数据库存在 [<Status 101>, <Status 111>, <Status 121>, <Status 131>]
            status_list = []
            for i in range(len(status)):
                status_dict = {
                    "id": status[i].level_id,
                    "name": status[i].level_name
                }
                status_list.append(status_dict)
            status_dict = {
                "status_level_list": status_list
            }
            # 设置缓存
            # try:
            #     r.setex(self.key, constants.UserProfileCacheTTL.get_val(), json.dumps(user_dict))
            # except RedisError as e:
            #     current_app.logger.error(e)
            # r.setex(self.key, 2 * 60 * 60, json.dump(status_dict))
            return jsonify(status_dict)
    @classmethod
    def get(cls):
        """
        获取缓存数据
        :return:
        """
        # 先查询redis缓存记录
        # 如果有记录直接返回
        # 如果没有记录 查询数据库
        #   数据库中如果有记录 设置redis记录 返回json string
        #   数据库中如果没有记录 设置redis保存不存在的记录 -1
        r = current_app.redis_cluster
        try:
            ret = r.get(cls.key)
        except RedisError as e:
            # 记录日志
            current_app.logger.error(e)
            # 在redis出现异常的时候，为了保证我们封装的get方法还能有返回值，可以进入数据库查询的部分
            ret = None

        if ret is not None:
            # 表示redis中有数据
            # 判断数据是表示不存在的-1值 还是有意义的缓存数据
            if ret == b'-1':
                return None
            else:
                status_dict = json.load(ret)
                return status_dict
        else:
            # 表示redis中没有数据
            # 从mysql数据库中查询数据
            return cls.save()

3. 定义蓝图&API类对象

3.1 创建 monitor/resources/monitorlevel文件夹

编辑 monitor/resources/monitorlevel/__init__.py

（1）创建level_bp蓝图；（2）创建API类对象，绑定蓝图对象；（3）API类对象收集类视图的注册信息

from flask import Blueprint
from flask_restful import Api
from . import level

level_bp=Blueprint('level',__name__)
level_api=Api(level_bp,catch_all_404s=True)
level_api.add_resource(level.MonitorLevel,'/v0_1/level',endpoint='StatusLevel')

3.2 将蓝图对象注册到全局的Flask应用。

    # 注册蓝图
    # 5.1 注册监测等级蓝图
    from .resources.monitorlevel import level_bp
    app.register_blueprint(level_bp)
    return app

4 测试

{
    "status_level_list": [
        {
            "id": 101,
            "name": "健康"
        },
        {
            "id": 111,
            "name": "轻度"
        },
        {
            "id": 121,
            "name": "中度"
        },
        {
            "id": 131,
            "name": "重度"
        }
    ]
}