百变星君---用户模块

古城微笑少年丶 2022-12-19 14:30 146阅读 0赞

### 目录 ###

*   *  一：获取验证码：
     *  二：注册登录：
     *  三：获取用户信息：
     *  四：Tocken刷新机制：
     *  五：修改用户头像：
     *   *  5.1： 七牛云头像测试：
         *  5.2：项目中封装七牛云：
         *  5.3：检验图片类型和封装：
         *  5.4：修改用户头像视图：
         *  5.5：YApi接口管理平台：
     *  六：查看前端交互：
     *   *  6.1：前端文件部署到服务器：
         *  6.2：解决前后端跨域问题:

## 一：获取验证码： ##

1：自定义转换器,然后注册转换器：  
`cmmon/utils/converters.py`

from werkzeug.routing import BaseConverter
    
    
    # 1：自定义转换器继承于BaseConverter
    class MobileConverter(BaseConverter):
        """
        手机号格式
        """
        # 2：重写regex
        regex = r'1[3-9]\d{9}'

`app/__init__.py`中的def register\_extensions中。

# 注册自定义转换器
        from utils.converters import MobileConverter
        app.url_map.converters['mob'] = MobileConverter

2：在视图中使用转换器：  
`app/resources/user/passport.py`

from flask import jsonify
    from flask_restful import Resource
    import random
    from app import redis_cli
    from utils.contants import SMS_CODE_EXPIRE
    
    class SMSCodeResource(Resource):
        """
        发送短信验证码的视图
        """
        def get(self, mobile):
            # 1：获取手机号码
            # 2：生成6位的短信验证码
            sms_code = "%06d" % (random.randint(0, 999999))
            sms_code = 123456
            # 3：将短信验证码存储到redis数据库
            key = "app:code:{}".format(mobile)
            redis_cli.setex(key, SMS_CODE_EXPIRE, sms_code)
            # 4: 调用第三方发送短信验证码
            print("发送短信验证码成功了：手机号码：{} 短信验证码{}".format(mobile,sms_code ))
    
            return {
        "mobile": mobile, "sms_code": sms_code}

3:测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]

## 二：注册登录： ##

1： 配置路由信息：  
`user/__init__.py`

user_api.add_resource(LoginRegisterResource, '/authorizations')

2：创建User用户的模型类以及关系表：  
`common/models/user.py`

from app import db
    from datetime import datetime
    
    
    class User(db.Model):
        """
        用户基本信息
        """
        __tablename__ = 'user_basic'
    
        id = db.Column(db.Integer, primary_key=True, doc='用户ID')
        mobile = db.Column(db.String(11), doc='手机号')
        name = db.Column(db.String(20), doc='昵称')
        last_login = db.Column(db.DateTime, doc='最后登录时间')
        introduction = db.Column(db.String(50), doc='简介')
        article_count = db.Column(db.Integer, default=0, doc='作品数')
        following_count = db.Column(db.Integer, default=0, doc='关注的人数')
        fans_count = db.Column(db.Integer, default=0, doc='粉丝数')
        profile_photo = db.Column(db.String(130), doc='头像')
    
        def to_dict(self):
            """模型转字典, 用于序列化处理"""
    
            return {
        
                'id': self.id,
                'name': self.name,
                'photo': self.profile_photo,
                # 注意：redis不支持None类型 但是支持空字符串
                'intro': self.introduction if self.introduction else "",
                'art_count': self.article_count,
                'follow_count': self.following_count,
                'fans_count': self.fans_count
            }
    
    
    class Relation(db.Model):
        """
        用户关系表
        """
        __tablename__ = 'user_relation'
    
        class RELATION:
            # 取消关注
            DELETE = 0
            # 关注
            FOLLOW = 1
            # 拉黑
            BLACKLIST = 2
    
        id = db.Column(db.Integer, primary_key=True, doc='主键ID')
        user_id = db.Column(db.Integer, doc='用户ID')  # 粉丝id
        author_id = db.Column(db.Integer, doc='目标用户ID')  # 作者id
        relation = db.Column(db.Integer, doc='关系')
        update_time = db.Column(db.DateTime, default=datetime.now, doc='更新时间')

`app/__init__.py`

from flask_migrate import Migrate
    def register_extensions(app:Flask):
    	...
        # 4: 执行数据库迁移
        Migrate(app, db)
        # 注意这里需要导包
       	from models.user import User

执行迁移命令：

> 1: 迁移命令  
> export FLASK\_APP = app.main  
> SET FLASK\_APP = app.main（windows）  
> 2: 迁移初始化  
> flask db init  
> 3: 生成迁移版本  
> flask db migrate  
> 4：升级迁移版本  
> flask db upgrade

恢复数据库数据：  
1：将sql文件移动到utils包下。  
2：远程登录后执行命令：  
![在这里插入图片描述][20201108201945343.png_pic_center]  
3：在utils中创建jwt\_utils.py：

import jwt
    from flask import current_app
    
    
    def generate_jwt(payload, expiry, secret=None):
        """
        生成jwt
        :param payload: dict 载荷
        :param expiry: datetime 有效期
        :param secret: 密钥
        :return: jwt
        """
        _payload = {
        'exp': expiry}
        _payload.update(payload)
    
        if not secret:
            secret = current_app.config['JWT_SECRET']
    
        token = jwt.encode(_payload, secret, algorithm='HS256')
        return token.decode()
    
    
    def verify_jwt(token, secret=None):
        """
        检验jwt
        :param token: jwt
        :param secret: 密钥
        :return: dict: payload
        """
        if not secret:
            secret = current_app.config['JWT_SECRET']
    
        try:
            payload = jwt.decode(token, secret, algorithm=['HS256'])
        except jwt.PyJWTError:
            payload = None
    
        return payload

4：在app/settings/config.py中增加JWT的配置信息：

class BaseConfig(object):
       ...
        # JWT配置信息
        # JWT密钥
        JWT_SECRET = "adadwAdmldadnawasdadwddnodam"
        # 2小时的tocken过期时间
        LOGIN_TOCKEN_EXPIRE = 2
        # 14天的刷新tockend的过期时间
        REFRESH_TOCKEN_EXPIRE = 14

5:构造生成两个tocken的函数：

class LoginRegisterResource(Resource):
    
        def _generator_tocken(self, user_id):
            """
            内部生成tocken的方法
            :param user_id:当前用户登录的
            :return:
            """
            login_payload = {
        
                "user_id": user_id,
                "is_refresh": False
            }
            expire_2h = datetime.datetime.utcnow() + datetime.timedelta(hours=current_app.config["LOGIN_TOCKEN_EXPIRE"])
            jwt_secret = current_app.config['JWT_SECRET']
            login_tocken = generate_jwt(payload=login_payload, expiry=expire_2h, secret=jwt_secret)
    
            refresh_payload = {
        
                "user_id": user_id,
                "is_refresh": True
            }
            expire_14d = datetime.datetime.utcnow() + datetime.timedelta(days=current_app.config["LOGIN_TOCKEN_EXPIRE"])
    
            refresh_tocken = generate_jwt(payload=refresh_payload, expiry=expire_14d, secret=jwt_secret)
    
            return login_tocken, refresh_tocken

6：登录注册逻辑：

> 登录注册接口的逻辑：  
> 1：获取参数  
> 1.1: mobile手机号  
> 1.2：code 用户填写的短信验证码  
> 2：检验参数—RequestParser  
> 3：逻辑处理  
> 3.1：根据手机号在reis数据库中查询出真正的验证码  
> 3.2：删除redis数据库中的验证码  
> 3.3：判断用户发的短信验证码是否为空，以及是否和redis中查到的一致。  
> 3.4：根据手机号在数据库中查询User是否存在  
> 3.5：用户存在–登录  
> 3.6：用户不存在—注册  
> 3.7：生成登录tocken和刷新tocken  
> 4: 构建响应返回  
> \# 返回登录tocken和刷新tocken.

class LoginRegisterResource(Resource):
    
        def _generator_tocken(self, user_id):
     	...
        def post(self):
            # 校验参数
            parser = RequestParser()
            parser.add_argument("mobile", required=True, location="json", type=regex(r'^1[3-9]\d{9}$'))
            parser.add_argument("code", required=True, location="json", type=regex(r'^\d{6}$'))
            ret = parser.parse_args()
            # 获取检验后的手机号和短信验证码
            mobile = ret['mobile']
            code = ret['code']
            # 根据手机号查询redis数据库的真实短信验证码
            key = "app:code:{}".format(mobile)
            real_code = redis_cli.get(key)
            # 删除redis中的短信验证码
            redis_cli.delete(key)
    
            # 判断短信验证码是否为空
            # 注意在创建redis数据的时候指定响应解码
            if real_code is None or code != real_code:
                return {
        "message": "invalid sms code"}, 400
            # 获取用户对象
            user = User.query.options(load_only(User.id)).filter(User.mobile == mobile).first()
            # 如果用户不存在，新建用户
            if user is None:
                user = User(mobile= mobile, name=mobile, last_login=datetime.datetime.now())
                db.session.add(user)
    
            else:
                # 如果用户存在，修改用户的登录时间
                user.last_login = datetime.datetime.now()
                db.session.add(user)
    
            # 尝试提交，不行就回滚。
            try:
                db.session.commit()
            except Exception as e:
                db.session.rollback()
                return {
        "messgae": e}, 507
    
            login_tocken, refresh_tocken = self._generator_tocken(user.id)
            return {
        
                "login_tocken": login_tocken,
                "refresh_tocken": refresh_tocken
            }

7: 测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]

## 三：获取用户信息： ##

1：`utils/middleware`中创建获取用户信息的装饰器，然后主动装饰。

from flask import request, current_app, g
    from utils.jwt_util import verify_jwt
    
    # 获取用户信息的接口
    def get_userinfo():
    
        # 1：获取请求头中的tocken信息
        # 规定前端通过Authorialization字段携带tocken
        tocken = request.headers.get("Authorization")
    
        # 2:进行tocken检验,载荷又可能为空
        # tocken错误，或者过期
        key = current_app.config["JWT_SECRET"]
        payload = verify_jwt(tocken, key)
        if payload:
            # 从载荷中提取用户信息
            g.user_id = payload.get("user_id")
            g.is_refresh = payload.get("is_refresh", False)
        else:
            g.user_id = None
            g.is_refresh = None

2：在`app/__init__.py`中对装饰器进行主动装饰：

def register_extensions(app:Flask):
    	...
        # 5：添加请求钩子
        from utils.middleware import get_userinfo
        app.before_request(get_userinfo)

3：创建强制用户登陆的装饰器：  
`utils/decoratores.py`

from flask import g
    
    # 强制用户登录
    def login_required(view_func):
        def wrapper(*args, **kwargs):
    
            user_id = g.user_id
            is_refresh = g.is_refresh
            if user_id is None:
                return {
        "message": "invalid tocken"}, 401
            elif user_id is not None and is_refresh:
                return {
        "message": "refresh tocken not for login"}, 403
            else:
                return view_func(*args, **kwargs)
        return wrapper

4：中文编码问题：  
`app/settings/config.py`

# 配置父类
    class BaseConfig(object):
    	...
        # 中文编码问题：
        LOGIN_AS_ASCII = False
        RESTFUL_JSON = {
        "ensure_ascii": False}

5：获取用户信息视图：  
`app/resource/user/passport.py`

# 获取当前登录用户信息
    class CurrentUserResource(Resource):
    
        method_decorators = {
        
            "get": [login_required]
        }
        def get(self):
            # 1:获取参数
            user_id = g.user_id
    
            # 2;根据user_id查询用户信息
            user = User.query.options(load_only(User.id,
                                                User.name,
                                                User.profile_photo,
                                                User.introduction,
                                                User.article_count,
                                                User.following_count,
                                                User.fans_count)).filter(User.id == user_id).first()
            
            # 3: 将用户对象转换成字典返回
            user_dict = user.to_dict()
            return user_dict

6：添加路由：  
`app/resource/user/__init__.py`

user_api.add_resource(CurrentUserResource, '/user')

7：进行测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]

## 四：Tocken刷新机制： ##

1:`app/resources/user/passport.py`

class LoginRegisterResource(Resource):
    
        def _generator_tocken(self, user_id):
    	...
        def post(self):
    	...
        def put(self):
            # 1: 获取user_id
            user_id = g.user_id
            # 2: 获取刷新tocken标志位
            is_refresh = g.is_refresh
            # 3判断是不是刷新tocken
            if user_id and is_refresh:
                login_tocken, is_refresh_tocken = self._generator_tocken(user_id)
                return {
        "new_tocken": login_tocken, "new_login_tocken": is_refresh_tocken}
            else:
                return {
        "message": "wrong refresh tocken"}, 403

2： 测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]

## 五：修改用户头像： ##

### 5.1： 七牛云头像测试： ###

1: 七牛云测试案例：

from qiniu import Auth, put_file, etag, put_data
    import qiniu.config
    
    def upload_pic(data):
        #  1：需要填写你的 Access Key 和 Secret Key
        access_key = 'LSo9n249hhQP9VQPHtJkNpC-2l6zAAJUgYm0q69J'
        secret_key = 'lnm0ebW2Qp3CLZberagsKPfBY2p_aDo_IV-_LP-J'
    
        #  2：构建鉴权对象
        q = Auth(access_key, secret_key)
        # 3：要上传的空间
        bucket_name = 'sztopnews'
    
        #上传后保存的文件名,图片名称为空，根据图片数据，通过哈希生成唯一的图片名称
        key = None
    
        # 4：生成上传 Token，可以指定过期时间等
        # 坑centos可能时间过期，要刷新centos的时间
        token = q.upload_token(bucket_name, key, 360000000)
    
        # 5：上传二进制文件数据
        ret, info = put_data(token, key, data)
    
        # 6: 判断是否上传成功
    
        # if info.status_code == 200:
        #     return ret['key']
        # else:
        #     # 抛出异常
        #     raise info.exception
    
        print(ret)
        print("**"*10)
        print(info)
    
    if __name__ == '__main__':
    
        with open("./1.png", 'rb') as f:
            upload_pic(f.read())

2： 测试运行结果：  
![在这里插入图片描述][20201109095146962.png_pic_center]

### 5.2：项目中封装七牛云： ###

1：在`app/settings/config.py`中增加七牛云的配置信息：

# 配置父类
    class BaseConfig(object):
      	...
        # 七牛云的配置信息
        QINIU_ACCESS_KEY =  'LSo9n249hhQP9VQPHtJkNpC-2l6zAAJUgYm0q69J'
        QINIU_SECRET_KEY =  'lnm0ebW2Qp3CLZberagsKPfBY2p_aDo_IV-_LP-J'
        QINIU_BUCKET_NAME = 'sztopnews'
        QINIU_DOMAIN = 'http://qji837cfs.hn-bkt.clouddn.com/'

2：在工具包中创建image\_storage.py:

from qiniu import Auth, put_file, etag, put_data
    from flask import current_app
    import qiniu.config
    
    def upload_pic(data):
        #  1：需要填写你的 Access Key 和 Secret Key
        access_key = current_app.config['QINIU_ACCESS_KEY']
        secret_key = current_app.config['QINIU_SECRET_KEY']
    
        #  2：构建鉴权对象
        q = Auth(access_key, secret_key)
        # 3：要上传的空间
        bucket_name = current_app.config['QINIU_BUCKET_NAME']
    
        #上传后保存的文件名,图片名称为空，根据图片数据，通过哈希生成唯一的图片名称
        key = None
    
        # 4：生成上传 Token，可以指定过期时间等
        # 坑centos可能时间过期，要刷新centos的时间
        token = q.upload_token(bucket_name, key, 360000000)
    
        # 5：上传二进制文件数据
        ret, info = put_data(token, key, data)
    
        # 6: 判断是否上传成功
    
        if info.status_code == 200:
            return ret['key']
        else:
            # 抛出异常
            raise BaseException(info.exception)

### 5.3：检验图片类型和封装： ###

1： 先在测试文件中测试：两种方案一种传入对象，一种传入图片数据。

import imghdr
    with open("./1.png", "rb") as f:
        # 方案一
        # 查看文件的类型
        type = imghdr.what(f)
        print(type)
        # 方案二：
        type2 = imghdr.what(None, f.read())
        print(type2)

2：将检验图片类型的函数封装到工具类中：

def img_type(value):
        """
        检验是否是图片类型
        :param value:
        :return:
        """
        try:
            type = imghdr.what(value)
        except Exception as e:
            raise ValueError(e)
        if type:
            return value
        else:
            raise ValueError("invalid image type")

### 5.4：修改用户头像视图： ###

1:`app/user/profile/py`中创建视图：

from flask_restful import Resource
    from flask import g
    
    from app import db
    from models.user import User
    from utils.decoratores import login_required
    from flask_restful.reqparse import RequestParser
    from flask import current_app
    from utils.img_storage import upload_pic
    from utils.parser import img_type
    
    class UserPhotoResource(Resource):
        """
        修改用户头像的视图
        """
        method_decorators = {
        
            "patch": [login_required]
        }
    
        def patch(self):
            # 1: 获取参数
            user_id = g.user_id
            # 2: 检验参数
            parser = RequestParser()
            parser.add_argument("photo", required=True, location="files", type=img_type)
            ret = parser.parse_args()
            # 3:获取检验后的图片对象
            photo_file = ret['photo']
    
            # 4:将图片转换成二进制数据
            photo_bytes = photo_file.read()
    
            # 5:调用工具类上传到七牛云
            try:
                img_name = upload_pic(photo_bytes)
            except Exception as e:
                return {
        "message": "Third Error : {}".format(e)}, 500
            # TODO :存储图片名称还是存储完整的URL路径呢？
            # 存储图片名称好，方便以后修改域名
    
            # 6：拼接完整的图片url地址
            full_url = current_app.config["QINIU_DOMAIN"] + img_name
    
            # 7: 查询用户，更新用户头像
            User.query.filter(User.id == user_id).update({
        "profile_photo": full_url})
            try:
                db.session.commit()
            except Exception as e:
                return {
        "message": e}, 507
    
            return {
        "photo_url": full_url}

2：增加路由`user/__init__.py`

user_api.add_resource(UserPhotoResource, '/user/photo')

3:测试：数据库和响应都存在了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]

### 5.5：YApi接口管理平台： ###

1：YApi的体验区：

> https://yapi.baidu.com

2：YApi的官方文档：

> hellosean1025.github.io/yapi

## 六：查看前端交互： ##

### 6.1：前端文件部署到服务器： ###

1： 在本地解压前端包：  
2：将文件上传到服务器：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]  
3：进入虚拟环境，然后启动前端文件：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 7]

### 6.2：解决前后端跨域问题: ###

1：安装flask\_cors:

> pip install flask-cors

2:解决跨域：  
`app/__init__.py`

from flask_cors import CORS
    def register_extensions(app:Flask):
    	...
        # 6:添加跨域请求
        # app：允许跨域的app对象，
        # supports_credentials= True,支持跨域的时候携带的cookie和session,tocken认证
        # methods = [], 允许跨域的请求方式。默认全部允许。
        CORS(app, supports_credentials=True)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/856e8b78c78f4179992b841563ad92b0.png
[20201108201945343.png_pic_center]: /images/20221120/23471c5728864c99b653d18a5b123b3e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201108213030492.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201109084715476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201109090127286.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[20201109095146962.png_pic_center]: https://img-blog.csdnimg.cn/20201109095146962.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201109110654192.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201109110810113.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201109113722842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201109114035784.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center