百变星君---头条模块

浅浅的花香味﹌ 2022-12-20 01:52 192阅读 0赞

### 这里写目录标题 ###

*   *  一：获取用户频道：
     *   *  1.1: 数据的准备：
         *  1.2：接口分析：
         *  1.3：接口代码：
         *  1.4：路由信息与测试：
     *  二：获取所有频道：
     *   *  2.1：文章模块初始化：
         *  2.2：获取所有频道接口：
     *  三：修改用户频道：
     *   *  3.1：业务逻辑分析：
         *  3.2：视图实现：
     *  四：首页文章列表：
     *   *  4.1：接口分析：
         *  4.2：时间戳问题：
         *  4.3：数据恢复：
         *  4.4：接口逻辑和实现：

## 一：获取用户频道： ##

### 1.1: 数据的准备： ###

1： 创建有关用户频道的模型类：  
`common/models/article.py`

from datetime import datetime
    from sqlalchemy.dialects.mysql import DATETIME
    from app import db
    
    
    class Channel(db.Model):
        """
        新闻频道
        """
        __tablename__ = 'news_channel'
    
        id = db.Column(db.Integer, primary_key=True, doc='频道ID')
        name = db.Column(db.String(30), doc='频道名称')
        is_default = db.Column(db.Boolean, default=False, doc='是否默认')
    
        def to_dict(self):
            return {
        
                'id': self.id,
                'name': self.name
            }
    
    
    class UserChannel(db.Model):
        """
        用户关注频道表
        """
        __tablename__ = 'news_user_channel'
    
        id = db.Column(db.Integer, primary_key=True, doc='主键ID')
        user_id = db.Column(db.Integer, doc='用户ID')
        channel_id = db.Column(db.Integer, doc='频道ID')
        sequence = db.Column(db.Integer, default=0, doc='序号')
        is_deleted = db.Column(db.Boolean, default=False, doc='是否删除')
    
    
    class Article(db.Model):
        """
        文章基本信息表
        """
        __tablename__ = 'news_article_basic'
    
        class STATUS:
            DRAFT = 0  # 草稿
            UNREVIEWED = 1  # 待审核
            APPROVED = 2  # 审核通过
            FAILED = 3  # 审核失败
            DELETED = 4  # 已删除
            BANNED = 5  # 封禁
    
        id = db.Column(db.Integer, primary_key=True, doc='文章ID')
        user_id = db.Column(db.Integer, doc='用户ID')
        channel_id = db.Column(db.Integer, doc='频道ID')
        title = db.Column(db.String(130), doc='标题')
        cover = db.Column(db.JSON, doc='封面')
        ctime = db.Column(DATETIME(fsp=3), default=datetime.now, doc='创建时间')
        status = db.Column(db.Integer, default=0, doc='帖文状态')
        # 注意：发布评论成功，需要将评论数量自增
        comment_count = db.Column(db.Integer, default=0, doc='评论数')
    
    
    class ArticleContent(db.Model):
        """
        文章内容表
        """
        __tablename__ = 'news_article_content'
    
        article_id = db.Column(db.Integer, primary_key=True, doc='文章ID')
        content = db.Column(db.Text, doc='帖文内容')
    
    
    class Attitude(db.Model):
        """
        文章态度表
        """
        __tablename__ = 'news_attitude'
    
        class ATTITUDE:
            DISLIKE = 0  # 不喜欢
            LIKING = 1  # 喜欢
            DELETE = -1  # 无态度
    
        id = db.Column(db.Integer, primary_key=True, doc='主键ID')
        user_id = db.Column(db.Integer, doc='用户ID')
        article_id = db.Column(db.Integer, doc='文章ID')
        attitude = db.Column(db.Integer, doc='态度')
    
    
    class Collection(db.Model):
        """
        用户收藏表
        """
        __tablename__ = 'news_collection'
    
        id = db.Column(db.Integer, primary_key=True, doc='主键ID')
        user_id = db.Column(db.Integer, doc='用户ID')
        article_id = db.Column(db.Integer, doc='文章ID')
        is_deleted = db.Column(db.Boolean, default=False, doc='是否删除')
    
    
    class Comment(db.Model):
        """
        文章评论
        """
        __tablename__ = 'news_comment'
    
        id = db.Column(db.Integer, primary_key=True, doc='评论ID')
        user_id = db.Column(db.Integer, doc='用户ID')
        article_id = db.Column(db.Integer, doc='文章ID')
        parent_id = db.Column(db.Integer, doc='被评论的评论id')
        reply_count = db.Column(db.Integer, default=0, doc='回复数')
        ctime = db.Column(db.DateTime, default=datetime.now, doc='创建时间')
        like_count = db.Column(db.Integer, default=0, doc='点赞数')
        content = db.Column(db.String(200), doc='评论内容')

2：在执行迁移前，导入包，让项目能够发现模型类。  
`app/__init__.py`

def register_extensions(app:Flask):
    	...
        # 4: 执行数据库迁移
        Migrate(app, db)
        from models import user, article

3:执行迁移建表：

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]  
4：恢复数据：

> 1：将sql文件导入utils中。  
> 2：登录远程执行命令：mysql -uroot -pmysql -D hm\_topnews < sql文件名  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]

### 1.2：接口分析： ###

*  业务逻辑：有两个频道，一个用户频道，一个推荐频道，两个频道加在一起是所有频道。
 *  需求：用户发送请求后返回用户选择的频道。
 *  关键点：怎样根据用户id查到用户的频道名？\[三张表, 如何利用中间表查询另外一张表的信息\]

> 答： 将UserChannel和Channel表联合，然后根据User\_id过滤。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 2]

### 1.3：接口代码： ###

`user/channel.py`

from flask_restful import Resource
    from flask import g
    from sqlalchemy.orm import load_only
    from app import db
    from models.article import Channel, UserChannel
    
    
    class UserChannelResource(Resource):
        """查询用户频道类视图"""
        def get(self):
            # 1: 获取参数
            user_id = g.user_id
            is_refresh = g.is_refresh
            # 2: 参数校验
            # 3: 逻辑处理
            # 如果是用户正常登录
            if user_id and is_refresh is False:
                # join表示将Channel表和UserChannel表联合，联合的条件是Channel表的id等于UserChannel表的channel_id
                # 过滤条件是UserChannel中的user_id等于现在代码中的user_id，并且用户频道表没有被逻辑删除。
                channel_list = Channel.query.options(load_only(Channel.id, Channel.name))\
                    .join(UserChannel, Channel.id == UserChannel.channel_id)\
                    .filter(UserChannel.user_id == user_id, UserChannel.is_deleted == False).all()
                # 如果用户没有任何选择频道
                if len(channel_list) == 0:
                    # 查询频道表中，默认的频道
                    channel_list = Channel.query.options(load_only(Channel.id, Channel.name)) \
                        .filter(Channel.is_default == True).all()
            # 如果用户没有登录
            else:
                # 也显示默认的频道
                channel_list = Channel.query.options(load_only(Channel.id, Channel.name))\
                    .filter(Channel.is_default == True).all()
    
            # 将查询到的频道列表对象，转换成频道列表
            channel_list_dict = [channel.to_dict() for channel in channel_list]
            # 在频道列表头部增加推荐频道。
            channel_list_dict.insert(0, {
        "id": "0", "name": "推荐"})
    
            return {
        "channels": channel_list_dict}

### 1.4：路由信息与测试： ###

路由信息：  
`user/__init__.py`

user_api.add_resource(UserChannelResource, '/user/channels')

测试—用户未登录：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 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]

![在这里插入图片描述][20201109152619194.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]

## 二：获取所有频道： ##

### 2.1：文章模块初始化： ###

1：创建文章模块的视图：  
`app/resourrce/article/channel.py`

from flask_restful import Resource
    
    class AllChannelResource(Resource):
        def get(self):
            pass

2：在常量文件中增加配置Article文章的前缀：  
`TopNews\common\utils\contants.py`

ARTICLE_URL_PREFIX = "/article"

2：在init文件中构造蓝图对象和响应格式：  
`app/resourrce/article/__init__.py`

from flask import Blueprint
    from flask_restful import Api
    from utils.contants import ARTICLE_URL_PREFIX
    from utils.output import output_json
    
    
    # 1: 创建文章模块的蓝图对象
    article_bp = Blueprint("article", __name__, url_prefix=ARTICLE_URL_PREFIX)
    
    # 2：将蓝图对象包装成APi对象
    article_api = Api(article_bp)
    
    # 3: 给蓝图添加路由信息
    from app.resources.article.channel import AllChannelResource
    article_api.add_resource(AllChannelResource, "/channels")
    
    
    # 4：注册蓝图对象---app下的init文件注册
    
    # 5：自定义返回json数据格式：
    article_api.representation(mediatype="application/json")(output_json)

3：注册蓝图：  
`app/__init__.py`

def register_Blueprint(app:Flask):
        # 1:注册用户模块的蓝图
        # 注意避免循环导包
        from app.resources.user import user_bp
        app.register_blueprint(user_bp)
    
        from app.resources.article import article_bp
        app.register_blueprint(article_bp)

### 2.2：获取所有频道接口： ###

`TopNews\app\resources\article\channel.py`

from flask_restful import Resource
    from sqlalchemy.orm import load_only
    
    from models.article import Channel
    
    
    class AllChannelResource(Resource):
        """
        获取所有频道接口
        """
        def get(self):
            # 1: 查询出所有的频道信息
            channels = Channel.query.options(load_only(Channel.id, Channel.name)).all()
            # 2：将所有的频道信息转换成字典列表
            channel_dict_list = [channel.to_dict() for channel in channels]
    
            return {
        "channels": channel_dict_list}

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

## 三：修改用户频道： ##

### 3.1：业务逻辑分析： ###

> 分析：前端会传递给我用户最新的频道id和频道排序。又可能用户删除原来的频道，也有可能用户修改了排序的位置，还有可能用户新增一个频道。  
> 操作：我们可以先将这个用户所选择的频道全部逻辑删除， 然后根据频道id,查询频道是否存在，如果存在将逻辑删除改成未删除，然后修改排序的位置。如果前端传过来的用户频道不存在，则新增频道添加到数据库。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 8]

### 3.2：视图实现： ###

class UserChannelResource(Resource):
        """查询用户频道类视图"""
        method_decorators = {
        
            "put": [login_required]
        }
    
        def put(self):
            # 1: 获取参数
            user_id = g.user_id
            channels = request.json.get("channels")
            # 2:将用户频道表中的该用户逻辑删除为False的全部改成True,即该用户选择的频道全部删除。
            UserChannel.query.filter(UserChannel.user_id == user_id, UserChannel.is_deleted == False).update({
        "is_deleted": True})
            # 3:遍历用户传递频道列表，拿到频道的id
            for channel_dict in channels:
                # 根据前端传递新的频道id,在频道表中查询，如果查询到就是用户以前选过的频道，如果查询不到就是用户新增的频道，得到一个None。
                user_channel = UserChannel.query.options(load_only(UserChannel.id))\
                    .filter(UserChannel.channel_id == channel_dict['id'],
                            UserChannel.user_id == user_id).first()
    
                # 如果不为空，也就是用户以前选过这个频道，更改这个频道的排序。
                if user_channel:
                    user_channel.is_deleted = False
                    user_channel.sequence = channel_dict['seq']
    
                # 如果为空，表示用户以前没有选过这个频道，新增这个频道到频道表。
                else:
                    user_channel = UserChannel(user_id= user_id, channel_id=channel_dict['id'], sequence=channel_dict['seq'])
    
                    db.session.add(user_channel)
            try:
                db.session.commit()
            except Exception as e:
                db.session.rollback()
                return {
        "message": e}, 507
            return {
        "channels": channels, "message": "修改用户成功"}

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

## 四：首页文章列表： ##

### 4.1：接口分析： ###

> 上拉加载与下拉刷新怎么实现的呢？

> 下拉刷新时，假设现在是9：10分，数据分页每页3条数据，前端将当前时间9：10传递给后端，后端查询比当前时间更早发布的文章（小于9：10）的。距离9：10最新的文章。并且按照时间降序返回给前端。

> 上拉加载时，前端将当前页最后那篇文章的时间戳，返回给后端，后端查询比上一篇文章更早的时间，按照时间降序返回给前端。

### 4.2：时间戳问题： ###

> 1: 前端时间戳是13位，因为最后一位前端是毫秒，而后端时间戳默认是10位，精确到秒。  
> 2：所以，前端传递时间戳给后端时，需要将时间戳从13位变成10位，还要将时间戳转换成日期。  
> 3：后端返给前端时，需要将日期转换成10位的时间戳，然后转换成13位的时间戳。还要将日期转换成标准日期格式的日期字符串。

from datetime import datetime
    
    # 1：时间戳 ：time.time()
    timestamp = time.time()
    print("时间戳[10位，单位秒]", timestamp)
    
    # 2：将时间戳转换成日期 ： datetime.fromtimestamp
    date_time = datetime.fromtimestamp(timestamp)
    print("日期", date_time)
    print(type(date_time))
    
    # 3: 将日期转换成日期字符串：# 标准日期格式
    date_str = datetime.isoformat(date_time)
    print("日期字符串：", date_str)
    print(type(date_str))
    
    # 4： 自定义日期格式：
    date_str2 = datetime.strftime(date_time, '%Y-%m-%d %H:%M:%S')
    print("自定义日期字符串：", date_str2)
    print(type(date_str2))
    
    # 5: 日期字符串转换成日期格式：
    # date_time.strptime()
    
    # 6: 将日期转换成时间戳：
    timestamp1 = datetime.timestamp(date_time)
    print("日期转换成时间戳", timestamp1)
    
    # 时间戳[10位，单位秒] 1604858070.5553937
    # 日期 2020-11-09 01:54:30.555394
    # <class 'datetime.datetime'>
    # 日期字符串： 2020-11-09T01:54:30.555394
    # <class 'str'>
    # 自定义日期字符串： 2020-11-09 01:54:30
    # <class 'str'>
    # 日期转换成时间戳 1604858070.555394

### 4.3：数据恢复： ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 11]

### 4.4：接口逻辑和实现： ###

> 思路分析：  
> 1: 获取参数  
> 1.1： 获取13位的时间戳timestamp  
> 1.2:channel\_id : 频道id  
> 1.3: per\_page : 每一页数量\[非必须传\]  
> 2：检验参数  
> 3：逻辑处理  
> 3.1： 将13位的时间戳转换成日期类型  
> 3.2：如果是推荐频道，返回空列表  
> 3.3：根据时间戳和频道id查询审核通过的文章数据和用哪个户数据，按照发布时间降序返回。  
> 4：构建响应  
> 4.1：获取当前页最后一篇日期，转换成13位的时间戳  
> 4.2：返回文章字典列表

`article/article.py`

from flask_restful import Resource
    from flask_restful.reqparse import RequestParser
    
    from app import db
    from models.article import Article
    from models.user import User
    from utils.contants import HOME_ARTICLE_PERPAGE
    from datetime import datetime
    class ArticleListResource(Resource):
    
        def get(self):
            # 1: 获取参数,前端将以查询字符串的方式传递给我们
            parser = RequestParser()
            parser.add_argument("time_stamp", type= int, required= True, location= "args")
            parser.add_argument("channel_id", type= int, required= True, location = "args")
            parser.add_argument("per_page", type= int, default = HOME_ARTICLE_PERPAGE, location = "args")
            # 开启解析
            ret = parser.parse_args()
            time_stamp = ret['time_stamp']
            channel_id = ret['channel_id']
            per_page = ret['per_page']
    
            # 2: 将13位的时间戳转换成日期格式
            # 将13位的时间戳转转成10位的时间戳
            time_stamp = int(time_stamp/1000)
            # 将时间戳转换成日期类型
            date_time = datetime.fromtimestamp(time_stamp)
            # 3：如果是推荐频道，返回空列表
            if channel_id == 0:
                return {
        "results": [], "per_timestamp": 0}
    
            #:4：查询文章数据和用户数据
            # 查询条件： 1：文章数据属于当前频道 2：文章审核通过 3：查询比timestamp发布时间更早的文章。
            # 5: 按照发布时间降序：
            # 6：根据per_page实现分页：
            article_list = db.session.query(
                Article.id,
                Article.title,
                Article.cover,
                Article.comment_count,
                Article.ctime,
                Article.user_id,
                User.name).join(User, Article.user_id == User.id)\
                .filter(Article.channel_id == channel_id, Article.status == Article.STATUS.APPROVED, Article.ctime < date_time)\
                .order_by(Article.ctime.desc()).limit(per_page).all()
    
            # 7: 获取当前页最后一篇文章的日期，转换成13位的时间戳
            per_timestamp = int(article_list[-1].ctime.timestamp())*100 if article_list[-1] else 0
    
            article_list_dict = [{
        
                'art_id':article.id,
                'title': article.title,
                'aut_id': article.user_id,
                'pubdate': article.ctime.isoformat(), # 转换标准的日期格式
                'aut_name': article.name,
                'comm_count': article.comment_count,
                'cover': article.cover
            } for article in article_list]
            return {
        "results": article_list_dict, "per_timestamp": per_timestamp}

注册路由：`article/__init__.py`

article_api.add_resource(ArticleListResource, "/articles")

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/713f5c6d3ce14f2087b64632f6030ae5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2020110913403097.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/20201109135815459.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/20201109151921485.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 4]: https://img-blog.csdnimg.cn/20201109152233540.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/20201109155456476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center
[20201109152619194.png_pic_center]: https://img-blog.csdnimg.cn/20201109152619194.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201109155516376.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/20201109174614336.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 8]: https://img-blog.csdnimg.cn/20201109180554247.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 9]: https://img-blog.csdnimg.cn/20201109202531768.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 10]: https://img-blog.csdnimg.cn/20201109203054151.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 11]: https://img-blog.csdnimg.cn/20201110094316275.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 12]: https://img-blog.csdnimg.cn/20201110113408315.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzQxNzU3,size_16,color_FFFFFF,t_70#pic_center