复制成功
RSS源订阅说明页面
本页面提供说明本站RSS源订阅的一些基本功能，订阅用户可以操作下面的控件查看RSS源订阅效果。本站提供了所有文章RSS源订阅功能， 同时也支持单个类别文章RSS源订阅，具体RSS-FEED请操作下面的组件获取。
订阅链接:
<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns="http://www.w3.org/2005/Atom">
<id>58</id>
<title>Blogin</title>
<updated>2023-09-27T02:08:19.928278+00:00</updated>
<link href="https://2dogz.cn"/>
<generator uri="https://lkiesow.github.io/python-feedgen" version="0.9.0">python-feedgen</generator>
<subtitle>Blogin是一个个人博客网站，后端使用Flask框架，前端使用Bootstrap4，主要分享一些编程类的技术以及一些陈词滥调的文章!</subtitle>
<entry>
<id>60</id>
<title>[Git]Gerrit接口使用说明</title>
<updated>2023-09-27T02:08:19.930028+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>使用Gerrit的REST API默认是<code>匿名用户</code>的权限，如果需要鉴权可以通过下面的方式实现，比如访问<code>/project/</code>需要鉴权在前面加上<code>/a/</code>就可以了，访问鉴权<code>/a/projects/</code>接口</p>
<h1>1.<strong> 获取Gerrit的Token</strong></h1>
<p>在用户设置界面的<code>HTTPCredentials</code>, 如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4623output.png" /></p>
<p>点击<code>GENERATE NEW PASSWORD</code>会弹出包含有<code>Token</code>的弹框，如下图<code>New Password</code>后面的就是 REST API的鉴权Token</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6254output%20%281%29.png" /></p>
<h1>2<strong>. 使用HTTP Basic鉴权</strong></h1>
<p>Gerrit使用的<code>HTTP Basic</code>的方式进行鉴权，在1.1获取Token后可以通过下面的方式去访问REST API接口</p>
<ul>
<li>
<p>命令行</p>
</li>
</ul>
<pre>
<code class="language-bash">curl --user admin:token https://gerrit.cn/a/projects/</code></pre>
<ul>
<li>
<p>python示例</p>
</li>
</ul>
<pre>
<code class="language-python">import requests
url = f'http://172.20.107.233:8888/a/projects/'
res = requests.get(url, auth=('admin', token))
print(res.text)</code></pre>
<blockquote class="m-blockquote">上面的<code>token</code>替换成上面获取的实际Token，Gerrit的地址替换成真实地址！</blockquote>
<p>正常的话，会返回下面的响应内容</p>
<pre>
<code class="language-json">)]}'
{
"All-Projects": {
"id": "All-Projects",
"state": "ACTIVE",
"web_links": [
{
"name": "browse",
"url": "/plugins/gitiles/All-Projects"
}
]
},
"All-Users": {
"id": "All-Users",
"state": "ACTIVE",
"web_links": [
{
"name": "browse",
"url": "/plugins/gitiles/All-Users"
}
]
},
"hello": {
"id": "hello",
"state": "ACTIVE",
"web_links": [
{
"name": "browse",
"url": "/plugins/gitiles/hello"
}
]
}
}</code></pre>
<blockquote class="m-blockquote">需要注意的是，为了防止<code>XSSI(XSSICross Site Script Inclusion)</code>攻击，JSON响应数据前面包含了<code>)]}&#39;</code>字符，在后续的数据处理中需要将其删除。</blockquote>
<h1><strong>3. 使用pygerrit2库访问Gerrit接口</strong></h1>
<p>由于Gerrit没有像python-gitlab那样的库，但是可以使用<code>pygerrit2</code>库来简化对Gerrit平台的API调用</p>
<pre>
<code class="language-bash">pip install pygerrit2</code></pre>
<p>简单的使用示例</p>
<pre>
<code class="language-python">from pygerrit2 import HTTPBasicAuth, GerritRestAPI
class GerritAPI:
def __init__(self, url, username, password):
self.gt = GerritRestAPI(url, auth=self.auth(username, password))
def auth(self, username, password):
return HTTPBasicAuth(username, password)
def get_all_projects(self):
projects = self.gt.get('/projects/')
return projects
kgt = GerritAPI(
url='http://172.20.107.241:8080',
username='admin',
password='替换为gerrit用户的密码'
)
# 获取授权用户所能查看的所有仓库列表
print(kgt.get_all_projects())</code></pre>
<p>虽然使用<code>requests</code>或者自带的<code>urllib</code>库也可以访问<code>Gerrit</code>的API接口，但是使用<code>pygerrit2</code>库可以简化我们的操作，比如</p>
<ul>
<li>
<p>对<code>Gerrit</code>接口返回数据的预处理</p>
</li>
<li>
<p>默认添加了授权，不需要在接口前面增加<code>/a</code></p>
</li>
</ul>
</content>
<link href="https://2dogz.cn/blog/article/60/" rel="alternate"/>
</entry>
<entry>
<id>59</id>
<title>[Python]Flask-SQLAlchemy一些高级用法记录(2)</title>
<updated>2023-09-27T02:08:19.930001+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 使用Mixin来定义普通公共方法" name="1. 使用Mixin来定义普通公共方法"></a>1. 使用Mixin来定义普通公共方法</h1>
<p>在<a href="https://2dogz.cn/blog/article/57/">上一节</a>中介绍了使用Mixin来定义公共字段，在最近的工作中，除了可以定义普通的公共字段之外还可以通过继承的方式定义普通的功能方法，如下面的代码示例</p>
<pre>
<code class="language-python">from sqlalchemy.ext.declarative import declared_attr
class BaseColumn:
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()</code></pre>
<p>定义上述类之后，之后在定义新的类模型时，就可以通过继承的方式去继承公共属性以及公共方法，如下示例</p>
<pre>
<code class="language-python">class Music(BaseColumn, db.Model):
__tablename__ = 't_music'
name = db.Column(db.String(512), default='', comment='歌曲名称')
author = db.Column(db.String(512), default='', comment='歌手名')
class Video(BaseColumn, db.Model):
__tablename__ = 't_video'
name = db.Column(db.String(512), default='', comment='电影名称')
director = db.Column(db.String(512), default='', comment='电影导演')</code></pre>
<blockquote class="m-blockquote">
<p>通过类对象的方式继承，在子类中字段都会被自动放到最前面，如果想放到子类字段的后面，参考上一节的内容！</p>
</blockquote>
<p><span class="marker">t_music</span>、<span class="marker">t_vedio</span>表结构如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6849image.png" /></p>
<p>在<span class="marker">BaseColumn</span>中还定义了两个共有方法，分别是<span class="marker">save</span>、<span class="marker">delete</span>，在对数据进行增删改查的时候，就可以直接通过模型类实例来调用这两个方法，实现数据的存储以及删除了，实例代码片段如下</p>
<pre>
<code class="language-python"># 插入数据
video = Video(name='让子弹飞',director='姜文')
video.save()
# 删除数据
v = Video.query.get(id)
v.delete()</code></pre>
<h1><a id="2. 定义类方法" name="2. 定义类方法"></a>2. 定义类方法</h1>
<p>除了上述的实例方法之外，还可以定义类方法。在使用flask-sqlalchemy的进行查询的时候一般都是ModelName.query的方式去进行查询的，下面示例代码片段演示了如何定义一个<span class="marker">update_or_insert</span>的类方法</p>
<pre>
<code class="language-python">class BaseColumn:
@classmethod
def update_or_insert(cls, condition: tuple, **kwargs):
"""
更新已有数据或者插入新的数据
:param condition: 查询条件
:param kwargs: 需要更新或者插入的字段
:return: 类实例对象
"""
existed = cls.query.filter(*condition)
if existed.first():
existed.update(kwargs)
existed = existed.first()
else:
existed = cls(**kwargs)
db.session.add(existed)
db.session.commit()
return existed</code></pre>
<p>通过<span class="marker">@classmethod</span>装饰器将<span class="marker">update_or_insert</span>变成类方法，在子类查询的时候就可以通过下面的示例代码片段进行使用了</p>
<pre>
<code class="language-python">video = Video.update_or_insert(Video.name == name, name=name, director=director)
video.save()</code></pre>
<p>完整的示例代码可以查询github仓库，仓库地址：<a href="https://github.com/weijiang1994/blog-demo/tree/main/orm_feature">https://github.com/weijiang1994/blog-demo/tree/main/orm_feature</a></p>
</content>
<link href="https://2dogz.cn/blog/article/59/" rel="alternate"/>
</entry>
<entry>
<id>58</id>
<title>[陈词滥调]2022年度总结</title>
<updated>2023-09-27T02:08:19.929974+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>时光啊，犹如白驹过隙一转眼的时间，一个年头又这么匆匆的离去了，今天是2022年的最后一天，回望过去这一年的时光，当时立下的Flag只是实现了一少部分，简单的总结一下2022这个年头。</p>
<p><strong>已完成的目标</strong></p>
<ol>
<li>学习了Vue框架，并使用Vue框架重构了论坛开源项目的后台管理页面（部分功能重构完成了），并应用到实际的工作中去（重构了公司内部的一个平台，但是未上线，公司新的平台使用的前后端分离架构，前端使用的Vue）</li>
<li>一个已完成的目标，但是不想公之于众（嘻嘻！）</li>
</ol>
<p><strong>未完成的目标</strong></p>
<ol>
<li><s>每个月最少更新一篇博客</s>（在归档中查看只有1、2、4、5、9月更新了）</li>
<li><s>考驾照</s>（目前还只通过最简单的科目一）</li>
<li><s>瘦下来20斤肉</s>（不减反增了，哎！）</li>
<li><s>深入MySQL的学习</s>（目前还只看了前半部分的内容，拖延症晚期）</li>
<li><s>完成论坛项目的系列教程更新</s>（目前只更新到了第10节，今年就更新了一节内容）</li>
</ol>
<p>上述未完成的目标又只能顺利延期到2023年了，哈哈哈，拖延症晚期真的没得治啊！！！</p>
</content>
<link href="https://2dogz.cn/blog/article/58/" rel="alternate"/>
</entry>
<entry>
<id>57</id>
<title>[Python]Flask-SQLAlchemy一些高级用法记录</title>
<updated>2023-09-27T02:08:19.929947+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 使用Mixin" name="1. 使用Mixin"></a>1. 使用Mixin定义共有字段</h1>
<p>使用ORM时，我们首先必须得先通过Class定义一个数据库表的模型对象，例如我有一张emp表，如下所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4010image.png" /></p>
<p>如果我们想通过ORM去操作这张表的话，首先需要通过定义Class来映射<span class="marker">emp表</span>的结构，如下面的代码所示，这样我们需要操作emp表的话，就可以直接通过Employee这个类来进行操作了。</p>
<pre>
<code class="language-python">class Employee(db.Model):
__tablename__ = 'emp'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), default='')
password = db.Column(db.String(128), default='')
department = db.Column(db.INTEGER, default=0, comment='')</code></pre>
<p>在很多场景，都需要将表中记录的创建时间以及修改时间记录下来，比如上述的<span class="marker">emp</span>表，如果需要记录，则需要在<span class="marker">Employee </span>的定义中新增两个字段，如下所示</p>
<pre>
<code class="language-python">class Employee(db.Model):
...
create_time = db.Column(db.DATETIME, default=datetime.now)
update_time = db.Column(db.DATETIME, default=datetime.now, onupdate=datetime.now)</code></pre>
<p>如果在其他表中也需要记录这两个字段呢，这时候我们就可以通过Mixin来将每个都有的公共字段定义在一个Class里面，然后通过继承该<span class="marker">Mixin</span>使得每个表结构中都包含该公有字段</p>
<pre>
<code class="language-python">class TimestampMixin(object):
create_time = db.Column(db.DateTime, default=db.func.now())
update_time = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())</code></pre>
<p>然后将Employee类继承自TimestampMixin类既可</p>
<pre>
<code class="language-python">class Employee(TimestampMixin, db.Model):
__tablename__ = 'emp'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), default='')
password = db.Column(db.String(128), default='')
department = db.Column(db.INTEGER, default=0, comment='')</code></pre>
<p>这是查看emp的表结构，如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8056image.png" /></p>
<p>可以发现，继承的两个字段被自动定义在了最前面了，这与平时的习惯不一致，一般都是ID为第一个字段，这种时间戳的字段一般都是放在表的末尾，那么要怎么做，才能将公共字段自动定义到表的末尾呢？可以通过SQLAlchemy里面的declared_attr装饰器去实现，如下代码</p>
<pre>
<code class="language-python">class TimestampMixin(object):
@declared_attr
def created_time(cls):
return db.Column(db.DateTime, default=datetime.now)
@declared_attr
def updated_time(cls):
return db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now)</code></pre>
<p>此时再去查看emp表的结构，就会发现公共字段被自动的定义到了末尾了，如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6977image.png" /></p>
<h1><a id="2. 使用JOIN" name="2. 使用JOIN"></a>2. 使用JOIN</h1>
<p>JOIN在MySQL语法中使用的非常之多，常见的有JOIN、RIGHT JOIN、LEFT JOIN三种形式，通过SQLAlchemy也可以实现这三种形式，跟随这第一节的例子，继续创建一张department表，用来存储部门相关的信息，如下代码</p>
<pre>
<code class="language-python">class Department(TimestampMixin, db.Model):
__tablename__ = 'dept'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), default='')
def __init__(self, name):
self.name = name</code></pre>
<p>emp表通过字段department与dept表进行关联，这里是通过逻辑外键进行关联的，而不是通过物理外键进行关联的，因此如果需要进行链表查询的话，就需要用JOIN的方式，比如查询部门为研发部的员工，可以通过下面的代码进行查询</p>
<pre>
<code class="language-python">emp = Employee.query.join(Department, Employee.department == Department.id).filter(Department.name == '研发部').all()</code></pre>
<p>默认的JOIN为内连接，如果需要使用左连接，可以是有<span class="marker">outerjoin</span>或者设置<span class="marker">is_outer=True</span></p>
<pre>
<code class="language-python">emp = Employee.query.outerjoin(Department, Employee.department == Department.id).filter(Department.name == '研发部').all()</code></pre>
<pre>
<code class="language-python">emp = Employee.query.join(Department, Employee.department == Department.id, is_outer=True).filter(Department.name == '研发部').all()</code></pre>
<p><strong>右连接跟左连接一样，想使用右连接直接调换一下表的顺序即可！</strong></p>
<h1><a id="3. 选择字段" name="3. 选择字段"></a>3. 选择字段</h1>
<p>在MySQL中SELECT * 表示选择所有字段，与此同时，也可以通过指定字段来使得查询结果中只包含有指定指端的值，在SQLAlchemy中可以通过with_entities来指定查询结果中返回哪些字段，在第二节中，使用了JOIN但是没有指定字段，因此还是无法获取到员工所在的部门信息，通过with_entities就可以获取员工所在部门的信息了，代码如下</p>
<pre>
<code class="language-python">emp = Employee.query.join(Department, Employee.department == Department.id).with_entities(Employee.username, Department.name).filter(
Department.name == '研发部').all()
print(str(emp))
</code></pre>
<p><strong>查询结果</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6884image.png" style="height:36px; width:415px" /></p>
<p>with_entities函数除了可以指定模型类的字段外，还可以在其中使用函数，比如我想查询各个部门的人数，代码如下</p>
<pre>
<code class="language-python">emp = Employee.query.join(Department, Employee.department == Department.id).with_entities(Department.name,db.func.count( Employee.id)).group_by(Department.name).all()
</code></pre>
<p><strong>查询结果</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6414image.png" /></p>
<p>完整的是示例代码请访问<a href="https://github.com/weijiang1994/blog-demo">https://github.com/weijiang1994/blog-demo</a>获取！</p>
</content>
<link href="https://2dogz.cn/blog/article/57/" rel="alternate"/>
</entry>
<entry>
<id>56</id>
<title>[应用部署]使用Docker部署flask应用</title>
<updated>2023-09-27T02:08:19.929920+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 安装Docker" name="1. 安装Docker"></a>1. 安装Docker</h1>
<blockquote class="m-blockquote">
<p>本文所有操作均在ubuntu2204上进行，请知悉！同时Docker的官方文档最开始使用的dockerfile，但是对于新手来说，我个人感觉dockerfile不是太友好（比如对于我来说），因此本文只介绍如何手动在Docker容器里面部署flask应用！</p>
</blockquote>
<p>通过apt命令查看软件源中是否包含有docker</p>
<pre>
<code class="language-bash">apt-cache policy docker.io</code></pre>
<p>如果出现类似下图的结果，则说明软件源中存在有docker的安装包直接通过下面的命令进行安装即可</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9635image.png" /></p>
<pre>
<code class="language-bash">sudo apt-get install docker.io
# 查看docker版本详细信息
sudo docker version</code></pre>
<p>如果显示如下图所示的信息，则说明docker成功安装了</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7592image.png" /></p>
<p>如果软件源里面没有docker的包，则可以直接去<a href="https://docs.docker.com/desktop/linux/install/">docker官网下载</a>，然后通过<span class="marker">dpkg -i</span>命令进行安装</p>
<h1><a id="2. 创建Docker容器" name="2. 创建Docker容器"></a>2. 创建Docker容器</h1>
<p>在docker中有两个概念：镜像、容器。镜像顾名思义，就是我们平时所说的操作系统比如<span class="marker">ubuntu、centos</span>等，但是在docker中的镜像一般都是经过<strong>精简后只提供最小的运行单元</strong>，比如你通过docker pull ubuntu 会自动将最新的ubuntu镜像从docker的服务器拉去到本地，通过docker images 可以看到如下图所示的信息，镜像的大小只有77.8MB.</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5979image.png" /></p>
<p>镜像是容器的基础，一个镜像可以创建多个容器，容器就是运行web应用的宿主机，简而言之就是类似于虚拟机，但是跟虚拟机还是有很大的差别，镜像与容器的关系如下图所示。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8842%E9%95%9C%E5%83%8F%E4%B8%8E%E5%AE%B9%E5%99%A8%20%282%29.png" /></p>
<p>通过下面的命令就可以创建我们自己的docker容器了</p>
<pre>
<code class="language-bash">sudo docker pull ubuntu # 从docker镜像仓库中拉去ubuntu最新的镜像
sudo docker run -p 8001:5000 -it ubuntu /bin/bash # 通过本地的ubuntu镜像去创建容器
sudo docker ps -a</code></pre>
<p>通过上面的命令就可以创建一个docker容器了，结果如下图所示则说明容器创建成功了，下面解释一下上面的参数</p>
<ul>
<li>-p 由于我们是将web应用部署在docker容器内部，容器对于宿主机来说是两个不同的环境，通过-p参数就可以将容器的端口映射到宿主机的端口，比如外部客户端访问宿主机的8000端口的服务器，实际上是访问到容器内部5000端口的服务</li>
<li>-it 加上这个参数我们就可以通过bash的方式进入容器内部</li>
<li>-a ps命令默认只会显示出正在运行的容器，加上-a参数可以显示本机所有的容器</li>
</ul>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/600image.png" /></p>
<p>创建好容器之后，就可以通过start命令去运行容器了，显示下图的信息就说明容器已经成功运行了</p>
<pre>
<code class="language-bash">sudo docker start adoring_wescoff # 跟容器名称
sudo docker ps </code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1877image.png" /></p>
<h1><a id="3. 进入容器手动部署应用" name="3. 进入容器手动部署应用"></a>3. 进入容器手动部署应用</h1>
<p>容器成功启动后，我们就可以通过exec命令进入容器内部，然后部署我们的应用了，不过在这之前我们可以通过rename去给容器重新修改一个名字，因为我们在执行run命令的时候，没有通过name参数给容器指定一个名称，因此docker会自动给我们的容器创建一个随机的名称，如下图所示，将容器重新命名为flask_app，然后通过ps命令去查看，容器显示命名称为flask_app，则说明容器名称修改成功。</p>
<pre>
<code class="language-bash">sudo docker rename adoring_wescoff flask_app
sudo docker ps </code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8720image.png" /></p>
<p>成功修改容器名称后，通过exec命令进入容器内部</p>
<pre>
<code class="language-bash">sudo docker exec -it flask_app /bin/bash</code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6146image.png" /></p>
<p>在根目录中通过下面的命令创建一个简单的flask应用，并启动</p>
<pre>
<code class="language-bash">mkdir demo
apt update
apt install python3 python3-pip vim # 安装一些必要的包
pip install flask
cd demo
vim app.py</code></pre>
<p>在app.py文件中输入下面的代码，通过python app.py运行应用</p>
<pre>
<code class="language-python">from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return "Hello, World![FROM DOCKER]"
if __name__ == '__main__':
app.run(host="0.0.0.0")</code></pre>
<p>在宿主机中打开浏览器，访问http://127.0.0.1:8000 即可看到下面的内容</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2778image.png" /></p>
<p>到此为止，使用docker容器手动部署flask web应用就完成了。</p>
<blockquote class="m-blockquote">
<p>手动部署肯定不是最好的方式，但是我感觉适合我这种对Linux比较熟悉，但是对docker不是太熟悉的人，后面会继续更新通过DockerFile进行部署的内容！</p>
</blockquote>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/56/" rel="alternate"/>
</entry>
<entry>
<id>55</id>
<title>[系列教程]使用Flask搭建一个校园论坛10-个人中心（1）</title>
<updated>2023-09-27T02:08:19.929890+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 功能介绍" name="1. 功能介绍"></a>1. 功能介绍</h1>
<p>论坛这种内容管理系统必不可少的一个功能模块就是个人中心，在个人中心中可以查看自己的账号基本信息、以及个人在社区的一些操作记录，比如发帖、评论、收藏等等，本论坛的个人中心功能如下图所示</p>
<p><img alt="个人中心功能脑图" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/3526image.png" /></p>
<h1><a id="2. 页面布局" name="2. 页面布局"></a>2. 页面布局</h1>
<p>个人中心的页面布局如下图所示，上面个人基本信息栏为个人中心所有页面通用部分，不管在个人中心的哪个栏目，上面通用部分的信息内容是不会改变的，下方的<span class="marker">四个tab</span>分别对应不同的功能模块，是差异性内容。</p>
<p><img alt="布局" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9269image.png" /></p>
<h2>2.1 通用部分</h2>
<p>在<span class="marker">Jinja2</span>的模板语法中，我们可以通过<span class="marker">include</span>关键字来将其他的模板文件引入到我们目标模板文件中，因为个人中心的上半部分的信息是通用，因此我们可以将其抽离出来，放入单独的html模板文件中去。除此之外<span class="marker">Jinja2</span>还支持<span class="marker">macro</span>块，<span class="marker">macro</span>的语法如下所示</p>
<pre>
<code class="language-html"># macro.html
{% macro sample() %}
&lt;p&gt;I am macro function!&lt;/p&gt;
{% endmacro %}
# other.html
{% from macro.html import sample with context %}
&lt;div&gt;
{{ sample() }}
&lt;/div&gt;</code></pre>
<p>为了方便管理，我们把所有的<span class="marker">macro</span>相关的都放到了<span class="marker">templates/macro.html</span>文件中，在文件中嵌入下面的代码</p>
<pre>
<code class="language-html">{% macro profile_header() %}
&lt;div class="row"&gt;
&lt;div class="col-md-3 col-lg-3 text-center"&gt;
&lt;img class="img-profile-bg" alt="{{ user.nickname }}" src="{{ user.avatar }}"&gt;
&lt;/div&gt;
&lt;div class="col-md-9 col-lg-9 div-center-md"&gt;
&lt;h3 class="mb-0"&gt;{{ user.nickname }}&lt;/h3&gt;
&lt;p class="text-muted mb-2"&gt;@{{ user.username }}&lt;/p&gt;
{% if user.slogan %}
&lt;p class="mb-2"&gt;{{ user.slogan }}&lt;/p&gt;
{% endif %}
{% if user.website or user.location %}
&lt;p class="mb-2"&gt;
{% if user.website %}
&lt;a class="text-decoration-none social-label" href="{{ user.website }}" target="_blank"
title="{{ user.nickname }}的个人主页"&gt;&lt;i class="fa fa-home fa-fw mr-1"&gt;&lt;/i&gt;{{ user.website }}&lt;/a&gt;
{% endif %}
{% if user.location %}
&lt;span class="social-label d-lg-inline d-none"&gt;&lt;i
class="fa fa-map-marker fa-fw mr-1"&gt;&lt;/i&gt;{{ user.location }}
&lt;/span&gt;
&lt;span class="social-label d-lg-none d-md-block" title="{{ user.location }}"&gt;&lt;i
class="fa fa-map-marker fa-fw mr-1"&gt;&lt;/i&gt;{{ user.location|truncate(8) }}
&lt;/span&gt;
{% endif %}
&lt;/p&gt;
{% endif %}
&lt;p&gt;
&lt;span class="mr-2"&gt;{{ user.post|length }}篇帖子&lt;/span&gt;
&lt;a href="{{ url_for('profile.follower', user_id=user.id) }}"
class="mr-2 span-hand a-link text-decoration-none"&gt;{{ user.followers.count() }}位粉丝&lt;/a&gt;
&lt;a href="{{ url_for('profile.following', user_id=user.id) }}"
class="mr-2 span-hand a-link text-decoration-none"&gt;{{ user.following.count() }}个关注&lt;/a&gt;
&lt;/p&gt;
{% if current_user.id == user.id %}
&lt;a class="btn btn-outline-success" href="{{ url_for('user.index', user_id=current_user.id) }}"&gt;个人主页&lt;/a&gt;
{% else %}
{% if current_user.is_following(user) %}
&lt;a class="btn btn-outline-info" href="/profile/unfollow/{{ user.id }}/"&gt;取消关注&lt;/a&gt;
{% else %}
&lt;a class="btn btn-outline-info" href="/profile/follow/{{ user.id }}/"&gt;关注TA&lt;/a&gt;
{% endif %}
&lt;!-- 弹出私信窗口 --&gt;
&lt;a class="btn btn-outline-primary" data-toggle="modal" data-userid="{{ user.id }}"
data-target="#privacyChat"&gt;私信&lt;/a&gt;
{% if not blocked %}
&lt;a class="btn btn-outline-danger" data-toggle="modal" data-userid="{{ user.id }}"
data-target="#confirmBlockUser"&gt;Block&lt;/a&gt;
{% else %}
&lt;a class="btn btn-primary disabled" data-toggle="modal" data-userid="{{ user.id }}"
data-target="#confirmBlockUser"&gt;Blocked&lt;/a&gt;
{% endif %}
{% endif %}
&lt;/div&gt;
&lt;/div&gt;
{% endmacro %}</code></pre>
<p>个人中心除了用户自己的，用户同样也可以访问其他用户的个人中心主页，因此在上面的代码中加入了判断，当前个人中心主页是否为当前用户个人的主页，如果不是，则在下方添加不同的功能按钮。</p>
<h2>2.2 TAB部分</h2>
<p>上面的通用部分内容既可以通过macro实现也可以通过include去实现，tab部分的内容就通过macro实现就比较方便了，在macro中我们也可以传入参数，同样的在macro.html中增加下列代码</p>
<pre>
<code class="language-html">{% macro profile_moment(tabName) %}
&lt;div class="mt-4"&gt;
&lt;ul class="nav nav-tabs nav-justified"&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link {% if tabName == '帖子' %}active{% endif %}" href="/profile/user/{{ user.id }}/"&gt;帖子&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link {% if tabName == '评论' %}active{% endif %}"
href="/profile/comment/{{ user.id }}/"&gt;评论&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link {% if tabName == '收藏' %}active{% endif %}"
href="/profile/collect/{{ user.id }}/"&gt;收藏&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link {% if tabName == '社交' %}active{% endif %}"
href="/profile/social/{{ user.id }}/"&gt;社交&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/div&gt;
{% endmacro %}</code></pre>
<p>这里与上面稍微有些不同，这里的<span class="marker">macro函数带有参数输入</span>，我们在函数体中通过判断参数的不同实现对应ab的被选中，当然这里也可以通过<span class="marker">include</span>去实现，可以通过<span class="marker">endpoint</span>来设置对应tab被选中。</p>
<h1><a id="3. 关注、取消关注用户" name="3. 关注、取消关注用户"></a>3. 关注、取消关注用户</h1>
<p>很多社交网站都会给用户提供关注的功能，论坛也提供了这个功能，用户既可以被别人关注，同时用户也可以关注他们，所以是多对多的关系，<span class="marker">Follow</span>表结构如下</p>
<pre>
<code class="language-python">class Follow(db.Model):
__tablename__ = 't_follow'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
follower_id = db.Column(db.INTEGER, db.ForeignKey('t_user.id'))
followed_id = db.Column(db.INTEGER, db.ForeignKey('t_user.id'))
# 正在关注用户的人
follower = db.relationship('User', foreign_keys=[follower_id], back_populates='following', lazy='joined')
# 用户自己正在关注的人
followed = db.relationship('User', foreign_keys=[followed_id], back_populates='followers', lazy='joined')
class User(db.Model, db.UserMixin):
...
following = db.relationship('Follow', foreign_keys=[Follow.follower_id], back_populates='follower',
lazy='dynamic', cascade='all')
followers = db.relationship('Follow', foreign_keys=[Follow.followed_id], back_populates='followed',
lazy='dynamic', cascade='all')</code></pre>
<p>这里需要注意的是，由于Follow表中的两个字段<span class="marker">follower_id</span>, <span class="marker">followed_id</span>都是user表的外键，因此我们在定义的时候需要指定每个关系所对应的字段，不然ORM框架会识别不了，<strong>follower指定为followe_id，followed指定为followed_id，</strong>与此同时，在user表中同样也是指定。</p>
<p>创建好Follow表之后，关注的逻辑就比较简单了，在<span class="marker">blueprint/profile.py</span>文件中增加下面的代码。代码逻辑十分简单，就是通过向Follow表中新增或者删除相应的数据，实现关注或者取消关注功能，同时还增加了自己不能关注自己的逻辑。</p>
<pre>
<code class="language-python">@profile_bp.route('/follow/&lt;user_id&gt;/', methods=['GET', 'POST'])
@login_required
def follow_user(user_id):
user = User.query.get_or_404(user_id)
if user.id == current_user.id:
flash('我关注我自己?禁止套娃!', 'info')
return redirect(request.referrer)
if current_user.is_following(user):
flash('你已经关注TA了!', 'info')
return redirect(request.referrer)
current_user.follow(user)
flash('关注成功!', 'success')
return redirect(request.referrer)
@profile_bp.route('/unfollow/&lt;user_id&gt;/', methods=['GET', 'POST'])
@login_required
def unfollow_user(user_id):
user = User.query.get_or_404(user_id)
if current_user.is_following(user):
current_user.unfollow(user)
if request.method == 'POST':
return jsonify({'tag': 1})
flash('取关成功!', 'success')
return redirect(request.referrer)</code></pre>
<h1><a id="4. 用户帖子" name="4. 用户帖子"></a>4. 用户帖子</h1>
<p>如上面所说，个人中心用户即可以访问自己的也可以访问他人，因此需要在帖子列表上做区分，在frontend/profile.py文件中增加下面的代码</p>
<pre>
<code class="language-python">@profile_bp.route('/user/&lt;user_id&gt;/')
@login_required
def index(user_id):
page = request.args.get('page', default=1, type=int)
user = User.query.get_or_404(user_id)
per_page = current_app.config['BBS_PER_PAGE']
# 其他人查看用户信息时候屏蔽用户匿名发表的帖子
if current_user.id == int(user_id):
pagination = Post.query.filter(Post.author_id == user_id, Post.status_id == 1).order_by(
Post.create_time.desc()).paginate(page=page, per_page=per_page)
posts = pagination.items
else:
pagination, posts = get_range_post(user.id,
page=page,
per_page=per_page,
range_day=TIME_RANGE.get(user.range_post.name))
blocked = BlockUser.query.filter(BlockUser.user_id == current_user.id,
BlockUser.block_user_id == user_id).all()
return render_template('frontend/profile/profile.html', user=user, tag=pagination.total &gt; per_page,
pagination=pagination, posts=posts, blocked=blocked)</code></pre>
<p>代码的逻辑很简单，如下</p>
<ol>
<li>通过路由参数中的user_id来获取对应的user，如果没有找到user则返回404；</li>
<li>判断当前user是否为路由参数中的user，如果不是，则只获取该用户状态为正常的帖子；</li>
<li>如果是则获取所有的状态的帖子；</li>
</ol>
<blockquote class="m-blockquote">
<p>上面还出现了BlockUser的相关代码，这个代码在后续用户主页的相关文章中进行讲解，这里暂时不做讲解！</p>
</blockquote>
<p>后端后去数据后，需要通过Jinja2模板进行渲染了，在<span class="marker">frontend/profile/profile.html</span>中新增下面的代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% from "macro.html" import profile_header, profile_moment, render_pagination, post_list with context %}
{% block head %}
{{ super() }}
&lt;style&gt;
.a-title {
font-size: 22px;
font-weight: bold;
}
.a-title-sm {
font-size: 16px;
font-weight: bold;
}
.f-12-b {
font-weight: bold;
font-size: 12px;
}
.span-hand {
cursor: pointer;
}
&lt;/style&gt;
{% endblock %}
{% block title %}
{{ user.nickname }}的个人主页
{% endblock %}
{% block content %}
{{ moment.locale(auto_detect=True) }}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container mt-2"&gt;
{% include "_flash.html" %}
{{ profile_header() }}
{{ profile_moment('帖子') }}
{% if posts %}
&lt;div class="mt-2"&gt;
{{ post_list(posts) }}
{% if user.range_post.name != '全部' and current_user.id != user.id %}
&lt;div class="mt-2 text-center"&gt;
&lt;p class="text-muted"&gt;&lt;b&gt;该用户仅展示最近{{ user.range_post.name }}的帖子&lt;/b&gt;&lt;/p&gt;
&lt;/div&gt;
{% endif %}
&lt;/div&gt;
{% else %}
{% if current_user.id == user.id %}
&lt;div class="text-center mt-5"&gt;
&lt;p class="text-muted"&gt;你还没有发送过帖子!&lt;/p&gt;
&lt;/div&gt;
{% else %}
&lt;div class="text-center mt-5"&gt;
{% if user.available_post_counts()|length %}
{% if user.range_post.name == '隐藏' %}
&lt;p class="text-muted"&gt;&lt;b&gt;该用户{{ user.range_post.name }}了帖子&lt;/b&gt;&lt;/p&gt;
{% else %}
&lt;p class="text-muted"&gt;&lt;b&gt;该用户仅展示最近{{ user.range_post.name }}的帖子&lt;/b&gt;&lt;/p&gt;
{% endif %}
{% else %}
&lt;p class="text-muted"&gt;&lt;b&gt;他还没有发送过帖子!&lt;/b&gt;&lt;/p&gt;
{% endif %}
&lt;/div&gt;
{% endif %}
{% endif %}
{% include "follow-modal.html" %}
&lt;/div&gt;
&lt;/main&gt;
&lt;/body&gt;
{% include "frontend/profile/contact-modal.html" %}
{% include "frontend/profile/block-user-modal.html" %}
{% endblock %}
</code></pre>
<blockquote class="m-blockquote">
<p>博客文章中的代码只截取了部分关键代码，很多细节代码没有贴出来，如果想要在本地机器上运行调试可以访问我的<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>或者<a href="https://gitee.com/weiijang/university-bbs">gitee仓库</a>仓库，如果想要看到实际效果请访问<a href="http://bbs.2dogz.cn/">二狗学院</a>！</p>
</blockquote>
</content>
<link href="https://2dogz.cn/blog/article/55/" rel="alternate"/>
</entry>
<entry>
<id>54</id>
<title>[Python]flask-babel在工厂模式下的使用</title>
<updated>2023-09-27T02:08:19.929863+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 使用flask-babel国际化流程" name="1. 使用flask-babel国际化流程"></a>1. 使用flask-babel国际化流程</h1>
<p>通过flask-babel的官方文档以及网络上的一些简单示例教程，flask-babel进行国际化的流程如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6201image.png" /></p>
<p>首先通过<span class="marker">pip install flask-babel</span>进行扩展的安装</p>
<pre>
<code class="language-bash">pip install flask-babel</code></pre>
<p>安装完成之后通过下面的代码进行初始化</p>
<pre>
<code class="language-python">from flask import Flask
from flask_babel import Babel
app = Flask(__name__)
babel = Babel(app)
</code></pre>
<p>初始化完成之后就需要在项目的根目录新建<span class="marker">flask-babel</span>的配置文件<span class="marker">babel.cfg</span>，文件名取什么都无所谓，这里只是好做区分，在<span class="marker">babel.cfg</span>文件中一般会输入下面的内容即可</p>
<pre>
<code class="language-ini">[python: **.py]
[jinja2: **/templates/**.html]
extensions=jinja2.ext.autoescape,jinja2.ext.with_</code></pre>
<p>之后通过<span class="marker">extract</span>命令将需要翻译的字符串抽离出来保存到根目录的模板文件中去</p>
<pre>
<code class="language-bash">pybabel extract -F babel.cfg -o messages.pot .</code></pre>
<p>这里的<span class="marker">-F</span>参数可以指定相应<span class="marker">babel配置文件</span>，<span class="marker">-o</span> 参数指定抽离的<span class="marker">模板文件名称</span> <span class="marker">. </span>则表示将模板文件保存到当前目录下，当然也可以指定到其他路径，抽离完模板文件之后，通过init命令初始化我们的目标语言模板文件，基于上一步骤抽离的<span class="marker">pot模板文件</span></p>
<pre>
<code class="language-bash">pybabel init -i messages.pot -d translations -l zh</code></pre>
<p><span class="marker">-i</span> 参数指定<span class="marker">根模板文件</span>的路径，<span class="marker">-d</span> 指定目标语言的模板文件<span class="marker">保存路径</span>（上面命令就是将目标语言的模板文件保存到当前目录的translations/zh目录下） <span class="marker">-l</span> 参数则是指定<span class="marker">转换的语言</span>，这里指定为中文，通过flask-babel实现国际化的流程大致就是如此，具体细节可以参考<a href="https://flask-babel.tkte.ch/">官方文档</a>以及网络资料。</p>
<h1><a id="2. 工厂模式应用使用flask-babel" name="2. 工厂模式应用使用flask-babel"></a>2. 工厂模式应用使用flask-babel</h1>
<p>单文件应用都是在实例化Flask后直接通过Babel(app)进行初始化的，下面通过一个示例演示如何在工厂模式应用中使用flask-babel。</p>
<h2>2.1 项目目录结构</h2>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8232image.png" /></p>
<p>项目目录结构如上图所示</p>
<ul>
<li><strong>app</strong>: 存放flask应用源代码</li>
<li><strong>translations</strong>: 存放翻译文件</li>
<li><strong>babel.cfg</strong>: flask-babel配置文件</li>
<li><strong>.flaskenv</strong>: flask环境变量文件</li>
<li><strong>message.pot</strong>: flask-babel 模板翻译文件3</li>
</ul>
<h2>2.2 工厂模式初始化babel</h2>
<p>在app目录下的__init__.py文件中输入如下代码</p>
<pre>
<code class="language-python">from flask import Flask, request
from app.extensions import babel
from app.views.index import idx_bp
import os
basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
def create_app():
app = Flask(__name__)
app.config['BABEL_DEFAULT_LOCALE'] = 'zh'
app.config['BABEL_TRANSLATION_DIRECTORIES'] = basedir + '/translations'
app.register_blueprint(idx_bp)
register_extensions(app)
@babel.localeselector
def get_local():
cookie = request.cookies.get('locale')
if cookie in ['zh', 'en']:
return cookie
return request.accept_languages.best_match(app.config.get('BABEL_DEFAULT_LOCALE'))
return app
def register_extensions(app):
babel.init_app(app)
</code></pre>
<p>flask-babel是通过装饰器函数<span class="marker">localselector</span>去获取当前需要渲染的语言，在<span class="marker">create_app</span>工厂方法中我们通过<span class="marker">get_local</span>函数去获取请求中cookie是否包含有local的值，如果有则返回cookie的值，如果没有则获取请求中<span class="marker">accept_language</span>获取与默认配置最匹配的语言，每次请求进入都会自动调用该函数，因此就可以达到动态切换语言的目的了。</p>
<p>与此同时，通过<span class="marker">BABEL_DEFAULT_LOCALE</span>以及<span class="marker">BABEL_TRANSLATION_DIRECTORIES</span>分别来<span class="marker">配置默认语言</span>以及<span class="marker">默认翻译文件存储路径</span>，如果不配置翻译文件默认存储位置，flask-babel默认会去app/translations目录下查找，这与我们翻译文件的路径是不一样。</p>
<h2>2.3 蓝图中的翻译</h2>
<p>flask-babel提供了三个函数来标志我们需要翻译的字符串分别是gettext、ngettext、lazy_gettext，其中gettext可以标志单个字符串，ngettext可以标记多个字符串，lazy_gettext只在使用到该字符串的时候才进行翻译，在views文件中新建index.py文件，输入下面的代码</p>
<pre>
<code class="language-python">from flask import Blueprint, render_template
from flask_babel import gettext
idx_bp = Blueprint('index', __name__)
@idx_bp.route('/')
@idx_bp.route('/index')
def index():
content = gettext('This is a flask-babel sample application')
return render_template('index.html', content=content)</code></pre>
<h2>2.4 模板中的翻译</h2>
<p>除了可以标记python文件中的字符串，还可以标记模板文件中的字符串，在templates目录中新建index.html文件，输入下面的代码</p>
<pre>
<code class="language-html">&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
&lt;meta charset="UTF-8"&gt;
&lt;title&gt;Flask Babel Sample &lt;/title&gt;
&lt;link rel="stylesheet" href="{{ url_for('static', filename='index.css') }}"&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;div class="container"&gt;
&lt;h3&gt;{{ _("Factory mode use Flask-Babel") }}&lt;/h3&gt;
&lt;hr&gt;
&lt;p&gt;1.{{ _('Blueprint Sample') }}&lt;/p&gt;
&lt;p&gt;{{ content }}&lt;/p&gt;
&lt;p&gt;2.{{ _('Template Sample') }}&lt;/p&gt;
&lt;p&gt;{{ _("I have a dream that one day this nation will rise up and live out the true meaning of its creed: 'We hold these truths to be self-evident, that all men are created equal.") }}&lt;/p&gt;
&lt;p&gt;{{ _("I have a dream that one day on the red hills of Georgia, the sons of former slaves and the sons of former slave owners will be able to sit down together at the table of brotherhood.") }}&lt;/p&gt;
&lt;p&gt;{{ _("I have a dream that one day even the state of Mississippi, a state sweltering with the heat of injustice, sweltering with the heat of oppression, will be transformed into an oasis of freedom and justice.") }}&lt;/p&gt;
&lt;p&gt;{{ _("I have a dream that my four little children will one day live in a nation where they will not be judged by the color of their skin but by the content of their character.") }}&lt;/p&gt;
&lt;button class="btn zh"&gt;&lt;a class="link" href=""&gt;中文&lt;/a&gt;&lt;/button&gt;
&lt;button class="btn en"&gt;&lt;a class="link" href=""&gt;English&lt;/a&gt;&lt;/button&gt;
&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre>
<p>在模板文件，将需要标志的字符串通过_()进行包括，为什么采用_()进行包裹，因为在babel.cfg文件中添加了extensions=jinja2.ext.autoescape,jinja2.ext.with_，在使用extract命令的时候会自动将其抽离出来。</p>
<h2>2.5 抽离模板生成翻译文件</h2>
<p>在使用gettext或者_()标记好需要翻译的字符串之后，通过extract命令自动抽离出python文件、模板文件中所有被标记的字符串</p>
<pre>
<code class="language-bash">pybabel extract -F babel.cfg -o message.pot .</code></pre>
<p>运行结束后会在项目根目录中生成一个message.pot文件，文件内容如下图所示（只截取了部分内容），可以看到文件中的内容都是事先标记好的字符串</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5718image.png" /></p>
<p>上面的message.pot文件为模板文件，通过init命令可以根据模板文件初始化目标语言po文件</p>
<pre>
<code class="language-bash">pybabel init -i message.pot -d translations -l zh</code></pre>
<p>上述命令会根据上一个步骤中生成的模板文件生成对应语言的翻译文件，在translations/zh/LC_MESSAGES目录中可以看到message.po文件，文件内容与message.pot文件内容一直，我们<strong>只需要在msgstr字段中填入对应语言的翻译内容即可</strong>，如下代码所示</p>
<pre>
<code class="language-php"># Chinese translations for PROJECT.
# Copyright (C) 2022 ORGANIZATION
# This file is distributed under the same license as the PROJECT project.
# FIRST AUTHOR &lt;EMAIL@ADDRESS&gt;, 2022.
#
msgid ""
msgstr ""
"Project-Id-Version: PROJECT VERSION\n"
"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
"POT-Creation-Date: 2022-02-27 20:36+0800\n"
"PO-Revision-Date: 2022-02-27 19:54+0800\n"
"Last-Translator: FULL NAME &lt;EMAIL@ADDRESS&gt;\n"
"Language: zh\n"
"Language-Team: zh &lt;LL@li.org&gt;\n"
"Plural-Forms: nplurals=1; plural=0\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.9.1\n"
#: app/templates/index.html:10
msgid "Factory mode use Flask-Babel"
msgstr "Flask-Babel在工厂模式下的应用"
#: app/templates/index.html:12
msgid "Blueprint Sample"
msgstr "蓝图示例"
#: app/templates/index.html:14
msgid "Template Sample"
msgstr "模板示例"
#: app/templates/index.html:15
msgid ""
"I have a dream that one day this nation will rise up and live out the "
"true meaning of its creed: 'We hold these truths to be self-evident, that"
" all men are created equal."
msgstr "我梦想有一天，这个国家会站立起来，真正实现其信条的真谛：“我们认为这些真理是不言而喻的——人人生而平等。”"
#: app/templates/index.html:16
msgid ""
"I have a dream that one day on the red hills of Georgia, the sons of "
"former slaves and the sons of former slave owners will be able to sit "
"down together at the table of brotherhood."
msgstr "我梦想有一天，在佐治亚的红山上，昔日奴隶的儿子将能够和昔日奴隶主的儿子坐在一起，共叙兄弟情谊。"
#: app/templates/index.html:17
msgid ""
"I have a dream that one day even the state of Mississippi, a state "
"sweltering with the heat of injustice, sweltering with the heat of "
"oppression, will be transformed into an oasis of freedom and justice."
msgstr "我梦想有一天，甚至连密西西比州这个正义匿迹，压迫成风的地方，也将变成自由和正义的绿洲。"
#: app/templates/index.html:18
msgid ""
"I have a dream that my four little children will one day live in a nation"
" where they will not be judged by the color of their skin but by the "
"content of their character."
msgstr "我梦想有一天，我的四个孩子将在一个不是以他们的肤色，而是以他们的品格优劣来评价他们的国度里生活。"
#: app/views/index.py:17
msgid "This is a flask-babel sample application"
msgstr "这是一个flask-babel的简单示例应用"
</code></pre>
<p>这时候浏览器打开http://127.0.01:5000首页显示页面内容如下，页面显示的中文，因为默认配置的语言为zh</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5383image.png" /></p>
<h1><a id="3. 动态切换语言" name="3. 动态切换语言"></a>3. 动态切换语言</h1>
<p>在第二节中，<strong>通过读取请求中cookie的值去判断当前语言</strong>，因此我们可以在<span class="marker">index.py</span>文件中添加下面的代码实现动态语言切换功能，代码片段如下</p>
<pre>
<code class="language-python">@idx_bp.route('/set-locale/&lt;language&gt;')
def set_locale(language):
resp = redirect(request.referrer)
if language:
resp.set_cookie('locale', language, max_age=30 * 24 * 60 * 60)
return resp</code></pre>
<p>然后将index.html文件中两个a标签的href改为如下代码</p>
<pre>
<code class="language-html">&lt;button class="btn zh"&gt;&lt;a class="link" href="{{ url_for('index.set_locale', language='zh') }}"&gt;中文&lt;/a&gt;&lt;/button&gt;
&lt;button class="btn en"&gt;&lt;a class="link" href="{{ url_for('index.set_locale', language='en') }}"&gt;English&lt;/a&gt;&lt;/button&gt;</code></pre>
<p>这样就可以点击按钮就可以动态切换语言了，如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1984image.png" /></p>
<h1><a id="4. 注意事项" name="4. 注意事项"></a>4. 注意事项</h1>
<ol>
<li>工厂模式将localselector装饰函数放到create_app下即可</li>
<li>注意翻译文件的路径，如果不是在项目源码目录下，需要配置<span class="marker">BABEL_TRANSLATION_DIRECTORIES</span></li>
<li>如果更新了标记字符串，使用pybabel update命令不要使用init命令，否则会初始化已翻译的内容</li>
<li>如果更新了标记字符串，<strong>记得要重启应用</strong></li>
<li>项目代码：<a href="https://github.com/weijiang1994/flask-babel-sample">https://github.com/weijiang1994/flask-babel-sample</a></li>
</ol>
</content>
<link href="https://2dogz.cn/blog/article/54/" rel="alternate"/>
</entry>
<entry>
<id>53</id>
<title>[电子游戏]原神抽卡分析</title>
<updated>2023-09-27T02:08:19.929836+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.声明" name="1.声明"></a>1.声明</h1>
<blockquote class="m-blockquote">
<p>抽卡分析记录所有者为上海米哈游影铁科技有限公司（原神发行商），如若此篇博文侵害了上海米哈游影铁科技有限公司相关利益，请联系我邮箱804022023@qq.com，我会在第一时间删除此博文，并致歉！</p>
</blockquote>
<blockquote class="m-blockquote">
<p>此篇博文最主要的目的是分享，请各位看官切勿拿去做一些非法交易！！！</p>
</blockquote>
<h1><a id="2.历史记录页面分析" name="2.历史记录页面分析"></a>2.历史记录页面分析</h1>
<p>我们在手机上玩原神的时候，进入祈愿页面，可以在左下角看到历史记录按钮，点击历史记录按钮就可以看到近六个月的抽卡历史记录，如果接触过安卓开发的同学应该可以看出来，这个页面应该是用<span class="marker">WebView</span>控件去实现的，这时候我们断开网络然后点击右上角的刷新按钮，就会出现类似下图的页面，这应该是安卓<span class="marker">WebView</span>的机制（我的猜想，因为开发安卓已经是很多年前的事情了）。</p>
<p><img alt="Android-webview无网络" class="d-block img-fluid mx-auto pic" src="http://wl.aidezy.com/2019061316320145796673.png" /></p>
<p>页面上出现的URL就是历史记录页面，也就是各种抽卡分析小程序需要你手动输入的URL，复制该URL然后粘贴到浏览器地址栏中，可以看到游戏祈愿历史记录一样的页面，如下图所示</p>
<p><img alt="祈愿历史记录页面" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8051image.png" /></p>
<h1><a id="3.历史记录API分析" name="3.历史记录API分析"></a>3.历史记录API分析</h1>
<p>在浏览器中按F12打开开发者模式，点击到网络TAB，可以看到获取历史记录的API。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7967image.png" /></p>
<p>如上图所示，可以看到这是通过GET请求携带路径参数获取祈愿历史记录，其路径参数一览表如下所示，<strong>下面只说明比较重要的参数，其他的参数按照默认值即可</strong></p>
<ol>
<li>authkey: 账号认证key，就是登录认证token</li>
<li>page: 当前页码，不过这个不起作用</li>
<li>size: 每页的大小，默认为6，最大值为20</li>
<li>end_id: 结束ID</li>
<li>begin_id: 开始ID</li>
<li>gacha_type: 祈愿类型
<ol>
<li>301：角色祈愿</li>
<li>200：常驻祈愿</li>
<li>302：武器祈愿</li>
</ol>
</li>
</ol>
<p>复制API链接，打开postman进行访问，如下所示，可以清楚的看到可以获取到对应的JSON数据（省略了后面的数据）</p>
<pre>
<code class="language-json">{
"retcode": 0,
"message": "OK",
"data": {
"page": "1",
"size": "6",
"total": "0",
"list": [
{
"uid": "***",
"gacha_type": "400",
"item_id": "",
"count": "1",
"time": "2022-02-08 09:39:39",
"name": "铁影阔剑",
"lang": "zh-cn",
"item_type": "武器",
"rank_type": "3",
"id": "***"
},
...
],
"region": "cn_gf01"
}
}</code></pre>
<blockquote class="m-blockquote">
<p>这里需要注意的authkey的必须经过<span class="marker">url_encode</span>编码后才是有效的<span class="marker">authkey</span>，否则会返回<span class="marker">authkey error</span>的错误！</p>
</blockquote>
<p>然后我们修改page的值范围2，发现获取的还是第一页的数据，如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8489image.png" /></p>
<p>继续在浏览器中点击下一页的按钮，我们可以发现<span class="marker">end_id</span>这个参数是发生变化的，如下图所示。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7279image.png" /><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/3233image.png" /></p>
<p>第一页时，<span class="marker">end_id</span>的值为0，从第二页开始<span class="marker">end_id</span>的值就发生了变化了。这里应该是通过<span class="marker">JavaScript</span>代码使<span class="marker">end_id</span>的值动态变化，后端在请求查询的时候从<span class="marker">end_id</span>这个值开始查询，因此如果我们end_id这个值一直不变化的话，那么永远只能获取当前这一页的值，那么end_id的值是怎么来的呢？仔细查看页面，<strong>我发现我浏览器右上角的vue开发工具插件亮了</strong>，发现这个页面是用Vue开发的，于是我切换到开发者工具源代码页面，在bundle_***.js文件中搜索<strong>end_id关键字</strong>，可以看到如下图所示的代码。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2867image.png" /></p>
<p>这下就豁然开朗了，<span class="marker">end_id</span>的值就是当前页面查询结果最后一条记录的id的值，在<strong>postman中手动改变end_id的值</strong>，就可以愉快的获取下一页的记录啦，如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4348image.png" /></p>
<h1><a id="4.保存历史记录到本地" name="4.保存历史记录到本地"></a>4.保存历史记录到本地</h1>
<p>原神祈愿历史记录页面只提供最近六个月的祈愿历史记录，因此我们可以通过代码将历史记录保存到本地，下面的Python代码就可以将历史记录保存到本地。</p>
<pre>
<code class="language-python">import requests
import json
import datetime
import time
# 需要先安装requests库 pip install requests
# 替换你自己的authkey，必须是url_encode编码
authkey = ''
size = 20
end_id = 0
end_flag = False
gacha_type = {301: '角色祈愿', 302: '武器祈愿', 200: '常驻祈愿'}
# 替换为自己个gacha_id
gacha_id = ''
today = datetime.datetime.today().strftime('%Y%m%d_%H%M%S')
url = 'https://hk4e-api.mihoyo.com/event/gacha_info/api/getGachaLog?authkey_ver=1&amp;sign_type=2&amp;auth_appid' \
'=webview_gacha&amp;init_type=301&amp;gacha_id={}&amp;timestamp=1641338923&amp;lang=zh-cn' \
'&amp;device_type=pc&amp;game_version=CNRELWin2.4.0_R5691054_S5715829_D5736476&amp;plat_type=pc&amp;region=cn_gf01&amp;authkey={' \
'}&amp;game_biz=hk4e_cn&amp;gacha_type={}&amp;page=2&amp;size={}&amp;end_id={}'
for gt in gacha_type.keys():
index = 1
end_flag = False
end_id = 0
data = []
while not end_flag:
wishes = requests.get(url.format(gacha_id, authkey, gt, size, end_id)).json()
print(f'正在获取{gacha_type.get(gt)}祈愿第{index}页...')
if not wishes['data']['list']:
end_flag = True
print(f'{"*"*10}{gacha_type.get(gt)}祈愿获取完成!{"*"*10}')
break
data += wishes['data']['list']
end_id = wishes['data']['list'][-1]['id']
time.sleep(0.2)
index += 1
with open(f'{today}_{gacha_type.get(gt)}.json', 'w', encoding='utf8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
</code></pre>
<h1><a id="5.再次声明" name="5.再次声明"></a>5.再次声明</h1>
<blockquote class="m-blockquote">
<p>抽卡分析记录所有者为上海米哈游影铁科技有限公司（原神发行商），如若此篇博文侵害了上海米哈游影铁科技有限公司相关利益，请联系我邮箱804022023@qq.com，我会在第一时间删除此博文，并致歉！</p>
</blockquote>
<blockquote class="m-blockquote">
<p>此篇博文最主要的目的是分享，请各位看官切勿拿去做一些非法交易！！！</p>
</blockquote>
</content>
<link href="https://2dogz.cn/blog/article/53/" rel="alternate"/>
</entry>
<entry>
<id>52</id>
<title>[Linux]Linux关于磁盘备份dd命令以及fstab文件简介</title>
<updated>2023-09-27T02:08:19.929809+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. dd命令的使用" name="1. dd命令的使用"></a>1. dd命令的使用</h1>
<p>工作中遇到的需求就是将一台已经配置好了的环境的服务器备份系统到新的磁盘，然后将新的磁盘安装在新的服务器上可以直接启动系统，同时不需要重新配置新的运行环境了。领导说要我直接使用<span class="marker">dd</span>命令去做，因为之前没有用过<span class="marker">dd</span>命令，这里记录一下。（ps：后来也是通过dd命令完成了这项任务）</p>
<p>Linux <span class="marker">dd</span> 命令用于读取、转换并输出数据，<span class="marker">dd</span> 可从标准输入或文件中读取数据，根据指定的格式来转换数据，再输出到文件、设备或标准输出，其可以携带的参数(只说明一些常用参数，详细参数可参考<a href="https://www.runoob.com/linux/linux-comm-dd.html">dd命令参数</a>)如下所示</p>
<ul>
<li>if 输入设备，输入文件名，默认为标准输入。即指定源文件</li>
<li>of 输出设备，输出文件名，默认为标准输出。即指定目的文件</li>
<li>bs 输入、输出块的大小</li>
</ul>
<p>备份一个磁盘分区到U盘</p>
<pre>
<code class="language-bash">sudo dd if=/dev/sda5 of=/dev/sdc</code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1987image.png" /></p>
<p>默认情况下，<span class="marker">bs</span>的大小为<span class="marker">512</span>，可以通过bs参数指定其大小，指定<span class="marker">bs</span>大小为5<span class="marker">M</span></p>
<pre>
<code class="language-bash">sudo dd if=/dev/sda5 of=/dev/sdc bs=5M</code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5105image.png" style="height:85px; width:581px" /></p>
<p>可以到拷贝的速度要比默认bs大小要快，<strong>至于bs的大小多少合理，应该要看磁盘的IO速度。</strong></p>
<p>如果说备份的内容比较大，我们要等待很久，这时我们可以打开一个新的终端，然后通过<span class="marker">watch</span>命令去查看dd命令的执行速度，执行完下面的命令后，回到dd命令执行的终端就可以看到执行进度了，如下图，如果不想查看，在<strong>执行watch命令的终端</strong>按<kbd>Ctrl+c</kbd>即可关闭。</p>
<pre>
<code class="language-bash">sudo watch -n 5 pkill -USR1 -x dd</code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8101image.png" /></p>
<h3><strong>dd与cp的区别</strong></h3>
<ol>
<li>dd命令是通过数据流进行复制的，而cp命令是通过文件为单位进行拷贝的；</li>
<li>dd命令的of输出的大小必须大于或者等于if输入磁盘的总大小(不是使用大小)，而cp命令只需要目标盘空间大于输入盘已使用空间大小即可；</li>
<li>dd命令执行完毕后of目标盘的分区、每个扇区的数据都与if盘一样，而cp命令只是将数据拷贝到目标盘空闲空间，扇区数据不一定与输入盘一致；</li>
</ol>
<p>如果我们需要备份系统，通过dd命令备份后，of输出盘可以直接插在其他机器上使用并顺利启动系统。</p>
<blockquote class="m-blockquote">
<p>使用dd命令时会清空目标盘的所有数据，请确保使用前已经备份目标盘的所有数据！！！</p>
</blockquote>
<h1><a id="2. fstab文件" name="2. fstab文件"></a>2. fstab文件</h1>
<p>很多服务器都是一个系统盘，然后若干个数据盘，我们通过dd命令备份系统盘之后，放在其他机器上启动时，有时候会发现进入<strong>rescue mode</strong>，查看启动信息如果发现是<strong>Timed out waiting for device xxxx</strong>这种错误的话<strong>一般是找不到fstab中指定的设备所导致的</strong>，接下来就说道说道fstab这个文件的作用。</p>
<p>fstab文件存在在/etc目录下，默认内容如下所示。</p>
<pre>
<code class="language-objectivec"># /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# &lt;file system&gt; &lt;mount point&gt; &lt;type&gt; &lt;options&gt; &lt;dump&gt; &lt;pass&gt;
# /dev/sdb3 LABEL=SYSROOT
UUID=ab6a416a-8664-4704-b86d-7260625f68c9 / ext4 rw,relatime 0 1
# /dev/sdb2 LABEL=SYSBOOT
UUID=446bc5e4-8100-4c9a-9dbf-1a8aeb5e94fc /boot ext4 rw,relatime 0 0
# /dev/sdb1 LABEL=ESP
UUID=DE13-1B25 /boot/efi vfat rw,relatime,fmask=0022,dmask=0022,codepage=437,iocharset=iso8859-1,shortname=mixed,errors=remount-ro 0 0
</code></pre>
<p>可以看到第一行 <strong>/etc/fstab: static file system information. </strong>意思就是静态文件系统信息。接下来可以看到提示信息通过<span class="marker">blkid</span>来获取设备的通用唯一标识符UUID，fstab配置文件所提供的参数有6种，如下所示</p>
<ul>
<li><strong>file system:</strong> 文件系统，可以通过<strong>/dev/xxx</strong>来表示或者通过<strong>UUID=xxx</strong>或者<strong>label</strong>来表示，<strong>这里推荐使用UUID的表示来配置，因为设备ID是唯一的</strong>，即使你重新插拔磁盘，其UUID是不会改变的，但是重新插拔后其/dev/xxx可能会改变，比如一开始设备编号是/dev/sdc，你插拔之后变为了/dev/sdd了，这时候如果你没改变fstab里面的内容，开机就会进入rescue mode；</li>
<li><strong>mount point:</strong> 挂载点，就是设备挂载在哪个路径下，跟我们执行mount命令时一样，这个目录必须是存在的；</li>
<li><strong>type:</strong> 文件系统类型，指定挂载设备的文件系统类型，可以通过<span class="marker">blkid查看到设备对应的文件系统类型</span>，如下图，常见的有ext4等</li>
<li><strong>option:</strong> 可以选参数，一般就是mount命令可以跟的参数，但是要注意有些参数只对应特定的文件系统才有效，一般填写<span class="marker">defaults</span>就可以了，既通过读写模式挂载，其他参数可以网上冲浪搜索；</li>
<li><strong>dump: </strong>是否使用dump工具进行备份，0表示忽略，1表示备份，填写1时你必须确保已经安装了dump工具；</li>
<li>pass: 是否使用fsck命令检查，可以设置为0, 1, 2，<strong>根文件系统必须设置为1</strong>，以保证其最高优先级，2则表示检查文件系统，0表示不检查文件系统；</li>
</ul>
<pre>
<code class="language-objectivec"># /dev/sda8 LABEL=WORK-DATA
UUID=39fd4aa5-e4ba-4618-8ce2-4ebe9e0325d5 /home/ubuntu/data ext4 defaults 0 0</code></pre>
<p>添加上面的配置信息，开机就会自动将<strong>/dev/sda8</strong>自动挂载到<strong>/home/ubuntu/data</strong>目录下；</p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/52/" rel="alternate"/>
</entry>
<entry>
<id>51</id>
<title>[MySQL]MySQL5.7版本后GROUP BY问题</title>
<updated>2023-09-27T02:08:19.929781+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 起因" name="1. 起因"></a>1. 起因</h1>
<p>最近在做一个开源项目，中间用到了<span class="marker">group by</span>查询，在本地测试的时候没有啥问题，但是项目更新到服务器上之后出现了下面的错误</p>
<blockquote class="m-blockquote">
<p>ERROR 1055 (42000): Expression #1 of SELECT list is not in GROUP BY clause and contains nonaggregated column &#39;bbs.t_private_message.id&#39; which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by</p>
</blockquote>
<p>字面上的意思是<span class="marker">SELECT</span>里面的列必须包含在<span class="marker">GROUP BY</span>当中，于是网上冲浪查询相关的坑，发现有下面两种解决方案。</p>
<h1><a id="2. 修改sql_mode" name="2. 修改sql_mode"></a>2. 修改sql_mode</h1>
<p>修改<span class="marker">global.sql_mode</span>有两种方式，第一种通过<code>SET</code>语句进行修改，如下</p>
<pre>
<code class="language-sql">select @@global.sql_mode
# ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
set @@global.sql_mode = `STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION`</code></pre>
<p>如果上面的方法没有生效，试着用下面的方法</p>
<pre>
<code class="language-sql">select @@session.sql_mode
#ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
set @@session.sql_mode = `STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION`</code></pre>
<p>第二种方式是通过修改配置文件，<strong>这种方法的可行性有待商榷</strong>，我自行修改没有生效，还会导致<strong>MySQL</strong>服务启动不起来了</p>
<pre>
<code class="language-sql"># 在文件最后加上下面的内容
[mysqld]
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
# 重启MySQL服务
sudo systemctl restart mysql.service</code></pre>
<h1><a id="3. 使用ANY_VALUE" name="3. 使用ANY_VALUE"></a>3. 使用ANY_VALUE</h1>
<p>程序猿都比较喜欢折腾，我也是。总感觉MySQL自动开启<span class="marker">ON_FULL_GROUP_BY</span>的运行模式有它自己的考虑。因此就去MySQL官网查找相关的文档，在<span class="marker">GROUP BY</span>这一节开篇有下面一段话</p>
<blockquote class="m-blockquote">
<p>SQL-92 and earlier does not permit queries for which the select list, <code>HAVING</code> condition, or <code>ORDER BY</code> list refer to nonaggregated columns that are not named in the <code>GROUP BY</code> clause. For example,this query is illegal in standard SQL-92 because the nonaggregated <code>name</code> column in the select list does not appear in the <code>GROUP BY</code>:</p>
</blockquote>
<pre>
<code class="language-sql">SELECT o.custid, c.name, MAX(o.payment)
FROM orders AS o, customers AS c
WHERE o.custid = c.custid
GROUP BY o.custid;</code></pre>
<p>上面引用的大概意思就是在<code>SQL-92</code>以及更早的版本<span class="marker">SELECT、HAVING、ORDER BY</span>中出现的字段名必须包含在<span class="marker">GROUP BY</span>当中，上面的查询语句当中包含有<span class="marker">name</span>字段，但是<span class="marker">name</span>字段没有包含在<span class="marker">GROUP BY</span>当中，所以上述SQL语句是非法的在SQL-92后的版本。</p>
<p>继续往下看也看到了上面两种解决方式<a href="https://dev.mysql.com/doc/refman/8.0/en/sql-mode.html#sqlmode_only_full_group_by">sql_mode相关介绍</a>，继续往下翻看到了下面的内容</p>
<blockquote class="m-blockquote">
<p>If you know that, <em>for a given data set,</em> each <code>name</code> value in fact uniquely determines the <code>address</code> value, <code>address</code> is effectively functionally dependent on <code>name</code>. To tell MySQL to accept the query, you can use the <a href="https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_any-value"><code>ANY_VALUE()</code></a></p>
</blockquote>
<p>意思就是可以使用<span class="marker">ANY_VALUE()</span>这个函数来包裹你想要查询的列，但是这个列又可以不包裹在<span class="marker">GROUP BY</span>当中，如下面的SQL语句就是合法的</p>
<pre>
<code class="language-sql">SELECT name, ANY_VALUE(address), MAX(age) FROM t GROUP BY name;</code></pre>
<h1>4. 栗子</h1>
<p>说一千道一万还不如举个栗子来个实在，这个问题是在我开源项目的私信模块里面发现的，最开始我就是想通过<span class="marker">GROUP BY</span>查找到与当前用户相关的私信，通过<span class="marker">sender_id</span>来进行分组，私信表结构如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2706image.png" /></p>
<p>下面就通过一个栗子来演示一下</p>
<pre>
<code class="language-python">"""
# coding:utf-8
@Time : 2021/11/23
@Author : jiangwei
@File : private_letter.py
@Desc : private_letter
@email : qq804022023@gmail.com
@Software: PyCharm
"""
from flask import Flask, render_template, redirect, url_for, flash
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.sql.expression import func
from faker import Faker
import random
import datetime
username = 'jiangwei'
password = '1994124'
database = 'demo'
f = Faker(locale='zh_CN')
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = f'mysql+pymysql://{username}:{password}@localhost/{database}?charset=utf8'
app.config['SECRET_KEY'] = 'sfajn1314jnm14h1'
db = SQLAlchemy(app)
class PrivateMessage(db.Model):
__tablename__ = 't_private_message'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
sender_id = db.Column(db.INTEGER, nullable=False)
receiver_id = db.Column(db.INTEGER, nullable=False)
content = db.Column(db.TEXT, nullable=False, default='')
c_time = db.Column(db.DATETIME, default=datetime.datetime.now)
db.create_all()
@app.route('/')
def index():
user_id = random.randint(1, 3)
return render_template('index.html', user_id=user_id)
@app.route('/insert')
def insert():
for i in range(10):
pm = PrivateMessage(
sender_id=random.randint(1, 20),
receiver_id=random.randint(1, 3),
content=f.sentence()
)
db.session.add(pm)
db.session.commit()
flash('插入数据成功!')
return redirect(url_for('.index'))
@app.route('/insert/&lt;user_id&gt;')
def query(user_id):
pms = PrivateMessage.query.\
with_entities(PrivateMessage.sender_id,
func.any_value(PrivateMessage.content),
func.max(PrivateMessage.c_time)). \
filter(PrivateMessage.receiver_id == user_id). \
order_by(func.max(PrivateMessage.c_time).desc()). \
group_by(PrivateMessage.sender_id).all()
return render_template('query.html', pms=pms, user_id=user_id)
if __name__ == '__main__':
app.run(port=5005, debug=True)</code></pre>
<p>上面是一个非常简答的Flask应用，首先我们通过继承<code>db.Model</code>来定义表<code>t_private_message</code>的表结构，之后通过<code>db.create_all</code>来创建表，然后实例化<code>Flask</code>创建一个<code>flask</code>实例，通过该实例创建了三个视图函数<code>index</code>、<code>insert</code>、<code>query</code>，分别对应<code>首页视图</code>、<code>插入数据视图</code>、<code>查询数据视图</code>，我们所用到的<code>any_value</code>方法就包含在查询视图中，代码如下</p>
<pre>
<code class="language-python">@app.route('/insert/&lt;user_id&gt;')
def query(user_id):
pms = PrivateMessage.query.\
with_entities(PrivateMessage.sender_id,
func.any_value(PrivateMessage.content),
func.max(PrivateMessage.c_time)). \
filter(PrivateMessage.receiver_id == user_id). \
order_by(func.max(PrivateMessage.c_time).desc()). \
group_by(PrivateMessage.sender_id).all()
return render_template('query.html', pms=pms, user_id=user_id)</code></pre>
<p>在<code>sqlalchemy</code>中我们可以使用<code>with_entities</code>来指定我们需要查询的列，通过<code>any_value</code>函数包裹<code>content、c_time</code>字段，然后通过<code>c_time</code>进行排序，最后通过<code>GROUP BY</code>进行分组，点击首页页面上<code>插入数据</code>按钮插入10条测试数据，然后点击<code>查询私信</code>按钮结果如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6751image.png" /></p>
<p>我们可以清楚地看到<code>Sender ID</code>出现顺序根据<code>Send Time</code>进行了逆序排列了，达到了最新发送的消息在最上方的目的，如下图(来自我的开源项目<code>university-bbs</code>私信模块，请忽略聊天文本，仅仅是为了测试所用<a href="!https://bbs.2dogz.cn">二狗学院</a>)</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5076image.png" /></p>
<blockquote class="m-blockquote">
<p>在<code>sqlalchemy</code>中如果使用了<code>with_entities</code>来指定了查询列，查询结果不再是<code>Object</code>对象了，而是一个列表中嵌套了元祖的形式！</p>
</blockquote>
<p>上面的代码只能在MySQL5.7以上的版本运行，因为MySQL5.7以下的版本没有<code>ANY_VALUE</code>这个函数，因此为了适配MySQL5.7以下的版本需要改进以下代码，如下代码段所示</p>
<pre>
<code class="language-python">@app.route('/insert/&lt;user_id&gt;')
def query(user_id):
try:
pms = PrivateMessage.query.\
with_entities(PrivateMessage.sender_id,
func.any_value(PrivateMessage.content),
func.max(PrivateMessage.c_time)). \
filter(PrivateMessage.receiver_id == user_id). \
order_by(func.max(PrivateMessage.c_time).desc()). \
group_by(PrivateMessage.sender_id).all()
except Exception as e:
pms = PrivateMessage.query.\
with_entities(PrivateMessage.sender_id,
PrivateMessage.content,
func.max(PrivateMessage.c_time)).\
filter(PrivateMessage.receiver_id == user_id).\
order_by(func.max(PrivateMessage.c_time).desc()).\
group_by(PrivateMessage.sender_id).all()
return render_template('query.html', pms=pms, user_id=user_id)</code></pre>
<p>很简单就是通过try来捕获异常，如果发生异常则使用<code>except</code>代码块里面的查询，上述示例代码存放于<a href="https://github.com/weijiang1994/blog-demo.git">https://github.com/weijiang1994/blog-demo.git</a></p>
</content>
<link href="https://2dogz.cn/blog/article/51/" rel="alternate"/>
</entry>
<entry>
<id>50</id>
<title>[Python]PIL图片添加文本时自动换行解决方案</title>
<updated>2023-09-27T02:08:19.929754+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 使用PIL给图片添加文本" name="1. 使用PIL给图片添加文本"></a>1. 使用PIL给图片添加文本</h1>
<p>如简介中所述，PIL可以方便的在图片上添加文本，一般都是通过PIL中ImageFont类实现该功能，下面的示例代码就是简单的在图片上添加两段文本。</p>
<pre>
<code class="language-python">from PIL import Image, ImageFont, ImageDraw
texts = ['燕子去了，有再来的时候；杨柳枯了，有再青的时候；桃花谢了，有再开的时候。但是，聪明的，你告诉我，我们的日子为什么一去不复返呢？——是有人偷了他们罢：那是谁？又藏在何处呢？是他们自己逃走了罢：现在又到了哪里呢？',
'我不知道他们给了我多少日子；但我的手确乎是渐渐空虚了。在默默里算着，八千多日子已经从我手中溜去；像针尖上一滴水滴在大海里，我的日子滴在时间的流里，没有声音，也没有影子。我不禁头涔涔而泪潸潸了。']
picture = 'congcong.png'
font_size = 24
font_file = 'simhei.ttf'
position = [34, 106]
def add_text():
with Image.open(picture) as im:
if im.mode.upper() == 'RGBA':
layer = Image.new(
'RGBA', im.size, color=(255, 255, 255, 255)
)
im = Image.alpha_composite(layer, im)
draw = ImageDraw.Draw(im)
font = ImageFont.truetype(font_file, font_size)
for text in texts:
draw.text(tuple(position), text, font=font, fill='black')
position[1] += 25
im.save('no_break.png', format='PNG')
im.show()
add_text()</code></pre>
<p>上面的示例代码很简单，首先通过<span class="marker">texts</span>列表定义了我们需要添加在图片上的文本，然后指定文本字体大小、字体文件路径以及开始添加文本的<span class="marker">坐标点(x, y)</span>，因为有些PNG图片是带有透明通道的，因此先判断了图片的模式是否是<span class="marker">RGBA</span>模式，如果是则添加透明的涂层，如果不是则直接通过<span class="marker">ImageDraw.draw()</span>方法实例化出一个<span class="marker">draw</span>对象，这个draw对象就是在图片上添加文本的核心实例对象，通过draw实例中的<span class="marker">text()</span>方法将两段文本添加到图片上去，上述代码的运行结果如下图所示。可以看到当需要添加的文本长度过长时，PIL并不会自动进行换行，因此我们需要在文本过长时让其进行自动换行。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/3661image.png" /></p>
<blockquote class="m-blockquote">
<p>如果在你添加的文本中包含有回车符号(\n)PIL是会自动给你进行换行的，但是在实际开发中很多时候我们都是事先不知道文本的具体的长度的！</p>
</blockquote>
<h1><a id="2. 跟字符数截取然后进行换行" name="2. 跟字符数截取然后进行换行"></a>2. 跟字符数截取然后进行换行</h1>
<p>在第一节的代码中我们可以清楚的知道在写到第<span class="marker">21</span>个字符的时候文本就所占用的像素长度就超过了图片的长度，因此我们可以通过21这个长度作为临界点来截取字符的长度然后换行重新书写，代码如下</p>
<pre>
<code class="language-python">from PIL import Image, ImageFont, ImageDraw
texts = ['燕子去了，有再来的时候；杨柳枯了，有再青的时候；hello, world,有再开的时候。But, you tell me '
'，我们的日子为什么一去不复返呢？——是有人偷了他们罢：那是谁？又藏在何处呢？是他们自己逃走了罢：现在又到了哪里呢？',
'我不知道他们给了我多少日子；但我的手确乎是渐渐空虚了。在默默里算着，八千多日子已经从我手中溜去；像针尖上一滴水滴在大海里，我的日子滴在时间的流里，没有声音，也没有影子。我不禁头涔涔而泪潸潸了。']
picture = 'congcong.png'
font_size = 24
font_file = 'simhei.ttf'
position = [34, 106]
def add_text():
with Image.open(picture) as im:
if im.mode.upper() == 'RGBA':
layer = Image.new(
'RGBA', im.size, color=(255, 255, 255, 255)
)
im = Image.alpha_composite(layer, im)
draw = ImageDraw.Draw(im)
font = ImageFont.truetype(font_file, font_size)
for text in texts:
index = 0
while index &lt; len(text):
draw.text(tuple(position), text[index:index+21], font=font, fill='black')
index += 21
position[1] += 30
position[1] += 20
im.show()
im.save('break_by_char_count.png', format='PNG')
add_text()
</code></pre>
<p>上面的代码跟第一节实例代码类似，只是在添加文本的时候自动截取了字符串的长度，然后重新换行书写，其结果如下图所示，但是我们还是会发现一些问题。如果当字符中包含有中英文的时候，因为中英文在同一种字体中一个字符所占用的长度明显是不一样的，可以看到第二行明显就没有对齐，对于这种情况我们可以使用第三节的解决方案。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/3432image.png" /></p>
<h1><a id="3. 使用X轴坐标阈值自动换行" name="3. 使用X轴坐标阈值自动换行"></a>3. 使用X轴坐标阈值自动换行</h1>
<p>在PIL的ImageFont库中，可以通过<span class="marker">font.font.get_size(text)</span>来获取text文本所占用的像素长度，因此可以通过设置一个X轴的最大阈值来判断文本是否过长，示意图如下。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2351image.png" /></p>
<p>首先我们通过一些软件(Photo Shop或者GIMP等)获取底图的书写开始坐标以及书写最大X轴坐标，先在代码中设置最大阈值，然后通过getsize()方法获取将要书写的文本的所占用的像素点，我们可以事先设置一个假设的长度，比如这里的21(在实际中可以先测试一下字符的个数然后设置一个理想值)来截取文本的长度，实例代码如下</p>
<pre>
<code class="language-python">from PIL import Image, ImageFont, ImageDraw
texts = ['燕子去了，有再来的时候；杨柳枯了，有再青的时候；hello, world,有再开的时候。But, you tell me '
'，我们的日子为什么一去不复返呢？——是有人偷了他们罢：那是谁？又藏在何处呢？是他们自己逃走了罢：现在又到了哪里呢？',
'我不知道他们给了我多少日子；但我的手确乎是渐渐空虚了。在默默里算着，八千多日子已经从我手中溜去；像针尖上一滴水滴在大海里，我的日子滴在时间的流里，没有声音，也没有影子。我不禁头涔涔而泪潸潸了。']
picture = 'congcong.png'
font_size = 24
font_file = 'simhei.ttf'
position = [34, 106]
max_x = 520
guess_count = 21
def add_text(gc=guess_count):
with Image.open(picture) as im:
if im.mode.upper() == 'RGBA':
layer = Image.new(
'RGBA', im.size, color=(255, 255, 255, 255)
)
im = Image.alpha_composite(layer, im)
draw = ImageDraw.Draw(im)
font = ImageFont.truetype(font_file, font_size)
for text in texts:
index = 0
while index &lt; len(text):
while font.font.getsize(text[index: index + gc])[0][0] + position[0] &lt; max_x and index + gc &lt; len(text):
gc += 1
draw.text(tuple(position), text[index:index + gc], font=font, fill='black')
index += gc
position[1] += 30
gc = guess_count
position[1] += 20
im.show()
im.save('break_by_char_count.png', format='PNG')
add_text()</code></pre>
<p>上述代码的关键地方在于最大X轴坐标、文本理想长度、以及getsize()方法，通过这三者就可以实现通过像素点进行自动换行了，效果图如下。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/725image.png" /></p>
<p>上面的代码源码都已开源在GitHub点击链接获取&nbsp;<a href="https://github.com/weijiang1994/blog-demo/tree/main/pillow_font_break">https://github.com/weijiang1994/blog-demo/tree/main/pillow_font_break</a></p>
</content>
<link href="https://2dogz.cn/blog/article/50/" rel="alternate"/>
</entry>
<entry>
<id>49</id>
<title>[Python]web2py的一些不常用的配置记录</title>
<updated>2023-09-27T02:08:19.929726+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 错误日志配置" name="1. 错误日志配置"></a>1. 错误日志配置</h1>
<p>在<span class="marker">web2py</span>的根目录中有一个<span class="marker">examples</span>的文件夹，其中有一个文件名为<span class="marker">logging.example.conf</span>的文件，执行下面的命令将其拷贝到web2py的根目录中。</p>
<pre>
<code class="language-bash">cp logging.example.conf ../logging.conf</code></pre>
<p>logging.conf文件的内容如下所示</p>
<pre>
<code class="language-ini"># Configure the Python logging facility.
# To use this file, copy it to logging.conf and edit logging.conf as required.
# See http://docs.python.org/library/logging.html for details of the logging facility.
# Note that this is not the newer logging.config facility.
#
# The default configuration is console-based (stdout) for backward compatibility;
# edit the [handlers] section to choose a different logging destination.
#
# Note that file-based handlers are thread-safe but not mp-safe;
# for mp-safe logging, configure the appropriate syslog handler.
#
# To create a configurable logger for application 'myapp', add myapp to
# the [loggers] keys list and add a [logger_myapp] section, using
# [logger_welcome] as a starting point.
#
# In your application, create your logger in your model or in a controller:
#
# import logging
# logger = logging.getLogger("web2py.app.myapp")
# logger.setLevel(logging.DEBUG)
#
# To log a message:
#
# logger.debug("You ought to know that %s", details)
#
# Note that a logging call will be governed by the most restrictive level
# set by the setLevel call, the [logger_myapp] section, and the [handler_...]
# section. For example, you will not see DEBUG messages unless all three are
# set to DEBUG.
#
# Available levels: DEBUG INFO WARNING ERROR CRITICAL
[loggers]
keys=root,rocket,markdown,web2py,rewrite,cron,app,welcome
[handlers]
keys=consoleHandler,messageBoxHandler,rotatingFileHandler
#keys=consoleHandler,rotatingFileHandler
#keys=osxSysLogHandler
#keys=notifySendHandler
[formatters]
keys=simpleFormatter
[logger_root]
level=WARNING
handlers=consoleHandler,rotatingFileHandler
[logger_web2py]
level=WARNING
handlers=consoleHandler,rotatingFileHandler
qualname=web2py
propagate=0
# URL rewrite logging (routes.py)
# See also the logging parameter in routes.py
#
[logger_rewrite]
level=WARNING
qualname=web2py.rewrite
handlers=consoleHandler,rotatingFileHandler
propagate=0
[logger_cron]
level=WARNING
qualname=web2py.cron
handlers=consoleHandler,rotatingFileHandler
propagate=0
# generic app handler
[logger_app]
level=WARNING
qualname=web2py.app
handlers=consoleHandler,rotatingFileHandler
propagate=0
# welcome app handler
[logger_welcome]
level=WARNING
qualname=web2py.app.welcome
handlers=consoleHandler,rotatingFileHandler
propagate=0
# loggers for legacy getLogger calls: Rocket and markdown
[logger_rocket]
level=WARNING
handlers=consoleHandler,messageBoxHandler,rotatingFileHandler
qualname=Rocket
propagate=0
[logger_markdown]
level=WARNING
handlers=consoleHandler,rotatingFileHandler
qualname=markdown
propagate=0
[handler_consoleHandler]
class=StreamHandler
level=WARNING
formatter=simpleFormatter
args=(sys.stdout,)
[handler_messageBoxHandler]
class=gluon.messageboxhandler.MessageBoxHandler
level=ERROR
formatter=simpleFormatter
args=()
[handler_notifySendHandler]
class=gluon.messageboxhandler.NotifySendHandler
level=ERROR
formatter=simpleFormatter
args=()
# Rotating file handler
# mkdir logs in the web2py base directory if not already present
# args: (filename[, mode[, maxBytes[, backupCount[, encoding[, delay]]]]])
#
[handler_rotatingFileHandler]
class=handlers.RotatingFileHandler
level=DEBUG
formatter=simpleFormatter
args=("web2py.log", "a", 1000000, 5)
[handler_osxSysLogHandler]
class=handlers.SysLogHandler
level=WARNING
formatter=simpleFormatter
args=("/var/run/syslog", handlers.SysLogHandler.LOG_DAEMON)
[handler_linuxSysLogHandler]
class=handlers.SysLogHandler
level=WARNING
formatter=simpleFormatter
args=("/dev/log", handlers.SysLogHandler.LOG_DAEMON)
[handler_remoteSysLogHandler]
class=handlers.SysLogHandler
level=WARNING
formatter=simpleFormatter
args=(('sysloghost.domain.com', handlers.SYSLOG_UDP_PORT), handlers.SysLogHandler.LOG_DAEMON)
[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=</code></pre>
<p>假设你的<span class="marker">application</span>名称为<span class="marker">hello</span>，在<span class="marker">logging.conf</span>文件中添加如下内容，为<span class="marker">hello</span>应用开启<span class="marker">logging</span>日志记录</p>
<pre>
<code class="language-ini">[logger_hello]
level=WARNING
qualname=web2py.app.hello
handlers=consoleHandler,rotatingFileHandler
propagate=0
</code></pre>
<p>同时在你的<span class="marker">models</span>目录的第一个文件中添加下面的代码</p>
<pre>
<code class="language-python">import logging
logger = logging.getLogger('web2py.app.hello')</code></pre>
<p>这样你在你的<span class="marker">controller</span>中就可以使用如下代码来追踪错误日志了</p>
<pre>
<code class="language-python"># hello.py
def index():
try:
user = db(db.auth_user).select()
except:
import traceback
logger.error(traceback.format_exc())</code></pre>
<h1><a id="2. 配置默认应用" name="2. 配置默认应用"></a>2. 配置默认应用</h1>
<p>在<span class="marker">web2py</span>的<span class="marker">applications</span>目录中默认的会有<span class="marker">welcome</span>这个应用，当我们启动服务访问<span class="marker">http://127.0.0.1:8000</span>的时候会自动定位到welcome这个application，其实我们可以通过配置来自行修改这个默认应用。进入到web2py的根目录中，新建一个<span class="marker">routes.py</span>文件</p>
<pre>
<code class="language-bash">cd /var/web2py
vim routes.py</code></pre>
<p>假设我们需要默认定位的应用为hello，在routes.py文件中输入下面的内容</p>
<pre>
<code class="language-python">default_application = "hello"
default_controller = "default"
default_function = "index"</code></pre>
<p>如果你想默认不是跳转到首页，你也可以自行定义<span class="marker">default_controller</span>以及<span class="marker">default_function</span>两个参数。个人认为这个配置一般的是在部署到服务器的时候使用域名访问的时候比较有用，在本地开发测试的时候没有必要去配置。</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/49/" rel="alternate"/>
</entry>
<entry>
<id>48</id>
<title>[系列教程]使用Flask搭建一个校园论坛9-支持Markdown语法</title>
<updated>2023-09-27T02:08:19.929698+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. python-markdown" name="1. python-markdown"></a>1. python-markdown</h1>
<p><span class="marker">python</span>的之所以变得非常的流行，其最强大的地方就是拥有很多第三库，通过第三方库可以快速的实现很多功能，论坛评论<span class="marker">markdown</span>语法的支持就是通过<span class="marker">python-markdown</span>库实现的，本节展示一下<span class="marker">python-markdown</span>库的基本用法。</p>
<p>首先通过<span class="marker">pip</span>命令进行安装</p>
<pre>
<code class="language-bash">pip install markdown</code></pre>
<p>最简单的<span class="marker">markdown</span>转换为<span class="marker">html</span>代码</p>
<pre>
<code class="language-python">from markdown import markdown
md = "## 标题2"
html = markdown(md)
print(html)</code></pre>
<p>我们只需要将要转换的<span class="marker">markdown</span>语法的内容传递给<span class="marker">markdown.markdown()</span>方法，就会转换成相应的<span class="marker">html</span>代码，上述代码的输出结果是<span class="marker">&lt;h2&gt;标题2&lt;/h2&gt;</span></p>
<p>markdown这个库的生态十分完整，很多常用的功能它都自己内部解决了，如果不能自行解决，在markdown()方法中还可以通过extensions位置参数提供不同的扩展，下面的代码就是通过TOC扩展实现自动添加目录的功能</p>
<pre>
<code class="language-python">from markdown import markdown
md = """[TOC]
## 1. 标题1
我的祖国
### 1. 湖南
我的家乡在湖南
"""
html = markdown(md, extensions=['markdown.extensions.toc'])
print(html)</code></pre>
<p>上面的代码输出如下图所示，通过TOC扩展，就可以实现自动生成目录的功能</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9739image.png" /></p>
<p>上面的代码中的TOC拓展渲染出来的ul没有样式，如果我们想要自定义对应元素的样式该怎么办呢？我们可以自定义我们的扩展，如下面的代码片段所示</p>
<pre>
<code class="language-python">from markdown import extensions
from markdown.treeprocessors import Treeprocessor
class MyMDStyleTreeProcessor(Treeprocessor):
def run(self, root):
for child in root.iter():
if child.tag == 'ul':
child.set('class', 'ul-content')
elif child.tag == 'li':
child.set('class', 'li-content-text')
return root
class MyMDStyleExtension(extensions.Extension):
def extendMarkdown(self, md):
md.registerExtension(self)
self.processor = MyMDStyleTreeProcessor()
self.processor.md = md
self.processor.config = self.getConfigs()
md.treeprocessors.add('mystyle', self.processor, '_end')
md = """[TOC]
## 1. 标题1
我的祖国
### 1. 湖南
我的家乡在湖南
"""
html = markdown(md, extensions=['markdown.extensions.toc', MyMDStyleExtension()])
print(html)</code></pre>
<p>在上面的代码中，首先通过继承<span class="marker">Treeprocessor</span>类，通过判断节点的属性是否为<span class="marker">ul或者li</span>来给节点添加上对应的<span class="marker">class</span>属性，之后通过继承<span class="marker">Extension</span>类，将我们自定义的<span class="marker">extension</span>注册到<span class="marker">markdown</span>文本上去，上述代码输出如下图所示，可以看到在ul和li标签分别添加上了对应的class属性，在html页面中我们就可以通过设置class属性的css来调整目录的样式了。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1327image.png" /></p>
<h1><a id="2. 预览评论" name="2. 预览评论"></a>2. 预览评论</h1>
<p>有了上面一节的基础后就可以开始实现评论markdown语法支持了，在评论区域使用的是两个TAB，第一个TAB是输入评论内容的，第二TAB是预览所输入的评论被渲染后的样式（参照github设计），原始markdown内容如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/473image.png" /></p>
<p>点击预览渲染后的样式如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1965image.png" /></p>
<p>评论内容是支持代码内容渲染的，在<span class="marker">extensions</span>位置参数中添加<code>extensions=[&#39;markdown.extensions.codehilite&#39;]</code>即可，但是该扩展依赖于<span class="marker">Pygments</span>，所以我们使用之前应该先安装<span class="marker">Pygments</span></p>
<pre>
<code class="language-bash">pip install pygments</code></pre>
<p>安装完成之后我们可以使用<code>pygmentize -S default -f html -a .codehilite &gt; styles.css</code> 命令导出代码高亮样式，<span class="marker">Pygments</span>支持变成语言以及代码样式非常多，可以访问<a href="https://pygments.org/demo/#">https://pygments.org/demo/#</a>进行选择，然后通过前面的命令在命令行中导出相应的样式css文件。</p>
<p>完成上述步骤之后，我们就可以自定义我们的markdown扩展了，自定义代码片段如下所示</p>
<pre>
<code class="language-python">class MyMDStyleTreeProcessor(Treeprocessor):
def run(self, root):
for child in root.getiterator():
if child.tag == 'table':
child.set("class", "table table-bordered table-hover")
elif child.tag == 'img':
child.set("class", "img-fluid d-block img-pd10")
elif child.tag == 'blockquote':
child.set('class', 'blockquote-comment')
elif child.tag == 'p':
child.set('class', 'mt-0 mb-0 p-break')
elif child.tag == 'pre':
child.set('class', 'mb-0')
elif child.tag == 'h1':
child.set('class', 'comment-h1')
elif child.tag == 'h2':
child.set('class', 'comment-h2')
elif child.tag == 'h3':
child.set('class', 'comment-h3')
elif child.tag in ['h4', 'h5', 'h6']:
child.set('class', 'comment-h4')
return root
# noinspection PyAttributeOutsideInit
class MyMDStyleExtension(extensions.Extension):
def extendMarkdown(self, md):
md.registerExtension(self)
self.processor = MyMDStyleTreeProcessor()
self.processor.md = md
self.processor.config = self.getConfigs()
md.treeprocessors.add('mystyle', self.processor, '_end')</code></pre>
<p>与第一节给ul以及li标签添加class属性一致，通过上面的代码可以自定义一些标签的相关样式。有些小伙伴就比较好奇，为什么不用定义代码高亮的样式呢？因为codehilite扩展会自动将我们的代码转换成对应的html，不同的代码内容自动添加不同class，然后通过前面导出的样式文件实现代码高亮，所以这里不需要我们做任何处理。完成了自定义扩展之后，就是后端视图函数的编写了，代码片段如下。</p>
<pre>
<code class="language-python">@normal_bp.route('/comment/render-md/', methods=['POST'])
@login_required
def render_md():
md = request.form.get('md')
html = to_html(md)
return jsonify({'html': html})
</code></pre>
<p>上面代码片段逻辑应该比较清楚了，就是获取前端传过来的原始md数据，然后通过to_html方式转换成html，然后返回给前端进行渲染，其中to_html()方法代码如下</p>
<pre>
<code class="language-python">def to_html(raw):
allowed_tags = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'a', 'abbr', 'b', 'br', 'blockquote', 'code', 'del', 'div',
'em', 'img', 'p', 'pre', 'strong', 'span', 'ul', 'li', 'ol']
allowed_attributes = ['src', 'title', 'alt', 'href', 'class']
html = markdown(raw, output_format='html',
extensions=['markdown.extensions.fenced_code',
'markdown.extensions.codehilite',
'markdown.extensions.tables', MyMDStyleExtension()])
clean_html = clean(html, tags=allowed_tags, attributes=allowed_attributes)
img_url = '&lt;img class="img-emoji" src="/static/emojis/{}" title="{}" alt="{}"&gt;'
for i in EMOJI_INFOS:
for ii in i:
emoji_url = img_url.format(ii[0], ii[1], ii[1])
clean_html = re.sub(':{}:'.format(ii[1]), emoji_url, clean_html)
return linkify(clean_html)</code></pre>
<p>在<span class="marker">to_html()</span>方法中又出现了一下新的内容<span class="marker">clean()</span>以及<span class="marker">linkify()</span>两个方法，这两个方法都来字<span class="marker">bleach</span>库中，关于<span class="marker">bleach</span>库这里不做过多的介绍，感兴趣的童鞋可以自己搜索相关文档了解，这里只介绍使用<span class="marker">clean()</span>以及<span class="marker">linkify()</span>的目的。</p>
<p>在使用<span class="marker">clean</span>之前我们定义了<span class="marker">allowed_tags</span>以及<span class="marker">allowed_attributes</span>两个列表，懂html的童鞋应该都知道这些事HTML的一些标签以及相应的标签属性，然后通过markdown方法将原始内容转换为HTML，然后使用clean方法，clean方法在这里的作用就是将不再<span class="marker">allowed_tags</span>以及<span class="marker">allowed_attributes</span>中的属性过滤掉。因为在提交评论的时候，一些不安好心的&#39;良民&#39;可能会在评论中添加一些恶意的<span class="marker">JavaScript代码</span>，就是我们所说的<span class="marker">XSS攻击</span>，通过clean方法就可以有效的防止这种攻击。linkify()方法的作用是将一些url转换为对应的HTML元素，例如下面的代码片段</p>
<pre>
<code class="language-python">from bleach import linkify
url = "链接: https://2dogz.cn"
print(linkify(url))
mail = "邮箱: 804022023@qq.com"
print(linkify(mail, parse_email=True))</code></pre>
<p>输出如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1697image.png" /></p>
<p>到此为止就完成了评论预览的功能了。</p>
<h1><a id="3.渲染评论并保存" name="3.渲染评论并保存"></a>3.渲染评论并保存</h1>
<p>用户在提交评论后，我们就可以通过上面的方式将评论渲染成HTML内容，然后保存到数据库中去，代码片段如下</p>
<pre>
<code class="language-python">@post_bp.route('/post-comment/', methods=['POST'])
@login_required
@statistic_traffic(db, CommentStatistic)
def post_comment():
...
comment_content = to_html(comment_content)
com = Comments(body=comment_content, post_id=post_id, author_id=current_user.id)
...
return jsonify({'tag': 1})
@post_bp.route('/reply-comment/', methods=['POST'])
@login_required
@statistic_traffic(db, CommentStatistic)
def reply_comment():
...
comment = to_html(comment)
post_id = request.form.get('post_id')
reply = Comments(body=comment, replied_id=comment_id, author_id=current_user.id, post_id=post_id)
...
return jsonify({'tag': 1})</code></pre>
<p>内容基本与上一节中的添加评论代码一致，只是在其中添加了to_html()方法，将原始的评论内容转换为HTML内容然后保存到数据库中去。</p>
<blockquote class="m-blockquote">
<p>博客文章中的代码只截取了部分关键代码，很多细节代码没有贴出来，如果想要在本地机器上运行调试可以访问我的<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>或者<a href="https://gitee.com/weiijang/university-bbs">gitee仓库</a>仓库，如果想要看到实际效果请访问<a href="http://bbs.2dogz.cn/">二狗学院</a>！</p>
</blockquote>
</content>
<link href="https://2dogz.cn/blog/article/48/" rel="alternate"/>
</entry>
<entry>
<id>47</id>
<title>[Python]Flask模板全局变量以及自定义过滤器</title>
<updated>2023-09-27T02:08:19.929669+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 模板全局变量" name="1. 模板全局变量"></a>1. 模板全局变量</h1>
<h2>1.1 current_user</h2>
<p>使用过<span class="marker">Flask-Login</span>的同学应该都知道，在他的扩展中有一个属性<span class="marker">current_user</span>用来保存当前登录用户的相关信息，比如登录状态、登录信息等。而且这个<span class="marker">current_user</span>属性除了能在我们后端的python代码中使用外，还可以在任何模板中进行使用，如下面的代码片段</p>
<p><strong>在python后端代码中使用</strong></p>
<pre>
<code class="language-python">def test():
...
# 在python后端代码中使用
if current_user.is_authenticated:
li = LoveInfo(user=current_user.username, user_ip=remote_ip)
else:
li = LoveInfo(user='Anonymous', user_ip=remote_ip)</code></pre>
<p><strong>在html模板文件中使用 </strong></p>
<pre>
<code class="language-html">{% if not current_user.is_authenticated %}
&lt;ul class="navbar-nav f-17"&gt;
&lt;li class="nav-item"&gt;&lt;a class="nav-link nav-text" href="/auth/login/"&gt;登录&lt;/a&gt;&lt;/li&gt;
&lt;li class="nav-item"&gt;&lt;a class="nav-link nav-text" href="/auth/register/"&gt;注册&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
{% else %}
...
{% endif %}</code></pre>
<p>在python代码中还比较好理解，当我们需要使用的时候，直接通过import导入即可，但是为什么<span class="marker">current_user</span>能够在任意模板文件中使用呢？我们可以通过分析Flask-Login的源码来理解为何可以在任意模板文件中使用。一般的，当我们使用Flask-Login的时候都是通过实例化<span class="marker">LoginManager</span>示例，然后通过<span class="marker">instance.init_app(app, *args)</span>来注册实例。我们可以进入LoginManager源码，<span class="marker">init_app()</span>函数代码如下</p>
<pre>
<code class="language-python">def init_app(self, app, add_context_processor=True):
'''
Configures an application. This registers an `after_request` call, and
attaches this `LoginManager` to it as `app.login_manager`.
:param app: The :class:`flask.Flask` object to configure.
:type app: :class:`flask.Flask`
:param add_context_processor: Whether to add a context processor to
the app that adds a `current_user` variable to the template.
Defaults to ``True``.
:type add_context_processor: bool
'''
app.login_manager = self
app.after_request(self._update_remember_cookie)
if add_context_processor:
app.context_processor(_user_context_processor)</code></pre>
<p>可以看到<span class="marker">add_context_processor</span>变量的注释</p>
<blockquote class="m-blockquote"><em>Whether to add a context processor to </em><em>the app that adds a `current_user` variable to the template. </em><em>Defaults to ``True``.</em></blockquote>
<p>&nbsp;翻译为中文的大概意思就是，是否向应用程序添加上下文处理器，以将 <span class="marker">current_user</span> 变量添加到模板，默认为True。继续看if语句里面的代码，<span class="marker">_user_context_processor</span>是一个方法，其代码如下</p>
<pre>
<code class="language-python">def _user_context_processor():
return dict(current_user=_get_user())</code></pre>
<p>可以看到函数就是返回了一个字典对象，可以发现字典的键就是<span class="marker">current_user</span>。为什么<span class="marker">current_user</span>可以使用在任意模板中，就是通过<span class="marker">app.context_processor Api</span>添加了一个应用程序上下文函数来实现，在Flask的文档中描述如下图所示，翻译过来的意思就是<strong>注册一个模板上下文处理器函数。</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8168%E5%9B%BE%E7%89%87.png" /></p>
<h2>1.2 使用</h2>
<p><span class="marker">context_processor</span>的使用方法有两种，如下代码所示，分别使用装饰器的方式定义模板全局变量以及方法，已函数的形式定义模板全局变量。</p>
<pre>
<code class="language-python">from flask import Flask
import datetime
app = Flask(__name__)
# use decorator
@app.context_processor()
def cur_day():
return datetime.date.today()
# context function
@app.context_processor()
def get_uuid():
import uuid
def _uuid():
return uuid.uuid3()
return dict(uuid=_uuid)
def current_time():
return dict(current_time=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
# use context_processor function
app.context_processor(current_time)</code></pre>
<h1><a id="2.自定义过滤器" name="2.自定义过滤器"></a>2.自定义过滤器</h1>
<p>Flask已经内置了很多过滤器，比如<span class="marker"><em>truncate</em>、</span><em><span class="marker">length</span>等，</em>除了内置的过滤器之外，我们还可以自定义Jinja2模板的过滤器。在Flask中有两种方法自定义过滤器，代码如下</p>
<pre>
<code class="language-python">@app.template_filter('reverse')
def reverse_filter(s):
return s[::-1]
def reverse_filter(s):
return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter</code></pre>
<p>第一种方法是使用<span class="marker">app.template_filter()</span>装饰器来实现，装饰器中的参数，就是后续可以在Jinja2模板文件中使用的过滤器名称；</p>
<p>第二种方法是通过<span class="marker">app.jinja_env.filters</span>将过滤器函数存入字典中，字典的键就是Jinja2模板文件中使用的过滤器名称；</p>
<p>示例代码链接:<a href="https://github.com/weijiang1994/flask-api-test">https://github.com/weijiang1994/flask-api-test</a></p>
</content>
<link href="https://2dogz.cn/blog/article/47/" rel="alternate"/>
</entry>
<entry>
<id>46</id>
<title>[Linux]SSH遭遇暴力破解简单解决方案</title>
<updated>2023-09-27T02:08:19.929642+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.事件复盘" name="1.事件复盘"></a>1.事件复盘</h1>
<p>今早登录服务器，想查看一下<span class="marker">gunicorn</span>的运行日志，阴差阳错的打开了log目录下的<span class="marker">auth.log</span>日志文件，之前不是很了解这个日志文件的作用是啥，文件里面包含了大量的<span class="marker">sshd</span>登录失败日志，而且登录IP都不是我经常使用的登录IP，sshd登录失败日志如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5455image.png" /></p>
<p>通过<a href="https://2dogz.cn/tool/query-ip/">IP查询工具</a>去查看这些登录IP的所在地，发现很多都是国外的，当然也存在一些国内的IP，我就很纳闷了，干点什么事情不好，为什么偏偏要搞这些东西？之后通过lastb命令查看登录失败日志，如下图，<span class="marker">lastb</span>命令是通过读取<span class="marker">/var/log/btmp</span>文件，去获取ssh登录失败日志，具体的使用方法可以自行百度，这里不详细说明。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7415image.png" /></p>
<h1>2.定时脚本监听日志</h1>
<p>既然通过日志文件可以查看到ssh登录失败的IP，那么我们就可以通过解析日志获取登录失败的IP，然后将这些IP加入到黑名单中，就可以有效的防止暴力破解登录密钥了。在Linux系统中通过/etc目录中的<span class="marker">hosts.allow</span>与<span class="marker">hosts.deny</span>两个文件来配置允许以及拒绝登录主机的IP，因此我们只需要通过解析<span class="marker">/var/log/auth.log</span>日志文件中的IP，然后将IP加入到<span class="marker">hosts.deny</span>文件中，这样在hosts.deny文件中的IP如果再视图连接登录我们的主机，就会出现connect refuse，通过下面的shell脚本来解析auth.log日志</p>
<pre>
<code class="language-bash">#! /bin/bash
cat /var/log/auth.log|awk '/Failed/{print $(NF-3)}'|sort|uniq -c|awk '{print $2"="$1;}' &gt; /usr/local/bin/black.list
for i in `cat /usr/local/bin/black.list`
do
IP=`echo $i |awk -F= '{print $1}'`
NUM=`echo $i|awk -F= '{print $2}'`
if [ ${#NUM} -gt 1 ]; then
grep $IP /etc/hosts.deny &gt; /dev/null
if [ $? -gt 0 ];then
echo "sshd:$IP:deny" &gt;&gt; /etc/hosts.deny
fi
fi
done</code></pre>
<p>上面的脚本十分简单，就是通过解析auth.log文件，通过失败登录次数来判断是否将其加入到<span class="marker">/etc/hosts.deny</span>文件中。之后我们可以将此脚本设置进定时任务中，定时执行脚本，刷新hosts.deny中的数据，关于定时任务的设置可以查看<a href="https://2dogz.cn/blog/article/7/">使用crontab定时备份数据库</a>博客。</p>
<h1>3.更改ssh登录端口号</h1>
<p>默认的我们的Linux主机的<span class="marker">ssh登录端口号一般为22</span>，我们将端口号修改端口号之后，可以大幅的减少他人暴力破解登录我们主机频率，因为如果ssh所连接的端口号错误的话，会直接返回Connection refused的连接拒绝信息。</p>
<p>ssh的的配置信息在<span class="marker">/etc/ssh</span>目录中的<span class="marker">sshd_config</span>文件，通过如下的命令可以修改ssh的连接端口号</p>
<pre>
<code class="language-bash">sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
sudo vim /etc/ssh/sshd_config
</code></pre>
<p>修改文件内容，把22端口关闭，然后改为其他的端口</p>
<pre>
<code class="language-nginx">Port 7895
Port 5555</code></pre>
<p>上述内容就是将端口号改为<span class="marker">7895</span>和<span class="marker">5555</span>，修改完后保存文件，然后通过下面的命令重启ssh服务</p>
<pre>
<code class="language-bash">sudo service ssh restart</code></pre>
<p>然后通过远程主机进行连接，通过上面修改的端口号。</p>
<h1>4.禁用密码登录</h1>
<p>在日常开发中很多人都是通过ssh登录密钥进行ssh远程登录，其实如果黑客知道了你的主机密钥，那么他也可以通过密码远程连接你的主机，然后对你的主机造成不必要的破坏，甚至勒索等等。ssh除了通过密码登录之外还可以通过<span class="marker">PublicKey</span>登录，其实就是将你们需要访问主机的目标机器的<span class="marker">id_ras.pub</span>内容添加到你的主机<span class="marker">know_hosts</span>文件中去，具体操作方法可以参考<a href="https://2dogz.cn/blog/article/25/">使用ssh时的一些骚操作</a>。</p>
<p>同样的修改配置文件的内容，就可以关闭密码登录，只能通过PublicKey认证登录了，修改完之后记得保存文件，然后重启ssh服务。</p>
<pre>
<code class="language-nginx">PasswordAuthentication no
ChallengeResponseAuthentication no</code></pre>
<blockquote class="m-blockquote">
<p><strong>进行此项操作之前请务必先将你个人电脑的Publickey添加到你需要登录的主机中去，进行测试，如果成功免密登录，在进行此项设置，以防登录不了主机！！！切记！！！！！</strong></p>
</blockquote>
<h1>5.小记</h1>
<p>暴露在公网的服务器请务必注意安全！上面的方案其实最有效可行的是修改ssh的登录端口，在我修改端口之后，就没有出现过类似的日志信息了！！！</p>
</content>
<link href="https://2dogz.cn/blog/article/46/" rel="alternate"/>
</entry>
<entry>
<id>45</id>
<title>[Linux]Shell脚本相关记录</title>
<updated>2023-09-27T02:08:19.929614+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.参数传递" name="1.参数传递"></a>1.参数传递</h1>
<p>在使用shell脚本的时候，经常会遇到参数需要根据输入进行变化的需求，shell脚本传递参数十分简单，直接在后面接参数即可，然后在脚本中通过<span class="marker"> $index</span> 来获取参数的值，如下面的例子所示，shell脚本的内容如下</p>
<pre>
<code class="language-bash">#/bin/bash
# test.sh
echo "参数1的值为:"$1
echo "参数2的值为:"$2
echo "参数3的值为:"$3</code></pre>
<p>在终端中执行下面的命令</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">./test.sh 12 34 56</div>
<p>&nbsp;</p>
<p>输出如下</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9363%E5%9B%BE%E7%89%87.png" /></p>
<p>我们发现参数序号是从已开始计算的，这有点不符合计算机的常规逻辑从0开始计算，其实不然，<span class="marker">$0</span>实际上是用来表示了我们的<span class="marker">shell脚本文件的名称</span>了，shell脚本代码修改如下</p>
<pre>
<code class="language-bash">#!/bin/bash
# test.sh
echo "参数0的值为:"$0
echo "参数1的值为:"$1
echo "参数2的值为:"$2
echo "参数3的值为:"$3
</code></pre>
<p>然后再执行脚本，发现输出如下</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6837%E5%9B%BE%E7%89%87.png" /></p>
<p>上述的输出结果验证了$0是用来保存我们的shell文件名!</p>
<h1><a id="2.参数名传递" name="2.参数名传递"></a>2.参数名传递</h1>
<p>除了上面的传递参数方式，在我们日常使用Linux系统的过程中，经常会看见很多命令后面可以带命名参数比如 ls -a，同样的shell脚本也可以实现，通过<span class="marker">getopts函数</span>来实现这种方式，getopts函数的格式如下所示</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">getopts [option[:]] [DESCPRITION] VARIABLE</div>
<p>&nbsp;</p>
<blockquote class="m-blockquote">
<p>option：表示为某个脚本可以使用的选项 &quot;:&quot; 冒号如果某个选项（option）后面出现了冒号（&quot;:&quot;），则表示这个选项后面可以接参数（即一段描述信息DESCPRITION） VARIABLE：表示将某个选项保存在变量VARIABLE中&nbsp;</p>
<p>getopts是linux系统中的一个内置变量，一般用在循环中。每当执行循环时，getopts都会检查下一个命令选项，如果这些选项出现 在option中，则表示是合法选项，否则不是合法选项。并将这些合法选项保存在VARIABLE这个变量中。 getopts还包含两个内置变量，及OPTARG和OPTIND OPTARG 就是将选项后面的参数（或者描述信息DESCPRITION）保存在此变量当中。 OPTIND 这个表示命令行的下一个选项或参数的索引（文件名不算选项或参数）</p>
</blockquote>
<p>使用下面的示例代码来说明一下getopts的简单用法</p>
<pre>
<code class="language-bash">#!/bin/bash
# test_param.sh
while getopts ":u:p:d:f:" opt
do
case $opt in
u)
echo "参数-u的值为:"$OPTARG;;
p)
echo "参数-u的值为:"$OPTARG;;
d)
echo "参数-u的值为："$OPTARG;;
f)
echo "参数-u的值为："$OPTARG;;
esac
done
</code></pre>
<p>&nbsp;执行脚本&nbsp;<span class="marker">./test_param.sh -u user -p 123 -d bbs -f /data/my-tool/</span>&nbsp;输出结果如下</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/962image.png" /></p>
<h1><a id="3.显示帮助信息" name="3.显示帮助信息"></a>3.显示帮助信息</h1>
<p>我们在使用Linux命令的时，很多命令都支持-h参数输出帮助帮助信息，我们自己定义的shell脚本同样的也可以支持<span class="marker">-h</span>参数，shell脚本示例代码如下</p>
<pre>
<code class="language-bash">help() {
echo "脚本参数如下:"
echo " -h : 帮助信息"
echo " -u : 数据库连接用户名"
echo " -p : 数据库登录密码"
echo " -d : 目标数据库名"
echo " -f : 导出sql文件路径"
exit 1
}
if [[ $# == 0 || "$1" == "-h" ]]; then
help
fi</code></pre>
<p>首先定义了help()函数，在函数中输出相关的帮助信息，之后通过判断用户输入的参数<span class="marker">是否为-h或者参数个数是否为零</span>，如果满足条件则执行help函数，执行脚本 <span class="marker">./test_param.sh -h</span> 输出结果如下</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6426image.png" /></p>
</content>
<link href="https://2dogz.cn/blog/article/45/" rel="alternate"/>
</entry>
<entry>
<id>44</id>
<title>[陈词滥调]房子一定要买顶层</title>
<updated>2023-09-27T02:08:19.929586+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>&nbsp;&nbsp;&nbsp; 房子一定要买顶层，房子一定要买顶层，房子一定要买顶层，重要的事情一定要说三遍。</p>
<p>&nbsp;&nbsp;&nbsp; 随着社会经济水平的发展，大部分都开始在城里谋生了，而我就是其中的一员。17年秋招的末尾，一家深圳自动化公司给了我offer，那时候的我不谙世事，无忧无虑，得过且过，活在当下，在正式通知录用我之后，就没有继续找工作了，临近毕业，毕业论文也是当时比较重要的事情，就这样，18年顺利毕业之后，就独自一人来到了深圳&ldquo;闯荡&rdquo;（实际上应该说是流浪）了。</p>
<p>&nbsp;&nbsp;&nbsp; 大城市那是&ldquo;针不挫&rdquo;，但是由于个人实力不济，不太可能在深圳定居，于是20年七月份就辞去了深圳的工作回到了长沙了。期间在深圳也租过两次房，且都不是在顶层，第一次是租在城中村中，两室一厅跟前同事&ldquo;小张总&rdquo;合租的，租金2200，这样的价格对于深圳来说算的是十分实惠的，在这里住了半年之后就搬走了，主要是因为城中村的房子太潮湿了，蟑螂随处可见。最让我印象深刻的事情是，有一次我想用我的电饭煲煮面条吃，那个电饭煲盖子还是盖着的，当我揭开盖子的时候我惊呆了，里面有几只小强在那里，顿时就感到十分的恶心，于是乎烧了一壶热水倒进了电饭煲的内胆里，想着用开水泡一下消毒一下应该就可以用了，但后来我还是直接把这个电饭煲给扔掉了，因为实在是太恶心了。在这边租房的其实住的还是挺不错的，楼上楼下、邻里邻居都很安静不吵闹，就是因为蟑螂太多了，住了半年就搬走了。</p>
<p>&nbsp;&nbsp;&nbsp; 后来就租的公寓，公寓的环境确实很不错，最主要的是没有蟑螂，唯一的缺点就是房间太小。睡觉的地方刚好能放进一张床铺，然后另外的空间就是厨房跟洗手间了，但是一个人住还是可以了，就是每次女朋友过来都会说我这个是小破屋。这边离深圳宝安国际机场很近，我住在12楼，每天下班后来能上楼顶看飞机，虽然说晚上睡觉的时候会有飞机引擎轰鸣的声音，但是这种噪声属于我感觉还比较催眠，在这边居住环境也非常地舒服，我从来没有听到过楼上有把地板弄得很响的声音，只是偶尔大半夜听到有人进出电梯的响声，但是都不会发出其他声音扰民。</p>
<p>&nbsp;&nbsp;&nbsp; 后来回到了长沙了，由于新东家这边不会提供住宿，就只能选择在外面租房了。内地城市跟沿海城市相比还是差的比较多，这里我都看不到租房的那种小广告，问了一下在这边上班的同学，说是这边房子都是房东托付给中介去租。后来在安居客上找到比较心仪的房源，联系中介看了房，就定下了，最后果然我与房东一人半个月的中介费用给中介（瞬间觉得好坑啊），房子挺大，一室一厅43平米左右，1500一月，水电费、物业费自己缴纳。才搬进来的时候，也没有感觉楼上吵，过了一段时间发现，可能是楼上的房子也是出租出去的，每天晚上12点到2点多，一直听到鞋子哒哒哒的声音，是不是的还能听到狗叫，有时候实在忍无可忍，就拿着拖把棍怼了几下天花板，楼上就安静了，有时候对打开窗户骂几句，也安静了。久而久之我也习惯了这样，晚上就带着耳塞睡觉了。又过了一段时间，感觉隔壁的房子也搬来的新的租户，有一天早上5、6点多的时候，就听到外面很大的声音，咋一听我还以为是在外面吵架，后来才发现，是隔壁这个傻逼女的。摸清楚了她的作息方式，每天晚上6点到7点左右出门，凌晨三四点的时候回来，因为经常我都听到很大声的关门声，打开手机看经常是凌晨三四点左右的时候，我都很好奇她是作什么的。我真是倒了八辈子的血霉，楼上、楼下都是这种玩意，素质教育的漏网之鱼。</p>
<p>&nbsp;&nbsp;&nbsp; 后来女朋友也来长沙这边上班了，由于上班的公司离我住的地方比较远，她就在河西那边租房了。不得不感叹我们的运气真他妈的好，这两天楼上的sb在作妖了，大早上5点多就开始在楼上搞得蹦蹦蹦响，一直不停，我上去敲门想跟它交涉一下，他妈的门都不开，于是女朋友就只站在阳台上说，说了之后好了几分钟，又他妈开始了，我已经打算在咸鱼上买神器了，对付这种人，就应该以暴制暴，这种人怎么不灭绝啊，都2021年了，还有这么多没有公德心的人啊。</p>
<p>&nbsp;&nbsp;&nbsp; 相比于长沙，让我觉得大城市的人口素质确实很高，可能是因为深圳的年轻人居多的原因吧。很奇怪的是，我之前租的房子隔壁与楼上两个玩意应该都是年轻人，隔壁那女的我还见过她，长得人模人样的，没一点素质、公德心可言。现在楼上应该是个大妈，目前为止还没有见过庐山真面目，不知道是人是鬼！！！</p>
<p>&nbsp;&nbsp;&nbsp; 买房子一定要买顶层，素质、公德心只能紧握在我们自己的手中，不要对他人抱有任何侥幸心理！！！因为楼上住的是人是狗，你又不知道！！！</p>
</content>
<link href="https://2dogz.cn/blog/article/44/" rel="alternate"/>
</entry>
<entry>
<id>43</id>
<title>[Python]flask-githubcard简单使用介绍</title>
<updated>2023-09-27T02:08:19.929559+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="安装依赖" name="安装依赖"></a>安装依赖</h1>
<p>跟其他的python第三方库一样，通过pip的方式就可以自动将其安装在自己的项目环境中，flask-githubcard依赖于flask、requests，在安装过程中会自动进行依赖安装。</p>
<pre>
<code class="language-python">pip install flask-githubcard</code></pre>
<h1><a id="简单使用" name="简单使用"></a>简单使用</h1>
<p>新建app.py文件，添加下面的代码</p>
<pre>
<code class="language-python">from flask import Flask, render_template
from flask_githubcard import GithubCard
app = Flask(__name__)
app.config['GITHUB_USERNAME'] = 'weijiang1994'
app.config['GITHUB_REPO'] = 'Blogin'
githubcard = GithubCard(app)
</code></pre>
<p>在上面的代码清单中，我们主要是实例化了一个flask实例，同时给其配置了<span class="marker">GITHUB_USERNAME</span> 以及 <span class="marker">GITHUB_REPO</span> 两个参数，此两个参数就是你要显示目标仓库卡片的相关信息，<span class="marker">flask-githubcard</span>支持配置的参数就只有此两个参数，在配置完成后就通过初始化了flask-githubcard实例了。</p>
<p>之后我们在<span class="marker">templates</span>目录中新建一个<span class="marker">index.html</span>文件，将下面的代码填入到文件中。</p>
<pre>
<code class="language-html">&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
&lt;meta charset="UTF-8"&gt;
&lt;title&gt;Sample-default theme&lt;/title&gt;
{{ githubcard.init_css() }}
{{ githubcard.init_js() }}
&lt;/head&gt;
&lt;body&gt;
&lt;div class="container mt-2"&gt;
&lt;h4&gt;&lt;b&gt;Flask-GithubCard extension sample.&lt;/b&gt;&lt;/h4&gt;
&lt;hr&gt;
&lt;a href="/default/"&gt;default&lt;/a&gt;
&lt;a href="/darkly/"&gt;darkly&lt;/a&gt;
&lt;div class="container mt-2"&gt;
&lt;div class="row "&gt;
&lt;div class="col-4"&gt;{{ githubcard.generate_card() }}&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre>
<p>在上面的代码中，首先在head section中通过<span class="marker">init_css()</span>以及<span class="marker">init_js()</span>初始化了依赖文件，flask-githubcard的主要依赖<span class="marker">bootstrap4</span>、<span class="marker">jQuery</span>以及<span class="marker">fontawesome</span>，然后在body section中通过<span class="marker">generate_card()</span>函数来完成了github card的渲染。</p>
<p>回到app.py文件，添加视图函数</p>
<pre>
<code class="language-python">@app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
app.run()</code></pre>
<p>运行app.py文件，访问http://127.0.0.1:5000既可以看到如下图所示的效果</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/06/10/66d2716789d8d.png" /></p>
<h1><a id="参数配置" name="参数配置"></a>参数配置</h1>
<p>在第二节中程序示例都采用的是默认的参数，我们可以根据需要配置自己的参数。</p>
<h2>配置css、js依赖</h2>
<p>默认的css、js依赖是使用的flask-githubcard static下的静态文件，fontawesome使用的jsdelivr的cdn，如果 你想更换的话，可以通过下面的方式来修改</p>
<pre>
<code class="language-html">&lt;head&gt;
{{githubcard.init_css(bootstrap='path/cdn_url', fontawesome='path/cdn_url')}}
{{githubcard.init_js(jquery='path/cdn_url', bootstrap='path/cdn_url')}}
&lt;/head&gt;
</code></pre>
<h2>配置主题模式</h2>
<p>flask-githubcard提供了两种主题模式，分别是default、darkly，可以通过下面的方式来指定</p>
<pre>
<code class="language-html">&lt;head&gt;
{{githubcard.init_css(theme='darkly')}}
&lt;/head&gt;
&lt;div&gt;
{{githubcard.generate_card(theme='darkly')}}
&lt;/div&gt;
</code></pre>
<p>darkly主题模式效果如下图</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/06/10/736fed4674429.png" /></p>
<h1><a id="注意事项" name="注意事项"></a>注意事项</h1>
<ol>
<li>
<p>由于使用了github的api在没有进行授权的情况下，唯一IP在每小时内限制的访问次数为60次，超过60次则会报403, 如果访问频率过高，请前往github上授权账号；</p>
</li>
<li>
<p>在国内访问github会出现超时的现象，可能会导致网页一直无法打开!</p>
</li>
</ol>
</content>
<link href="https://2dogz.cn/blog/article/43/" rel="alternate"/>
</entry>
<entry>
<id>42</id>
<title>[Git]git不常用操作记录(2)</title>
<updated>2023-09-27T02:08:19.929531+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id=".gitignore的使用" name=".gitignore的使用"></a>.gitignore的使用</h1>
<p>.gitignore大部分人都知道如何使用，在项目的根目录创建一个.gitigonre文件，可以在提交代码的时候将一个不需要提交的文件给忽略掉。</p>
<pre>
<code class="language-bash">$ cat .gitignore
*.[oa]
*~</code></pre>
<p>第一行告诉 Git 忽略所有以 .o 或 .a 结尾的文件。一般这类对象文件和存档文件都是编译过程中出现的。 第二行告诉 Git 忽略所有名字以波浪符（~）结尾的文件，许多文本编辑软件（比如 Emacs）都用这样的文件名保存副本。 此外，你可能还需要忽略 log，tmp 或者 pid 目录，以及自动生成的文档等等。 要养成一开始就为你的新仓库设置好 .gitignore 文件的习惯，以免将来误提交这类无用的文件。</p>
<p>文件 <span class="marker">.gitignore </span>的格式规范如下：<br />
&bull; 所有空行或者以 # 开头的行都会被 Git 忽略。<br />
&bull; 可以使用标准的 glob 模式匹配，它会递归地应用在整个工作区中。<br />
&bull; 匹配模式可以以（/）开头防止递归。<br />
&bull; 匹配模式可以以（/）结尾指定目录。<br />
&bull; 要忽略指定模式以外的文件或目录，可以在模式前加上叹号（!）取反。</p>
<blockquote class="m-blockquote">
<p>所谓的 glob 模式是指 shell 所使用的简化了的正则表达式。 星号（*）匹配零个或多个任意字符；[abc] 匹配任何一个列在方括号中的字符 （这个例子要么匹配一个 a，要么匹配一个 b，要么匹配一个 c）； 问号（?）只匹配一个任意字符；如果在方括号中使用短划线分隔两个字符， 表示所有在这两个字符范围内的都可以匹配（比如 [0-9] 表示匹配所有 0 到 9 的数字）。 使用两个星号（**）表示匹配任意中间目录，比如 a/**/z 可以匹配 a/z 、 a/b/z 或 a/b/c/z 等。</p>
</blockquote>
<p>看一个简单的栗子</p>
<pre>
<code class="language-ini"># 忽略所有的 .a 文件
*.a
# 但跟踪所有的 lib.a，即便你在前面忽略了 .a 文件
!lib.a
# 只忽略当前目录下的 TODO 文件，而不忽略 subdir/TODO
/TODO
# 忽略任何目录下名为 build 的文件夹
build/
# 忽略 doc/notes.txt，但不忽略 doc/server/arch.txt
doc/*.txt
# 忽略 doc/ 目录及其所有子目录下的 .pdf 文件
doc/**/*.pdf </code></pre>
<p>在最简单的情况下，一个仓库可能只根目录下有一个 .gitignore 文件，它递归地应用到整个仓库中。 然而，子目录下也可以有额外的 .gitignore 文件。子目录中的 .gitignore文件中的规则只作用于它所在的目录中。</p>
<p>github有一个十分详细的针对数十种语言及其项目的.gitignore文件配置，你可以在https://github.com/github/gitignore中找到。</p>
<h1><a id="git log查看提交历史" name="git log查看提交历史"></a>git log查看提交历史</h1>
<p>通过git log命令我们可以查看到当前仓库的所有提交历史记录，它会按照时间倒叙的方式将提交记录显示在屏幕上，如下图所示</p>
<p><img alt="git log sample" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4181%E5%9B%BE%E7%89%87.png" /></p>
<p>当我们在使用git log命令的时候，如果不加上参数的话默认会输出该仓库中所有的提交记录，如果我们需要查看详细的修改信息，我们可以通过<span class="marker">-p</span> 或者 <span class="marker">-patch</span>参数来获取</p>
<pre>
<code class="language-bash">git log -p
commit 868f4bcb4d3290f4b5320f030fccdf1e7fc8ac8a (HEAD -&gt; main, origin/main, origin/HEAD)
Merge: 1ee3c37f4 a25cba2c0
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Mon May 31 21:06:37 2021 +0100
Merge pull request #5897 from tiennou/fix/coding-style-comment
commit a25cba2c0f4d85dc030c8fd65f5660acf00e9463
Author: Etienne Samson &lt;samson.etienne@gmail.com&gt;
Date: Thu May 27 10:01:55 2021 +0200
docs: fix incorrect comment marker
diff --git a/docs/coding-style.md b/docs/coding-style.md
index d5188f0bc..b8b94d69c 100644
--- a/docs/coding-style.md
+++ b/docs/coding-style.md
@@ -172,7 +172,7 @@ tags:
*
* @param s String to froznicate
* @return A newly allocated string or `NULL` in case an error occurred.
- * /
+ */
char *froznicate(const char *s);
```
commit 1ee3c37f48479e92f57c1a5da8c8393f4a745d13
Merge: 319ff3490 6b1f6e00b
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Wed May 19 09:31:30 2021 +0100
Merge branch 'pr/5853'
# 省略后续部分</code></pre>
<p>如果我们需要限制输出的行数我们可以在后面加上<span class="marker">-number</span>[1,2,3,4....]</p>
<pre>
<code class="language-bash">git log -p -2
commit 868f4bcb4d3290f4b5320f030fccdf1e7fc8ac8a (HEAD -&gt; main, origin/main, origin/HEAD)
Merge: 1ee3c37f4 a25cba2c0
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Mon May 31 21:06:37 2021 +0100
Merge pull request #5897 from tiennou/fix/coding-style-comment
commit a25cba2c0f4d85dc030c8fd65f5660acf00e9463
Author: Etienne Samson &lt;samson.etienne@gmail.com&gt;
Date: Thu May 27 10:01:55 2021 +0200
docs: fix incorrect comment marker
diff --git a/docs/coding-style.md b/docs/coding-style.md
index d5188f0bc..b8b94d69c 100644
--- a/docs/coding-style.md
+++ b/docs/coding-style.md
@@ -172,7 +172,7 @@ tags:
*
* @param s String to froznicate
* @return A newly allocated string or `NULL` in case an error occurred.
- * /
+ */
char *froznicate(const char *s);
```
</code></pre>
<p>如果我们不想看详细的patch只需要显示初略的信息，我们可以通过<span class="marker">--stat</span>参数来获取初略提交信息</p>
<pre>
<code class="language-bash">git log --stat
commit 868f4bcb4d3290f4b5320f030fccdf1e7fc8ac8a (HEAD -&gt; main, origin/main, origin/HEAD)
Merge: 1ee3c37f4 a25cba2c0
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Mon May 31 21:06:37 2021 +0100
Merge pull request #5897 from tiennou/fix/coding-style-comment
commit a25cba2c0f4d85dc030c8fd65f5660acf00e9463
Author: Etienne Samson &lt;samson.etienne@gmail.com&gt;
Date: Thu May 27 10:01:55 2021 +0200
docs: fix incorrect comment marker
docs/coding-style.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
commit 1ee3c37f48479e92f57c1a5da8c8393f4a745d13
Merge: 319ff3490 6b1f6e00b
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Wed May 19 09:31:30 2021 +0100
Merge branch 'pr/5853'
commit 319ff349039dc73f5fe099f83f198fb65782414f
Merge: b5dcdad34 1b1e541dd
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Tue May 18 20:49:40 2021 +0100
Merge pull request #5892 from libgit2/ethomson/memleak
tests: clean up memory leak, fail on leak for win32
commit 6b1f6e00bf7c91b3b5230e20ecb57a7d9792cee7
Author: Edward Thomson &lt;ethomson@edwardthomson.com&gt;
Date: Tue May 18 12:21:15 2021 +0100
diff: test ignore-blank-lines
tests/diff/workdir.c | 35 +++++++++++++++++++++++++++++++++++
1 file changed, 35 insertions(+)
# 省略后续部分</code></pre>
<p>在git log还有一个比较有用的参数是--pretty，可以通过该参数来定制commit log的不同显示模式，例如online、short、full、fuller等。oneline就是将所有的提交记录显示在一行，其他的类似只是详细方式各不相同，最有用的是format参数，他可以定制commit log的显示格式，对应格式如下表所示</p>
<p><img alt="pretty" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/652%E5%9B%BE%E7%89%87.png" /></p>
<p>通过下面的命令来显示提交信息的简短hash值、提交作者、提交日期、提交log等</p>
<pre>
<code class="language-bash">git log --pretty=format:"%h - %an, %ar: %s"
868f4bcb4 - Edward Thomson, 7 天前: Merge pull request #5897 from tiennou/fix/coding-style-comment
a25cba2c0 - Etienne Samson, 11 天前: docs: fix incorrect comment marker
1ee3c37f4 - Edward Thomson, 3 周前: Merge branch 'pr/5853'
319ff3490 - Edward Thomson, 3 周前: Merge pull request #5892 from libgit2/ethomson/memleak
6b1f6e00b - Edward Thomson, 3 周前: diff: test ignore-blank-lines
1b1e541dd - Edward Thomson, 3 周前: tests: clean up refs::races zero oid test
a6fb72a8b - Edward Thomson, 3 周前: tests: exit with error on win32 leakcheck
b5dcdad34 - Edward Thomson, 3 周前: Merge pull request #5852 from implausible/httpclient/skip-entire-body
3532c5f49 - Edward Thomson, 3 周前: Merge pull request #5850 from punkymaniac/comment-format
9ccb900d7 - Edward Thomson, 3 周前: Merge pull request #5831 from todaysoftware/bindings/libgit2-delphi
589443883 - Edward Thomson, 3 周前: Merge branch 'zero_oid_in_old'
cf323cb9d - Edward Thomson, 3 周前: refs: test git_reference_create_matching failure for zero oid
be95f684d - Edward Thomson, 4 周前: Merge pull request #5839 from staktrace/find_similar
# 省略后续内容</code></pre>
<p>git log的参数如下图所示</p>
<p><img alt="git log参数" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/504%E5%9B%BE%E7%89%87.png" /></p>
</content>
<link href="https://2dogz.cn/blog/article/42/" rel="alternate"/>
</entry>
<entry>
<id>41</id>
<title>[Python]Flask-Caching的简单应用</title>
<updated>2023-09-27T02:08:19.929503+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.安装Flask-Caching" name="1.安装Flask-Caching"></a>1.安装Flask-Caching</h1>
<p>进入到需要使用到该拓展的项目根目录，通过下面的命令安装。这个拓展是fork <code>Flask-Cache</code>仓库进行修改的，由于<code>Flask-Cache</code>已经年久失修了，所以这边推荐使用<code>Flask-Caching</code>，在安装的时候不要装错了拓展名。</p>
<pre>
<code class="language-bash">pip install flask-caching</code></pre>
<h1><a id="2.简单的使用" name="2.简单的使用"></a>2.简单的使用</h1>
<p>使用一个简单的例子来说明cache的作用以及使用方法</p>
<pre>
<code class="language-python">from flask import Flask
from flask_caching import Cache
app = Flask(__name__)
@app.route('/no-cache/')
def no_cache():
time.sleep(1)
return '没有使用缓存页面'
@app.route('/cache/')
@cache.cached(timeout=10 * 60)
def cache_page():
time.sleep(1)
return '使用缓存页面'
if __name__ == '__main__':
app.run(debug=True)</code></pre>
<p>启动应用，分别访问no-cache与cache页面，<kbd>F12 </kbd>打开控制台，查看两个页面的请求时间。</p>
<ul>
<li>打开no-cache页面每次请求时间都要1s以上，因为在视图函数中进行了一秒的延时；</li>
<li>打开cache页面第一次也需要1s以上的时间，但第二次打开就只要毫秒级别的时间了，这就是flask-cache的作用，它将视图函数的结果缓存在字典中(因为使用的是simple方式)，当请求过来时候直接去字典中取值然后返回响应；</li>
</ul>
<h1><a id="3.更新缓存" name="3.更新缓存"></a>3.更新缓存</h1>
<p>当使用缓存之后，我们会遇到的一个问题，就是数据不会实时刷新，比如我这个博客，如果主页使用了缓存，那么当我新增了文章或者删除了文章，如果没有及时的更新缓存那么访问主页还是获取的原来的数据，因此在必要的时候，我们需要将对应的缓存进行更新。</p>
<p>在我的博客系统中，侧边栏的<code>github</code>信息以及<code>每日一句</code>都采用了缓存，核心代码如下所示</p>
<pre>
<code class="language-python">@blog_bp.route('/load-github/', methods=['POST'])
@cache.cached(timeout=5*60)
def load_github():
theme = request.form.get('theme')
star = rd.get('star')
if star is None:
star, fork, watcher, star_dark, fork_dark, watcher_dark, user_info, repo_info = github_social()
avatar = user_info.json()['avatar_url']
repo_desc = repo_info.json()['description']
# 获取浅色主题的shield
rd.set('star', star.text)
rd.set('fork', fork.text)
rd.set('watcher', watcher.text)
# 获取深色主题的shield
rd.set('star_dark', star_dark.text)
rd.set('fork_dark', fork_dark.text)
rd.set('watcher_dark', watcher_dark.text)
rd.set('avatar', avatar)
rd.set('repo_desc', repo_desc)
star = star.text
if theme == 'dark':
star = star_dark.text
else:
if theme == 'dark':
fork = rd.get('fork_dark')
watcher = rd.get('watcher_dark')
star = rd.get('star_dark')
else:
fork = rd.get('fork')
watcher = rd.get('watcher')
avatar = rd.get('avatar')
repo_desc = rd.get('repo_desc')
return jsonify({'star': star,
'fork': fork,
'watcher': watcher,
'avatar': avatar,
'repo_desc': repo_desc
})
@blog_bp.route('/load-one/', methods=['POST'])
@cache.cached(timeout=60*60)
def load_one():
one = rd.get('one')
# 防止服务器重启之后清空了redis数据导致前端获取不到当日one内容
if not one:
one = OneSentence.query.filter_by(day=datetime.date.today()).first()
return jsonify({'one': one.content})
return jsonify({'one': one})</code></pre>
<p>在这两个请求的视图函数中，添加了caching的装饰器，每个视图的缓存时间为5分钟，在本地测试之后，感觉功能正常就部署到了生产环境中了。</p>
<p>我的博客有两套主题，一套是light另外一套是dark，其中github shield标签是会根据主题模式进行变化的，但是当我加上了缓存之后，发现切换主题模式之后github shield不会改变，如下所示</p>
<p><strong>light主题</strong><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6652image.png" /><strong>dark主题&nbsp;</strong><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5322image.png" /></p>
<p>这是回过头来发现，是因为缓存的原因导致没有更新<code>github shield</code>，于是在切换主题的视图函数中添加了清除缓存的代码，如下</p>
<pre>
<code class="language-python">@blog_bp.route('/themes/&lt;string:theme_name&gt;/')
def change_theme(theme_name):
if theme_name not in current_app.config['BLOG_THEMES'].keys():
abort(404)
cache.clear()
response = redirect(request.referrer)
response.set_cookie('blog_theme', current_app.config['BLOG_THEMES'].get(theme_name), max_age=30 * 24 * 60 * 60)
return response</code></pre>
<p>上面的代码就是在切换主题的时候，<strong>清除了缓存信息</strong>，这样我们就会重新去获取对应主题的<code>github shield</code>了。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6151image.png" /></p>
<p>所以在使用数据缓存的时候，我们需要时刻注意保持数据的最新状态。本篇文章就到此了，只是演示了一些简单的<code>Flask-Caching</code>的应用，感兴趣的可以去查找相关文档或者教程进一步的学习。</p>
</content>
<link href="https://2dogz.cn/blog/article/41/" rel="alternate"/>
</entry>
<entry>
<id>40</id>
<title>[系列教程]使用Flask搭建一个校园论坛8-帖子评论</title>
<updated>2023-09-27T02:08:19.929475+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.功能简介" name="1.功能简介"></a>1.功能简介</h1>
<p>所有公开的论坛，都会提供用户评论以及用户回复的功能，本节讲述如何实现用户评论帖子、用户回复帖子以及一些其他的功能。</p>
<h1><a id="2.数据表设计" name="2.数据表设计"></a>2.数据表设计</h1>
<p>每篇帖子任何用户都可以在其下方留下评论，因此，帖子对于评论的关系是一个<code>一对多</code>的关系，如下图所示，这样当我们加载帖子的时候，就可以通过帖子的id获取其全部的评论。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7514image.png" /></p>
<p>在很多论坛中，我们可以看到用户可以在任何帖子下方回复任何评论，每条评论我都们需要发送评论的是谁，同时如果是回复某条评论，我们也需要知道回复的是谁，因此我们可以通过<code>自关联</code>的方式来实现，评论表的设计如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8284image.png" /></p>
<p>有了上面的思路，我们就可以设计评论表的，在<code>bbs/models.py</code>模块中加入下面的代码</p>
<pre>
<code class="language-python">class Comments(db.Model):
__tablename__ = 't_comments'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
body = db.Column(db.Text)
timestamps = db.Column(db.DATETIME, default=datetime.datetime.now)
replied_id = db.Column(db.INTEGER, db.ForeignKey('t_comments.id'))
author_id = db.Column(db.INTEGER, db.ForeignKey('t_user.id'))
post_id = db.Column(db.INTEGER, db.ForeignKey('t_post.id'))
delete_flag = db.Column(db.INTEGER, default=0, comment='is it delete? 0: no 1: yes')
post = db.relationship('Post', back_populates='comments')
author = db.relationship('User', back_populates='comments')
replies = db.relationship('Comments', back_populates='replied', cascade='all')
replied = db.relationship('Comments', back_populates='replies', remote_side=[id])
def can_delete(self):
return self.author_id == current_user.id</code></pre>
<p>上面的代码中，我们定义了评论表的相关字段，其中delete_flag字段为当前评论的状态，如果等于1则表示当前评论已经被作者删除了。这里的删除是软删除，就是将其状态置为某个标志，并不是真正的在数据库中清除掉。同时我们定义了一个实例函数can_delete此函数的主要作用是用来判断当前评论删除的权限，如果当前评论的作者id等于当前登录用户的id，则可以删除此条评论，反之则不能删除。</p>
<h1><a id="3.评论帖子" name="3.评论帖子"></a>3.评论帖子</h1>
<p>帖子的评论的实现主要是前后端的配合，我们先来实现前端的评论输入。</p>
<h2>a.评论输入框</h2>
<p>用户需要评论帖子则需要一个评论的入口，所以我们需要在帖子详情页面下方加上用户输入评论的区域，打开<code>bbs/templates/frontend/post/read-post.html</code>，添加下面的关键代码</p>
<pre>
<code class="language-html">&lt;div class="post-div post-comment"&gt;
&lt;p id="commentPosition"&gt;&lt;/p&gt;
{% if current_user.is_authenticated %}
&lt;div&gt;
&lt;ul class="nav nav-pills " role="tablist"&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link active" data-toggle="pill" href="#addComment"&gt;&lt;i class="fa fa-commenting mr-2"&gt;&lt;/i&gt;评论&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link" onclick="getMarkDownData()" data-toggle="pill" href="#previewComment"&gt;&lt;i class="fa fa-print mr-2"&gt;&lt;/i&gt;预览&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;div class="tab-content"&gt;
&lt;div id="addComment" class="tab-pane active"&gt;
&lt;textarea onkeydown="tab(this)" class="form-control mt-2 report-textarea" style="height: 150px!important;" id="commentContent" placeholder="请输入评论内容"&gt;&lt;/textarea&gt;
&lt;div class="d-flex mt-1"&gt;
&lt;a class="mb-1 text-decoration-none mr-2 a-link" href="#" id="commentEmoji" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;
&lt;i class="fa fa-smile-o mr-1"&gt;&lt;/i&gt;表情
&lt;/a&gt;
&lt;div class="dropdown-menu" id="emoji-list" aria-labelledby="commentEmoji"&gt;
{% for emoji_url in emoji_urls %}
&lt;div style="padding:3px"&gt;
{% for emoji in emoji_url %}
&lt;button class="btn p-1"&gt;
&lt;img class="img-emoji"
src="{{ url_for('static', filename='emojis/'+emoji[0]) }}"
data-toggle="tooltip" data-placement="right"
title="{{ emoji.1 }}" alt="{{ emoji.1 }}"
data-emoji=":{{ emoji.1 }}:"&gt;
&lt;/button&gt;
{% endfor %}
&lt;/div&gt;
{% endfor %}
&lt;/div&gt;
&lt;a onclick="upload()" class="mb-1 text-decoration-none mr-2 a-link span-hand"&gt;&lt;i class="fa fa-photo mr-1"&gt;&lt;/i&gt;图片&lt;/a&gt;
&lt;input type="file" id="uploadInput" onchange="uploadImage()" accept=".png" hidden="hidden"&gt;
&lt;a href="#" class="mb-1 text-decoration-none mr-2 a-link" data-toggle="modal" data-target="#markdownHelp"&gt;&lt;i class="fa fa-file mr-1"&gt;&lt;/i&gt;帮助&lt;/a&gt;
&lt;p class="flex-grow-1 text-right mb-1 p-error-hint"&gt;请输入评论内容!&lt;/p&gt;
&lt;/div&gt;
&lt;div class="d-flex flex-row-reverse"&gt;
&lt;button class="btn btn-info" id="commentBtn" onclick="postComment()"&gt;评论&lt;/button&gt;
&lt;button hidden="hidden" id="replyBtn" onclick="replyComment()" class="btn btn-success mt-2"&gt;回复&lt;/button&gt;
&lt;button hidden="hidden" id="cancleReplyBtn" onclick="cancleReply()" class="btn btn-danger mt-2 mr-2"&gt;取消&lt;/button&gt;
&lt;a id="replyUserP" hidden="hidden" class="p-reply flex-grow-1 text-decoration-none"&gt;&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;!-- 评论预览界面 --&gt;
&lt;div id="previewComment" class="tab-pane fade"&gt;
&lt;div id="previewHtml" class="mt-2" style="min-height: 50px"&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% else %}
&lt;div class="text-center"&gt;
&lt;div class="card-body text-center m-2 m-md-3 f-16" id="no-editor"&gt;
&lt;div&gt;您尚未登录，
&lt;a href="/auth/login/"&gt;&lt;span class="badge badge-info"&gt;登录&lt;/span&gt;&lt;/a&gt; 或
&lt;a href="/auth/register/"&gt;&lt;span class="badge badge-success"&gt;注册&lt;/span&gt;&lt;/a&gt; 后评论
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% endif %}
&lt;/div&gt;</code></pre>
<p>在帖子的详情页页面，我们就可以看到如下所示的评论输入框</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/93image.png" /></p>
<h2>b.处理用户评论与回复</h2>
<p>在用户在帖子详情页面输入了评论内容之后，点击评论按钮就要将相关参数信息发送到后台服务器中，将这些信息处理、存储在对应的数据库表中，大致流程如下图所示</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/454image.png" /></p>
<p>打开<code>bbs/frontend/post.py</code>模块中加入下面的代码</p>
<pre>
<code class="language-python">@post_bp.route('/post-comment/', methods=['POST'])
@login_required
@statistic_traffic(db, CommentStatistic)
def post_comment():
comment_content = request.form.get('commentContent')
post_id = request.form.get('postId')
post = Post.query.get_or_404(post_id)
com = Comments(body=comment_content, post_id=post_id, author_id=current_user.id)
# 如果评论帖子用户与发帖用户不为同一人则发送消息通知
if current_user.id != post.author_id:
notice = Notification(target_id=post_id, target_name=post.title, send_user=current_user.username,
receive_id=post.author_id, msg=comment_content)
db.session.add(notice)
post.update_time = datetime.datetime.now()
db.session.add(com)
db.session.commit()
return jsonify({'tag': 1})</code></pre>
<p>上面的代码逻辑基本上按照图上的流程所进行的，因为用户可以回复其他用户的评论，在代码中还加入通知被回复用户的逻辑。</p>
<h2>c.提交评论回复</h2>
<p>在写完后端逻辑之后，我们还需要在帖子详情页面中加入一些js代码来实现与后端的交互，打开<code>bbs/templates/frontend/post/read-post.html</code>文件，在JavaScript标签块中加入下面的代码</p>
<pre>
<code class="language-javascript">// 刷新页面清除保存在sessionStorage中的原始数据
$(function () {
sessionStorage.setItem('md', '');
})
function cancleReply() {
$("#commentBtn").removeAttr('hidden');
$("#replyBtn").attr('hidden', 'hidden');
$("#cancleReplyBtn").attr('hidden', 'hidden');
$("#replyUserP").html('');
$("#replyUserP").attr('hidden', 'hidden');
}
function replyComment() {
comment = isEmpty();
if (!comment){
return false;
}
commentId = sessionStorage.getItem('commentId');
commentUserId = sessionStorage.getItem('commentUserId');
postId = $("#postTitle").data('id');
$.ajax({
type: "post",
url: "/post/reply-comment/",
data: {"post_id":postId, "comment_id": commentId, "comment_user_id": commentUserId, "comment": comment},
success: function (res) {
window.location.reload();
}
})
}
function reply(commentId, commentUser, commentUserId) {
$("#commentBtn").attr('hidden', 'hidden');
$("#replyBtn").removeAttr('hidden');
$("#cancleReplyBtn").removeAttr('hidden');
$("#replyUserP").removeAttr('hidden');
$("#replyUserP").html('@'+commentUser);
$("#replyUserP").attr('href', '/profile/user/'+commentUserId+'/');
sessionStorage.setItem('commentId', commentId);
sessionStorage.setItem('commentUserId', commentUserId);
$('html,body').animate({ scrollTop: $("#commentPosition").offset().top - 100 }, 200)
}
// 提交评论
function postComment() {
comment = isEmpty();
if (!comment){
return false;
}
let postId = $("#postTitle").data("id");
$.ajax({
type:"post",
data: {"commentContent": comment, 'postId': postId},
url: "/post/post-comment/",
success: function (res) {
window.location.reload();
}
})
}</code></pre>
<p>上面的JavaScript代码主要是用来后端模块进行交互，这里就不进行详细解释，整个帖子的评论系统就完成了。</p>
<blockquote class="m-blockquote">
<p>再次提醒！博客文章中的代码只截取了部分关键代码，很多细节代码没有贴出来，如果想要在本地机器上运行调试可以访问我的<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>或者<a href="https://gitee.com/weiijang/university-bbs">gitee仓库</a>仓库，如果想要看到实际效果请访问<a href="http://bbs.2dogz.cn/">二狗学院</a></p>
</blockquote>
</content>
<link href="https://2dogz.cn/blog/article/40/" rel="alternate"/>
</entry>
<entry>
<id>39</id>
<title>[好文收录]Break the Cycle of Procrastination</title>
<updated>2023-09-27T02:08:19.929448+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>拖延症患者很少什么都不做，他们只是单纯地不做手头上的事。拖延症患者时常会发现他们自己正在打扫房间、喂猫、和阿姨打电话或者陷入一个有趣但是没有任何意义的Youtube未知领域--他们不是什么事情都不做，只是没有做他们自己想做和需要做的事情。</p>
<p>消除你的拖延症怪圈的第一步就是你要明白为什么你没有做任何你应该做的事情。</p>
<h1>你为什么要拖延？</h1>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为需要完成的事情我感觉过于困难压力太大</h3>
<ul>
<li>分块是你的朋友
<ul>
<li>把大的事情可以分解成一小块、一小块...</li>
<li>把你的时间分块：每次花在每个项目或者课程上的时间不要超过1-2个小时。</li>
<li>把日常学习分块：每个科目每天学习一点点的知识，这样每个科目都会均匀提升。</li>
<li>制定<a href="https://live-learning-strategies-center.pantheonsite.io/how-to-study/studying-for-and-taking-exams/the-five-day-study-plan/" onclick="window.open(this.href, 'five-day-learn-plan', 'resizable=no,status=no,location=no,toolbar=no,menubar=no,fullscreen=no,scrollbars=no,dependent=no'); return false;">五天学习计划</a>。</li>
</ul>
</li>
<li>在开始你的项目之前先进行锻炼或者冥想</li>
</ul>
<h3><em><strong>&nbsp; &nbsp;&nbsp;</strong></em>拖延，是因为我感到沮丧</h3>
<ul>
<li>规划好你的休息时间在你的工作当中。</li>
<li>学习新知识必然会有些许挑战，沮丧必然会成为其中的一部分，请牢记这一点。</li>
<li>培养成长心态可以有所帮助！</li>
<li>当你遇到有挑战的知识时可以寻求他人的帮助。</li>
</ul>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为我的完美主义</h3>
<ul>
<li>完美主义者经常觉得他们需要坐下来思考自己的想法，直到项目完美地出现。但是这不是通常情况下的工作方式，时刻提醒或者说服自己做草稿，草稿是很强大的工具。如果你做了一个草稿并思考了一段时间，大多数想法/项目/论文都会得到改进。草稿给你时间和空间，让你的想法有效地炖煮。</li>
<li>首先设定一个目标，不是完成一篇论文，而是开始起草草稿。</li>
<li>项目最终的结果真的需要完美无缺吗？尝试着让自己觉得足够好就可以了。但是如果一味的追求平庸那也不是一个好的想法，但是如果策略性的追求&ldquo;足够好&rdquo;那是没问题的。</li>
</ul>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为我的懒惰</h3>
<ul>
<li>大部分人发现结束一项工作比开始一项工作要难。因此不要把完成某个项目当做你最终的目标，你只要启动它就行了。</li>
<li>如何开始呢？制定一个5分钟的计时，关闭所有让你分心的东西，在这5分钟内只做与你项目相关的事情，时间结束之后，如果你想继续做那就继续做下去。不管怎么说，现在你已经开始了。</li>
<li>你是否想等到恐慌来侵扰你内心的时候才打算开始吗？如果你不想为了完成事情而感到恐慌，那就通过管理你的时间和日历来避免恐慌。</li>
</ul>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为我的执行力不足</h3>
<ul>
<li>弄清楚你需要完成的事情与你目标之前的潜在关系，这样就可以获得足够的动力去执行。</li>
<li>注意你的自言自语：尝试用 &quot;我想 &quot;代替 &quot;我必须&quot;。</li>
</ul>
<h3><em><strong>&nbsp; &nbsp; </strong></em>拖延，是因为自我怀疑</h3>
<ul>
<li>花些许的时间消除消极的想法，诚实地盘点你的成就。恭喜你，努力工作成就了现在的你，请继续保持努力！</li>
</ul>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为愤怒</h3>
<ul>
<li>如果你不做作业是因为你对老师很生气或者你不喜欢这门课，扪心自问:你不做作业伤害了谁？
<ul>
<li>
<p>怎样才能有效地发泄你的愤怒呢？</p>
</li>
</ul>
</li>
</ul>
<h3><strong><em>&nbsp; &nbsp; </em></strong>拖延，是因为我真的没有时间</h3>
<ul>
<li>考虑下自己为何如此之忙？你可以与自己或与他人重新协商哪些承诺？</li>
<li>更好地计划时间，并允许自己停止过度安排。</li>
</ul>
<p><strong>循环的拖延症怪圈</strong></p>
<p><strong><img alt="" class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/04/01/05d91002dc616.png" /></strong></p>
<p><strong>原文链接：<a href="https://lsc.cornell.edu/break-the-cycle-of-procrastination/">Break the Cycle of Procrastination</a></strong></p>
<p>翻译如果不当之处，请评论处留言，互相学习，拒绝拖延！！！</p>
</content>
<link href="https://2dogz.cn/blog/article/39/" rel="alternate"/>
</entry>
<entry>
<id>38</id>
<title>[测试相关]Selenium自动化测试工具简单使用示例</title>
<updated>2023-09-27T02:08:19.929421+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.安装浏览器驱动" name="1.安装浏览器驱动"></a>1.安装浏览器驱动</h1>
<p>访问<a href="https://chromedriver.storage.googleapis.com/index.html?path=&amp;sort=desc" onclick="window.open(this.href, 'chrome', 'resizable=yes,status=no,location=yes,toolbar=no,menubar=yes,fullscreen=no,scrollbars=yes,dependent=no'); return false;">下载链接</a>，既可以进入<code>chrome</code>驱动下载页面，目前<code>selenium</code>支持chrome、Firefox、IE 以及Remote。</p>
<ul>
<li>
<p>Windows安装</p>
<p>将下载好的驱动文件放入任意位置即可，比如放在<code>F:/ChormeDriver/chormedriver.exe</code>中，我们将其路径设置到环境变量的<code>Path</code>中即可；</p>
</li>
<li>
<p>Linux中安装</p>
<p>将下载好的驱动文件放入<code>/usr/bin</code>目录中即可</p>
<pre>
<code class="language-bash">sudo cp chromedriver /usr/bin</code></pre>
</li>
</ul>
<h1><a id="2.安装selenium" name="2.安装selenium"></a>2.安装selenium</h1>
<p>在你项目的环境中通过下面的命令进行安装</p>
<pre>
<code class="language-bash">pip install selenium -i https://pypi.douban.com/simple</code></pre>
<p>上面的<code>-i</code>参数是可选的，是指定在哪个<code>pip</code>在哪个源搜索<code>selenium</code>，这里指定的是douban的源，下载速度相较于默认的<code>python.org</code>要更加的快。</p>
<h1><a id="3.简单的示例" name="3.简单的示例"></a>3.简单的示例</h1>
<pre>
<code class="language-python">from selenium import webdriver
driver = webdriver.Chrome()
driver.get('https://www.baidu.com')
print(driver.title)
assert '百度' in driver.title
assert '我是' in driver.title</code></pre>
<p>在上面的代码中，通过访问<code>https://www.baidu.com</code>来获取该网站的title信息，并判断<code>百度</code>以及<code>我是</code>是否在title中，运行结果如下。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/03/23/97731ba7128ea.png" /></p>
<p>因为<code>我是</code>没有包含在<code>title</code>中所以出错。</p>
<h1><a id="4.模拟键盘输入" name="4.模拟键盘输入"></a>4.模拟键盘输入</h1>
<pre>
<code class="language-python">from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome()
driver.maximize_window()
driver.get("https://2dogz.cn")
assert "Blogin" in driver.title
elem = driver.find_element_by_name("q")
elem.clear()
elem.send_keys("装饰器")
elem.send_keys(Keys.RETURN)
assert "装饰器" in driver.page_source
assert "No results found." in driver.page_source</code></pre>
<p>通过<code>Keys</code>模块我们可以模拟键盘的输入，在上面的代码中我们做了如下的事情</p>
<ul>
<li>
<p>通过<code>find_element_by_name</code>来获取搜索的输入框</p>
</li>
<li>
<p>通过<code>send_keys</code>在输入框中嵌入搜索关键字<code>百度一下</code></p>
</li>
<li>
<p>通过<code>send_keys</code>模拟按下<code>ENTER</code>按键，进入下一个搜索结果页面</p>
</li>
<li>
<p>在搜素结果页面中判断<code>装饰器</code>是否在其中</p>
</li>
<li>
<p>在搜索页面中判断<code>No results found</code>是否在其中</p>
</li>
</ul>
<p><strong>执行结果如下</strong></p>
<p><strong>浏览器页面</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/03/23/47967cad6b570.png" /></p>
<p>&nbsp;</p>
<p><strong>控制台输出</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/03/23/83eb4eb4088ae.png" /></p>
<h1><a id="5.结合unittest使用" name="5.结合unittest使用"></a>5.结合unittest使用</h1>
<p><code>selenium</code>自身不提供测试框架或者工具，我们可以通过Python 的<code>unittest</code>模块来写测试用例，也可以通过其他的的第三方测试工具如<code>pytest</code>或者<code>nose</code>等。</p>
<pre>
<code class="language-python">import unittest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
class BaiduTest(unittest.TestCase):
def setUp(self) -&gt; None:
self.driver = webdriver.Chrome()
def test_title(self):
driver = self.driver
driver.get('https://2dogz.cn')
self.assertIn('Blogin', driver.title)
def test_blog_search(self):
driver = self.driver
driver.get('https://2dogz.cn')
search = driver.find_element_by_name('q')
search.send_keys('装饰器')
search.send_keys(Keys.RETURN)
self.assertIn('装饰器', driver.page_source)
self.assertNotIn('没有找到', driver.page_source)
def tearDown(self) -&gt; None:
self.driver.close()
if __name__ == '__main__':
unittest.main()</code></pre>
<p><img class="d-block img-fluid mx-auto pic" src="https://7.dusays.com/2021/03/23/4025fa784de4e.png" /></p>
<p>通过<code>unittest</code>模块将其与<code>selenium</code>结合起来实现自动化测试，上面的结果说明两个测试都是通过的，我们从网页中手动去搜索发下也是一样的结果。</p>
</content>
<link href="https://2dogz.cn/blog/article/38/" rel="alternate"/>
</entry>
<entry>
<id>37</id>
<title>[应用部署]使用COS备份云服务器数据</title>
<updated>2023-09-27T02:08:19.929394+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1. 什么是对象存储" name="1. 什么是对象存储"></a>1. 什么是对象存储</h1>
<p>COS（Cloud Object Storage，COS）的意思就是对象存储，提供的一种存储海量文件的分布式存储服务，用户可通过网络随时存储和查看数据。在COS中有两个概念一个是bucket还有一个是object。在这里bucket就相当于我们电脑上的硬盘，用来存储object的，从而object就相当于是我们电脑硬盘中每一个文件。</p>
<h1><a id="2. 创建BUCKET" name="2. 创建BUCKET"></a>2. 创建BUCKET</h1>
<p>首先登录腾讯云的控制台页面，在所有产品中输入COS，就可以找到对象存储的页面，按照页面上的提示一步一步的操作即可，最后会进入到如下页面</p>
<p><img alt="创建bucket" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1347image.png" /></p>
<blockquote class="m-blockquote">
<p>这里要注意的是，最好是创建一个跟自己云服务在同一个区域的对象存储，因为在同一个区域的话，就不会耗费对象上传所需要的的费用了。当然如果你是土豪，那么可以忽略这一点。</p>
</blockquote>
<h1><a id="3. 查看网络是否连通" name="3. 查看网络是否连通"></a>3. 查看网络是否连通</h1>
<p>登录到自己的云服务器，通过telnet命令来判断云服务器晕COS之间的网络是否连通，命令如下</p>
<pre>
<code class="language-bash">telnet examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com 80
Trying 169.254.0.47....
Connected to 169.254.0.47.
Escape character is '^]'.</code></pre>
<p>连接可以到自己的COS对应的bucket概览中查看，如果出现上述结果，则说明云服务器与COS是连通的。.</p>
<h1><a id="4.上传文件到bucket中" name="4.上传文件到bucket中"></a>4.上传文件到bucket中</h1>
<p>上传文件到bucket中的方式有很多种，这里只介绍通过Python SDK的方式上传文件到bucket。</p>
<p>首先需要先通过pip安装第三方库，命令如下</p>
<pre>
<code class="language-bash">pip install -U cos-python-sdk-v5</code></pre>
<p>然后需要获取两个关键认证参数，SecretId与SecretKey，访问<a href="https://console.cloud.tencent.com/cam/capi">该页面</a>既可以获取到</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8397image.png" /></p>
<p>然后新建一个脚本文件输入如下代码</p>
<pre>
<code class="language-python"># -*- coding=utf-8
# appid 已在配置中移除,请在参数 Bucket 中带上 appid。Bucket 由 BucketName-APPID 组成
# 1. 设置用户配置, 包括 secretId，secretKey 以及 Region
from qcloud_cos import CosConfig
from qcloud_cos import CosS3Client
import sys
import logging
logging.basicConfig(level=logging.INFO, stream=sys.stdout)
secret_id = 'COS_SECRETID' # 替换为用户的 secretId
secret_key = 'COS_SECRETKEY' # 替换为用户的 secretKey
region = 'COS_REGION' # 替换为用户的 Region
token = None # 使用临时密钥需要传入 Token，默认为空，可不填
scheme = 'https' # 指定使用 http/https 协议来访问 COS，默认为 https，可不填
config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token, Scheme=scheme)
# 2. 获取客户端对象
client = CosS3Client(config)
with open('picture.jpg', 'rb') as fp:
response = client.put_object(
Bucket='examplebucket-1250000000',
Body=fp,
Key='picture.jpg',
StorageClass='STANDARD',
EnableMD5=False
)
print(response['ETag'])
</code></pre>
<p>上述代码中的参数根据自己实际的bucket参数进行配置，运行上面的脚本就可以将数据上传到bucket中了。</p>
<p>如果我们希望在bucket中对文件进行分类，可以在腾讯云控制台中新建文件夹，如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5064image.png" /></p>
<p>如果我们希望将picture.jog上传到博客图片文件中，修改上面的代码为如下所示就可以了</p>
<pre>
<code class="language-python">with open('picture.jpg', 'rb') as fp:
response = client.put_object(
Bucket='examplebucket-1250000000',
Body=fp,
Key='博客图片/picture.jpg',
StorageClass='STANDARD',
EnableMD5=False
)</code></pre>
<p>之后在控制台就可以手动下载你想下载的文件啦，速度非常快，但是还是需要注意费用哦，如果文件体量不大，一年也花不了太多钱。</p>
</content>
<link href="https://2dogz.cn/blog/article/37/" rel="alternate"/>
</entry>
<entry>
<id>36</id>
<title>[Python]给个人博客添加RSS订阅支持</title>
<updated>2023-09-27T02:08:19.929368+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.RSS指北" name="1.RSS指北"></a>1.RSS指北</h1>
<p>可能很多小伙伴看到RSS这个缩写或多或少都不太明白其意思，这里稍微做一下指北介绍</p>
<h2>a.什么是RSS</h2>
<p><strong>RSS</strong>是单词<strong>Really Simple Syndication</strong>三个单词的首个字母，其意思就是简易信息聚合(翻译来自百度百科)，它基于XML标准，是一种在互联网上被广泛采用的内容包装和投递协议。RSS是一种描述和同步网站内容的格式，是使用最广泛的XML应用。</p>
<h2>b.为什么要采用RSS</h2>
<p>假设我有一个个人的博客网站，如果某些用户对我的网站比较感兴趣，一般的操作方式就是收藏我的网站，然后不定期的访问网站来查看我的网站是否有内容进行更新，这样一来对于用户来说就比较耗费时间。如果我的网站提供了RSS订阅源，那么用户只需要订阅我网站的RSS源，就不需要不定期的来访问我的网站来查看是否有内容更新了。当用户订阅了我网站的RSS源之后，每当我的网站有内容更新，用户端的RSS源也会随之更新，这就是RSS的好处，既可以方便用户又可以有效的传播我们的文章。</p>
<h1><a id="2.Python生成RSS源" name="2.Python生成RSS源"></a>2.Python生成RSS源</h1>
<p>我的网站是基于Python3+Flask来搭建的，所以这里就介绍一下如果使用Python来生成RSS源。</p>
<p>其实<code>RSS</code>本质就是一个<code>.xml</code>文件，我们可以通过很多中方法来生成<code>.xml</code>文件，在这里我使用<code>python-feengen</code>这个第三方库来实现RSS源的生成。首先通过下面的命令安装</p>
<pre>
<code class="language-bash">pip install feedgen</code></pre>
<p>安装完成之后，根据官方文档写一个简单的示例，代码清单如下</p>
<pre>
<code class="language-python">from feedgen.feed import FeedGenerator
fg = FeedGenerator()
fg.id('https://2dogz.cn/')
fg.title('Blogin')
fg.author({'name': 'Blogin', 'email': 'weijiang1994_1@qq.com'})
fg.link(href='https://2dogz.cn/')
fg.logo('https://2dogz.cn/accounts/avatar/%E6%B8%85%E6%B0%B44.jpg/')
fg.subtitle('这是一个测试feed')
# 生成feed
print(fg.atom_str(pretty=True)) # 这里输出的是bytes类型的数据
print(str(fg.atom_str(pretty=True), encoding='utf-8'))</code></pre>
<p>运行结果如下图所示，我们可以看到就是一个xml组织结构的文本</p>
<p><img alt="feed" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn//backend/files/3164image.png" /></p>
<blockquote class="m-blockquote">
<p>如果你想将其写入<code>xml</code>文件中可以通过<code>fg.atom_file(&#39;filename.xml&#39;)</code>将其存入到xml文件中去!</p>
</blockquote>
<p>上面仅仅是生成feed，我们还需要将实例(entry)填入其中，在上面的代码中加入下面的代码清单</p>
<pre>
<code class="language-python">fe = fg.add_entry()
fe.id('https://2dogz.cn/blog/article/34/')
fe.title('不期而至的三月雨')
fe.content('白日依山尽，黄河入海流，欲穷千里目，更上一层楼。')
print(str(fg.atom_str(pretty=True), encoding='utf-8'))</code></pre>
<p>结果如下图，我们可以看到新添加进去的内容被放入到<strong>feed</strong>节点中了已<strong>entry</strong>作为节点名</p>
<p><img class="d-block img-fluid mx-auto pic" src="http://2dogz.cn/backend/files/8278image.png" /></p>
<p>这样就完成了RSS源的生成了。</p>
<h1><a id="3.在Flask中使用" name="3.在Flask中使用"></a>3.在Flask中使用</h1>
<p>最终的目的还是要给我们自己的博客网站提供一个RSS的源，供用户订阅，那么怎么来实现呢？看下面代码清单</p>
<pre>
<code class="language-python">@rss_bp.route('/')
def rss_feed():
blogs = Blog.query.filter_by(delete_flag=1).order_by(Blog.create_time.desc()).all()
fg = FeedGenerator()
fg.title('Blogin')
fg.description('Blogin是一个个人博客网站，后端使用Flask框架，前端使用Bootstrap4，主要分享一些编程类的技术以及一些陈词滥调的文章!')
fg.link(href='https://2dogz.cn')
fg.id(str(len(blogs)))
for blog in blogs:
fe = fg.add_entry()
fe.title('[{}]'.format(blog.blog_types.name)+blog.title)
fe.id(blog.id)
fe.link(href='https://2dogz.cn//blog/article/{}/'.format(blog.id))
fe.description(blog.introduce)
fe.guid(str(blog.id), permalink=False) # Or: fe.guid(article.url, permalink=True)
fe.author(name='Blogin', email='weijiang1994_1@qq.com')
fe.content(blog.content)
rss_data = str(fg.atom_str(pretty=True), 'utf-8')
response = make_response(rss_data)
response.headers.set('Content-Type', 'rss+xml')
return response</code></pre>
<p>上面的代码来自我自己博客网站rss源生成的代码，其具体操作流程就是先将博客网站上所有的文章从数据库中提取出来，然后通过feedgen来生成.xml标准的文本，然后通过response将其作为返回。我们访问<a href="https://2dogz.cn/rss-feed/">https://2dogz.cn/rss-feed/</a>就可以看到效果了。</p>
<h1><a id="4.需要注意的地方" name="4.需要注意的地方"></a>4.需要注意的地方</h1>
<ol>
<li>在给response设置headers的时候记得需要将其设置为rss+xml，不需要设置为application/rss+xml，否则会出现乱码</li>
<li>博客中如果使用到了图片需要将其设置为绝对路径，否则在RSS阅读器中可能无法看到博客中的图片</li>
</ol>
</content>
<link href="https://2dogz.cn/blog/article/36/" rel="alternate"/>
</entry>
<entry>
<id>35</id>
<title>[MySQL]MySQL查询之排序分页</title>
<updated>2023-09-27T02:08:19.929340+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.排序的基本用法" name="1.排序的基本用法"></a>1.排序order by的基本用法</h1>
<p>在MySQL中排序的基本语法如下所示</p>
<pre>
<code class="language-sql"># 单字段
SELECT column1, column2 from table order by column1 desc;
# 多字段
SELECT column1, column2 from table order by column1, column2 desc;</code></pre>
<p>通过下面的语句新建一张student表，并插入一些数据</p>
<pre>
<code class="language-sql">CREATE TABLE student(
id int primary key auto_increment,
name varchar(128) default '' not null ,
score integer default 0 not null ,
birth date not null
)</code></pre>
<p>插入一些测试数据</p>
<pre>
<code class="language-sql">INSERT INTO student (name, score, birth) VALUES
('张三', 89, '2005-08-12'),
('李四', 78, '2002-11-03'),
('王五', 89, '2004-09-11'),
('赵六', 68, '2005-08-24'),
('赵七', 59, '2001-04-22'),
('钱八', 95, '2008-08-31');</code></pre>
<h2>a.单字段排序</h2>
<p>通过<code>分数</code>对查询结果进行排序，升序排列</p>
<pre>
<code class="language-sql">select name, score, birth from student order by score;</code></pre>
<p><strong>查询结果</strong></p>
<p><img alt="分数单字段" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8373%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_69.png" /></p>
<p>通过<code>分数</code>对查询结果进行排序，降序排列</p>
<pre>
<code class="language-sql">select name, score, birth from student order by score desc ;</code></pre>
<p><strong>查询结果</strong></p>
<p><strong><img alt="分数降序" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2697%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_70.png" /></strong></p>
<h2>b. 多字段排序</h2>
<p>上面的数据中我们可以看到分数有相同的情况，如果某个字段存在相同的数据，那么可以用其他字段作为第二个、第三个等次要条件来排序</p>
<p>使用<code>score</code>、<code>birth</code>字段来排序</p>
<pre>
<code class="language-sql">select name, score, birth from student order by score desc , birth desc;</code></pre>
<p><strong>&nbsp;查询结果</strong></p>
<p><img alt="多字段排序" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1513%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_71.png" /></p>
<blockquote class="m-blockquote">
<p>多字段我们可以指定每个字段的排序方式(升序或者降序)！</p>
</blockquote>
<h2>&nbsp;c.按函数排序</h2>
<p>除了字段之外，我们还可以使用内置的函数来排序，比如通过<code>birth</code>字段的年份来排序</p>
<pre>
<code class="language-sql">select name, score, year(birth), birth from student order by year(birth);</code></pre>
<p><strong>查询结果</strong></p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4846%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_72.png" /></p>
<h1><a id="2.分页limit的用法" name="2.分页limit的用法"></a>2.分页limit的用法</h1>
<p>limit顾名思义，是用来显示查询返回的长度，其语法如下所示</p>
<pre>
<code class="language-sql">SELECT column1, column2 from table limit offset, count;</code></pre>
<ul>
<li>offset：表示偏移量，就是跳过多少行数据，可以省略默认为0</li>
<li>count：表示去多少行数据，如果设置了offset则跳过offset行数据后开始取数据</li>
</ul>
<h2>a.获取前n行记录</h2>
<p>我们想获取成绩排名前面的学生</p>
<p>首先我们需要对数据进行降序排列，然后通过limit来获取前3排名的数据</p>
<pre>
<code class="language-sql">select name, score from student order by score desc limit 3;</code></pre>
<p><strong>查询结果</strong></p>
<p><img alt="limit前三" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4898%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_73.png" /></p>
<h2>b.获取n-m行记录</h2>
<p>如果想获取成绩排名2-4名的学生，通过limit怎么实现呢？</p>
<p>首先我们要跳过第一名就是将offset设置为1，同时要取2-4名count设为3;</p>
<ul>
<li>offset: n-1</li>
<li>count: m-n+1</li>
</ul>
<pre>
<code class="language-sql">select name, score from student order by score desc limit 1, 3;</code></pre>
<p><strong>查询结果</strong></p>
<p><strong><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8649%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_74.png" /></strong></p>
<h1><a id="3.分页查询" name="3.分页查询"></a>3.分页查询</h1>
<p>在实际开发过程中我们经常会遇到分页查询的功能，一般的都通过limit来实现，当然还有一些邪道，这里就不说。</p>
<p>上面插入的数据量太小了，我们需要重新插入一下测试数据</p>
<pre>
<code class="language-sql">insert into student (name, score, birth) values
('李明', FLOOR(RAND()*100), '2006-06-06'),
('李红', FLOOR(RAND()*100), '2001-01-23'),
('王宝静', FLOOR(RAND()*100), '2006-04-18'),
('李耀武', FLOOR(RAND()*100), '2003-11-11'),
('宋青书', FLOOR(RAND()*100), '2006-12-08'),
('任我行', FLOOR(RAND()*100), '2006-08-22'),
('裘千仞', FLOOR(RAND()*100), '2006-01-24'),
('小龙女', FLOOR(RAND()*100), '2006-07-26')</code></pre>
<p>上面使用了生成随机数的函数，大家可以自行百度一下。</p>
<p>执行select语句，看看数据是否插入成功</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5906image.png" /></p>
<p>比如我们按照成绩降序，需要查询第2页，每页5条数据，怎么实现呢？</p>
<blockquote class="m-blockquote">
<ul>
<li>第1页 5条数据 1-5，offset=0 count=5</li>
<li>第2页 5条数据 6-10 offset=5 count=5</li>
<li>第3页 5条数据 11-15 offse=10 count =5</li>
<li>...</li>
<li>第n页 5条数据 (n-1)*5 - 5n offset=(n-1)*5 count=5</li>
</ul>
</blockquote>
<pre>
<code class="language-sql">select name, score, birth from student order by score desc limit 5, 5;</code></pre>
<p><strong>查询结果</strong></p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/7172image.png" />&nbsp;</p>
<h1><a id="4.避免踩坑" name="4.避免踩坑"></a>4.避免踩坑</h1>
<ol>
<li>limit后面不能跟表达式
<pre>
<code class="language-sql"># 报错，limit后面不能跟表达式
select * from student where limit 1,4+1;</code></pre>
<p>这种写法是会报错，limit后面只能跟具体的数字</p>
</li>
<li>
<p>limit后面不能为负数</p>
<pre>
<code class="language-sql"># 报错，limit后面不能跟负数
select * from student where limit -1,-4;</code></pre>
</li>
<li>排序分页问题<br />
排序最好用两个字段进行排序，如果一个字段中可能出现同等的值，那么就会造成排序分页冗余的问题，可以指定多个字段进行排序，保证其排序结果的唯一性！<br />
&nbsp;</li>
</ol>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/35/" rel="alternate"/>
</entry>
<entry>
<id>34</id>
<title>[陈词滥调]不期而至的三月细雨</title>
<updated>2023-09-27T02:08:19.929313+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>&nbsp; &nbsp; 自从15年9月去桂林读研之后，已经许久没有见过潇湘阳春三月的样子了。</p>
<p>&nbsp; &nbsp; 在读研的三年时间里，每年中间还能间断的回来几次，不过那时候的故乡也只有夏冬。印象中读研期间的第一个寒假回家，回家那天晚上下了大学，还兴致勃勃的在秋秋空间中发布了一条打油诗的说说，现在看起来当初自己的感觉好蠢啊，如果放到现在我肯定不会厚着脸皮往朋友圈发。<br />
<img alt="归雪" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8305%E5%BD%92%E9%9B%AA.png" /></p>
<p>&nbsp; &nbsp; 思绪回转到桂林，桂林的天气真的就是一个女人，十分的善变。很多次，跟着连同学骑着小电炉去市区溜达，出门的时候还是晴空大太阳，突然之间来了一团乌云，然后暴雨将至，因此出门的时候我们总是不约而同的在小电炉的后备箱中放一把小雨伞，以防万一。</p>
<p>&nbsp; &nbsp; 岭南地区流传着&rdquo;回南天&ldquo;的说法，记得研一下学期开学时，那天晚上刚回到学校，就感觉自己床铺上的被子十分的潮湿，简直不能入睡，而且我还是在上铺，可想而知睡在我下铺的兄弟会怎么样。那时候研一住在一楼，三四月份的时候，宿舍的地板天天都是湿漉漉的，晾在外面的衣服也总是发霉。研一结束之后宿舍楼上就有了空宿舍，几个舍友就一起搬到3楼去了。搬到了3楼之后，回南天带来的影响就相对1楼很小了，至少宿舍地板不是每天都很潮湿了，这大概就是我对桂林这个城市最深刻的记忆了，哦对了，还有那便宜有很好吃的荔枝了，哈哈哈。总而言之，桂林给我的第一感觉就是潮湿还有那种山雨欲来风满楼的感觉~</p>
<p>&nbsp; &nbsp; 18年6月底毕业之后离开了这个生活、学习了三年的地方了，记得最后一次离开桂林是同张同学一起坐车离开的，在开往桂林站的的士上，路过解放桥时拍下了在桂林的最后一张照片，关于桂林的记忆就停留于此了，但是关于桂林的人和事有很多很多!<br />
<img alt="桂林" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2557%E6%A1%82%E6%9E%97.jpg" /></p>
<p>&nbsp; &nbsp; 毕业之后来到了深圳，这是第二次来到深圳了。早在17年就有过一面之缘，那时候由于身体抱恙，来深圳看了一下(各位还是要多注意一下自己的身体啊~不要太劳累)。大城市真的有大城市的便利，不管是交通还是其他方面，但是便利归便利，这里的灯红酒绿终究是不属于我。</p>
<p>&nbsp; &nbsp; 第一年来到深圳恰逢18年的山竹大台风，那一天恰巧是星期天，那算是生平的初见台风。那时候住在公司给应届生分配的宿舍中，好在有很多小伙伴一起聊天、扯淡，来度过了内心比较恐惧的一天，那天还停电了很久直到第二天晚上下班回到宿舍才来电，9月份的深圳十分炎热，不敢去想那晚我是怎么入睡的。</p>
<p>&nbsp; &nbsp; 深圳的雨相比桂林就温和多了，至少我没有遇到过突然之间就下来磅礴大雨，但是很烦人的是深圳的雨总是喜欢在上下班的时候下，可能是在提醒奔波的人们放慢脚步当心一点。18年底公司给应届生住的宿舍到期了，迫不得已得自己到外面去租房住了，就跟同事小张总一起在西乡共乐小学附近合租了一间两室一厅城中村的房子。由于出租屋附近没有地铁，每天只能挤着公交车上下班，生平第一次坐着人挤人的公交车，有一次感觉整个身子都是飘起来的，脚根本没有着地，很多时候就连公交车师傅开门的时候都会吆喝一声&quot;站在门口的注意啦，要开门了~&quot;，不幸中的万幸是我们那站离发车站不算太远每次都能挤上车，而且不会被挤到门口附近。</p>
<p>&nbsp; &nbsp; 就这样日子一天天无聊的过去了，每天除了上班下班睡觉就没有其他的事情可以做了，住在这边的这段时间里最烦人就是每天打不死、灭不尽的小强了。时间快进到19年6月底，这边的房子要到期了，跟小张总合计着租到有地铁的地方去，这样子上班就相对比较方便了。在离租期结束的上一个周末就去固戍那边找房子，接纳我们的中介比较好，是个漂亮的小妹子，骑着小电驴在地铁口等着我们，后来跟着她去了要出租的公寓，这期间还往机场东那边跑了一圈，可惜距离太远而且价格也没有便宜太多，后来就还是租在固戍这边了。去机场东的途中是我第一次在深圳骑电动车，还跟着中介一起闯红灯了(主要是没车o)。这边就没有跟小张总一起合租了，因为这时候我有女朋友了，所以就跟他租的同一栋楼同一层的单间了。不得不说深圳的黑房东是真的很多，第一次退房黑房东就扣了我们900块钱，一个灯要300块。</p>
<p>&nbsp; &nbsp; 坐地铁上班的日子也没有想象中的那么美好，每天早上7点就要起床，然后30之前必须出门，不然固戍地铁口就是一条长龙了。由于固戍离市中心的距离比较远了，这边的房租相对比较便宜，很多在南山、福田上班的人都住在这边，所以每天早上就能看到深圳奇观，地铁口一条条长龙，不管是几号线，都是这样。排队只是开始，在进入地铁之后，你可能还得等待第二趟地铁才能上车，好在是深圳地铁的频率比较高，不用等待太久。</p>
<p>&nbsp; &nbsp; 2020年初疫情来了，不得不说985毕业的小张总还是很有远见的，在关于疫情新闻才报道出来的时候，他就拉着我去买口罩，而我那时候却对他这种想法有点不屑，但是还是跟他一起去买了。2020年春节由于疫情公司延迟了一周的假期，回到深圳之后，昔日里繁忙的一号线看不到几个踪影。后来根据社区通知，我是从岳阳返深的需要居家隔离14天，两周真的是一天没出过门，买菜都是外送。</p>
<p>&nbsp; &nbsp; 时间来到年中，6月份恰好找到了长沙的工作，然后就跟公司提交了辞呈，好在我经受住了领导画的大饼，最后在7月初就离职了，离开了第一个老东家。后面大半个月的时间过得很悠闲，去珠海玩了一趟，然后回深圳收拾完东西之后退完房，就回岳阳老家了。在老家待了不到一个星期就回到了长沙入职了，到现在也有大半年的时间了。</p>
<p>&nbsp; &nbsp; 三月份的长沙，许久未见的朦胧细雨又如期而至，仿佛又回到大学那时。不知道是什么原因，好像每个地方的雨都喜欢在上下班的时候下，不管是深圳还是在长沙好像都是这样。长沙还是正在发展中的城市，在公共交通肯定是没有深圳那么便利，公司所在的地方属于是商业区，但是现在还没有开通地铁，只有公交车，而且下了公交车步行的距离也比较远。并且已经在深圳享受了一大早坐公交车那种晕晕吐吐的感觉，在长沙就不想再次体验了。因此每天就骑着共享电动车上下班了。</p>
<p>&nbsp; &nbsp; 连续多天的绵绵细雨，扰乱我的心神。很多次闹钟里面播放着今天的天气是多云，而等我出门就又在下雨了。而后就只能走路去公司，虽然不远只有3公里左右的路程，40分钟就能到，但是出门晚就迟到了。</p>
<p>&nbsp; &nbsp; 在外飘摇了五年多的时间，最后还是回到了热爱的潇湘，虽然说比不上大城市的繁华，但是还是比较喜欢这里的市井气息，让人的生活更加惬意~</p>
<p>&nbsp; &nbsp; 不期而至的三月雨啊，你不要再上下班的时候下啦，不然打工人的全勤奖就没啦~</p>
</content>
<link href="https://2dogz.cn/blog/article/34/" rel="alternate"/>
</entry>
<entry>
<id>33</id>
<title>[系列教程]使用Flask搭建一个校园论坛7-帖子详情</title>
<updated>2023-09-27T02:08:19.929285+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.功能简介" name="1.功能简介"></a>1.功能简介</h1>
<p>不管什么论坛，当用户发布了帖子之后，最原始的目的就是让更多的用户来看到帖子，同时参与到该帖子的讨论当中去。到目前为止我们还没有实现用户阅读帖子的页面，本节主要实现这个功能。</p>
<h1><a id="2.阅读帖子" name="2.阅读帖子"></a>2.阅读帖子</h1>
<p>在首页中我们显示了三个tab的帖子列表，用户点击对应的帖子标题超链接就进入对应的详情页面，但是在上一节之前还没有实现阅读帖子的视图函数，所以上一节中的点击帖子标题跳转到帖子详情页面的功能还不能使用，这里开始实现此功能。打开<code>bbs/blueprint/frontend/post.py</code> 模块，添加下面的代码</p>
<pre>
<code class="language-python">@post_bp.route('/read/&lt;post_id&gt;/', methods=['GET'])
def read(post_id):
post = Post.query.get_or_404(post_id)
if current_user.is_authenticated:
c_tag = Collect.query.filter(Collect.user_id == current_user.id, Collect.post_id == post_id).first()
else:
c_tag = None
post.read_times += 1
db.session.commit()
return render_template('frontend/post/read-post.html', post=post, c_tag=c_tag)</code></pre>
<p>上面代码十分简单，就是通过请求中的参数从数据库中获取帖子的相关内容，然后渲染到页面中，但此时还没有对应的页面，因此需要创建模板文件，打开<code>bbs/templates/frontend/post/</code>，新建模板文件<code>read-post.html</code>，并添加下面的代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% block head %}
{{ super() }}
{{ ckeditor.load_code_theme() }}
&lt;!--suppress ALL --&gt;
&lt;style&gt;
.post-title-h1{
font-size: 22px;
font-weight: bold;
}
.post-div{
color: white;
background: #303030;
padding: 5px 15px 8px 15px;
border-radius: 5px;
}
.post-content{
color: white;
background: #343434;
padding: 8px;
border-radius: 5px;
}
article&gt;h1 {
font-size: 20px;
font-weight: bold;
margin: 10px 0 10px 0;
padding: 0 10px;
border-left: 5px solid #20c997;
line-height: 2em;
}
article&gt;h2 {
font-size: 18px;
margin-top: 5px;
margin-bottom: 5px;
padding: 5px 5px 5px 5px;
border-bottom: 1px solid #28a745;
}
article&gt;h3 {
font-size: 18px;
margin-top: 10px;
margin-bottom: 10px;
padding: 5px 5px 5px 5px;
border-bottom: 1px solid #28a745;
}
blockquote&gt;p {
font: 14px/22px normal helvetica, sans-serif;
margin: 5px 0px 5px 0px;
font-style:italic;
}
.report-textarea{
height: 100px!important;
}
.preview{
background: white;
border-radius: 5px;
color: black!important;
}
.blockquote-comment{
margin-top: 5px;
border-left: 6px solid #6c6c6c;
background: #6c757d;
color: white;
padding: 8px;
}
.p-error-hint{
color: #f94b43;
display: none;
font-weight: bold;
}
.p-reply{
color: #80bdff;
margin-bottom: 0px;
}
.div-comment-body{
border-bottom: 1px solid #828286;
padding-bottom: 6px;
}
.div-gutter20{
height: 20px;
}
@media screen and (max-width: 567px){
.div-gutter20{
height: 5px;
}
}
.hr-margin-5{
margin: 5px 0 5px 0!important;
}
&lt;/style&gt;
{% endblock %}
{% block title %}
{{ post.title }}
{% endblock %}
{% block content %}
{{ moment.locale(auto_detect=True) }}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container mt-2"&gt;
{% include "_flash.html" %}
&lt;ol class="breadcrumb"&gt;
&lt;li class="breadcrumb-item"&gt;&lt;a class="text-decoration-none" href="/"&gt;主页&lt;/a&gt;&lt;/li&gt;
&lt;li class="breadcrumb-item"&gt;&lt;a class="text-decoration-none" href="#"&gt;杂谈&lt;/a&gt;&lt;/li&gt;
&lt;li class="breadcrumb-item active"&gt;帖子标题&lt;/li&gt;
&lt;/ol&gt;
&lt;!-- 帖子主要信息 --&gt;
&lt;div class="post-div"&gt;
&lt;h1 class="post-title-h1" id="postTitle" data-id="{{ post.id }}"&gt;{{ post.title }}&lt;/h1&gt;
&lt;div class="d-flex mb-0"&gt;
&lt;p class="text-muted mr-2 mb-0"&gt;&lt;i class="fa fa-thumbs-o-up mr-1"&gt;&lt;/i&gt;&lt;span class="d-none d-lg-inline-block"&gt;点亮&lt;/span&gt;({{ post.likes }}) &lt;/p&gt;
&lt;p class="text-muted mr-2 mb-0"&gt;&lt;i class="fa fa-thumbs-o-down mr-1"&gt;&lt;/i&gt;&lt;span class="d-none d-lg-inline-block"&gt;点灭&lt;/span&gt;({{ -post.unlikes }}) &lt;/p&gt;
&lt;p class="text-muted mr-2 mb-0"&gt;&lt;i class="fa fa-heart mr-1"&gt;&lt;/i&gt;&lt;span class="d-none d-lg-inline-block"&gt;收藏&lt;/span&gt;({{ post.collects }}) &lt;/p&gt;
&lt;p class="text-muted mb-0"&gt;&lt;i class="fa fa-calendar-minus-o mr-1"&gt;&lt;/i&gt;{{ post.create_time }}&lt;/p&gt;
&lt;/div&gt;
&lt;div class="d-flex"&gt;
{% if post.is_anonymous == 1 %}
&lt;img src="{{ post.user.avatar }}" class="rounded avatar-50"&gt;
&lt;div class="d-flex"&gt;
&lt;div&gt;
&lt;a class="ml-2 text-decoration-none" href="{{ url_for('profile.index', user_id=post.user.id) }}"&gt;{{ post.user.nickname }}&lt;/a&gt;
&lt;div class="d-flex"&gt;
&lt;a class="text-decoration-none ml-2"&gt;&lt;span class="badge badge-pill badge-success"&gt;{{ post.user.college.name }}&lt;/span&gt;&lt;/a&gt;
&lt;a class="text-decoration-none ml-2"&gt;&lt;span class="badge badge-pill badge-info"&gt;{{ post.user.role.name }}&lt;/span&gt;&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% else %}
&lt;img src="{{ url_for('static', filename='img/anonymous.jpeg') }}" class="rounded avatar"&gt;
&lt;div class="d-flex"&gt;
&lt;div&gt;
&lt;a class="ml-2 text-muted text-decoration-none"&gt;匿名&lt;/a&gt;
&lt;div class="d-flex"&gt;
&lt;a class="text-decoration-none ml-2"&gt;&lt;span class="badge badge-pill badge-success"&gt;{{ post.user.college.name }}&lt;/span&gt;&lt;/a&gt;
&lt;a class="text-decoration-none ml-2"&gt;&lt;span class="badge badge-pill badge-info"&gt;{{ post.user.role.name }}&lt;/span&gt;&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% endif %}
&lt;/div&gt;
&lt;div class="mt-2"&gt;
&lt;article&gt;
{{ post.content|safe }}
&lt;/article&gt;
&lt;/div&gt;
{% if current_user.is_authenticated and current_user.id == post.user.id %}
&lt;div class="d-flex flex-row-reverse mt-1"&gt;
&lt;a class="text-decoration-none text-muted" href="/post/edit/{{ post.id }}/"&gt;&lt;small&gt;编辑&lt;/small&gt;&lt;/a&gt;
&lt;a class="mr-2 text-decoration-none text-muted" href="/post/delete/{{ post.id }}/"&gt;&lt;small&gt;删除&lt;/small&gt;&lt;/a&gt;
&lt;/div&gt;
{% elif current_user.is_authenticated %}
&lt;div class="d-flex flex-row-reverse mt-1"&gt;
&lt;a class="text-decoration-none text-muted ml-2" data-toggle="modal" data-target="#exampleModal" href="#"&gt;&lt;small&gt;举报&lt;/small&gt;&lt;/a&gt;
&lt;a class="text-decoration-none text-muted ml-2" href="/post/collect/{{ post.id }}/"&gt;
&lt;small&gt;
{% if c_tag %}
取消收藏
{% else %}
收藏
{% endif %}
&lt;/small&gt;
&lt;/a&gt;
&lt;a class="text-decoration-none text-muted ml-2" href="/post/unlike/{{ post.id }}/"&gt;&lt;small&gt;点灭&lt;/small&gt;&lt;/a&gt;
&lt;a class="text-decoration-none text-muted ml-2" href="/post/like/{{ post.id }}/"&gt;&lt;small&gt;点亮&lt;/small&gt;&lt;/a&gt;
&lt;/div&gt;
{% endif %}
&lt;/div&gt;
&lt;div class="div-gutter20"&gt;&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;
&lt;/body&gt;
{% endblock %}
</code></pre>
<p>在该模板文件中，首先在<code>head</code>块中定义了一些代码样式，然后将主要是内容写在<code>content</code>块里面，在这个块里面做了下面几件事</p>
<ul>
<li>显示顶部面包屑导航</li>
<li>展示帖子相关信息点亮、点灭、收藏数等等</li>
<li>如果帖子是匿名的方式发布的则隐藏发布者的相关信息</li>
<li>如果打开帖子的当前用户是该帖子的发帖者，则在帖子内容底部显示编辑、删除操作按钮，如果是其他用户则显示收藏、点亮、点灭按钮</li>
</ul>
<blockquote class="m-blockquote">
<p>&nbsp;一般的，我们都会将style样式单独定义在一个css文件中，然后通过link标签来引用，由于是在开发过程中，如果样式需要频繁修改，则可以先定义在HTML文件中，因为如果定义在单独的css文件中，修改了样式需要清除浏览器缓存，不然样式不会更新。我们可以在调整好样式之后，将样式统一放入到一个css文件中去!</p>
</blockquote>
<p>&nbsp;接下来，就需要对阅读帖子页面上的一些按钮进行功能开发了。</p>
<h1><a id="3.帖子操作" name="3.帖子操作"></a>3.帖子操作</h1>
<p>在第二小节中在阅读帖子页面中加入了很多功能按钮，对于帖子所有者有删除、编辑帖子功能按钮，对于其他访问者有点亮、点灭、收藏等按钮，在这一小节中就分别实现对应按钮的功能。</p>
<h2>a.点亮、点灭操作</h2>
<p>打开<code>bbs/blueprint/frontend/post.py</code>模块，将下面的代码块添加进去</p>
<pre>
<code class="language-python">@post_bp.route('/like/&lt;post_id&gt;/', methods=['GET'])
@login_required
def like(post_id):
post = Post.query.get_or_404(post_id)
post.likes += 1
db.session.commit()
return redirect(url_for('.read', post_id=post_id))
@post_bp.route('/unlike/&lt;post_id&gt;/', methods=['GET'])
@login_required
def unlike(post_id):
post = Post.query.get_or_404(post_id)
post.unlikes += 1
db.session.commit()
return redirect(url_for('.read', post_id=post_id))</code></pre>
<p>两个视图函数的功能分别是将帖子的点亮数、点灭数+1操作，其实这里做有点不严谨，因为没有绑定用户的id，只是单纯的进行+1的操作，那么用户可以无限点击，要绑定用户id还需要增加表，就交给聪明的读者来实现吧，在下一小节收藏、取消收藏操作中实现了这个功能，可以参照一下代码，如果没有实现思路，可以参照一下下面的代码。</p>
<h2>b.收藏、取消收藏操作</h2>
<p>跟大多数论坛一样，当用户看到一个比较感兴趣的帖子之后，可以通过收藏该帖子，如果下次用户还想去浏览该帖子，就不需要导出去找，同样的我们也可以实现此功能。打开<code>bbs/blueprint/frontend/post.py</code> 模块，添加进下面的代码</p>
<pre>
<code class="language-python">@post_bp.route('/collect/&lt;post_id&gt;/')
@login_required
def collect(post_id):
post_collect(post_id)
return redirect(url_for('.read', post_id=post_id))
def post_collect(post_id):
post = Post.query.get_or_404(post_id)
c = Collect.query.filter(Collect.user_id == current_user.id, Collect.post_id == post_id).first()
if c:
post.collects -= 1
db.session.delete(c)
flash('取消收藏帖子成功!', 'success')
else:
post.collects += 1
c = Collect(user_id=current_user.id, post_id=post_id)
db.session.add(c)
flash('收藏帖子成功!', 'success')
db.session.commit()</code></pre>
<p>在上面的代码中，出现了一个新的模型类Collect，该类就是用来存储用户收藏帖子的数据库表，这张表属于多对多关系的中间表。因为一个用户可以收藏多个帖子，而一个帖子又可以被多个用户收藏，因此就需要通过一张中间表来存储用户与帖子之间的关系，ER图如下所示</p>
<p><img alt="er图" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8439%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_68.png" /></p>
<p>打开<code>bbs/models.py</code>模块，新建<code>Collect</code>模型类，代码清单如下</p>
<pre>
<code class="language-python">class Collect(db.Model):
__tablename__ = 't_collect'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
user_id = db.Column(db.INTEGER, db.ForeignKey('t_user.id'))
post_id = db.Column(db.INTEGER, db.ForeignKey('t_post.id'))
timestamps = db.Column(db.DateTime, default=datetime.datetime.now)
user = db.relationship('User', back_populates='collect', lazy='joined')
post = db.relationship('Post', back_populates='collect', lazy='joined')</code></pre>
<p>回到前一段代码，先通过传过来的<code>post_id</code>参数以及<code>当前登录用户的id</code>在<code>t_collect</code>表中查找是否包含这个数据，如果包含，则说明用户点击的是取消收藏的按钮，反之则表明用户点击的是收藏按钮，按照对应的方式处理插入数据还是增加数据。</p>
<h2>c.帖子编辑</h2>
<p>帖子编辑功能是每个论坛都必须提供的功能，接下来就实现此功能，打开bbs/forms.py模块，加入下面的代码</p>
<pre>
<code class="language-python">class EditPostForm(BasePostForm):
submit = SubmitField(u'保存编辑', render_kw={'class': 'source-button btn btn-danger btn-xs mt-2 text-right'})</code></pre>
<p>同样的在<code>bbs/blueprint/frontend/post.py</code>模块加入下面的代码</p>
<pre>
<code class="language-python">@post_bp.route('/edit/&lt;post_id&gt;/', methods=['GET', 'POST'])
@login_required
def edit(post_id):
form = EditPostForm()
post = Post.query.get_or_404(post_id)
if form.validate_on_submit():
title = form.title.data
ep = Post.query.filter_by(title=title).first()
# 修改标题不能是其他已经存在帖子的标题
if ep and ep.id != post.id:
flash('该帖子标题已经存在', 'danger')
return redirect(url_for('.edit', post_id=post_id))
cate = form.category.data
anonymous = form.anonymous.data
content = form.body.data
post.title = title
post.cate_id = cate
post.is_anonymous = anonymous
post.content = content
db.session.commit()
flash('帖子编辑成功!', 'success')
return redirect(url_for('.read', post_id=post_id))
form.title.data = post.title
form.body.data = post.content
form.category.data = post.cate_id
form.anonymous.data = post.is_anonymous
return render_template('frontend/post/edit-post.html', post=post, form=form)</code></pre>
<p>在上面的代码中，使用了EditPostForm这个表单类，通过继承自BasePostForm，就如同用户发表帖子那一节一样。之后我们根据请求参数中post_id来从数据库中获取对应的帖子内容，如果是提交表单请求的操作就进行帖子内容的更新，如果是编辑表单的请求操作就将该帖子的内容渲染在模板文件中，打开bbs/templates/frontend/post/目录，新建edit-post.html模板文件，嵌入下面的代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% import 'bootstrap/wtf.html' as wtf %}
{% block head %}
{{ super() }}
{% endblock %}
{% block title %}
编辑帖子-{{ post.title }}
{% endblock %}
{% block content %}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container mt-3"&gt;
{% include "_flash.html" %}
&lt;h3 class="text-info"&gt;&lt;strong&gt;编辑帖子&lt;/strong&gt;&lt;/h3&gt;
&lt;hr class="bg-secondary"&gt;
&lt;form action="/post/edit/{{ post.id }}/" method="post"&gt;
{{ form.csrf_token }}
{{ wtf.form_field(form.title) }}
&lt;div class="row"&gt;
&lt;div class="col"&gt;
{{ wtf.form_field(form.category) }}
&lt;/div&gt;
&lt;div class="col"&gt;
{{ wtf.form_field(form.anonymous) }}
&lt;/div&gt;
&lt;/div&gt;
{{ form.body }}
&lt;div class="text-right"&gt;
{{ form.submit }}
&lt;/div&gt;
&lt;/form&gt;
&lt;/div&gt;
&lt;/main&gt;
&lt;/body&gt;
{{ ckeditor.load() }}
{{ ckeditor.config(name='body') }}
&lt;script&gt;
CKEDITOR.on( 'instanceReady', function( evt ) {
evt.editor.dataProcessor.htmlFilter.addRules( {
elements: {
img: function(el) {
el.addClass('img-fluid d-block mx-auto');
},
table: function (el){
el.addClass('table table-responsive');
},
thead: function (el){
el.addClass('thead-light');
},
blockquote: function (el){
el.addClass('m-blockquote');
}
}
});
});
&lt;/script&gt;
{% endblock %}</code></pre>
<p>跟发布帖子那一节差不多，只是在添加了一些<code>JavaScript</code>代码，这些代码的主要作用是用来定制一些<code>CKEditor</code>元素的样式的，具体可以去查看<code>CKEditor4</code>的文档，这里不进行细说。</p>
<h2>d.删除帖子</h2>
<p>删除帖子的功能相对来说就十分的简单了，这里的删除实际上不是在数据库中删除，而是将帖子设置为某种状态，在很多互联网企业中删除都是通过这种方式来实现的，打开<code>bbs/blueprint/frontend/post.py</code>模块，添加下面的代码清单</p>
<pre>
<code class="language-python">@post_bp.route('/delete/&lt;post_id&gt;/', methods=['GET'])
@login_required
def delete(post_id):
post = Post.query.get_or_404(post_id)
if post.can_delete():
post.status_id = 2
db.session.commit()
flash('帖子删除成功!', 'success')
else:
flash('不是你的东西,你没有权限删除!', 'danger')
return redirect(url_for('index_bp.index'))</code></pre>
<p>通过请求参数post_id 从数据库中获取对应post，通过<code>can_delete()</code>方法来判断当前帖子是否属于当前用户，如果不是则返回提示消息，如果是则将当前帖子的<code>status_id</code>置为2，然后保存到数据库中，返回提示消息。</p>
<p>至此，本节内容就全部讲完啦，整个项目差不多已经写完了，可以到<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>下载源码对照我博客网站上的教程阅读。读者对照教程一边看教程一边写代码可能会出错哦，因为教程是在我代码写完之后开始写的，可能有些地方会遗漏，请谅解~哈哈哈~</p>
</content>
<link href="https://2dogz.cn/blog/article/33/" rel="alternate"/>
</entry>
<entry>
<id>32</id>
<title>[应用部署]记一次网站被高频爬虫攻击</title>
<updated>2023-09-27T02:08:19.929257+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.问题</h1>
<p>昨天下午(2021-02-22)4点多的时候，访问网站发现打开速度非常的慢，个人感觉有点不正常。虽然说部署服务器的带宽只有1M，但是首页的日访问量一般都是100-200之间，其中还包括我本人的访问量，因此感觉是有IP一直占用这服务器带宽，导致网站打开十分缓慢。</p>
<h1>2.排查</h1>
<p>通过SSH登录到云服务器上，发现SSH也变得十分卡顿，这一般都是因为网络出口带宽太低或者被占用，平时通过SSH操作的时候都十分流畅，毕竟买的是鹅肠成都地区的服务器，通过如下命令查看网络流量详情</p>
<pre>
<code class="language-bash">sudo iftop </code></pre>
<blockquote class="m-blockquote">
<p>iftop不是系统自带工具需要安装</p>
<ul>
<li>sudo apt-get install iftop&nbsp;</li>
</ul>
<p>因为服务器配置低只有一个网卡，如果有多个网卡可以通过-i参数来指定哪个网卡</p>
<ul>
<li>sudo iftop -i eth0&nbsp;</li>
</ul>
</blockquote>
<p>流量详情如下图</p>
<p><img alt="iftop" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6457%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_66.png" /></p>
<p>可以看到IP<code>116.253.54.18</code>一直有网络数据交换，而且瞬时数据量非常大(虽然说只有1M多点但对于我这个IM带宽的服务器已经是很巨大了)，经过IP查询该IP为广西贺州，如下图</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5147%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20210223093031.png" /></p>
<h1>3.解决办法</h1>
<p>那么查明了问题的根源解决办法就出来了，可以封禁该IP来解决这个问题，现在是我的SSH很卡没办法使用，我们可以通过鹅肠云服务器安全组策略来禁止该IP。</p>
<h2>a.通过网页控制台</h2>
<p>登录鹅肠云服务器控制台，点击左侧安全组选项，在右侧页面中点击<code>蓝色新建</code>按钮，模板选择自定义，其他的默认设置就好。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2166image-20210223093525078.png" /></p>
<p>点击确认按钮然后弹出提示框点击立即设置安全规则，在入站规则中添加规则，按照下面的提示进行设置即可，然后点击完成。</p>
<p><img alt="image-20210223093757362" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/3249image-20210223093757362.png" /></p>
<p>到现在只是添加了安全规则，但是并没有在你的云服务器实例上生效，在点击页面上关联实例tab，将新建的安全规则关联到对应的实例上，然后点击确定，这时候你禁用的IP就访问不了你的服务器了。</p>
<p><img alt="image-20210223094114780" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2291image-20210223094114780.png" /></p>
<h2>b.通过nginx封禁IP</h2>
<p>上面那种方式是在SSH没办法正常使用的情况下的解决方法，如果SSH能够正常使用的话，那么可以通过nginx的一些机制来禁用访问IP。</p>
<p>假设nginx安装在<code>/etc/nginx/</code>目录下，在该目录中新建黑名单IP配置文件</p>
<pre>
<code class="language-bash">sudo vim blacklist.conf </code></pre>
<p>在<code>blacklist.conf</code>中按照下面的方式写入内容</p>
<pre>
<code class="language-ini">禁用IP
deny 116.253.54.18;
禁用IP段
deny 116.253.54.0/225; </code></pre>
<p>保存退出文件，输入下面的命令配置nginx.conf</p>
<pre>
<code class="language-bash">sudo vim nginx.conf</code></pre>
<p>在<code>http</code>配置段中加入下面的内容</p>
<pre>
<code class="language-nginx">include blacklist.conf;</code></pre>
<p>测试配置是否正确</p>
<pre>
<code class="language-bash">sudo nginx -t
# 出现下面的提示则说明配置正确
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful </code></pre>
<p>重启nginx配置</p>
<pre>
<code class="language-bash">sudo nginx -s reload</code></pre>
<blockquote class="m-blockquote">
<p>blacklist.conf文件可以新建在任何地方，在ngxin.conf中引用的时候加入绝对路径就可以了；</p>
<p>nginx封禁IP只是将响应返回403并没有真正的封禁IP；</p>
</blockquote>
<p>当然除了上面的两种方式还可以通过防火墙等其他方式来解决这个问题，这篇文章只说明我个人的处理方式。</p>
<p>网站恢复正常访问之后打开运行日志发现这个B发起了6800多次请求，如下图</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6003%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20210223101858.png" /></p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/32/" rel="alternate"/>
</entry>
<entry>
<id>31</id>
<title>[前端开发]详解HTML聊天对话框的实现</title>
<updated>2023-09-27T02:08:19.929230+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.看看长啥样</h1>
<p>我截取了本站<a href="https://2dogz.cn/timeline/">建站日志</a>的样式如下图所示</p>
<p><img alt="示例图片" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2720%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_54.png" /></p>
<p>其详细的css代码如下，左边的小箭头其实就是通过<span class="marker">:before</span>这个伪元素来实现的。</p>
<pre>
<code class="language-css">.cd-timeline-content {
position: relative;
margin-left: 60px;
background: #303030;
border-radius: 0.25em;
padding: 1em;
box-shadow: 0 3px 0 #202020;
}
.cd-timeline-content:before {
content: '';
position: absolute;
top: 16px;
right: 100%;
height: 0;
width: 0;
border: 7px solid transparent;
border-right: 7px solid #303030;
}</code></pre>
<p>现在我们先不讨论下面的代码，我们先来看看其他的知识点。</p>
<h1>2. :before</h1>
<p>before顾名思义就是在什么之前，与之对应的是<span class="marker">:after</span>伪元素，通过该伪元素可以在目标元素前加入某些内容，看看下面的示例</p>
<pre>
<code class="language-html">&lt;style&gt;
.hello:before{
content: "Hello ";
}
.hello:after{
content: "!";
}
.hello{
color: white;
}
&lt;/style&gt;
&lt;body&gt;
&lt;p class="hello"&gt;World&lt;/p&gt;
&lt;p class="hello"&gt;Tom&lt;/p&gt;
&lt;p class="hello"&gt;Jack&lt;/p&gt;
&lt;/body&gt;</code></pre>
<p><img alt="hello" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5750%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_56.png" /></p>
<p>可以看到在每个p标签前面加上了<code>Hello</code> 在后面加上了<code>!</code>，通过伪元素<code>:before</code>和<code>:after</code>来实现的。</p>
<h1>3.position属性</h1>
<p>position字面意思是位置，在css中position有五个值</p>
<ul>
<li>static (默认值)</li>
<li>relative</li>
<li>fixed</li>
<li>absolute</li>
<li>sticky</li>
</ul>
<p>在上面的代码中使用到了relative以及absolute，这里就初略讲一个两个属性的功能。</p>
<h2>a.relative</h2>
<p>相对定位是一个非常容易掌握的概念。如果对一个元素进行相对定位，它将出现在它所在的位置上。然后，可以通过设置垂直或水平位置，让这个元素&ldquo;相对于&rdquo;它的起点进行移动。</p>
<p>如果将 top 设置为 20px，那么框将在原位置顶部下面 20 像素的地方。如果 left 设置为 30 像素，那么会在元素左边创建 30 像素的空间，也就是将元素向右移动。</p>
<pre>
<code class="language-css">.box_relative {
position: relative;
left: 30px;
top: 20px;
}</code></pre>
<p><img alt="relative" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2675%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_55.png" /></p>
<h2>b.absolute</h2>
<p>绝对定位的元素的位置相对于最近的已定位父元素，如果元素没有已定位的父元素，那么它的位置相对于&lt;html&gt;</p>
<pre>
<code class="language-css">.box_absolute {
position: absolute;
left: 30px;
top: 20px;
}</code></pre>
<p><img alt="absolute" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2600%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_57.png" /></p>
<h1>4.border属性</h1>
<p>相信很多小伙伴都很疑惑那个三角形是怎么来的，其实就是通过border以及border-right来实现的，听我慢慢道来。</p>
<p>border就是给容易添加一个外边框，可以看看如下的例子</p>
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height: 50px;
width: 50px;
background-color: white;
border: 4px solid #aaaaaa;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2100%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_59.png" /></p>
<p>我们可以清楚的看到在div加了一个灰色的外边框，接下来我们将四个方向的边框颜色修改一下，并且为了更加直观，将边框的宽度改为10px；</p>
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height: 50px;
width: 50px;
background-color: white;
border-top: 10px solid red;
border-right: 10px solid blue;
border-left: 10px solid green;
border-bottom: 10px solid cayon;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
<p><img alt="10px" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1131%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_60.png" /></p>
<p>这下小伙伴们应该有点思路了吧关于小三角形怎么形成的。我们可以清楚的看到四个方向边框交界处是通过45&deg;进行划分的，也就是所在四个角相邻的两个边框各占一半，边框的长度就是对应水平或者垂直方向的长度，如果到这里还不明白的话我们继续修改例子。</p>
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height:0;
width: 0;
background-color: white;
border-top: 30px solid red;
border-right: 30px solid blue;
border-left: 30px solid green;
border-bottom: 30px solid cadetblue;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
<p><img alt="30px" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8708%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_61.png" /></p>
<p>我们将div的长宽都设置为0，那么边框的长度不就都变为了0么？那么同一个方向两个角直接就没有长度了，所以就形成了三角形的样子，如图上所示的，我们可以清楚的看到四个三角形，如果我们需要保留哪个方向的三角形我们将其他方向边框颜色设置为透明就可以啦。</p>
<ul>
<li>保留top
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height:0;
width: 0;
background-color: white;
border: 30px solid transparent;
border-top: 30px solid red;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
</li>
<li>保留bottom
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height:0;
width: 0;
background-color: white;
border: 30px solid transparent;
border-bottom: 30px solid red;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
</li>
<li>保留right
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height:0;
width: 0;
background-color: white;
border: 30px solid transparent;
border-right: 30px solid red;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
</li>
<li>保留left
<pre>
<code class="language-html">&lt;style type="text/css"&gt;
.border-gray{
height:0;
width: 0;
background-color: white;
border: 30px solid transparent;
border-left: 30px solid red;
}
&lt;/style&gt;
&lt;body&gt;
&lt;div class="border-gray"&gt;&lt;/div&gt;
&lt;/body&gt;</code></pre>
</li>
</ul>
<p><img alt="result" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9422%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_63.png" />&nbsp;</p>
<blockquote class="m-blockquote">
<ol>
<li>注意border必须在border-* 前面定义，如果border定义在border-*后面则会覆盖掉border-*的样式</li>
<li>需要哪个朝向的箭头则定义相反方向的border-*，如需要left朝向的箭头则定义border-right</li>
</ol>
</blockquote>
<h1>5.搞一个试试</h1>
<pre>
<code class="language-html">&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
&lt;meta charset="UTF-8"&gt;
&lt;title&gt;Title&lt;/title&gt;
&lt;style type="text/css"&gt;
.chat{
position: relative;
min-height: 45px;
width: 200px;
border-radius: 3px;
padding: 3px;
background-color: #eeeeee;
font-size: 14px;
}
.chat&gt;p{
margin: 0;
}
.chat:before{
content: '';
position: absolute;
right: 100%;
top: 15px;
height: 0;
width: 0;
border: 7px solid transparent;
border-right: 7px solid #eeeeee;
}
&lt;/style&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;div class="chat"&gt;
&lt;p&gt;白日依山尽，黄河入海流。欲穷千里目，更上一层楼。&lt;/p&gt;
&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre>
<p>&nbsp;<img alt="sample" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9787%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_65.png" /></p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/31/" rel="alternate"/>
</entry>
<entry>
<id>30</id>
<title>[MySQL]MySQL学习摘要之管理常用命令</title>
<updated>2023-09-27T02:08:19.929203+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.权限生效时间</h1>
<p>⽤户及权限信息放在库名为mysql的库中， mysql启动时，这些内容被读进内存并且从此时⽣效，所以如果通过直接操作这些表来修改⽤户及权限信息的，需要重启mysql或者执⾏flush privileges;才可以⽣效。<br />
⽤户登录之后， mysql会和当前⽤户之间创建⼀个连接，此时⽤户相关的权限信息都保存在这个连接中，存放在内存中，此时如果有其他地⽅修改了当前⽤户的权限，这些变更的权限会在下⼀次登录时才会⽣效。</p>
<h1>2.查看mysql所有用户</h1>
<pre>
<code class="language-sql">use mysql
select user, host from user;</code></pre>
<p><strong>结果：</strong></p>
<p><img alt="alluser" class="d-block img-fluid mx-auto pic" src="/backend/files/8071%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_47.png" /></p>
<h1>3.创建用户</h1>
<p><strong>语法：</strong></p>
<pre>
<code class="language-sql">create user 用户名[@主机名] [identified by '密码']</code></pre>
<ul>
<li>主机名默认值为%，%意味着该用户可以从任何主机连接MySQL服务器</li>
<li>密码可以省略，表示无密码登录</li>
</ul>
<h2>a.不指定主机名</h2>
<pre>
<code class="language-sql">use mysql;
create user demo;
select user, host from user;</code></pre>
<p><strong>结果：</strong></p>
<p><img alt="创建user" class="d-block img-fluid mx-auto pic" src="/backend/files/9468%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_48.png" /></p>
<p>上面创建的用户<span class="marker">demo</span>没有设置主机以及登录密码，因此可以无密码登录MySQL服务器，通过demo用户登录数据库。</p>
<pre>
<code class="language-bash">mysql -udemo</code></pre>
<h2>b.指定主机密码</h2>
<pre>
<code class="language-sql"># 指定主机
use mysql;
create user 'user2'@'localhost';
# 指定主机密码
create user 'user3'@'127.0.0.1' identified by '123456';
# 任意主机指定密码
create user 'user4'@'%' identified by '123456';
# 指定IP段
create user 'user5'@'192.168.1.%' identified by '123456';</code></pre>
<ul>
<li>user2只能在本机登录可以通过无密码的方式</li>
<li>user3只能在本机登录并且需要指定密码</li>
<li>user4可以在任何机器上登录需要指定密码</li>
<li>user5只能在IP段为192.168.1的机器上登录</li>
</ul>
<h1>4.修改登录密码</h1>
<ol>
<li>通过管理员修改
<pre>
<code class="language-sql">SET PASSWORD FOR '用户名'@'主机'=PASSWORD('密码')；</code></pre>
</li>
<li>create user
<pre>
<code class="language-sql">create user 用户名[@主机名][identified by '密码'];
set password = password('密码');</code></pre>
</li>
<li>通过mysql.user表修改
<pre>
<code class="language-sql">use mysql;
update user set authentication_string = password('321') where user =
'test1' and host = '%';
flush privileges;</code></pre>
<div class="m-block-text" style="background:#eeeeee;border:1px solid #cccccc;padding:5px 10px;">通过表的⽅式修改之后，需要执⾏flush privileges;才能对⽤户⽣效。<br />
MySQL5.7版本中user表中的authentication_string字段表⽰密码，⽼的⼀些版本中密码字段是password。</div>
</li>
</ol>
<h1>&nbsp;5.用户授权</h1>
<p>在创建了新的用户之后，如果不给用户授权那没有太多的实际意义。</p>
<p><strong>语法：</strong></p>
<pre>
<code class="language-sql">grant privileges ON database.table TO 'username'@'host' with grant option</code></pre>
<p><strong>说明：</strong></p>
<ul>
<li>privileges可以是all，也可以是多个权限比如select、update等，使用&#39;,&#39;隔开;</li>
<li>ON&nbsp;&nbsp; &nbsp;⽤来指定权限针对哪些库和表，格式为数据库.表名 ，点号前⾯⽤来指定数据库名，点号后⾯⽤来指定表名， *.* 表⽰所有数据库所有表;</li>
<li>TO&nbsp;&nbsp; &nbsp;表⽰将权限赋予某个⽤户,&nbsp;&nbsp; &nbsp;格式为username@host， @前⾯为⽤户名， @后⾯接限制的主机，可以是IP、 IP段、域名以及%， %表⽰任何地⽅;</li>
<li>WITH&nbsp;&nbsp; &nbsp;GRANT&nbsp;&nbsp; &nbsp;OPTION&nbsp;&nbsp; &nbsp;这个选项表⽰该⽤户可以将⾃⼰拥有的权限授权给别⼈。注意：经常有⼈在创建操作⽤户的时候不指定WITH&nbsp;&nbsp; &nbsp;GRANT&nbsp;&nbsp; &nbsp;OPTION选项导致后来该⽤户不能使⽤GRANT命令创建⽤户或者给其它⽤户授权。 备注：可以使⽤GRANT重复给⽤户添加权限，权限叠加，⽐如你先给⽤户添加⼀个select权限，然后又给⽤户添加⼀个insert权限，那么该⽤户就同时拥有了select和insert权限;</li>
</ul>
<p><strong>示例：</strong></p>
<pre>
<code class="language-sql"># 给user1授权可以操作所有库所有权限
grant all on *.* to 'user1'@'%';
# 给user2授权demo库中所有表的select权限
grant select on demo.* to 'user2'@'%';
# 给user3授权demo库所有标的select、update权限
grant select,update on demo.* to 'user3'@'%';
# user4只能查询mysql.user的user,host字段
grant select(host, user) on mysql.user 'user4'@'%';</code></pre>
<h1>6.查看权限</h1>
<pre>
<code class="language-sql"># 查看当前登录用户权限
show grants;
# 查看指定用户权限
show grants for 'user1'@'localhost';</code></pre>
<p><img alt="all priliveges" class="d-block img-fluid mx-auto pic" src="/backend/files/6353%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_50.png" /></p>
<h1>7.删除用户权限</h1>
<p><strong>语法：</strong></p>
<pre>
<code class="language-php">revoke privileges ON database.table FROM '用户名'@'主机名';</code></pre>
<p><strong>示例：</strong></p>
<pre>
<code class="language-sql"># 查看用户权限
show grants for 'user2'@'localhost';
</code></pre>
<p><img alt="revoke" class="d-block img-fluid mx-auto pic" src="/backend/files/1164%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_51.png" /></p>
<pre>
<code class="language-sql"># 删除mysql.user表的select(host)权限
revoke select(host) on mysql.user from 'user2'@'localhost';
# 查看user2现有权限
show grants for 'user2'@'localhost';</code></pre>
<p><img alt="revoke" class="d-block img-fluid mx-auto pic" src="/backend/files/4697%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_52.png" /></p>
<p>根据结果可以看到<span class="marker">user2</span>的<span class="marker">select(host)</span>权限已经不存在了。</p>
<h1>8.删除用户</h1>
<ol>
<li>drop命令
<pre>
<code class="language-sql">drop user '用户名'@'主机';
drop user 'user2'@'localhost';</code></pre>
</li>
<li>mysql.user表
<pre>
<code class="language-sql">delete from user where user='⽤户名' and host='主机';
flush privileges;</code></pre>
<blockquote class="m-blockquote">
<p>注意通过表的⽅式删除的，需要调⽤flush privileges;刷新权限信息（权限启动的时候在内存中保存着，通过表的⽅式修改之后需要刷新⼀下）。</p>
</blockquote>
</li>
</ol>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/30/" rel="alternate"/>
</entry>
<entry>
<id>29</id>
<title>[应用部署]给ngxin服务器添加HTTPS</title>
<updated>2023-09-27T02:08:19.929175+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1><a id="1.获取免费的SSL证书" name="1.获取免费的SSL证书"></a>1.获取免费的SSL证书</h1>
<p>在部署HTTPS之前，我们需要先获取SSL证书，我购买的是鹅肠的云服务器，可以申请免费证书，点击这个链接进行申请<a href="https://console.cloud.tencent.com/ssl">鹅肠SSL证书申请</a>，按照界面的上的操作步骤进行操作就可以了，审核通过之后，下载证书即可，下载的压缩文件中包含的文件如下图所示，具体看你使用的哪款服务器进行部署的，自行选择，我这里选择的ngxin服务器。</p>
<p><img alt="ssl证书" class="d-block img-fluid mx-auto pic" src="/backend/files/252%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_45.png" /></p>
<h1><a id="2.拷贝SSL证书" name="2.拷贝SSL证书"></a>2.拷贝SSL证书</h1>
<p>下载好证书之后解压出来，将证书文件拷贝到服务器中的目标文件夹中。我这里使用ngxin作为示例，一般存放在</p>
<ol>
<li>/etc/nginx/cert/ssl_name.crt</li>
<li>/etc/nginx/cert/ssl_name.key</li>
</ol>
<p>其中<span class="marker">cert</span>目录是不存在的而且命名可以随意命名，但是建议使用望文生义的名称，这两个路径十分重要，后续的配置中需要用到。</p>
<h1><a id="3.配置nginx" name="3.配置nginx"></a>3.配置nginx</h1>
<p>打开ngxin的配置文件</p>
<pre>
<code class="language-bash">sudo vim /etc/nginx/sites-avaliable/default
</code></pre>
<p>在你需要的<span class="marker">Server</span>块中修改为下面内容</p>
<pre>
<code class="language-nginx">server{
# listen 80 default_server;
# listen [::]:80 default_server;
# SSL configuration
#
# listen 443 ssl default_server;
# listen [::]:443 ssl default_server;
listen 443;
ssl on;
ssl_certificate /etc/nginx/cert/1_2dogz.cn_bundle.crt;
ssl_certificate_key /etc/nginx/cert/2_2dogz.cn.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
ssl_prefer_server_ciphers on;
}</code></pre>
<blockquote class="m-blockquote">
<p>上面的内容为配置HTTPS，server块中的其他内容不能删除掉！</p>
</blockquote>
<h1><a id="4.配置重定向" name="4.配置重定向"></a>4.配置重定向</h1>
<p>因为原来采用的http的方式访问，经过上述配置之后采用http方式访问就会失效，因此我们需要将http访问方式重定向到https上面来，同样在上一小节的配置文件中加入如下内容</p>
<pre>
<code class="language-nginx">server {
listen 80;
server_name 2dogz.cn;
rewrite ^(.*)$ https://$host$1 permanent;
}
</code></pre>
<p>其中server_name是你自己网站的域名。</p>
<p>这样我们的网站就可以通过https的方式访问啦，如下图，在浏览器的地址栏会显示一个锁的图标，点击即可以看到相关信息</p>
<p><img alt="https访问" class="d-block img-fluid mx-auto pic" src="/backend/files/2674%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_46.png" /></p>
<h1><a id="5.配置HTTP2" name="5.配置HTTP2"></a>5.配置HTTP2</h1>
<p>配置HTTP2协议其实非常的简单，只需要在配置文件监听端口部分加入下面的配置即可</p>
<pre>
<code class="language-nginx">server{
# listen 80 default_server;
# listen [::]:80 default_server;
# SSL configuration
#
# listen 443 ssl default_server;
# listen [::]:443 ssl default_server;
listen 443 ssl http2;
ssl on;
ssl_certificate /etc/nginx/cert/1_2dogz.cn_bundle.crt;
ssl_certificate_key /etc/nginx/cert/2_2dogz.cn.key;
ssl_session_timeout 5m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
ssl_prefer_server_ciphers on;
}</code></pre>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/29/" rel="alternate"/>
</entry>
<entry>
<id>28</id>
<title>[Python]Python中的asyncio简单介绍</title>
<updated>2023-09-27T02:08:19.929147+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.协程</h1>
<p>我们经常听到过进程、线程可能很少有听到协程这个概念，但是相信大家肯定都听说过携程，但此协程非彼携程，下图可以比较好说明进程、线程、协程三者之间的关系。</p>
<p><img alt="协程" class="d-block img-fluid mx-auto pic" src="/backend/files/6157image-20210202111401909.png" /></p>
<p>那么协程相对于线程有哪些优势呢？</p>
<ol>
<li>
<p>我们都知道不管线程还是进程之间的切换调度都需要使用系统的资源，而协程的切换不是属于多线程或者多进程，而是在单个线程中进行切换的，相当于是子程序的切换，因此相对多线程数量越多的应用，协程的优势就更加明显了；</p>
</li>
<li>
<p>在多线程中如果我们需要在不同的线程中控制同一个变量，我们就需要用到锁的机制，但是协程是在同一个线程中执行的，因此不会出现同时写变量的冲突了，不需要对共享资源加锁，只需要判断执行状态，效率肯定是优于多线程的执行方式的；</p>
</li>
</ol>
<p>&nbsp;举一个简单的消费者生产者的例子，传统的方式是两个线程一个线程写消息一个线程读取消息，通过锁机制控制队列和等待，但是如果程序猿的水平不过关很容易出现死锁的情况。如果使用协程的方式呢？Python中有一个yield的关键字(这个关键字Lua语言中也有)，通过该关键字可以简单的模拟一下协程，下面的程序&quot;抄袭&quot;的<a href="https://www.liaoxuefeng.com/wiki/1016959663602400/1017968846697824">廖雪峰网站的示例</a></p>
<pre>
<code class="language-python">def consumer():
r = ''
while True:
n = yield r
if not n:
return
print('[CONSUMER] Consuming {}'.format(n))
r = '200 OK'
def produce(c):
c.send(None)
n = 0
while n &lt; 5:
n = n + 1
print('[PRODUCER] Producing {}...'.format(n))
r = c.send(n)
print('[PRODUCER] Consumer return:{}'.format(r))
c.close()
con = consumer()
produce(con)</code></pre>
<p>程序的执行结果如下</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
<p>[PRODUCER] Producing 1...<br />
[CONSUMER] Consuming 1<br />
[PRODUCER] Consumer return:200 OK<br />
[PRODUCER] Producing 2...<br />
[CONSUMER] Consuming 2<br />
[PRODUCER] Consumer return:200 OK<br />
[PRODUCER] Producing 3...<br />
[CONSUMER] Consuming 3<br />
[PRODUCER] Consumer return:200 OK<br />
[PRODUCER] Producing 4...<br />
[CONSUMER] Consuming 4<br />
[PRODUCER] Consumer return:200 OK<br />
[PRODUCER] Producing 5...<br />
[CONSUMER] Consuming 5<br />
[PRODUCER] Consumer return:200 OK</p>
</div>
<p>在函数<code>consumer</code>中使用了yield关键字，所以该函数不是一个函数了而是一个生成器，然后将其传入到<code>produce</code>函数中</p>
<ol>
<li>
<p>首先调用<code>send()</code>函数启动生成器；</p>
</li>
<li>
<p>如果<code>produce</code>中生产了东西，则通过<code>c.send(n)</code>切换到生成器<code>consumer</code>中执行；</p>
</li>
<li>
<p><code>consumer</code>通过<code>yield</code>拿到消息，又通过<code>yield</code>返回结果；</p>
</li>
<li>
<p><code>produce</code>拿到<code>consumer</code>处理的结果，继续生产下一条消息；</p>
</li>
<li>
<p><code>produce</code>决定不生产了，通过<code>c.close()</code>关闭<code>consumer</code>，整个生产消费过程</p>
</li>
</ol>
<h1>2.asyncio</h1>
<p>asyncio是Python中用来编写并发代码的库。使用 <strong>async/await</strong> 语法。asyncio 被用作多个提供高性能 Python 异步框架的基础，包括网络和网站服务，数据库连接库，分布式任务队列等等。asyncio 往往是构建 IO 密集型和高层级 <strong>结构化</strong> 网络代码的最佳选择。</p>
<h1>3.简单的例子</h1>
<p>要真正运行一个协程，asyncio 提供了三种主要机制:</p>
<ul>
<li>
<p><a href="https://docs.python.org/zh-cn/3/library/asyncio-task.html#asyncio.run"><code>asyncio.run()</code></a> 函数用来运行最高层级的入口点 &quot;main()&quot; 函数 (参见上面的示例。)</p>
</li>
<li>
<p>等待一个协程。以下代码段会在等待 1 秒后打印 &quot;hello&quot;，然后 <em>再次</em> 等待 2 秒后打印 &quot;world&quot;:</p>
</li>
</ul>
<h2>a.运行一个协程</h2>
<pre>
<code class="language-python">import asyncio
import time
async def say_after(delay, what):
await asyncio.sleep(delay)
print(what)
async def main():
print(f"started at {time.strftime('%X')}")
await say_after(1, 'hello')
await say_after(2, 'world')
print(f"finished at {time.strftime('%X')}")
asyncio.run(main())</code></pre>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">started at 13:48:14<br />
hello world<br />
finished at 13:48:17</div>
<h2>b.并发执行</h2>
<p>在上面的代码中我们并没有看到两个函数调用并发执行的效果，要是实现并发执行的效果我们需要用到<code>asyncio.create_task()</code>函数，修改上面的代码</p>
<pre>
<code class="language-python">import asyncio
import time
async def say_after(delay, what):
await asyncio.sleep(delay)
print(what)
async def main():
t1 = asyncio.create_task(say_after(1, 'hello'))
t2 = asyncio.create_task(say_after(2, 'world'))
print(f"started at {time.strftime('%X')}")
await t1
await t2
print(f"finished at {time.strftime('%X')}")
asyncio.run(main())</code></pre>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">started at 13:57:33<br />
hello world<br />
finished at 13:57:35</div>
<p>可以看到运行两个协程只花费了2s的时间，完成了协程并发执行的功能。</p>
<h2>c.可等待对象</h2>
<p>在Python中如果一个对象可以在await语句中使用，那么这个对象就是可等待对象，可等待对象主要有三种类型:<code>协程</code>、<code>任务</code>和<code>Future</code></p>
<ul>
<li>
<p>协程</p>
<ol>
<li>
<p>协程函数：通过async def形式定义的函数；</p>
</li>
<li>
<p>协程对象：调用协程函数所返回的对象；</p>
</li>
</ol>
</li>
<li>
<p>task</p>
<p>通过task我们可以并发执行协程，当一个协程通过asyncio.create_task()函数打包成一个任务，该协程将会自动进入schedule中准备立即运行</p>
</li>
</ul>
<h2>d.休眠</h2>
<p>通过<code>asyncio.sleep</code>函数可以阻塞指定的秒数，下面的程序每隔一秒输出当前时间</p>
<pre>
<code class="language-python">import asyncio
import datetime
async def display_date():
loop = asyncio.get_running_loop()
end_time = loop.time() + 5.0
while True:
print(datetime.datetime.now())
if (loop.time() + 1.0) &gt;= end_time:
break
await asyncio.sleep(1)
asyncio.run(display_date())</code></pre>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">2021-02-02 14:20:52.537776<br />
2021-02-02 14:20:53.539077<br />
2021-02-02 14:20:54.540297<br />
2021-02-02 14:20:55.541478<br />
2021-02-02 14:20:56.542681</div>
<h2>e.并发运行任务2</h2>
<p>通过<code>asyncio.gather(*aws, loop=None, return_exceptions=False)</code>函数可以并发执行asw序列中的可等待对象。</p>
<pre>
<code class="language-python">import asyncio
async def factorial(name, number):
f = 1
for i in range(2, number + 1):
print(f"Task {name}: Compute factorial({i})...")
await asyncio.sleep(1)
f *= i
print(f"Task {name}: factorial({number}) = {f}")
async def main():
# Schedule three calls *concurrently*:
await asyncio.gather(
factorial("A", 2),
factorial("B", 3),
factorial("C", 4),
)
asyncio.run(main())</code></pre>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">Task A is runnning at 14:59:22<br />
Task B is runnning at 14:59:22<br />
Task C is runnning at 14:59:22<br />
Task A is finished at 14:59:23<br />
Task C is finished at 14:59:23</div>
<p>将函数中的关键字参数<code>return_exceptions</code>设置为False(默认)，所引发的首个异常会立即传播给等待 <code>gather()</code> 的任务。<em>aws</em> 序列中的其他可等待对象 <strong>不会被取消</strong> 并将继续运行。</p>
<pre>
<code class="language-python">import asyncio
import time
async def divid(name, number):
print(f"Task {name} is runnning at {time.strftime('%X')}")
ret = 12 / number
await asyncio.sleep(1)
print(f"Task {name} is finished at {time.strftime('%X')}")
async def main():
await asyncio.gather(
divid('A', 3),
divid('B', 0),
divid('C', 3)
)
asyncio.run(main())</code></pre>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">Task A is runnning at 15:11:55<br />
Task B is runnning at 15:11:55<br />
Task C is runnning at 15:11:55<br />
Traceback (most recent call last):<br />
&nbsp; File &quot;test7.py&quot;, line 18, in &lt;module&gt;<br />
&nbsp; &nbsp; asyncio.run(main())<br />
&nbsp; File &quot;/usr/local/lib/python3.7/asyncio/runners.py&quot;, line 43, in run<br />
&nbsp; &nbsp; return loop.run_until_complete(main)<br />
&nbsp; File &quot;/usr/local/lib/python3.7/asyncio/base_events.py&quot;, line 587, in run_until_complete<br />
&nbsp; &nbsp; return future.result()<br />
&nbsp; File &quot;test7.py&quot;, line 15, in main<br />
&nbsp; &nbsp; divid(&#39;C&#39;, 3),<br />
&nbsp; File &quot;test7.py&quot;, line 6, in divid<br />
&nbsp; &nbsp; ret = 12 / number<br />
ZeroDivisionError: division by zero</div>
<p>关于asyncio暂时介绍这些东西，因为我也是在摸索阶段，如有不正确的地方欢迎指正。&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/28/" rel="alternate"/>
</entry>
<entry>
<id>27</id>
<title>[系列教程]使用Flask搭建一个校园论坛6-论坛首页</title>
<updated>2023-09-27T02:08:19.929118+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.功能简介</h1>
<p>在第二节中，我们已经把首页的基础框架建好了，首页分为主体以及右边的侧边栏个两个部分。在主体中我们需要显示论坛的帖子，其中帖子又可以根据一些条件进行分类，比如今日热帖、最新的帖子以及随机推荐的帖子等等。在侧边栏中需要显示一些用户信息、发布帖子入口等其他信息。本节主要是是处理首页的主体部分内容，以及侧边栏首个栏位(主要是侧边栏下面的没想好要添加什么内容)。</p>
<h1>2.显示帖子列表</h1>
<p>为了显示帖子列表，我们需要先在渲染主页模板文件的视图函数中获取帖子的相关数据，并传入到首页模板文件中。</p>
<h2>a.最新的帖子</h2>
<p>打开<code>bbs/blueprint/frontend/index.py</code>模块，添加下面的代码。</p>
<pre>
<code class="language-python">from flask import Blueprint, render_template, request, current_app
from bbs.models import Post, VisitStatistic
from bbs.extensions import db
from sqlalchemy.sql.expression import func
from bbs.decorators import statistic_traffic
index_bp = Blueprint('index_bp', __name__)
@index_bp.route('/')
@index_bp.route('/index/')
def index():
page = request.args.get('page', 1, type=int)
pagination = Post.query.filter_by(status_id=1).order_by(Post.update_time.desc()).\
paginate(page, per_page=current_app.config['BBS_PER_PAGE'])
latest = pagination.items
return render_template('frontend/index.html', latest=latest, pagination=pagination)</code></pre>
<p>在上面的代码中出现了一个新的东西<code>paginate</code>，该方法会返回一个<code>Pagination</code>类，这样就实现了分页操作。</p>
<p>当用户向首页路由发起请求后，首先会获取请求中的参数<code>page</code>，如果不存在则默认为1，然后通过<code>paginate</code>函数进行分页查询，获取到<code>Pagination</code>实例，通过该实例我们可以获取到当前页码的帖子记录，然后将结果返回到模板文件中进行渲染。打开<code>bbs/templates/frontend/index.html</code>文件，加入下面的代码。</p>
<pre>
<code class="language-html">{% block content %}
{{ moment.locale(auto_detect=True) }}
&lt;main&gt;
&lt;div class="container mt-2"&gt;
{% include "_flash.html" %}
&lt;ul class="nav nav-pills"&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link active" href="{{ url_for('.index') }}"&gt;最新&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item "&gt;
&lt;a class="nav-link" href="{{ url_for('.hot') }}"&gt;热帖&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item "&gt;
&lt;a class="nav-link" href="{{ url_for('.rands') }}"&gt;随机&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr class="bg-secondary"&gt;
&lt;div class="row"&gt;
&lt;div class="col-md-8 mt-1"&gt;
&lt;div class="tab-content"&gt;
&lt;div id="latestPost" class="tab-pane active"&gt;
{{ post_item(latest) }}
&lt;div class="float-right mt-3"&gt;
{% if tag %}
{{ render_pagination(pagination) }}
{% endif %}
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% include "frontend/slider.html" %}
&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;
{% endblock %}</code></pre>
<p>在上面代码中将帖子分为了三个tab分别是最新、热帖以及随机，三个tab分别定义了三个模板文件(另外两个后续会讲)，在用户访问index路由的时候默认显示的最新的帖子。</p>
<p>在模板文件中，我们使用了<code>post_item()</code>宏来渲染帖子的列表。因为我们显示帖子列表的页面有几个，所以可以将代码抽离出来进行宏定义，这样就减少了冗余的代码。打开<code>bbs/templates/</code>文件夹，新建<code>macro.html</code>宏定义文件，添加下面的代码到文件中。</p>
<pre>
<code class="language-html">{% macro post_item(posts) %}
&lt;ul class="list-group"&gt;
{% for post in posts %}
&lt;li class="list-group-item pl-1"&gt;
&lt;div class="d-flex"&gt;
{% if post.is_anonymous == 1 %}
&lt;img class="avatar-50 rounded mr-2" src="{{ post.user.avatar }}" alt="{{ post.user.nickname }}"&gt;
{% else %}
&lt;img class="avatar-50 rounded mr-2" src="{{ url_for('static', filename='img/anonymous.jpeg') }}" alt="anonymous"&gt;
{% endif %}
&lt;div class="flex-grow-1"&gt;
&lt;a class="text-decoration-none" href="{{ url_for('post.read', post_id=post.id) }}"&gt;{{ post.title }}&lt;/a&gt;
&lt;div class="row mt-2"&gt;
&lt;div class="col"&gt;
&lt;p class="mb-0 text-muted f-12"&gt;
&lt;a class="badge badge-secondary mr-2" href="{{ url_for('post.post_cate', cate_id=post.cats.id) }}"&gt;{{ post.cats.name }}&lt;/a&gt;
&lt;i class="fa fa-user-o mr-1"&gt;&lt;/i&gt;
{% if post.is_anonymous == 1 %}
&lt;a class="text-decoration-none" href="{{ url_for('profile.index', user_id=post.author_id) }}"&gt;{{post.user.nickname}}&lt;/a&gt;
{% else %}
匿名
{% endif %}
&lt;span&gt;&lt;a class="text-decoration-none ml-2 text-muted flex-grow-1 text-left f-12-b" &gt;
&lt;span data-toggle="tooltip" data-placement="right" data-timestamp="{{ post.create_time }}" data-delay="500" data-original-title="" title="{{ post.create_time }}"&gt;{{ moment(post.create_time, local=True).fromNow(refresh=True) }}&lt;/span&gt;
&lt;/a&gt;&lt;/span&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="col text-right flex-row-reverse d-lg-flex d-none"&gt;
&lt;p class="f-12 text-muted mb-0"&gt;&lt;i class="fa fa-comment mr-1"&gt;&lt;/i&gt;{{ post.comments|length }}&lt;/p&gt;
&lt;p class="f-12 text-muted mb-0"&gt;&lt;i class="fa fa-eye mr-1"&gt;&lt;/i&gt;{{post.read_times}} &lt;/p&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/li&gt;
{% endfor %}
&lt;/ul&gt;
{% endmacro %}</code></pre>
<p>在该宏定义函数中，我们使用了bootstrap4的列表组组件来显示我们的帖子。通过for循环来遍历我们的帖子将每篇帖子的相关信息以列表的形式展示出来。同时如果帖子是用户匿名进行发布的，那么在显示帖子基本信息的时候都会用匿名信息进行填写。</p>
<p>我们通过上一节的帖子发布页面发布几个测试帖子，再次访问首页就可以看到如下所示的页面了。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/6730image.png" /></p>
<h2>b.最热的帖子</h2>
<p>同样的在<code>bbs/blueprint/frontend/index.py</code>模块中加入下面的代码</p>
<pre>
<code class="language-python">@index_bp.route('/hot-post/')
def hot():
page = request.args.get('page', 1, type=int)
pagination = Post.query.order_by(Post.read_times.desc()).paginate(page, per_page=current_app.config['BBS_PER_PAGE'])
hots = pagination.items
tag = pagination.total &gt; current_app.config['BBS_PER_PAGE']
return render_template('frontend/index/hot-post.html', hots=hots, pagination=pagination, tag=tag)</code></pre>
<p>上面的代码跟<code>index视图函数</code>的代码十分类似，只是在数据库的查询条件上做了一些变化，通过帖子的阅读次数来进行排序，并将输出的内容进行分页处理。因此模板文件也与<code>index.html</code>文件类似，在<code>bbs/templates/frontend/index</code>目录中新建<code>hot-post.html</code>模板文件，添加下面的代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% from "macro.html" import post_item, render_pagination with context%}
{% block title %}
主页
{% endblock %}
{% block content %}
{{ moment.locale(auto_detect=True) }}
&lt;main&gt;
&lt;div class="container mt-2"&gt;
{% include "_flash.html" %}
&lt;ul class="nav nav-pills"&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link" href="{{ url_for('.index') }}"&gt;最新&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item"&gt;
&lt;a class="nav-link active" href="{{ url_for('.hot') }}"&gt;热帖&lt;/a&gt;
&lt;/li&gt;
&lt;li class="nav-item "&gt;
&lt;a class="nav-link" href="{{ url_for('.rands') }}"&gt;随机&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr class="bg-secondary"&gt;
&lt;div class="row"&gt;
&lt;div class="col-md-8 mt-1"&gt;
&lt;div class="tab-content"&gt;
&lt;div id="latestPost" class="tab-pane active"&gt;
{{ post_item(hots) }}
&lt;div class="float-right mt-3"&gt;
{% if tag %}
{{ render_pagination(pagination) }}
{% endif %}
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% include "frontend/slider.html" %}
&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;
{% endblock %}</code></pre>
<h2>c.随机推荐的帖子</h2>
<p>处理完上面两个tab之后只剩下最后一个随机推荐的tab了，随机推荐的帖子数量我这里设置的是20篇帖子，我们可以使用<code>flask-sqlachemy</code> orm框架中<code>func</code>来轻松实现在数据库中随机获取对应条数的数据，在<code>bbs/blueprint/index.py</code>模块中加入下面的视图函数代码</p>
<pre>
<code class="language-python">from sqlalchemy.sql.expression import func
@index_bp.route('/rand-post/')
def rands():
rand = Post.query.filter_by(status_id=1).order_by(func.random()).limit(20)
return render_template('frontend/index/rand-post.html', rands=rand)</code></pre>
<p>打开<code>bbs/templates/frontend/index</code>目录中新建<code>rand-post.html</code>模板文件，模板文件中需要添加代码与上面两小节的代码类似，这里就不在累述了，如果读者不清楚可以去项目的<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>克隆完整的代码查看。</p>
<h1>3.首页侧边栏</h1>
<p>在上面的小节中，处理完了首页主要内容中的帖子列表显示，到此侧边栏还没有对应的内容。关于侧边栏的设计，根据不同的功能来将每个功能块用一个<code>card</code>来显示，在这一章节的教程中只完成用户个人资料card。</p>
<p>侧边栏slider是一个通用部分的内容，因此我们可以将其抽离出来，在需要使用的时候可以通过<code>include</code>来导入，类似于我们的<code>base.html</code>文件，打开<code>bbs/templates</code>目录，新建<code>slider.html</code>文件，代码清单如下</p>
<pre>
<code class="language-html">&lt;div class="col-md-4 mt-1"&gt;
&lt;div class="card border-secondary mb-2"&gt;
&lt;div class="card-header"&gt;&lt;i class="fa fa-user mr-2"&gt;&lt;/i&gt;用户&lt;/div&gt;
&lt;div class="card-body"&gt;
{% if not current_user.is_authenticated %}
&lt;div&gt;&lt;small class="text-danger"&gt;&lt;b&gt;您尚未登录！&lt;/b&gt;&lt;/small&gt;请先
&lt;a href="/auth/login/"&gt;&lt;span class="badge badge-info"&gt;登录&lt;/span&gt;&lt;/a&gt; 或
&lt;a href="/auth/register/"&gt;&lt;span class="badge badge-success"&gt;注册&lt;/span&gt;&lt;/a&gt;！
&lt;/div&gt;
{% else %}
&lt;div class="d-flex"&gt;
&lt;img src="{{ current_user.avatar }}" class="rounded avatar-50"&gt;
&lt;div&gt;
&lt;p class="mb-1 ml-1 text-success"&gt;&lt;b&gt;{{ current_user.nickname }}&lt;/b&gt;&lt;/p&gt;
&lt;p class="mb-1 ml-1 text-muted"&gt;&lt;small&gt;@{{ current_user.username }}&lt;/small&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div class="d-flex flex-row-reverse"&gt;
&lt;a href="/post/new/" class="btn btn-secondary h-75 ml-2"&gt;&lt;i class="fa fa-plus"&gt;&lt;/i&gt;&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;hr class="bg-secondary"&gt;
&lt;div class="d-flex p-1"&gt;
&lt;div class="pr-2 dropdown"&gt;
&lt;button class="btn btn-success dropdown-toggle" type="button" id="dropdownMenuButton"
data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;
主题
&lt;/button&gt;
&lt;div class="dropdown-menu" aria-labelledby="dropdownMenuButton"&gt;
{% for theme_name, display_name in config.BBS_THEMES.items() %}
&lt;a class="dropdown-item"
href="{{ url_for('normal.change_theme', theme_name=theme_name, next=request.full_path) }}"&gt;
{{ theme_name }}&lt;/a&gt;
{% endfor %}
&lt;/div&gt;
&lt;/div&gt;
&lt;div class="dropdown"&gt;
&lt;button class="btn btn-success dropdown-toggle" type="button" id="dropdownMenuButton"
data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;
操作
&lt;/button&gt;
&lt;div class="dropdown-menu" aria-labelledby="dropdownMenuButton"&gt;
&lt;a class="dropdown-item" href="{{url_for('profile.index', user_id=current_user.id)}}"&gt;&lt;i class="fa fa-fw fa-user mr-2"&gt;&lt;/i&gt;个人中心&lt;/a&gt;
&lt;a class="dropdown-item" href="{{url_for('user.index', user_id=current_user.id)}}"&gt;&lt;i class="fa fa-fw fa-cog mr-2"&gt;&lt;/i&gt;设置&lt;/a&gt;
{% if current_user.role_id == 1 %}
&lt;a class="dropdown-item" href="{{url_for('be_index.index')}}"&gt;&lt;i class="fa fa-fw fa-magnet mr-2"&gt;&lt;/i&gt;后台管理&lt;/a&gt;
{% endif %}
&lt;a class="dropdown-item" href="/auth/logout/"&gt;&lt;i class="fa fa-fw fa-sign-out mr-2"&gt;&lt;/i&gt;登出&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
{% endif %}
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;</code></pre>
<p>首先通过<code>flask-login</code>的<code>current_user</code>属性来判断用户是否已登录，如果没有登录则显示用户登录或者注册的视图。如果用户已经登录，则显示用户已经登录的视图。在已登录视图中，做了一个权限判断如果是普通用户则不显示后台管理的URL，如果是管理员则显示。在这个视图中用户可以做一些操作，如果切换页面主题、进入个人中心、设置个人资料、退出等等，这时候我们再访问首页，效果如下所示。</p>
<blockquote class="m-blockquote">
<p>这里有很多后端endpoint还没有实现，如果读者出现报错，可以把href这个属性全部删除掉!</p>
</blockquote>
<p><img alt="首页效果" class="d-block img-fluid mx-auto pic" src="/backend/files/7446%E9%A6%96%E9%A1%B5%E6%95%88%E6%9E%9C.png" /></p>
<p>这一章节的内容就大致说完了，读者可以到项目<a href="https://github.com/weijiang1994/university-bbs">github仓库</a>下载完整的示例代码。目前代码的前端部分基本上已经完成了。</p>
</content>
<link href="https://2dogz.cn/blog/article/27/" rel="alternate"/>
</entry>
<entry>
<id>26</id>
<title>[系列教程]使用Flask搭建一个校园论坛5-帖子发布</title>
<updated>2023-09-27T02:08:19.929089+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.知识预览</h1>
<p>在本节中将会学习到以下的内容</p>
<ol>
<li>
<p>sqlachemy的分页查询方法</p>
</li>
<li>
<p>flask-ckeditor富文本编辑器的使用</p>
</li>
<li>
<p>bootstrap 分页渲染</p>
</li>
</ol>
<h1>2.数据库模型</h1>
<p>作为一个论坛的应用程序，那么帖子是必不可少的东西。因此在实现首页功能之前，需要先在数据库中建立对应表，来存储这些数据。打开｀bbs/models.py模块，嵌入Post模型类&nbsp;</p>
<pre>
<code class="language-python">class Post(db.Model):
__tablename__ = 't_post'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True, index=True)
title = db.Column(db.String(100), index=True, nullable=False)
content = db.Column(db.TEXT, nullable=False)
textplain = db.Column(db.TEXT, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.datetime.now)
update_time = db.Column(db.DateTime, default=datetime.datetime.now)
is_anonymous = db.Column(db.INTEGER, default=1, comment='post is anonymous? 2: yes 1: no')
read_times = db.Column(db.INTEGER, default=0)
# 用户对帖子的操作
likes = db.Column(db.INTEGER, default=0, comment='like post persons')
unlikes = db.Column(db.INTEGER, default=0, comment='unlike post persons')
collects = db.Column(db.INTEGER, default=0, comment='collect post persons')
# 外键id
cate_id = db.Column(db.INTEGER, db.ForeignKey('t_postcate.id'))
author_id = db.Column(db.INTEGER, db.ForeignKey('t_user.id'))
status_id = db.Column(db.INTEGER, db.ForeignKey('t_status.id'), default=1)
# 用户关系
cats = db.relationship('PostCategory', back_populates='post')
user = db.relationship('User', back_populates='post')
status = db.relationship('Status', back_populates='post')</code></pre>
<p>在上面的代码中，定义了<code>Post</code>类的相关属性。论坛里面的帖子数量庞大，且种类也十分多，因此使用了外键<code>cate_id</code>来关联帖子的类别，同时使用<code>author_id</code>来关联当前帖子属于哪个用户发布。用户发布了帖子之后当然也可以删除帖子，使用<code>status_id</code>来关联帖子的状态。同时当帖子被举报次数较多时候，论坛管理员也可以屏蔽帖子，因此通过<code>status_id</code>可以来定义帖子的不同状态。</p>
<p>在前面的章节中，已经建好了user、status表的相关信息，因此这里只需要创建Category模型类即可，同时需要在status模型中将post的外键关系加进去，继续在该模块中加入下面的代码。</p>
<pre>
<code class="language-python">class PostCategory(db.Model):
__tablename__ = 't_postcate'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
name = db.Column(db.String(40), nullable=False)
create_time = db.Column(db.Date, default=datetime.date.today)
post = db.relationship('Post', back_populates='cats', cascade='all')
class Status(db.Model):
# 省略已有的代码
post = db.relationship('Post', back_populates='status', cascade='all')</code></pre>
<p>到此为止，目前关于帖子相关的数据库表的信息就创建完成了。但是在帖子类别表中还没有数据，我们可以手动到数据库中去添加，或者在<code>bbs/__init__.py</code>文件中添加下面的代码.</p>
<pre>
<code class="language-python">def register_cmd(app: Flask):
@app.cli.command()
def init():
init_cate()
click.echo('初始化帖子类别表完成!')
def init_cate():
categories = ['杂谈', '趣事', '表白', '寻物', '咸鱼', '活动']
for category in categories:
pc = PostCategory(name=category)
db.session.add(pc)
db.session.commit()</code></pre>
<p>在init_cate()函数中定义了六种帖子类别，这里读者可以自由发挥。然后我们在终端中输入下面的命令将帖子类别数据加入到数据库中</p>
<pre>
<code class="language-bash">flask init</code></pre>
<blockquote class="m-blockquote">
<p>使用该命令会清楚数据库中的原始数据!</p>
</blockquote>
<h1>3.flask-migrate</h1>
<p>我们创建完了数据库之后，可以根据第三节的<code>flask init</code>来初始化数据库，但是如果我们在开发环境中有很多测试数据了，如果进行数据库初始化，那将会把原来的数据都清空掉。如果我们使用的是MySQL数据库，我们可以通过<code>flask-migrate</code>这个工具来对数据库进行升级以及迁移。</p>
<p>首先在虚拟环境中安装flask-migrate</p>
<pre>
<code class="language-bash">pip install flask-migrate</code></pre>
<p>安装程序执行完成之后，需要在我们的程序中实例化<code>migrate</code>。打开<code>bbs/extensions.py</code>模型，添加下面的代码</p>
<pre>
<code class="language-python">from flask_migrate import Migrate
mg = Migrate()</code></pre>
<p>然后打开<code>bbs/__init__.py</code>模块，将实例化的migrate初始化</p>
<pre>
<code class="language-python">from extensions import mg
def register_extensions(app: Flask):
# 省略已有代码
mg.init_app(app, db)</code></pre>
<p>完成上面的操作之后，在终端中输入下面的命令，创建数据库迁移环境，</p>
<pre>
<code class="language-bash">flask db init</code></pre>
<p>我们可以在我们项目的同级目录中看到一个<code>migrations</code>的文件夹，该文件中保存的就是数据迁移的相关文件，使用下面的命令创建迁移文件。</p>
<pre>
<code class="language-bash">flask db migrate -m "add post table"</code></pre>
<p>在上面的命令中-m是可选的参数，加上只是为了可以<code>track</code>某些操作，当我们迁移出错之后。然后打开<code>migrations</code>文件夹，我们可以看到生成的迁移文件，文件内容读者可以自行去查看，然后通过下面的命令进行数据库的升级操作。</p>
<pre>
<code class="language-bash">flask db upgrade</code></pre>
<blockquote class="m-blockquote">
<p>在进行git上传的时候，最好是吧migrations文件夹加入.gitignore文件中去，这样我们在生产环境进行数据库迁移的时候就不会出现冲突了。</p>
</blockquote>
<h3>4.发布帖子</h3>
<p>在创建好相应的前序工作之后，我们就可以开始实现发布帖子的功能了。在实现发布帖子的功能，我们使用到了flask-ckeditor库，通过该库可以很轻松的实现富文本编辑功能，首先需要安装flask-ckeditor。</p>
<h2>a.flask-ckedito配置</h2>
<pre>
<code class="language-bash">pip install flask-ckeditor</code></pre>
<p>安装完成之后，使用CKEditor需要做一些初始化配置，打开bbs/settting.py模块，在BaseConfig类中添加下面的代码</p>
<pre>
<code class="language-python">class BaseConfig(object):
# 省略已有代码
# CKEditor configure
CKEDITOR_SERVE_LOCAL = True
CKEDITOR_ENABLE_CODESNIPPET = True
CKEDITOR_HEIGHT = 400
CKEDITOR_FILE_UPLOADER = 'normal.image_upload'</code></pre>
<p>在给<code>CKEditor</code>配置文件上传路由时，配置了<code>normal.image_upload</code>路由，但是此时我们的应用程序中还没有这个路由，因此需要创建这个路由，打开<code>bbs/blueprint/frontend/</code>文件夹，创建一个名为<code>normal.py</code>的模块，添加下面的代码</p>
<pre>
<code class="language-python">from flask import Blueprint
normal_bp = Blueprint('normal', __name__, url_prefix='/normal')
@normal_bp.route('/image/upload/')
def image_upload():
pass</code></pre>
<p>之后需要把该蓝图在<code>__init__.py</code>文件中进行注册，在这里我们先不对文件上传视图函数做处理，后面我们再来处理这个函数。</p>
<h2>b.创建表单</h2>
<p>同样使用wtfform来渲染前端创建帖子的表单，打开<code>bbs/forms.py</code>模块，添加下面的代码</p>
<pre>
<code class="language-python">class BasePostForm(FlaskForm):
title = StringField(u'标题', validators=[DataRequired(message='帖子标题不能为空'),
Length(min=1, max=50, message='用户名长度必须在1到50位之间')],
render_kw={'class': '', 'rows': 50, 'placeholder': '输入您的帖子标题'})
category = SelectField(label=u'分区',
default=0,
coerce=int)
anonymous = SelectField(label=u'是否匿名', default=1, choices=[(1, '实名'), (2, '匿名')], coerce=int)
body = CKEditorField('帖子内容', validators=[DataRequired(message='请输入帖子内容')])
submit = SubmitField(u'发布', render_kw={'class': 'source-button btn btn-primary btn-xs mt-2 text-right'})
def __init__(self, *args, **kwargs):
super(BasePostForm, self).__init__(*args, **kwargs)
categories = PostCategory.query.all()
self.category.choices = [(cate.id, cate.name) for cate in categories]
# noinspection PyMethodMayBeStatic
class CreatePostForm(BasePostForm):
def validate_title(self, filed):
if Post.query.filter_by(title=filed.data).first():
raise ValidationError('该标题已存在请换一个!')
class EditPostForm(BasePostForm):
submit = SubmitField(u'保存编辑', render_kw={'class': 'source-button btn btn-danger btn-xs mt-2 text-right'})</code></pre>
<p>跟用户登录、注册表单类似，因为帖子除了发布之外还可以编辑，因此可以通过基类定义共同属性，在子类中定义各自的特有属性。在基类中我们定义了表单的字段，同时通过构造函数去获取了<code>PostCategory</code>中所有类别，并将其值赋给<code>category</code>字段了。</p>
<h2>c.后端逻辑</h2>
<p>在<code>bbs/blueprint/frontend/</code>中创建名为<code>post.py</code>的模块，添加下面的代码</p>
<pre>
<code class="language-python">import datetime
from flask import Blueprint, render_template, flash, redirect, url_for, request, jsonify, current_app
from bbs.blueprint.frontend.normal import to_html
from bbs.models import Post, Collect, PostReport, ReportCate, Comments, Notification, CommentStatistic, PostStatistic, \
PostCategory
from bbs.forms import CreatePostForm, EditPostForm
from flask_login import login_required, current_user
from bbs.extensions import db
from bbs.utils import get_text_plain, EMOJI_INFOS
from bbs.decorators import statistic_traffic
post_bp = Blueprint('post', __name__, url_prefix='/post')
@post_bp.route('/new/', methods=['GET', 'POST'])
@login_required
def new_post():
form = CreatePostForm()
if form.validate_on_submit():
title = form.title.data
cate = form.category.data
anonymous = form.anonymous.data
content = form.body.data
textplain = get_text_plain(content)
post = Post(title=title, cate_id=cate, content=content, is_anonymous=anonymous, author_id=current_user.id,
textplain=textplain)
db.session.add(post)
db.session.commit()
flash('帖子发布成功!', 'success')
return redirect(url_for('post.read', post_id=post.id))
return render_template('frontend/post/new-post.html', form=form)</code></pre>
<p>在该模块中，前端用户所有关于帖子的操作都会存放于此，因此在实例化蓝图的时候添加了<code>url_prefix</code>位置参数，此蓝图中的所有视图函数都会有<code>post</code>的前缀url，在该蓝图中的所有视图函数都是用于帖子的相关操作。</p>
<p>与此同时，我们添加了一个new_post()视图函数，在视图函数上面添加了两个装饰器</p>
<ol>
<li>
<p>post_bp.rout()</p>
<p>路由装饰器，这里就不做过多的解释了，属于flask的最基本知识点</p>
</li>
<li>
<p>login_required</p>
<p>这个装饰器是用来判断限定只有用户登录之后才能进行发布帖子的操作，属于<code>flask_login</code>第三方模块的装饰器。其原理就是通过session来判断用户是否登录，如果没有则跳转到系统定义的登录页面；</p>
</li>
</ol>
<p>之后实例化了上一步创建的表单类，通过<code>validate_form_submit</code>来判断用户是提交表单数据还是初始进入创建帖子页面，如果是初始进入页面则返回模板文件渲染，如果是提交则将用户提交的信息添加到数据库中，实现发布帖子的功能。</p>
<p>现在我们还没有创建对应的模板文件，接下来就需要创建发布帖子的模板文件。</p>
<h2>d.发布帖子模板文件</h2>
<p>打开<code>bbs/templates/frontend/post/</code>文件夹，新建<code>new-post.html</code>文件，在文件中添加如下代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% import 'bootstrap/wtf.html' as wtf %}
{% block title %}
发布新的帖子
{% endblock %}
{% block content %}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container mt-3"&gt;
&lt;h3 class="text-info"&gt;&lt;strong&gt;新的帖子&lt;/strong&gt;&lt;/h3&gt;
&lt;hr class="bg-secondary"&gt;
&lt;form action="/post/new/" method="post"&gt;
{{ form.csrf_token }}
{{ wtf.form_field(form.title) }}
&lt;div class="row"&gt;
&lt;div class="col"&gt;
{{ wtf.form_field(form.category) }}
&lt;/div&gt;
&lt;div class="col"&gt;
{{ wtf.form_field(form.anonymous) }}
&lt;/div&gt;
&lt;/div&gt;
{{ form.body }}
&lt;div class="text-right"&gt;
{{ form.submit }}
&lt;/div&gt;
&lt;/form&gt;
&lt;/div&gt;
&lt;/main&gt;
&lt;/body&gt;
{{ ckeditor.load() }}
{{ ckeditor.config(name='body') }}
{% endblock %}</code></pre>
<p>同样的还是通过继承基模板来实现我们的页眉跟页脚的布局，然后在content块中定义我们自己的内容。content中的内容跟注册表单差不多，就是把后端的wtfform字段进行渲染。</p>
<pre>
<code class="language-html">{{ ckeditor.load() }}
{{ ckeditor.config(name='body') }}</code></pre>
<p>通过这两段代码我们就渲染了CKEditor的富文本编辑器了。尤其注意config中的name=&#39;body&#39;，这个body就是我们BasePostForm中定义的字段名，根据该字段名就会将CKEditor渲染到该前端元素中去。然后我们在浏览器中输入<a href="http://127.0.0.1:5000/post/new/">http://127.0.0.1:5000/post/new/</a>就可以看到下面的页面了，CKEditor最上边工具栏中的图片上传还不能使用，在后面的章节中将会进行处理。</p>
<p><img alt="发布帖子" class="d-block img-fluid mx-auto pic" src="/backend/files/9094%E5%8F%91%E5%B8%83%E5%B8%96%E5%AD%90.png" /></p>
<p>在页面中随便输入一些信息，点击发布，然后到数据库中就可以看到相关的帖子数据啦。</p>
<p>好啦，感谢各位看官读到这里，本节的功能就全部完成了。在下一节中将会实现阅读帖子内容，以及首页相关内容。</p>
</content>
<link href="https://2dogz.cn/blog/article/26/" rel="alternate"/>
</entry>
<entry>
<id>25</id>
<title>[Linux]使用ssh时的一些骚操作</title>
<updated>2023-09-27T02:08:19.929058+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>基本使用</h1>
<p>在Windows平台上，可以使用免费的putty工具来进行ssh连接，同时也有其他功能更加强大的收费工具，比如XShell等等。这些工具都具有可视化界面，具体使用方法这里就不再累述。</p>
<p>在Linux或者MacOS平台上，在终端中使用下面的命令就能很简单的连接远程主机了。</p>
<pre>
<code class="language-bash">ssh hostName@hostIP </code></pre>
<h1>配置ssh命令别称</h1>
<p>在Linux发行版或者MacOS系统中，默认的都会在系统中安装<code>bash</code>工具，工具一般位于<code>/usr/bin/bash</code>。通过<kbd>Ctrl+Shift+T</kbd>组合按键可以来打开终端工具，在每次打开终端时，都会去加载<code>/home/username/.bashrc</code>文件中的配置，查看<code>.bashrc</code>文件中的内容如下图</p>
<p><img alt=".bashrc" class="d-block img-fluid mx-auto pic" src="/backend/files/9972bashrc%E6%96%87%E4%BB%B6%E5%86%85%E5%AE%B9.png" /></p>
<p>在上图中可以看到很多<code>alias</code>翻译过来的意思就是别名，比如</p>
<ul>
<li>
<p>alias ll=&#39;ls -alF&#39;</p>
</li>
<li>
<p>alias la=&#39;ls -A&#39;</p>
</li>
</ul>
<p>在终端中我们使用<code>ll</code>就是执行了<code>ls -alF</code>命令，执行<code>la</code>就相当于执行了<code>ls -A</code>的命令。因此也可以将我们常用的命令配置成别名的方式，使用下面的方式配置ssh别名</p>
<pre>
<code class="language-bash">sudo vim ~/.bashrc
# 在文件内容末尾输入下面的内容
alias stx='ssh ubuntu@hostIP -p 22'</code></pre>
<p>其中hostIP就是你需要连接的远程主机的公网IP地址，退出保存，执行如下命令</p>
<pre>
<code class="language-bash">source ~/.bashrc</code></pre>
<p>注意修改完了<code>~/.bashrc</code>文件之后，一定要记得执行<code>source</code>命令，不然不会生效，当然你也可以重新开启一个终端窗口。然后在终端中输入<code>stx</code>命令就可以连接你的远程主机了，输入密码就可以进入你的远程主机了。如果你有经常需要连接的远程主机，使用该方式可以省去我们每次都需要输入远程主机名跟IP了，大大提高工作效率。</p>
<h1>sshpass工具</h1>
<p>上面的方法确实可以节省我们输入远程主机名以及IP地址的时间，但是有一个问题是我们每次都需要输入远程主机的登录密码，那么有没有一种方式让我们省去输入密码步骤呢？答案是肯定的，我们可以通过sshpass工具将登录密码直接附加上登录命令中。首先我们通过下面的命令来安装<code>sshpass</code>工具</p>
<pre>
<code class="language-bash">sudo apt-get install sshpass</code></pre>
<p>之后可以通过下面的命令测试是否可用</p>
<pre>
<code class="language-bash">sshpass -p password ssh -p 22 hostName@hostIP</code></pre>
<p>测试成功之后就可以按照方法一一样将该命令配置一个别名，然后在命令行中输入<code>sptx</code>就可以免去密码直接登录远程主机了。</p>
<pre>
<code class="language-bash">sudo vim ~/.bashrc
alias sptx='sshpass -p password ssh -p 22 hostName@hostIP'</code></pre>
<p><img alt="sshpass" class="d-block img-fluid mx-auto pic" src="/backend/files/3364image-20210122101105986.png" /></p>
<h1>SSH-key 免密登录</h1>
<p>上面的方式其实算不上真正的免密登录，我们只是把登录密码使用其他工具附加到登录命令中了。那怎么真正的实现免密登录呢？我们可以通过ssh-key来实现这一需求。</p>
<ul>
<li>
<p>在本机生成ssh-key</p>
<p>首先查看本机是否已经生成了ssh-key。</p>
<pre>
<code class="language-bash">cd ~/.ssh
ls | grep id</code></pre>
<p>如果存在，则可以省去下面这个步骤。如果不存在，则使用下面的命令生成本机秘钥。</p>
<pre>
<code class="language-bash">ssh-keygen -t rsa</code></pre>
<p>一路回车就生成了本机的ssh秘钥了。其中<code>id_rsa</code>为私钥，<code>id_rsa.pub</code>为公钥，我们将公钥拷贝到远程主机中</p>
<pre>
<code class="language-bash">scp ~/.ssh/id_rsa.pub hostName@hoatIP</code></pre>
<p>在远程主机中将客户端的公钥写入<code>~/.ssh/authorized_keys</code>文件中</p>
<pre>
<code class="language-bash">cat id_rsa.pub &gt;&gt; ~/.ssh/authorized_keys</code></pre>
</li>
<li>客户端配置<br />
虽然这样子配置之后可以免密登录，但是每次还是需要输入远程主机名、IP等等。可以通过客户端的<code>~/.ssh/config</code>配置服务器的相关参数简化登录命令。
<pre>
<code class="language-bash">sudo vim ~/.ssh/config
# 填入下面的内容在文件结尾
Host Servername
HostName IP
Port 22
User hostName
IdentityFile ~/.ssh/id_rsa</code></pre>
<p>然后在终端中使用你配置的Servername就可以登录远程主机了。</p>
<pre>
<code class="language-bash">ssh Servername</code></pre>
<p>当然我们也可以根据方法一配置别名使得命令更加简短，这里就不再做出说明了。</p>
</li>
</ul>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/25/" rel="alternate"/>
</entry>
<entry>
<id>24</id>
<title>[应用部署]使用github+jsdelivr加速网站静态资源访问速度</title>
<updated>2023-09-27T02:08:19.929019+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1. github CDN</h1>
<p>查看jsdelivr文档github CND那小节，可以看到我们可以如下内容</p>
<ol>
<li>加载任何github仓库的release、commit、branch
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/user/repo@version/file</code></pre>
</li>
<li>加载指定版本的文件
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/dist/jquery.min.js
https://cdn.jsdelivr.net/gh/jquery/jquery@32b00373b3f42e5cdcb709df53f3b08b7184a944/dist/jquery.min.js</code></pre>
</li>
<li>使用范围版本代替指定版本
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/jquery/jquery@3.2/dist/jquery.min.js
https://cdn.jsdelivr.net/gh/jquery/jquery@3/dist/jquery.min.js</code></pre>
</li>
<li>忽略版本使用latest来加载最新的release版本(不推荐在生产环境中使用)
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/jquery/jquery@latest/dist/jquery.min.js
https://cdn.jsdelivr.net/gh/jquery/jquery/dist/jquery.min.js</code></pre>
</li>
<li>在任何JS / CSS文件中添加&ldquo; .min&rdquo;以获得缩小版本-如果不存在，我们将为您生成。 所有生成的文件都带有源映射，可以在开发期间轻松使用：
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/src/core.min.js</code></pre>
</li>
<li>获取目录清单
<pre>
<code class="language-http">https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/
https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/dist/</code></pre>
</li>
</ol>
<p>有了以上的内容，我们就可以通过github来托管我们的静态资源文件，然后使用jsdelivr来加载了。</p>
<h1>2. github相关操作</h1>
<p>在进行jsdelivr加载之前，我们需要在github上进行一系列操作。</p>
<h2>新建github仓库</h2>
<p>进入个人github 看板页面，点击New，既可以进入创建新的仓库页面，相关信息可以自定义。</p>
<p><img alt="create repo" class="d-block img-fluid mx-auto pic" src="/backend/files/8345%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_39.png" /></p>
<h2>克隆仓库</h2>
<p>点击Create repository之后，会自动跳转到仓库主页中去，点击Code按钮，复制clone连接</p>
<p><img alt="git clone" class="d-block img-fluid mx-auto pic" src="/backend/files/1192%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20210118140029.png" /></p>
<p>进入你想存放仓库的文件夹，输入下面的命令进行仓库克隆</p>
<pre>
<code class="language-bash">git clone 复制的连接</code></pre>
<h2>添加静态资源文件</h2>
<p>将仓库克隆到本地之后，把你想要加载的静态资源文件存放到本地仓库中，然后使用如下命令推送到github上</p>
<pre>
<code>git add --al
git commit
git push</code></pre>
<h2>生成release</h2>
<p>推送完成之后，点击仓库右侧的new release按钮，新建一个release版本，信息由你自己定义，然后点击publish按钮即可。</p>
<p><img alt="release" class="d-block img-fluid mx-auto pic" src="/backend/files/9808%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_40.png" /></p>
<h1>3. 使用jsdelivr加载</h1>
<p>完成了上述步骤之后，就可以通过jsdelivr进行加载了，在我的仓库中我存放了bootstrap4.3.1的css文件以及js文件，在需要引入的html文件中引入方式如下</p>
<pre>
<code class="language-html">&lt;link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/weijiang1994/BlogCDN@1.0/bootstrap4/bootstrap.4.3.1.min.css"&gt;
&lt;script src="https://cdn.jsdelivr.net/gh/weijiang1994/BlogCDN@1.0/bootstrap4/bootstrap.4.3.1.min.js"&gt;&lt;/script&gt;
</code></pre>
<p>引用的格式如下</p>
<blockquote class="m-blockquote">
<p>https://cdn.jsdelivr.net/gh/github用户名/github仓库名@release版本号/文件路径</p>
</blockquote>
<h1>4.QA</h1>
<p><strong>Q:</strong>jsdelivr能提高加载速度吗？</p>
<p><strong>A:</strong>jsdelivr在国内有很多节点，因此裸连的速度也是相当的客观。</p>
<p><strong>Q:</strong>删除github仓库还能生效吗？</p>
<p><strong>A:</strong>jsdelivr使用永久性的S3存储，以确保即使GitHub发生故障，或者其作者删除了存储库或发行版，所有文件仍然可用。 仅在第一次或S3故障时才直接从GitHub提取文件。</p>
<p><strong>Q:</strong>其他玩法?</p>
<p><strong>A:</strong>在你自己的服务器带宽很低的情况下，可以通过这种方式加载大文件，测试了加载12M的图片文件，仅仅耗时4s不到。</p>
</content>
<link href="https://2dogz.cn/blog/article/24/" rel="alternate"/>
</entry>
<entry>
<id>23</id>
<title>[系列教程]使用Flask搭建一个校园论坛4-登录注册</title>
<updated>2023-09-27T02:08:19.928983+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>1.知识预览</h1>
<p>在本届中将学习到以下内容的知识</p>
<ol>
<li>如何使用wtform来渲染表单</li>
<li>如果使用flask-mail来发送邮件</li>
</ol>
<h1>2.用户注册</h1>
<p>在前端中form表单是用的比较多的东西，我们可以使用<code>wtforms</code>这个框架，直接通过后端代码来渲染前端表单。新建<code><strong>bbs/forms.py</strong></code>文件，嵌入以下代码</p>
<pre>
<code class="language-python">from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, SelectField, BooleanField, TextAreaField, FileField, Label, HiddenField, \
PasswordField
class BaseUserForm(FlaskForm):
user_name = StringField(u'用户名',
validators=[DataRequired(message='用户名不能为空'),
Length(min=1, max=16, message='用户名长度限定在1-16位之间'),
Regexp('^[a-zA-Z0-9_]*$',
message='用户名只能包含数字、字母以及下划线.')],
render_kw={'placeholder': '请输入用户名长度1-16之间'})
nickname = StringField(u'昵称',
validators=[DataRequired(message='昵称不能为空'),
Length(min=1, max=20, message='昵称长度限定在1-20位之间')],
render_kw={'placeholder': '请输入昵称长度1-20之间'})
user_email = StringField(u'注册邮箱',
render_kw={'placeholder': '请输入注册邮箱', 'type': 'email'})
submit = SubmitField(u'注册', render_kw={'class': 'btn btn-success btn-xs'})</code></pre>
<p>在上面的代码中，首先导入相关的库，然后新建了一个<code>BaseUserForm</code>的类，因为用户的信息在很多表单中使用到了，因此可以将共同的属性剥离出来，然后在不同的场合继承该基类，并且可以根据不同的场合在子类中定制我们的表单属性，这样就可以降低代码的冗余量。如果在每个需要使用到用户信息的表单代码中写入同样的内容，那么久显得代码很臃肿了。</p>
<p><code>BaseUserForm</code>类中使用到了<code>wtforms</code>中的一些属性，比如<code>StringField</code>就相当于是我们前端的<code>input</code>标签，<code>SubmitField</code>就相当于是<code>&lt;input type=&quot;submit&quot;&gt;</code>，具体可以去看<a href="https://link.zhihu.com/?target=https%3A//wtforms.readthedocs.io/en/2.3.x/" target="_blank">wtforms</a>的官方文档。</p>
<p>继续在上面的文件中嵌入如下代码，新建注册表单类</p>
<pre>
<code class="language-python">class RegisterForm(FlaskForm):
user_name = StringField(u'用户名',
validators=[DataRequired(message='用户名不能为空'),
Length(min=1, max=16, message='用户名长度限定在1-16位之间'),
Regexp('^[a-zA-Z0-9_]*$',
message='用户名只能包含数字、字母以及下划线.')],
render_kw={'placeholder': '请输入用户名长度1-16之间'})
nickname = StringField(u'昵称',
validators=[DataRequired(message='昵称不能为空'),
Length(min=1, max=20, message='昵称长度限定在1-16位之间')],
render_kw={'placeholder': '请输入昵称长度1-20之间'})
user_email = StringField(u'注册邮箱',
validators=[DataRequired(message='注册邮箱不能为空'),
Length(min=4, message='注册邮箱长度必须大于4')],
render_kw={'placeholder': '请输入注册邮箱', 'type': 'email'})
password = StringField(u'密码',
validators=[DataRequired(message='用户密码不能为空'),
Length(min=8, max=40, message='用户密码长度限定在8-40位之间'),
EqualTo('confirm_pwd', message='两次密码不一致')],
render_kw={'placeholder': '请输入密码', 'type': 'password'})
confirm_pwd = StringField(u'确认密码',
validators=[DataRequired(message='用户密码不能为空'),
Length(min=8, max=40, message='用户密码长度限定在8-40位之间')],
render_kw={'placeholder': '输入确认密码', 'type': 'password'})
colleges = SelectField(u'学院', choices=[(1, '计算机')])
submit = SubmitField(u'注册', render_kw={'class': 'source-button btn btn-primary btn-xs mt-2'})
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
cols = College.query.all()
self.colleges.choices = [(col.id, col.name) for col in cols]
def validate_user_name(self, filed):
if User.query.filter_by(username=filed.data).first():
raise ValidationError('用户名已被注册.')
def validate_user_email(self, filed):
if User.query.filter_by(email=filed.data.lower()).first():
raise ValidationError('邮箱已被注册.')
def validate_nickname(self, filed):
if User.query.filter_by(nickname=filed.data).first():
raise ValidationError('昵称已被注册')</code></pre>
<p>因为学院的选项有许多，我们可以在类的构造函数中通过数据库去获取数据库中已经存在的学院，然后将其设置到<code>colleges</code>类属性的<code>choices</code>值上，这样当我们打开页面渲染表单时，数据就会自动渲染到<code>select</code>标签<code>option</code>上去了，如下图</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://pic3.zhimg.com/80/v2-d47873c2d185b3a5dd625b9b8b4ec642_720w.jpg" style="margin:0px auto; width:250px" /></p>
<p>然后还新建了三个函数<code>validate_user_name</code>、<code>validate_user_email</code>以及<code>validate_nickname</code>，这三个函数主要是用来判断<code>email、username、nickname</code>三个字段的唯一性，因为在数据库建表的时候将这三个字段设置为<code>unique=True</code>，因此在这里需要做一个唯一性的判断。</p>
<blockquote class="m-blockquote">使用<code><strong>wtforms</strong></code>时，我们可以通过<code><strong>validate_</strong></code>加上你需要校验的属性字段名称来检验前端用户输入的数据是否符合标准。</blockquote>
<p>表单类的编写已经完成，接下来就是整个注册逻辑的实现了。新建<code><strong>bbs/templates/frontend/register.html</strong></code>文件，嵌入以下代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% import 'bootstrap/wtf.html' as wtf %}
{% block title %}
用户注册
{% endblock %}
{% block content %}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container"&gt;
&lt;div class="jumbotron pt-5 pb-1 mt-2"&gt;
&lt;div class="row"&gt;
&lt;div class="col-md-8"&gt;
&lt;h3 class="text-muted"&gt;&lt;b&gt;欢迎注册加入狗子学院~&lt;/b&gt;&lt;/h3&gt;
&lt;hr class="bg-primary"&gt;
&lt;p&gt;&lt;b&gt;在这里你可以:&lt;/b&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;浏览当下校园的一些趣事、杂谈以及谁和谁的八卦&lt;/li&gt;
&lt;li&gt;发布一些咸鱼交易、寻物启事等等&lt;/li&gt;
&lt;li&gt;发现臭味相投的朋友、开拓自己的圈子&lt;/li&gt;
&lt;/ul&gt;
&lt;img src="{{ url_for('static', filename='img/index.jpg') }}" class="rounded img-fluid"&gt;
&lt;/div&gt;
&lt;div class="col-md-4"&gt;
&lt;div class="card mb-3 w-100 bg-light"&gt;
&lt;div class="card-header"&gt;&lt;h4 class="text-muted"&gt;&lt;strong&gt;用户注册&lt;/strong&gt;&lt;/h4&gt;&lt;/div&gt;
&lt;div class="card-body"&gt;
{% include "_flash.html" %}
&lt;form class="bs-component" action="/auth/register/" method="post"&gt;
{{ form.csrf_token }}
{{ wtf.form_field(form.user_name) }}
{{ wtf.form_field(form.nickname) }}
{{ wtf.form_field(form.user_email) }}
{{ wtf.form_field(form.password) }}
{{ wtf.form_field(form.confirm_pwd) }}
{{ wtf.form_field(form.colleges) }}
&lt;label for="captcha"&gt;验证码&lt;/label&gt;
&lt;div class="input-group"&gt;
&lt;input type="text" class="form-control" name="captcha" id="captcha" placeholder="请输入验证码" aria-required="true" aria-describedby="captcha" required&gt;
&lt;div class="input-group-append"&gt;
&lt;button class="btn btn-success" onclick="sendCapt()" id="sendCaptcha"&gt;发送&lt;/button&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p class="p-hint"&gt;验证码发送成功,10分钟内有效!&lt;/p&gt;
{{ form.submit }}
&lt;hr&gt;
&lt;small&gt;已有账号? &lt;a style="text-decoration: none;" href="{{ url_for('.login') }}"&gt;登录.&lt;/a&gt;
&lt;/small&gt;
&lt;/form&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;</code></pre>
<p>然后打开<strong><code>bbs/blueprint/frontend/auth.py</code></strong>文件，接着在上一节下面嵌入如下代码</p>
<pre>
<code class="language-python">@auth_bp.route('/register/', methods=['GET', 'POST'])
def register():
colleges = College.query.all()
form = RegisterForm()
return render_template('frontend/register.html', colleges=colleges, form=form)</code></pre>
<p>在后端代码中我们通过<code>render_template</code>函数返回了前端注册页面，并且携带注册表单的实例参数。在前端html文件中，我们可以通过form.参数名的方式来进行表单渲染。同时还在前端文件中导入了<code>bootstrap/wtf.html</code>，这样就可以将表单的样式渲染成<code>bootstrap</code>的样式，当然也可以不是bootstrap/wtf.html来渲染，在后端表单类中可以通过<code>render_kw</code>参数来指定我们表单的一些特定参数。</p>
<p>在前端页面中我们还手动加入了一行验证码输入框，点击发送按钮就可以将验证码发送到用户填写的邮箱当中去了。为什么不将此输入框写到后端表单中去？因为那样不好处理前端样式了。</p>
<p>访问http://127.0.0.1/auth/register/ 将会看到如下页面：</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://pic4.zhimg.com/80/v2-9dcef0c7f76a95b78c06063259642503_720w.jpg" style="margin:0px auto; width:1902px" /></p>
<p>在注册页面中是需要用户填写邮箱收到的验证码，因此我们需要在后端代码中实现发送邮件的功能。发送邮件的功能是通过flask-email来实现的，打开bbs/extensions.py文件，加入下面的代码，然后在<code><strong>__init__.py</strong></code>文件中进行注册。</p>
<pre>
<code class="language-python">from flask_mail import Mail
mail = Mail()</code></pre>
<p>在使用发送邮件功能之前，首先我们需要到qq邮箱或者网易邮箱或者其他可以使用的邮箱申请SMTP服务，具体流程可以某度某歌搜索一下，这里就不再累述。将申请到的私密信填入到<code>.env</code>文件中</p>
<pre>
<code class="language-ini">MAIL_SERVER='smtp.qq.com'
MAIL_USERNAME='你的qq邮箱名'
MAIL_PASSWORD='qq邮箱秘钥不是登录密码是申请SMTP那串无规则秘钥'</code></pre>
<p>然后在<code><strong>bbs/setting.py</strong></code>文件中加入下面的代码</p>
<pre>
<code class="language-python">class BaseConfig(object):
# 省略之前代码
BBS_MAIL_SUBJECT_PRE = '[狗子学院]'
MAIL_SERVER = os.getenv('MAIL_SERVER')
MAIL_PORT = 465
MAIL_USE_SSL = True
MAIL_USERNAME = os.getenv('MAIL_USERNAME')
MAIL_PASSWORD = os.getenv('MAIL_PASSWORD')
MAIL_DEFAULT_SENDER = ('BBS Admin', MAIL_USERNAME)</code></pre>
<p>新建<code><strong>bbs/email.py</strong></code>文件，并将下面代码写入其中。</p>
<pre>
<code class="language-python">from threading import Thread
from bbs.extensions import mail
from flask_mail import Message
from flask import current_app, render_template
def async_send_mail(app, msg):
with app.app_context():
mail.send(msg)
def send_email(to_mail, subject, template, **kwargs):
message = Message(current_app.config['BBS_MAIL_SUBJECT_PRE'] + subject,
recipients=[to_mail],
sender=current_app.config['MAIL_USERNAME'])
message.body = render_template(template + '.txt', **kwargs)
message.html = render_template(template + '.html', **kwargs)
th = Thread(target=async_send_mail, args=(current_app._get_current_object(), message))
th.start()
return th</code></pre>
<p>在send_email函数中，使用了render_template()来渲染了邮件消息body以及html参数，因此需要先将这两个模板准备好。新建<code><strong>bbs/templates/email/verifyCode.html</strong></code>&nbsp;与<code>bbs/templates/email/verifyCode.txt</code>&nbsp;文件，将下面的代码写到文件中去</p>
<p><strong><code>verifyCode.html</code></strong></p>
<pre>
<code class="language-html">&lt;h3 style="font-weight: bold;font-size: 18px"&gt;Hello {{ username }},&lt;/h3&gt;
&lt;p&gt;Welcome to join the &lt;a href="http://bbs.2dogz.cn"&gt;狗子学院&lt;/a&gt;!This is your register captcha below here.&lt;/p&gt;
&lt;h1&gt;&lt;strong&gt;{{ ver_code }}&lt;/strong&gt;&lt;/h1&gt;
&lt;h5&gt;&lt;b&gt;&lt;i&gt;The captcha will expire after 10 minutes.&lt;/i&gt;&lt;/b&gt;&lt;/h5&gt;
&lt;p style="color: red; font-style: italic"&gt; If this operate is not by yourself, please change your password right now!Maybe your account was cracked.&lt;/p&gt;
&lt;small&gt;(Please do not reply to this notification, this inbox is not monitored.)&lt;/small&gt;</code></pre>
<p><code><strong>verifyCode.txt</strong></code></p>
<pre>
<code class="language-todotxt">Hello {{ username }}
Welcome to Blogin!
Welcome to join the 狗子学院!This is your register captcha below here.
{{ ver_code }}
The captcha will expire after 10 minutes.
If this operate is not by yourself, please change your password right now!Maybe your account was cracked.&lt;/p&gt;
(Please do not reply to this notification, this inbox is not monitored.)</code></pre>
<p>然后开始编写发送邮件的后端逻辑代码，新建<code><strong>bbs/blueprint/frontend/normal.py</strong></code>&nbsp;文件，因为发送邮件属于通用行为，因此将其放入normal.py模块中，将以下代码嵌入其中</p>
<pre>
<code class="language-python">from flask import Blueprint, send_from_directory, request, jsonify
from bbs.extensions import db
from bbs.email import send_email
from bbs.models import VerifyCode, Gender, Role, College
@normal_bp.route('/send-email/', methods=['POST'])
def send():
to_email = request.form.get('user_email')
username = request.form.get('user_name')
ver_code = generate_ver_code()
send_email(to_mail=to_email, subject='Captcha', template='email/verifyCode', username=username,
ver_code=ver_code)
# 判断是否已经存在一个最新的可用的验证码,以确保生效的验证码是用户收到最新邮件中的验证码
exist_code = VerifyCode.query.filter(VerifyCode.who == to_email, VerifyCode.is_work == 1).order_by(
VerifyCode.timestamps.desc()).first()
if exist_code:
exist_code.is_work = False
nt = datetime.datetime.now()
et = nt + datetime.timedelta(minutes=10)
verify_code = VerifyCode(val=ver_code, who=to_email, expire_time=et)
db.session.add(verify_code)
db.session.commit()
return jsonify({'tag': 1, 'info': '邮件发送成功!'})</code></pre>
<p>我们根据请求中的keyword来获取前端发送过来的请求参数，然后调用send_email()函数进行发送邮件，同时将生成的随机验证码放入到邮件消息体中去。</p>
<p>然后判断数据库中是否已经存在了属于该注册用户的验证码，如果有则将它设置为过期的，然后将新的验证码存入到数据库中，并设置过期时间为10分钟。这里是通过MySQL来保存的验证码信息，也有其他方法来保存验证码信息，比如使用redis来保存，redis可以设置字段过期时间，如果达到了这个时间，再去取这个字段的值就会为None。</p>
<p>接着我们来处理前端发送邮件的代码，打开bbs/templates/frontend/register.html文件，加入下面的代码</p>
<pre>
<code class="language-html">&lt;main&gt;
...
&lt;/main&gt;
&lt;script&gt;
let time = 60;
let reg = /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/;
function sendCapt(){
let $sendBtn = $("#sendCaptcha");
let $email = $("#user_email");
let $username = $("#user_name");
if ($username.val() === '' || $email.val() === '' || !reg.test($email.val())){
return false;
}
$sendBtn.attr('disabled', true);
getRandomCode($sendBtn);
$.ajax({
url: '/normal/send-email/',
type: 'post',
data: {'user_name': $username.val(), 'user_email': $email.val()},
success: function (res){
if (res.tag){
$(".p-hint").slideDown(500).delay(3000).hide(500);
}
}
})
}
//倒计时
function getRandomCode(obj) {
if (time === 0) {
time = 60;
obj.text('发送');
obj.attr('disabled', false);
return;
} else {
time--;
obj.text(time+'(秒)');
}
setTimeout(function() {
getRandomCode(obj);
},1000);
}
&lt;/script&gt;</code></pre>
<p>通过ajax向后端<code><strong>/normal/send-email/</strong></code>发送请求，同时将<code>email</code>与<code>username</code>传递到后端，同时将发送验证码按钮置为不可点击状态，间隔60s才能发送一次，并在前端页面给用户一个提示信息。这样发送验证码邮件的整个流程就完成了，接下里要处理用户点击注册按钮之后的逻辑。</p>
<p>我们使用的是wtfforms来渲染的后端表单，并且在某些表单字段中加入了一些限制信息。在后端代码中，我们可以通过wtfforms的示例来验证我们的表单，打开<strong><code>bbs/blueprint/frontend/auth.py</code></strong>&nbsp;加入下面的代码</p>
<pre>
<code class="language-python">@auth_bp.route('/register/', methods=['GET', 'POST'])
def register():
...
if form.validate_on_submit():
username = form.user_name.data
nickname = form.nickname.data
password = form.confirm_pwd.data
email = form.user_email.data
college = form.colleges.data
captcha = request.form.get('captcha')
code = VerifyCode.query.filter(VerifyCode.who == email, VerifyCode.is_work == 1).order_by(
VerifyCode.timestamps.desc()).first()
if code:
if code.val != int(captcha):
flash('验证码错误!', 'danger')
return redirect(request.referrer)
elif code.expire_time &lt; datetime.datetime.now():
flash('验证码已过期!', 'danger')
return redirect(request.referrer)
else:
flash('请先发送验证码到邮箱!', 'info')
return redirect(request.referrer)
user = User(username=username,
college_id=college,
nickname=nickname,
email=email,
password=password,
status_id=1)
user.generate_avatar()
user.set_password(password)
code.is_work = False
db.session.add(user)
db.session.commit()
flash('注册成功,欢迎加入二狗学院!', 'success')
return redirect(url_for('.login'))</code></pre>
<p>通过<code>form.validate_on_submit()</code>来判断提交的表单是否通过了验证，通过验证之后通过<code>form.字段名.data</code>来获取对应表单字段的值，然后根据邮箱来查找上一步数据库保存的验证码，如果不存在验证码，则提示用户发送验证码到邮箱，因为存在着一种可能用户乱填一个验证码，而不发送验证码到邮箱。然后判断验证码是否正确或者过期，如果未通过，则发送对应的提示消息提示用户，如果通过，则将用户信息保存到数据库中，然后重定向到登录页面。至此，用户注册的功能就已经完成了。</p>
<h1>用户登录</h1>
<p>相比注册功能，用户登录就比较简单了。新建<code><strong>bbs/templates/frontend/login.html</strong></code>文件，该文件为用户登录的前端页面模板文件，同样的我们使用wtfforms来渲染表单，在文件中嵌入下面的代码</p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% import 'bootstrap/wtf.html' as wtf %}
{% block title %}
用户登录
{% endblock %}
{% block content %}
&lt;body&gt;
&lt;main&gt;
&lt;div class="container"&gt;
{% include "_flash.html" %}
&lt;div class="jumbotron pt-5 pb-3 mt-5"&gt;
&lt;div class="row"&gt;
&lt;div class="col-md-8"&gt;
&lt;img src="{{ url_for('static', filename='img/index.jpg') }}" class="rounded img-fluid"&gt;
&lt;/div&gt;
&lt;div class="col-md-4"&gt;
&lt;div class="card mb-3 w-100 bg-light align-self-center"&gt;
&lt;div class="card-header"&gt;&lt;h4 class="text-muted"&gt;&lt;strong&gt;用户登录&lt;/strong&gt;&lt;/h4&gt;&lt;/div&gt;
&lt;div class="card-body "&gt;
&lt;form class="bs-component" action="/auth/login/" method="post"&gt;
{{ form.csrf_token }}
{{ wtf.form_field(form.usr_email) }}
{{ wtf.form_field(form.password) }}
{{ wtf.form_field(form.remember_me) }}
{{ form.submit }}
&lt;hr&gt;
&lt;small&gt;没有账号? &lt;a style="text-decoration: none;" href="{{ url_for('.register') }}"&gt;注册.&lt;/a&gt;
&lt;/small&gt;
&lt;/form&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;
&lt;/body&gt;
{% endblock %}</code></pre>
<p>代码中的<code>form.csrf_token</code>&nbsp;是一种防止csrf攻击的手段，关于csrf攻击具体可以百度，之后的代码就跟注册模板一样，通过wtfforms进行表单渲染，因此我们需要新建一个渲染登录表单的类，打开bbs/forms.py模块，加入新建登录表单的代码，如下所示</p>
<pre>
<code class="language-python">class LoginForm(FlaskForm):
usr_email = StringField(u'邮箱/用户名', validators=[DataRequired(message='用户名或邮箱不能为空')],
render_kw={'placeholder': '请输入邮箱或用户名'})
password = StringField(u'登录密码',
validators=[DataRequired(message='登录密码不能为空'),
Length(min=8, max=40, message='登录密码必须在8-40位之间')],
render_kw={'type': 'password', 'placeholder': '请输入用户密码'})
remember_me = BooleanField(u'记住我')
submit = SubmitField(u'登录', render_kw={'class': 'source-button btn btn-primary btn-xs'})</code></pre>
<p>接着需要处理后端的登录视图函数，打开<code>bbs/blueprint/frontend/auth.py</code>模块，新建一个视图函数，代码如下所示</p>
<pre>
<code class="language-python">from flask_login import current_user, login_user, logout_user
@auth_bp.route('/login/', methods=['GET', 'POST'])
def login():
if current_user.is_authenticated:
return redirect(url_for('index_bp.index'))
form = LoginForm()
if form.validate_on_submit():
usr = form.usr_email.data
pwd = form.password.data
user = User.query.filter(or_(User.username == usr, User.email == usr.lower())).first()
if user is not None and user.status.name == '禁用':
flash('您的账号处于封禁状态,禁止登陆！联系管理员解除封禁!', 'danger')
return redirect(url_for('.login'))
if user is not None and user.check_password(pwd):
if login_user(user, form.remember_me.data):
flash('登录成功!', 'success')
return redirect(url_for('index_bp.index'))
elif user is None:
flash('无效的邮箱或用户名.', 'danger')
else:
flash('无效的密码', 'danger')
return render_template('frontend/login.html', form=form)</code></pre>
<p>关于登录逻辑处理，flask有一个十分流行好用的第三方库flask-login，使用该第三库我们可以很方便的处理登录、退出权限控制等操作。</p>
<p>首先通过current_user来判断用户是否已经登录了，如果登录则返回主页面。接着通过LoginForm示例来获取前端登录页面传递过来的值，从数据库获取用户的相关信息，首先判断账号是否被禁用了，如果被禁用则弹出提示信息，并返回给前端页面。接着判断用户密码是否匹配，如果不匹配则返回登录页面，并提示用户密码不匹配，反之则重定向到主页。</p>
<blockquote class="m-blockquote">这里的登录成功重定向其实可以做的更加人性化，当用户进入到需要登录才能操作的页面时候，这时候会自动跳转到登录页面。如果用户登录成功，应该是返回前一个页面而不是固定返回主页。flask_login的login_required装饰器重定向到登录页面的时候会带一个next参数，因此我们可以通过此参数来让用户登录成功之后重定向到上一页，具体实现很简单，就请读者自主开发吧!</blockquote>
<p>这时候我们打开登录页面，可以看到如下页面</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://pic3.zhimg.com/80/v2-1c206b89e8d4fbf7b2abebea969f320a_720w.jpg" style="margin:0px auto; width:720px" /></p>
<p>到此，用户登录注册功能就已经全部实现了，下一节将开始讲述论坛主页的实现。</p>
</content>
<link href="https://2dogz.cn/blog/article/23/" rel="alternate"/>
</entry>
<entry>
<id>22</id>
<title>[系列教程]使用Flask搭建一个校园论坛3-登录注册</title>
<updated>2023-09-27T02:08:19.928953+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h2>1.知识预览</h2>
<p>在本章节中，将学习到以下内容：</p>
<ol>
<li>flask-sqlachemy 数据库orm的使用</li>
<li>click 注册命令，初始化项目基础数据</li>
</ol>
<h2>2.轮子</h2>
<p>Flask本身的定义是一个微框架，何为其义呢？&ldquo;微&rdquo;并不代表整个应用只能塞在一个 Python 文件内， 当然塞在单一文件内也没有问题。 &ldquo;微&rdquo;也不代表 Flask 功能不强。 微框架中的&ldquo;微&rdquo;字表示 Flask 的目标是保持核心简单而又可扩展。 Flask 不会替你做出许多决定，比如选用何种数据库。 类似的决定，如使用何种模板引擎，是非常容易改变的。 Flask 可以变成你任何想要的东西，一切恰到好处，由你做主。因此，可以在开源的世界中找到非常多的flask扩展，本项目中使用的orm框架是<code>flask-sqlachemy</code>，基于<code>sqlachemy</code>开发的flask扩展。</p>
<p>在bbs目录下新建<code>extensions.py</code>模块，这个模块主要是用来存放我们第三方拓展使用。</p>
<p><strong>bbs/extensions.py</strong></p>
<pre>
<code class="language-python">from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()</code></pre>
<h2>3.项目配置</h2>
<p>项目可以有开发环境、测试环境、生产环境等，不同环境所使用的配置肯定也是不同的，同时项目也有一些配置是通用的。在bbs目录下面新建setting.py模块，该模块用来存储项目所有配置参数。</p>
<p>在第三小节中，我们使用了flask-salachemy这个框架，使用这个框架之前，有一些默认参数需要我们进行配置，我们将下面的代码写入到<code>setting.py</code>文件中去。</p>
<p><strong>bbs/setting.py</strong></p>
<pre>
<code class="language-python">import os
basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
class BaseConfig(object):
SQLALCHEMY_TRACK_MODIFICATIONS = False
DATABASE_USER = os.getenv('DATABASE_USER')
DATABASE_PWD = os.getenv('DATABASE_PWD')
DATABASE_HOST = os.getenv('DATABASE_HOST')
DATABASE_PORT = os.getenv('DATABASE_PORT')
class DevelopmentConfig(BaseConfig):
SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://{}:{}@{}/bbs?charset=utf8mb4'.format(BaseConfig.DATABASE_USER,
BaseConfig.DATABASE_PWD,
BaseConfig.DATABASE_HOST)
# REDIS_URL = "redis://localhost"
REDIS_URL = "redis://localhost:6379"</code></pre>
<p>首先通过内置的os模块获取了项目的根目录，同时新建了一个BaseConfig类，在该类中定义了一些参数(配置参数名称一般使用大写命名)，由于数据库连接的参数都属于是比较高危的数据，因此将其保存在环境变量中，通过<code>os.getenv()</code>去获取这些参数的具体数值。</p>
<p><code>DevelopmentConfig</code>类继承于<code>BaseConfig</code>类，该类是在开发环境中使用的。在该类中定义了<code>SQLALCHEMY_DATABASE_URI</code>参数，flask-sqlachemy在初始化时，会自动根据该参数去连接数据库。</p>
<p>数据库连接参数都保存在环境变量中，有以下两种方式将其保存至环境变量：</p>
<ul>
<li>使用export命令(Linux)</li>
</ul>
<pre>
<code class="language-python">export DATABASE_USER=root
export DATABASE_PWD=123456
export DATABASE_HOST=127.0.0.1
export DATABASE_PORT=3306</code></pre>
<p>使用该方式的弊端就是我们每次都需要手动去执行这些命令。</p>
<ul>
<li>.env文件<br />
可以将这些参数保存到.env文件中，然后通过<code>python-dotenv</code>库自动加载.env文件中的内容到环境变量。在<code>university-bbs</code>目录下新建<code>.env</code>文件，并嵌入下面的代码。</li>
</ul>
<pre>
<code class="language-ini">DATABASE_USER=weijiang
DATABASE_PWD=1994124
DATABASE_HOST=127.0.0.1
DATABASE_PORT=3306</code></pre>
<p>如果没有自动加载我们可以在<code>setting.py</code>模块顶部中加入如下代码</p>
<pre>
<code class="language-python">from dotenv import load_dotenv
load_dotenv('.env')</code></pre>
<h2>4.表的创建</h2>
<p>在完成了上面的准备工作之后就可以开始创建数据库表了。作为一个<code>CMS系统</code>，数据库的使用是必不可少的，在这里采用的<code>MySQL</code>数据库，当然你也可以使用其他的关心数据库，如<code>MariaDB</code>等。</p>
<p>在<code>bbs</code>目录下新建一个<code>models.py</code>模块，该模块主要是用来定义我们的数据库表模型用的，嵌入以下代码</p>
<p><strong>bbs/models.py</strong></p>
<pre>
<code class="language-python">class User(db.Model, UserMixin):
__tablename__ = 't_user'
id = db.Column(db.INTEGER, primary_key=True, nullable=False, index=True, autoincrement=True)
username = db.Column(db.String(40), nullable=False, index=True, unique=True, comment='user name')
nickname = db.Column(db.String(40), nullable=False, unique=True, comment='user nick name')
password = db.Column(db.String(256), comment='user password')
email = db.Column(db.String(128), unique=True, nullable=False, comment='user register email')
slogan = db.Column(db.String(40), default='')
website = db.Column(db.String(128), default='', comment="user's website")
location = db.Column(db.String(128), default='', comment='user location')
avatar = db.Column(db.String(100), nullable=False, comment='user avatar')
avatar_raw = db.Column(db.String(100), comment='use avatar raw file')
create_time = db.Column(db.DATETIME, default=datetime.datetime.now)
status_id = db.Column(db.INTEGER, db.ForeignKey('t_status.id'))
college_id = db.Column(db.INTEGER, db.ForeignKey('t_college.id'))
role_id = db.Column(db.INTEGER, db.ForeignKey('t_role.id'), default=3, comment='user role id default is 3 '
college = db.relationship('College', back_populates='user')
role = db.relationship('Role', back_populates='user')
status = db.relationship('Status', back_populates='user') 'that is student role')</code></pre>
<p>在上面代码中定义了一个User类，并且让它继承自<code>Model</code>、<code>UserMiXin</code>两个基类。之后在类中定义了一些参数，其中使用<code>db.Column</code>定义就是表的字段，使用<code>db.relationship</code>定义是表与表之间的关系。在有些字段中我们使用了db.Foreignkey，这表示该字段是一个外键。通过外键关系，可以保证数据唯一性与完整性。</p>
<p>在这种小项目中使用外键可以提高开发效率，但如果项目量级大，并且业务并发量大，就不要去使用外键这种数据库层面的逻辑维护，可以将数据完整性维护添加到业务代码中去。</p>
<blockquote class="m-blockquote">外键的字段命名没有明确的要求，因为使用的其他表的<code>主键id</code>作为外键进行连接，因此为了方便阅读，使用<code>表名_id</code>的形式进行命名，同时ForeignKey类传入参数为<code>表名.字段名</code>。模型类对应的表名由flask-sqlachemy自动生成，如果你在模型类中定义了__<em>tablename</em>__ 参数，则会使用该参数的值作为表名。</blockquote>
<p>在User表中，我们使用了三个外键，分别是status_id、college_id、role_id，因此需要新建Status、College、Role三个表模型，同时role跟permission又是外键关系，因此还需要创建permission模型，在models.py模块中嵌入如下代码</p>
<pre>
<code class="language-python">class College(db.Model):
__tablename__ = 't_college'
id = db.Column(db.INTEGER, primary_key=True, nullable=False, autoincrement=True, index=True)
name = db.Column(db.String(100), nullable=False)
create_time = db.Column(db.DATETIME, default=datetime.datetime.now)
user = db.relationship('User', back_populates='college', cascade='all')
class Role(db.Model):
__tablename__ = 't_role'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True, index=True)
name = db.Column(db.String(40), nullable=False)
permission_id = db.Column(db.INTEGER, db.ForeignKey('t_permission.id'), nullable=False)
user = db.relationship('User', back_populates='role', cascade='all')
permission = db.relationship('Permission', back_populates='role')
class Status(db.Model):
__tablename__ = 't_status'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True, index=True)
name = db.Column(db.String(40), nullable=False)
user = db.relationship('User', back_populates='status', cascade='all')
class Permission(db.Model):
__tablename__ = 't_permission'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True, index=True)
name = db.Column(db.String(40), nullable=False)
role = db.relationship('Role', back_populates='permission', cascade='all')</code></pre>
<p>定义db.relationship()关系属性有什么作用呢？通过下图来进行解释。</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://pic1.zhimg.com/80/v2-36a4d6f213b80651ba720551c4976d20_720w.jpg" style="width:375px" /></p>
<blockquote class="m-blockquote">一个角色可以对应多个用户，一个用户只能对应一个角色，我们在Role模型类中定义了user关系变量，在User模型类中定义了role关系变量。</blockquote>
<pre>
<code class="language-python">user = User.query.filter_by(id=1).first()
print(user.role.name)
role = Role.query.filter_by(id=1).first()
print(role.user)</code></pre>
<p>上面代码就解释了定义关系变量的作用，在一对多的关系中，在一端我们可以直接通过关系参数获取到对应多端的值，在多端关系参数返回是一个集合，在这个集合中我们可以获取到集合元素的所有值，大大的简化了我们工作。</p>
<h2>5.初始化基础数据</h2>
<p>完成了上述模型类的定义后，我们需要在数据库中建立我们的表。在__<em>init</em>__.py模块中加入下面的代码：</p>
<pre>
<code class="language-python">from bbs.models import *
from bbs.extensions import db
def create_app(config_name=None):
# 省略之前的代码
app.config.from_object(DevelopmentConfig)
register_extensions(app)
return app
def register_extensions(app: Flask):
db.init_app(app)</code></pre>
<p>在register_extensions()函数中初始化flask-sqlachemy,然后在工厂函数中进行注册调用。</p>
<blockquote class="m-blockquote">有关Flask的第三方拓展一般都是使用的extension.init_app(app)的方式进行初始化注册!</blockquote>
<p>接下来我们继续在__<em>init.py</em>__模块中添加下面的代码，用作初始化项目的必须基础数据。</p>
<pre>
<code class="language-python">def create_app(config_name=None):
# 省略已有代码
register_cmd(app)
return app
def register_cmd(app: Flask):
@app.cli.command()
def init():
click.confirm('这个操作会清空整个数据库,要继续吗?', abort=True)
db.drop_all()
click.echo('清空数据库完成!')
db.create_all()
init_status()
click.echo('初始化状态表完成!')
init_colleges()
click.echo('初始化学院表完成!')
init_permission()
click.echo('初始化权限表完成!')
init_role()
click.echo('初始化角色表完成!')
db.session.commit()
click.echo('数据库初始化完成!')
def init_status():
s1 = Status(name='正常')
db.session.add(s1)
s2 = Status(name='禁用')
db.session.add(s2)
db.session.commit()
def init_colleges():
colleges = ['计算机科学与技术学院', '信息与通信工程学院', '法学院', '外国语学院', '体育学院', '生命科学学院', '文学院']
for college in colleges:
c = College(name=college)
db.session.add(c)
db.session.commit()
def init_permission():
permissions = ['ALL', 'SOME', 'LITTLE']
for per in permissions:
p = Permission(name=per)
db.session.add(p)
db.session.commit()
def init_role():
roles = ['超级管理员', '老师', '学生']
r1 = Role(name=roles[0], permission_id=1)
r2 = Role(name=roles[1], permission_id=2)
r3 = Role(name=roles[2], permission_id=3)
db.session.add(r1)
db.session.add(r2)
db.session.add(r3)
db.session.commit()</code></pre>
<p>在上述代码中我们定义了一个<code>register_cmd(app)</code>函数，同时在工厂函数中调用了它。在register_cmd函数中，<strong>通过app.cli.command()装饰器可以将函数admin()注册为一个flask命令</strong>，在admin()函数中，做了数据库初始化的操作。</p>
<p>通过使用前面定义的模型类，实例化对应的模型类对象，然后通过db.session.add(instance)添加到数据库，最后通过db.session.commit()函数将修改提交到数据库中。</p>
<blockquote class="m-blockquote">在对数据库做了任何修改操作之后，我们都需要进行commit()操作!</blockquote>
<p>确保激活了虚拟环境，在终端输入如下命令，就可以进行数据库初始化操作，通过终端输出的信息，可以看到数据库初始化的进度。</p>
<pre>
<code class="language-bash">flask init</code></pre>
<h2>6. auth蓝图</h2>
<p>完成上述工作之后就可以开始用户注册功能开发了。用户注册、登录等操作都属于验证操作，可以将其放入同一个功能蓝图中去，在<code>bbs/blueprint</code>目录下新建<code>auth.py</code>模块，嵌入如下代码。</p>
<pre>
<code class="language-python">from flask import Blueprint
auth_bp = Blueprint('auth', __name__, url_prefix='/auth')</code></pre>
<blockquote class="m-blockquote">别忘了在创建新的蓝图之后需要到<strong>create_app()</strong>函数中去进行注册，否则路由会找不到对应的视图函数而抛出404错误!</blockquote>
<p>注册、登录部分的功能我打算分为两个章节来写，如果一个章节过长，就会导致读者失去耐心，因此，本章节的内容就到这里了。</p>
<p>教程中的资源文件可以进入我的github仓库下载源代码使用&nbsp;<a href="https://link.zhihu.com/?target=https%3A//github.com/weijiang1994/university-bbs" target="_blank">仓库连接</a></p>
<p>下一节，我们将继续进行用户注册、登录功能的实现啦，尽请期待啦~~~</p>
</content>
<link href="https://2dogz.cn/blog/article/22/" rel="alternate"/>
</entry>
<entry>
<id>21</id>
<title>[系列教程]使用Flask搭建一个校园论坛2-基本框架</title>
<updated>2023-09-27T02:08:19.928925+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>在上一节中，我们介绍了整个项目的起因、功能设计等，这节开始，我们就是真正开始写(chao)代码了~~</p>
<h1>1. 储备物资</h1>
<p>在阅读这个系列教程之前，我们需要在我们的脑海中储备以下知识:</p>
<ol>
<li>Python编程语言的基本语法</li>
<li>Flask框架的基本用法</li>
<li>Jinja2模板引擎基本使用</li>
<li>Python ORM框架</li>
<li>HTML JS CSS 简单的了解</li>
</ol>
<p>有了以上的基础知识，我们就可以很顺利的阅读这个系列的教程啦~</p>
<h1>2. 开始耕地</h1>
<p>很多人都称我们程序员为码农码农，那我们就开始种地吧~</p>
<h2>2.1 服务入口</h2>
<p>相信阅读过flask文档的朋友都知道flask包含有以下两种启动方式</p>
<ul>
<li>通过<span class="marker">python脚本</span>的方式运行
<pre>
<code class="language-python">from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Hello, flask!'
if __name__ == '__main__':
app.run()
</code></pre>
</li>
<li>通过<span class="marker">命令行</span>的方式<br />
使用该方式启动flask应用的时候，我们需要先在命令行窗口中输入如下命令：
<pre>
<code class="language-bash">export FLASK_APP=app</code></pre>
<blockquote class="m-blockquote">
<p>然后通过<span class="marker">flask run</span> 命令来启动应用。<br />
<br />
注意：Windows 用户请将export替换成set</p>
</blockquote>
</li>
</ul>
<p>在此教程中，我们采用第二种方式来进行应用启动，因为我们项目内容相对比较多，<span class="marker">都是CURD:)</span>，应用的不同功能都分布在不同的模块中，使用flask的<span class="marker">Blueprint</span>来分割每个功能模块。</p>
<p>在<span class="marker">bbs</span>目录下新建<span class="marker">__init__.py</span>文件，该模块为我们的应用启动入口，在里面嵌入如下代码</p>
<pre>
<code class="language-python">from flask import Flask
def create_app():
app = Flask('bbs')
@app.route('/')
def index():
return 'Hello, university bbs'
return app
</code></pre>
<p>然后在控制台中输入2.1节的命令，访问 http://127.0.0.1:5000，我们就可以看到如下页面了，说明我们的flask应用已经成功启动了。</p>
<p><img alt="2-1" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/27722-1.png" style="height:108px; width:238px" /></p>
<p>上面的代码，我们创建了一个名为<span class="marker">create_app </span>的函数，在该函数中我们实例化了一个<span class="marker">Flask对象</span>，然后通过装饰器的方式注册了一个<span class="marker">路由&#39;/&#39;</span>，最后将这个Flask对象返回。当我们使用命令启动flask应用的时候，这个函数就是我们的入口函数，这种方式我们称作为工厂模式。</p>
<h2>2.2 开启debug</h2>
<p>我们在开发过程中，肯定是修改代码之后就要立即调试，flask提供了debug模式，当我们开启debug的时候，我们修改完了代码，会auto reload 我们的应用，这样我们就不用每次修改了代码之后，手动去重新启动服务了，我们只需要在命令行中输入如下命令即可</p>
<pre>
<code class="language-bash">export FLASK_ENV=development</code></pre>
<h2>2.3 通用部分</h2>
<p>我们的网站大概长成下面这个样子</p>
<p><img alt="页面布局" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/1267%E9%A1%B5%E9%9D%A2%E5%B8%83%E5%B1%80.png" style="height:514px; width:663px" /></p>
<p>其中，页眉和页脚在我们每个页面中都会出现，这样我们就可以将其抽取出来变为一个公共部分，又jinja2提供模板继承的功能，我们可以在其他页面中继承这些通用部分的内容。<br />
在bbs/templates文件中我们新建一个<span class="marker">frontend</span>文件夹，然后新建一个名为<span class="marker">base.html</span>的文件，在该文件中嵌入以下内容：</p>
<p><strong>bbs/templates/frontend/base.html</strong></p>
<pre>
<code class="language-html">&lt;!DOCTYPE html&gt;
{% from "macro.html" import nav_item with context %}
&lt;!--suppress ALL --&gt;
&lt;html lang="zh-hans"&gt;
{% block head %}
&lt;head&gt;
&lt;meta charset="UTF-8"&gt;
&lt;title&gt;{% block title %}{% endblock %}-二狗学院&lt;/title&gt;
&lt;meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0"&gt;
&lt;link rel="shortcut icon" href="{{url_for('static', filename='img/favorite.png')}}" type="image/x-icon"&gt;
&lt;link rel="icon" href="{{ url_for('static', filename = 'img/favorite.png') }}" type="image/x-icon"&gt;
&lt;script src="https://cdn.jsdelivr.net/npm/jquery@3.5.1/dist/jquery.min.js"&gt;&lt;/script&gt;
&lt;script src="https://cdn.staticfile.org/popper.js/1.15.0/umd/popper.min.js"&gt;&lt;/script&gt;
&lt;link href="https://cdn.bootcss.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet"&gt;
&lt;link rel="stylesheet" href="{{ url_for('static', filename='themes/darkly.bootstrap.min.css'}}"&gt;
&lt;script src="{{ url_for('static', filename='validator/form-validation.js') }}"&gt;&lt;/script&gt;
&lt;script src="https://cdn.staticfile.org/twitter-bootstrap/4.3.1/js/bootstrap.min.js"&gt;&lt;/script&gt;
&lt;/head&gt;
{% endblock %}
{% block nav %}
&lt;nav class="navbar navbar-expand-lg navbar-dark bg-dark"&gt;
&lt;div class="container align-self-end"&gt;
&lt;a class="navbar-brand" href="/"&gt;&lt;i class="fa fa-bbs"&gt;&lt;/i&gt;狗子学院&lt;/a&gt;
&lt;button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navHome" aria-controls="navHome" aria-expanded="false" aria-label="Toggle navigation"&gt;
&lt;span class="navbar-toggler-icon"&gt;&lt;/span&gt;
&lt;/button&gt;
&lt;div class="collapse navbar-collapse" id="navHome"&gt;
&lt;ul class="navbar-nav mr-auto"&gt;
&lt;li class="nav-item dropdown mr-5"&gt;
&lt;a class="nav-link dropdown-toggle" href="#" id="talk" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;&lt;i class="fa fa-fire mr-1"&gt;&lt;/i&gt;大食堂&lt;/a&gt;
&lt;div class="dropdown-menu" aria-labelledby="talk"&gt;
&lt;a class="dropdown-item" href="#"&gt;杂谈&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;趣事&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;表白&lt;/a&gt;
&lt;/div&gt;
&lt;/li&gt;
&lt;li class="nav-item dropdown mr-5"&gt;
&lt;a class="nav-link dropdown-toggle" href="#" id="talk" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;&lt;i class="fa fa-shopping-cart mr-1"&gt;&lt;/i&gt;便利店&lt;/a&gt;
&lt;div class="dropdown-menu" aria-labelledby="talk"&gt;
&lt;a class="dropdown-item" href="#"&gt;寻物&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;咸鱼&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;活动&lt;/a&gt;
&lt;/div&gt;
&lt;/li&gt;
&lt;li class="nav-item dropdown mr-5"&gt;
&lt;a class="nav-link dropdown-toggle" href="#" id="talk" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"&gt;&lt;i class="fa fa-delicious mr-1"&gt;&lt;/i&gt;组织&lt;/a&gt;
&lt;div class="dropdown-menu" aria-labelledby="talk"&gt;
&lt;a class="dropdown-item" href="#"&gt;学院&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;社团&lt;/a&gt;
&lt;a class="dropdown-item" href="#"&gt;圈子&lt;/a&gt;
&lt;/div&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;form class="form-inline my-2 my-md-0"&gt;
&lt;input class="form-control" type="text" placeholder="请输入关键字" aria-label="Search" required&gt;
&lt;/form&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/nav&gt;
{% endblock %}
{% block content %}
{% endblock %}
{% block footer %}
&lt;footer class="container-fluid mt-4 py-0 bg-dark"&gt;
&lt;div class="card-body text-center px-0 f-14"&gt;
&lt;p class="card-text mb-1"&gt;Copyright&amp;nbsp;©&amp;nbsp;&lt;span&gt;2020&lt;/span&gt;
&lt;a href="http://2dogz.cn/" target="_blank" title="官网"&gt;University BBS&lt;/a&gt;&amp;nbsp;Design&amp;nbsp;by&amp;nbsp;Flask1.01.
&lt;/p&gt;
&lt;/div&gt;
&lt;/footer&gt;
{% endblock %}
{% block script %}
&lt;script&gt;
$(function () {
$('[data-toggle="tooltip"]').tooltip()
})
&lt;/script&gt;
{% endblock %}
&lt;/html&gt;</code></pre>
<p>代码释义:</p>
<p>我们在base.html 文件中写了几个<code><span class="marker">block</span></code>块定义，分别是<span class="marker">head</span>、<span class="marker">nav</span>、<span class="marker">title</span>、<span class="marker">content</span>、<span class="marker">footer</span>以及<span class="marker">script</span>。分别用来定义我们的html文件的<span class="marker">引用</span>、<span class="marker">导航栏</span>、<span class="marker">标题</span>、<span class="marker">内容</span>、<span class="marker">页脚</span>以及<span class="marker">js代码块</span>。通过<span class="marker">{% block name&nbsp;%}</span>，当我们的子模板继承自<span class="marker">base.html</span>模板的时候，我们子模板可以重写这个<span class="marker">block</span>的定义，当然也可以使用<span class="marker">{{ super()&nbsp;}}</span>函数来继承父模板的定义，然后自己定义新的内容。</p>
<ul>
<li>在head中引用了项目需要引入的框架，比如jQuery、bootstrap4等；</li>
<li>在nav中我们使用bootstrap的导航栏组件轻松完成了顶部导航栏的构建</li>
</ul>
<h2>2.4 主页</h2>
<p>我们写完了页面的通用部分之后，就可以在主页中继承该模板了。在<span class="marker">bbs/templates/frontend/</span>文件夹中新建<span class="marker">index.html</span>文件，并嵌入下面的代码</p>
<p><strong>bbs/templates/frontend/index.html</strong></p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% from "macro.html" import post_item, render_pagination with context%}
{% block title %}
主页
{% endblock %}
{% block content %}
&lt;main&gt;
&lt;div class="container mt-2"&gt;
&lt;/div&gt;
&lt;/main&gt;
{% endblock %}</code></pre>
<p>我使用extends关键字继承了基模板base.html，然后在content块中写了我们自己需要定义的内容。</p>
<p>在完成了我们主页模板代码之后，我们就需要通过路由将它渲染出来，并显示在用户的网页中。</p>
<p>在bbs目录下新建一个<span class="marker">blueprint</span>包，并新增模块<span class="marker">index.py</span>, 在其中嵌入如下代码</p>
<p><strong>bbs/blueprint/index.py</strong></p>
<pre>
<code class="language-python">from flask import Blueprint, render_template
index_bp = Blueprint('index_bp', __name__)
@index_bp.route('/')
@index_bp.route('/index/')
def index():
return render_template('frontend/index.html')
</code></pre>
<p>首先我们实例化了一个Blueprint对象，然后通过该对象注册了两个路由&#39;/&#39; 、&#39;/index/&#39;，并将这两个路由指向视图函数index，在index函数中，我们将我们之前创建的主页文件渲染，然后返回给客户端。</p>
<p>我们在这里注册一个同样的路由，因此我们需要删除__init__.py模块中的index视图函数,同时我们在新建blueprint之后，需要将该蓝图进行注册，__init__.py最新代码如下</p>
<pre>
<code class="language-python">from flask import Flask
from bbs.blueprint.index import index_bp
def create_app():
app = Flask('bbs')
register_bp(app)
return app
def register_bp(app: Flask):
app.register_blueprint(index_bp)</code></pre>
<p>此时，我们访问http://127.0.0.1:5000看到的将是如下页面</p>
<p><img alt="主页" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/4527%E4%B8%BB%E9%A1%B5.png" /></p>
<h2>2.5 错误处理</h2>
<p>我们在访问网页的时候，经常会出现404,、500这种错误代码。如果我们使用flask提供的默认错误页面，是下面这种样子，如果用户不小心访问到了，将会一头雾水，不知所措，因此我们需要将特定错误页面进行处理，在用户进入错误页面之后，能对其有效的指引。</p>
<p><img alt="404" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2012404.png" /></p>
<p>flask提供了<span class="marker">errorhandle</span>装饰器，能让我们很轻松的处理请求错误。在<span class="marker">__init__.py</span>模块中添加新的代码</p>
<p><strong>bbs/__init__.py</strong></p>
<pre>
<code class="language-python">def create_app(config_name=None):.
...
register_error_handlers(app)
def register_error_handlers(app: Flask):
@app.errorhandler(400)
def bad_request(e):
return render_template('error/400.html'), 400
@app.errorhandler(403)
def forbidden(e):
return render_template('error/403.html'), 403
@app.errorhandler(404)
def not_found(e):
return render_template('error/404.html'), 404
@app.errorhandler(500)
def server_error(e):
return render_template('error/500.html'), 500</code></pre>
<p>在<span class="marker">register_error_handlers</span>函数中，我们分别将对应的错误渲染了对应的错误模板了，因此当用户访问出错的时，页面显示的就是我们自己自定义的错误页面样式了。</p>
<p>在<span class="marker">bbs/templates/error/</span>目录中新建对应的模板文件，由于内容一致，这里只展示404页面的代码</p>
<p><strong>bss/templates/error/404.html</strong></p>
<pre>
<code class="language-html">{% extends "frontend/base.html" %}
{% block title %}
页面未找到
{% endblock %}
{% block content %}
&lt;main&gt;
&lt;div class="container mt-2"&gt;
&lt;div class="card-body"&gt;
&lt;div class="card text-white bg-dark mb-3"&gt;
&lt;div class="card-body"&gt;
&lt;img src="{{ url_for('static', filename='img/404.png') }}" class="img-fluid d-block mx-auto"&gt;
&lt;/div&gt;
&lt;div class="card-footer text-right"&gt;
&lt;a class="btn btn-outline-danger" href="/"&gt;返回主页&lt;/a&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/main&gt;
{% endblock %}</code></pre>
<p>代码跟<span class="marker">index.html</span>类似，聪明的你应该看得懂，就不做多余的解释了。<br />
然后我们输入一个未定义的路由，404页面就是下面你这个样子啦~~~</p>
<p><img alt="404-2" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/8521404.png" /></p>
<p>至此，本节的内容就已经全部做完啦~是不是很简单啊~</p>
<p>教程中的资源文件可以进入我的github仓库下载源代码使用 <a href="https://github.com/weijiang1994/university-bbs">仓库连接</a></p>
<p>下一节，我们将开始进行用户注册登录功能的实现啦，尽请期待啦~~~</p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/21/" rel="alternate"/>
</entry>
<entry>
<id>20</id>
<title>[系列教程]使用Flask搭建一个校园论坛1-项目初始化</title>
<updated>2023-09-27T02:08:19.928897+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>Flask&middot;缘起</h1>
<p>在上家公司的时候，一次偶然的机会上级让我使用<code>webpy</code>框架开发一个网页版的计算工具，具体设计到一些控制算法的计算。当时没有接触过web开发的项目。在那之前都是使用PyQt5去做一些桌面应用程序的开发。</p>
<p>一开始搜索<code>webpy</code>的资料的时候，发现资料十分的匮乏，然后还惊奇的发现该框架的作者已经逝世了(震惊且惋惜)。然后搜索其他的开发框架，就这样我发现<code>Flask</code>这个轻量级web框架了。</p>
<h1>整一个教程</h1>
<p>使用Flask也有一年多的时间，看了很多书籍教程，让我最受益匪浅的是李辉出版本的那本web开发教程。在此期间也遇到了很多问题，作为<code>CCCV</code>型的程序员的我，那<code>某D某G</code>是必须会的。然后我也使用Flask搭建一个<a href="http://2dogz.cn">个人博客网站</a>，很多我在开发过程中遇到的问题都记录在里面了。</p>
<p>虽然也写了一些博客，但是终归没有一个系列的教程，就这一直想着出一个系列的教程。一来可以学习到一些新知识或者巩固旧知识，二来可以锻炼自己的写作叙事水平以及逻辑思维能力。正当我思考着用什么作为这篇系列教程的基础时，想到了一句话，<code>遇事不决，先来一个CMS~</code>！于是乎，我就打算已<code>bbs</code>来作为本系列教程内容了!</p>
<h1>借(chao)鉴(xi)</h1>
<p>现在网络上有很多形形色色的论坛，论坛的功能也大有不同，在这里我们选择借鉴<a href="https://www.v2ex.com">v2ex</a>以及<a href="http://www.hupu.com">hupu</a>的功能以及大致页面布局方式。</p>
<h1>画图纸</h1>
<p>经过<code>深思熟虑</code>之后，大致功能如下：<img alt="功能设计" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/728image-20201214123814927.png" /></p>
<h1>搭建项目开发环境</h1>
<p>本项目采用的<span class="marker"><code>Python3.6+Flask1.1.2+Bootstrap4.5</code></span>进行开发的。</p>
<p>找一个你想要存放代码的地方新建一个名为<span class="marker"><code>university-bbs</code></span>的文件夹，当然名字你也可以按照你自己的想法来取，然后在根目录执行如下命令</p>
<pre>
<code class="language-bash">python3 -m venv venv</code></pre>
<p>这时候我们的本地虚拟环境就创建完成了,然后我们使用如下命令激活虚拟环境。</p>
<pre>
<code class="language-bash">source venv/bin/activate</code></pre>
<blockquote class="m-blockquote">
<p><strong>为什么要创建虚拟环境?</strong></p>
<p>因为Python的版本非常的多，而且每个第三方的库的版本也十分的多。我们A项目可能依赖的环境是foo 1.x版本，而B项目依赖的环境是foo 3.x版本，那么我们如果让A/B两个项目同事使用一个全局环境，那么肯定是行不通的。这时候我们就可以对每个项目创建一个虚拟环境来运行，各自项目对应运行在各自的虚拟环境中，互不冲突。</p>
<p>Python社区繁荣昌盛，我们的包管理工具非常的多。比如pipenv、virtualenv、poetry等等。感兴趣的可以去了解一下，特别是poetry，当下十分流行。在本项目中我们使用Python3内置的venv模块以及pip来管理虚拟环境以及包。</p>
</blockquote>
<h1>项目组织架构</h1>
<p>在开发Flask应用时，虽然我们可以在一个文件中写完所有的功能，但是当我们的项目越来越大，代码量越来越多的时候，这样的方式我们就很难管理了。合适的项目组织架构可以使我们更加好的管理代码，并且层次条理十分清晰，本项目的组织如下：</p>
<p><img alt="项目组织架构" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/5424image-20201214141801191.png" style="height:356px; width:163px" /></p>
<p>我们可以在我们项目的根目录中按照上图的组织架构，新建好对应的文件夹。</p>
<ul>
<li>
<p>bbs</p>
<p>项目代码存放目录</p>
<ul>
<li>
<p>blueprint</p>
<p>存放蓝图模块包</p>
<ul>
<li>
<p>frontend</p>
<p>前端蓝图</p>
</li>
<li>
<p>backend</p>
<p>后端管理界面蓝图</p>
</li>
</ul>
</li>
<li>
<p>static</p>
<p>静态文件存放目录，主要是用来存放css、js还有一些静态资源的目录</p>
</li>
<li>
<p>templates</p>
<p>存放html文件目录</p>
<ul>
<li>
<p>frontend</p>
<p>前端html文件</p>
</li>
<li>
<p>backend</p>
<p>后端html文件</p>
</li>
</ul>
</li>
</ul>
</li>
<li>
<p>resources</p>
<p>存放用户资源文件</p>
<ul>
<li>
<p>avatars</p>
<p>存放用户头像</p>
</li>
<li>
<p>images</p>
<p>用户上传的图片，包括帖子、评论等</p>
</li>
</ul>
</li>
</ul>
<p>至此，本项目前期的准备工作都已做完了，下一节开始，我们就开始真正的开发流程了。</p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/20/" rel="alternate"/>
</entry>
<entry>
<id>19</id>
<title>[应用部署]子域名部署多个应用</title>
<updated>2023-09-27T02:08:19.928869+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>添加子域名解析</h1>
<p>首先，我们得有一台云服务器，我购买的是鹅肠的云服务器。我们登录到云服务器的控制台，进入dns解析页面，点击添加记录，并按照下面的方式输入。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/1779%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_32.png" /></p>
<ul>
<li>主机记录中填入你要访问的子域名我这里填写的是<code><span class="marker">dnfliar</span></code></li>
<li>记录类型选择 <code><span class="marker">A类型</span></code></li>
<li>线路选择 <code><span class="marker">默认 </span></code></li>
<li>记录值 &#39;你的云服务器的外网IP地址&#39;</li>
</ul>
<p>填写完成之后点击保存，过一会儿我们就可以通过如下命令测试子域名是否生效</p>
<pre>
<code class="language-bash">ping 你的子域名</code></pre>
<p>如果成功，则说明生效了。</p>
<h1>配置nginx</h1>
<p>登录我们的云服务器，输入如下命令配置ngxin</p>
<pre>
<code class="language-bash">sudo vim /etc/nginx/site-avaliables/default</code></pre>
<p>在末尾新增如下内容</p>
<pre>
<code class="language-nginx">server{
listen 80;
server_name dnfliar.2dogz.cn; # 你映射的子域名
access_log /var/log/nginx/access.log; # 访问记录日志
error_log /var/log/nginx/error.log; # 错误记录日志
location / {
proxy_pass http://127.0.0.1:8001; # 映射的本地端口
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real_IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /static {
alias /home/ubuntu/dnf-liar/dnf/static/; # 静态文件缓存
expires 30d;
}
}
</code></pre>
<p>保存退出，然后输入如下命令测试ngxin配置文件是否出错</p>
<pre>
<code class="language-bash">sudo nginx -t</code></pre>
<p>如果没有出错则表示配置成功了。</p>
<h1>使用supervisor管理应用</h1>
<p>当我们有多个应用程序的时候，我们可以使用supervisor来管理。可以参考我这一篇博客 <a href="http://2dogz.cn/blog/article/3/">supervisor使用</a></p>
<p>使用下面的命令配置supervisor</p>
<pre>
<code class="language-bash">sudo vim /etc/supervisor/conf.d/blog.conf</code></pre>
<p>上述命令中最后的配置文件名跟你实际定义的一致，不一定是命令上的文件名，在文件末尾添加如下内容。</p>
<pre>
<code class="language-bash">[program:flask-blog-owner]
command=/home/ubuntu/supervisor/dnf.sh
directory=/home/ubuntu/dnfliar/dnf
user=root
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true</code></pre>
<p>最后，我们重启nginx、supervisor即可了。</p>
<pre>
<code class="language-bash">sudo service nginx restart
sudo service supervisor restart</code></pre>
<p>之后就可以通过子域名访问你的网站了。</p>
<p><s>dnf骗子汇总: <a href="http://dnfliar.2dogz.cn">http://dnfliar.2dogz.cn</a></s></p>
<p>我的博客网站: <a href="http://2dogz.cn">https://2dogz.cn</a></p>
<blockquote class="m-blockquote">
<p>有时候可能执行了上述的操作后，达不到效果，可以从以下三个方面去处理</p>
<ol>
<li>大部分浏览器都有缓存机制，我们可以清理一下缓存，然后重新尝试访问；</li>
<li>很多DNS服务器的生效时间是10分钟，如果没有效果，我们可以多等待一会儿；</li>
<li>看看是否忘记重启Nginx了，可以通过 sudo nginx -s reload 或者 service nginx restart 或者 systemctl restart nginx 如果没有效果就先stop然后start！</li>
</ol>
</blockquote>
</content>
<link href="https://2dogz.cn/blog/article/19/" rel="alternate"/>
</entry>
<entry>
<id>17</id>
<title>[陈词滥调]打工人的全勤奖没啦~</title>
<updated>2023-09-27T02:08:19.928840+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>2020年7月初，我顶着烈日，从深圳的公司辞职了。</p>
<p>当初校招的时候，我连自己未来在哪里发展都没有想好，就稀里糊涂的来到了深圳。来到深圳之后，也就随遇而安了，拿着不高的薪水，干着不算太累的活，工作日过着三点一线的生活<code>狗窝-&gt;地铁站-&gt;公司-&gt;地铁站-&gt;狗窝</code>，周末就一个人宅在狗窝里打游戏，看电视，简单而有趣。慢慢的，我觉得这样的日越来越没有趣了。这时候就有打算回老家工作了，期间还旧情复燃，跟前女友复合了，由于深圳的房价遥不可及，这就更加催使我回老家工作了。</p>
<p>幸运的是，很快就有人联系我，我也对其职位以及公司比较感兴趣，然后开始一系列的面试流程，所幸的是最后被成功录用了。然后就在深圳这边的公司提交了离职流程。辞呈提交之后，当然少不了领导的<code>画饼</code>，这时候的我已经去意已决了，饼再大我也无动于衷了。最后还是在约定的日期离职了，这里也要感谢老东家的同事领导，毕竟人生的第一份工作，学到的东西也不少。</p>
<p>离职之后的日子没有你们说的那么轻松，离职之后的轻松是你们想象不到的！</p>
<p>我再也不用每天7点起床只为了了能在人少的时候挤进固戍地铁F口;</p>
<p>我再也不用为了第二天的工作而提心吊胆与恐惧了；</p>
<p>我再也不用为了...</p>
<p>之后约了女朋友跟老友去珠海玩了一趟，从深圳坐船过去，第一次坐在大海(哈哈，其实也算不上是大海吧，在深圳湾里面~)里航行的船只，整个人都不好了，不过还好没有ou!</p>
<p>到达珠海的那天晚上，在珠海工作的老友带我们去了情侣路、爱琴湾溜达了一圈。徐徐的海风吹在身上，即使是热辣的七月，还让人感觉到丝丝的凉意。远远的望过去，还可以看到雄伟的港珠澳大桥!</p>
<p><img alt="珠港澳大桥" class="d-block img-fluid mx-auto" src="http://2dogz.cn/gallery/2020-10-13/l1%E7%8F%A0%E6%B8%AF%E6%BE%B3%E5%A4%A7%E6%A1%A5.jpg" /></p>
<p>后来我们去长隆溜达了一圈，确实是个好玩的地方，第一次坐过山车，吓死我了。起初上去的时候，我觉得并没有啥，然后上去了，我感觉我的叫声比后排的妹子还大，问题是女朋友确若无其事的，哈哈哈~</p>
</content>
<link href="https://2dogz.cn/blog/article/17/" rel="alternate"/>
</entry>
<entry>
<id>16</id>
<title>[Python]使用flask-apscheduler控制定时任务遇到的问题</title>
<updated>2023-09-27T02:08:19.928813+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>定时任务不启动的问题</h1>
<p>在我使用flask-apscheluder进行测试的时候，我发现定时任务不会启动，我的应用采用的启动方式是命令行模式，同时使用的是工厂方法去创建实例。但是在我使用<code>flask run</code>来启动了应用，定时任务并没有定时执行。</p>
<p>我运行flask-aspscheduler文档中的示例代码的时候，定时任务会按照我设定的值进行启动，为什么我使用<code>flask run</code>去启动的时候，不按照我预设的值去执行定时任务呢？</p>
<p>经过一番摸索之后，我发现需要将当前启动环境设置为<code>production</code>模式，即生产模式。如果你使用的.flaskenv文件去配置的话，可以将<code>FLASK_ENV</code>参数设置为<code>production</code>&nbsp;。</p>
<pre>
<code class="language-ini">FLASK_ENV=production</code></pre>
<p>如果你使用的<code>export</code>的方式</p>
<pre>
<code class="language-ini">export FLASK_ENV=production</code></pre>
<p>再次运行，定时任务成功启动了。这个不知道是bug还是什么问题，没有细看flask-aspscheluder的文档。</p>
<h1>在定时任务中进行数据库操作</h1>
<p>我原本的目的就是想在定时任务中执行数据库操作，在每天的零点零五分在数据库中插入一条数据。一开始没有仔细看官方给的示例，死活使用不了，后来看了官方的示例文档，发现如果要操作数据库，需要通过如下方式执行</p>
<pre>
<code class="language-python">@aps.task('cron', id='do_job_3', day='*', hour='00', minute='00', second='50')
def auto_insert_data():
"""
定时任务,每天00:00:50时刻自动向数据库中插入一条数据,如果数据库中存在了则不作任何动作
"""
with db.app.app_context():
date = datetime.date.today()
contribute = Contribute.query.filter_by(date=date).first()
visit = VisitStatistics.query.filter_by(date=date).first()
lk = LikeStatistics.query.filter_by(date=date).first()
com = CommentStatistics.query.filter_by(date=date).first()
if not contribute:
con = Contribute(contribute_counts=0, date=date)
db.session.add(con)
if not visit:
vis = VisitStatistics(date=date, times=0)
db.session.add(vis)
if not lk:
like = LikeStatistics(date=date, times=0)
db.session.add(like)
if not com:
comm = CommentStatistics(date=date, times=0)
db.session.add(comm)
db.session.commit()</code></pre>
<h1>使用gunicorn多进程部署问题</h1>
<p>当我在开发环境中测试通过时，我把更新过后的代码推送到服务器上去了。第二天发现了问题，同时在数据库中插入了六条数据。一时半会想不明白是什么原因，然后google了一会儿，很多人也遇到过同样的问题，<strong>大致意思就是gunicorn开启的进程个数有多个少个，就会启动多少个定时任务。</strong>我的gunicorn开了六个进程，所以启动了六个定时任务，向数据库中插入了六条数据。</p>
<p><strong>解决办法</strong></p>
<pre>
<code class="language-python"># __init__.py 文件
def scheduler_init(app):
"""
保证系统只启动一次定时任务
:param app: 当前flask实例
:return: None
"""
if platform.system() != 'Windows':
fcntl = __import__("fcntl")
f = open(basedir+'/scheduler.lock', 'wb')
try:
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
aps.init_app(app)
aps.start()
app.logger.debug('Scheduler Started,---------------')
except:
pass
def unlock():
fcntl.flock(f, fcntl.LOCK_UN)
f.close()
atexit.register(unlock)
else:
msvcrt = __import__('msvcrt')
f = open(basedir+'scheduler.lock', 'wb')
try:
msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1)
aps.init_app(app)
aps.start()
app.logger.debug('Scheduler Started,----------------')
except:
pass
def _unlock_file():
try:
f.seek(0)
msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
except:
pass
atexit.register(_unlock_file)</code></pre>
<p>在你的工厂函数中调用该方法，就可以避免同时启动多个定时任务啦!</p>
</content>
<link href="https://2dogz.cn/blog/article/16/" rel="alternate"/>
</entry>
<entry>
<id>15</id>
<title>[Linux]在Linux系统下安装使用微信(非网页版)</title>
<updated>2023-09-27T02:08:19.928786+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>什么是Wine</h1>
<p>Wine （&ldquo;Wine Is Not an Emulator&rdquo; 的首字母缩写）是一个能够在多种 POSIX-compliant 操作系统（诸如 Linux，macOS 及 BSD 等）上运行 Windows 应用的兼容层。Wine 不是像虚拟机或者模拟器一样模仿内部的 Windows 逻辑，而是將 Windows API 调用翻译成为动态的 POSIX 调用，免除了性能和其他一些行为的内存占用，让你能够干净地集合 Windows 应用到你的桌面。</p>
<h1>安装deepin wine</h1>
<p>deepin wine应该是深度公司根据wine进行改写可以友好的运行国内的一些软件产品比如微信、QQ等，在Linux系统之上。(水平有限，这段话可能有误!)</p>
<p>首先克隆gitee仓库中的完整代码，在终端中输入如下命令</p>
<pre>
<code class="language-bash">git clone https://gitee.com/wszqkzqk/deepin-wine-for-ubuntu.git</code></pre>
<p>进入项目的根目录中，执行如下命令</p>
<pre>
<code class="language-bash">sudo ./install.sh</code></pre>
<p>等待安装完成，然后在控制台中输入<span class="marker">deepin wine --version</span>&nbsp; 如果出现版本号的话，则表示安装成功了。</p>
<h1>安装微信</h1>
<p>点击链接下载微信deb包 <a href="https://gitee.com/wszqkzqk/deepin-wine-containers-for-ubuntu/raw/master/deepin.com.wechat_2.6.8.65deepin0_i386.deb">微信下载地址</a> ，下载完成之后，进入文件所在目录，使用如下命令进行微信安装。</p>
<pre>
<code class="language-bash">sudo dpkg -i deepin.com.wechat_2.6.8.65deepin0_i386.deb </code></pre>
<p>等待安装完成，你就可以在自己电脑的软件库看到微信程序了，点击它就会打开微信了，如下图。</p>
<p><img alt="login" class="d-block img-fluid mx-auto pic" src="/backend/files/4416%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_27.png" /></p>
<p>第一次使用是扫描二维码的图片，使用自己的手机微信扫描一下登录即可。</p>
<h1>问题</h1>
<h2>1. 图片问题</h2>
<p>登录微信的时候不显示我个人图像，同时我在聊天框中发送图片，也发送不出去。在终端中输入如下命令就可以解决这个问题了。</p>
<pre>
<code class="language-bash">sudo apt-get install libjpeg62:i386</code></pre>
<h2>2.中文乱码问题</h2>
<p>在使用中文输入法的时候，输入框显示的文字是乱码黑条，但是发送出去的是正确的文本，我们可以使用如下步骤进行解决这个问题。</p>
<p>先百度一下下载一个<span class="marker">微软雅黑</span>的字体，解压。其他的也可以，但是需要支持中文字体。</p>
<blockquote class="m-blockquote">
<p><strong><em>注意这里的<code><span class="marker"> msyh.tcc </span></code>是根据你自己的字体名称来确定的</em></strong></p>
</blockquote>
<ul>
<li>添加字体
<ul>
<li>拷贝字体到指定目录下</li>
<li>
<pre>
<code class="language-bash">cp msyh.ttc ~/.deepinwine/Deepin-WeChat/drive_c/windows/Fonts</code></pre>
</li>
</ul>
</li>
</ul>
<ul>
<li>
<p>修改注册表</p>
<ul>
<li>
<p>使用任意一个可视化编辑器打开指定目录下的文件</p>
</li>
<li>
<pre>
<code class="language-bash">gedit ~/.deepinwine/Deepin-WeChat/system.reg
#修改以下两行
"MS Shell Dlg"="msyh"
"MS Shell Dlg 2"="msyh"</code></pre>
</li>
</ul>
</li>
<li>新建字体注册文件
<ul>
<li>新建一个.reg文件，并在文件中输入如下内容</li>
<li>
<pre>
<code class="language-bash">gedit msyh_config.reg
#内容添加
REGEDIT4
[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink]
"Lucida Sans Unicode"="msyh.ttc"
"Microsoft Sans Serif"="msyh.ttc"
"MS Sans Serif"="msyh.ttc"
"Tahoma"="msyh.ttc"
"Tahoma Bold"="msyhbd.ttc"
"msyh"="msyh.ttc"
"Arial"="msyh.ttc"
"Arial Black"="msyh.ttc"</code></pre>
</li>
</ul>
</li>
<li>注册字体
<ul>
<li>打开终端输入如下代码注册字体</li>
<li>
<pre>
<code class="language-bash">WINEPREFIX=~/.deepinwine/Deepin-WeChat deepin-wine regedit msyh_config.reg</code></pre>
</li>
<li>重启微信</li>
</ul>
</li>
</ul>
<p>再次开启微信，在输入框中输入中文就不会是乱码啦!</p>
<p><img alt="test" class="d-block img-fluid mx-auto pic" src="/backend/files/3503%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_28.png" /></p>
<p>这样我们就可以愉快的在Linux中使用微信了啊!</p>
</content>
<link href="https://2dogz.cn/blog/article/15/" rel="alternate"/>
</entry>
<entry>
<id>14</id>
<title>[Python]使用Python内置模块共享文件</title>
<updated>2023-09-27T02:08:19.928759+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>Python -m</h1>
<p>在叙述如何使用Python内置模块在局域网内部传输文件之前，我们需要先了解到<code><span class="marker">-m</span></code>的用法。打开终端，我们可以在终端中输入<code><span class="marker">python --help</span></code> 我们可以看到如下的内容</p>
<p><img alt="python --help" class="d-block img-fluid mx-auto" src="/backend/files/6543%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_23.png" /></p>
<p>我们可以看到上面的话翻译过来，意思就是<span class="marker">把库模块当做一个脚本来运行</span>。</p>
<p>对于&ldquo;python -m name&rdquo;，一句话解释：<strong>Python 会检索<code>sys.path</code> ，查找名字为&ldquo;name&rdquo;的模块或者包（含命名空间包），并将其内容当成&ldquo;__main__&rdquo;模块来执行。</strong> 这里没办法解释的非常清楚，有时间我好好去研究一下，重新写一篇博客来解释。</p>
<h1>一行命令开启一个http服务</h1>
<p>首先进入我们需要共享文件的目录，打开终端，然后输入如下命令</p>
<pre>
<code class="language-bash">python3 -m http.server 6000</code></pre>
<p>出现如下图所示的画面，则说明开启成功。</p>
<p><img alt="run server" class="d-block img-fluid mx-auto" src="/backend/files/6592%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_24.png" /></p>
<p>此时，你在浏览器中打开<span class="marker">http://&lt;你主机的IP地址&gt;:6000</span>, 可以看到你当前目录的文件都被显示在web页面里了，如下图所示。</p>
<p><img alt="service" class="d-block img-fluid mx-auto" src="/backend/files/7258page-server.png" /></p>
<p>在同一个局域网中的主机，就可以进入这个页面进行文件下载啦。</p>
</content>
<link href="https://2dogz.cn/blog/article/14/" rel="alternate"/>
</entry>
<entry>
<id>13</id>
<title>[Python]使用flask-apscheduler控制定时任务</title>
<updated>2023-09-27T02:08:19.928731+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>Flask-APScheduler介绍</h1>
<p>Flask-APScheduler是基于APScheduler库开发的Flask拓展库。APScheduler的全称是Advanced Python Scheduler。允许您将Python代码安排为稍后执行，可以只执行一次，也可以定期执行。您可以随时添加新作业或删除旧作业。如果您将作业存储在数据库中，那么调度程序重启后它们也将存活下来并保持其状态。当调度器重新启动时，它将运行它在离线时应该运行的所有作业，<a href="https://apscheduler.readthedocs.io/en/latest/index.html">APScheduler文档</a>。</p>
<p>社区的强大性，让我们在使用flask的时候可以很方便的调用APScheduler库，我们可以通过flask-apscheduler来调用APScheduler库。进入你的pyhton虚拟环境，安装flask-apscheduler库</p>
<pre>
<code class="language-bash">pip install flask-apscheduler</code></pre>
<p>顺利的话，我们可以使用这个第三方库了。</p>
<h1>使用flask配置启动定时任务</h1>
<p>APSchedule可以使用很多方式进行启动任务，比如interval，或者cron等等，下面就分别介绍一下这两种方式启动任务。</p>
<h2>interval间隔时间执行</h2>
<p>我们可以通过配置如下参数来每间隔多少时间来启动任务</p>
<blockquote class="m-blockquote">
<p>JOBS = [<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;id&#39;: &#39;job1&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;func&#39;: &#39;scheduler:task&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;args&#39;: (1, 2),<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;trigger&#39;: &#39;interval&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;seconds&#39;: 10<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />
&nbsp;&nbsp;&nbsp; ]</p>
</blockquote>
<p>其中<code><span class="marker">func</span></code>表示你要启动的函数，<code><span class="marker">trigger</span></code>表示触发方式，这里使用的<code><span class="marker">interval</span></code>表示间隔触发，<code><span class="marker">second</span></code>表示间隔的时间长短。</p>
<p>我们可以通过flask配置启动定时任务，栗子如下</p>
<pre>
<code class="language-python">"""
# coding:utf-8
@Time : 2020/11/19
@Author : jiangwei
@mail : jiangwei1@kylinos.cn
@File : scheduler.py
@Software: PyCharm
"""
from flask import Flask
import datetime
from flask_apscheduler import APScheduler
aps = APScheduler()
class Config(object):
JOBS = [
{
'id': 'job1',
'func': 'scheduler:task',
'args': (1, 2),
'trigger': 'interval',
'seconds': 10
}
]
SCHEDULER_API_ENABLED = True
def task(a, b):
print(str(datetime.datetime.now()) + ' execute task ' + '{}+{}={}'.format(a, b, a + b))
if __name__ == '__main__':
app = Flask(__name__)
app.config.from_object(Config())
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
app.run(port=8000)
</code></pre>
<p>上述代码中，<strong><code>通过APScheduler每间隔10秒钟执行一次task函数。</code></strong></p>
<p>输出结果如下图，我们可以看到每隔10s中执行了一次函数。</p>
<p><img alt="interval-10s" class="d-block img-fluid mx-auto" src="/backend/files/937interval-10s.png" /></p>
<p>上面的例子中，将需要执行的函数定义在该文件内部，如果我们的函数定义在其他文件中，可以通过导包的方式引用。比如下面的栗子， <code><span class="marker">task.py</span></code>位于当前文件的上一层目录中</p>
<pre>
<code class="language-python"># task.py
def task_1(a, b):
print(a+b)</code></pre>
<p>那么我们可以如下定义JOBS</p>
<blockquote class="m-blockquote">
<p>JOBS = [<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;id&#39;: &#39;job1&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;func&#39;: &#39;.task:task_1&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;args&#39;: (1, 2),<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;trigger&#39;: &#39;interval&#39;,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &#39;seconds&#39;: 10<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }<br />
&nbsp;&nbsp;&nbsp; ]</p>
</blockquote>
<h2>cron启动任务</h2>
<p>crontab是Linux中定时任务启动程序，我们可以通过配置crontab的配置文件来定时启动任务。在APScheduler中也可以通过cron的形式来定时启动任务。下载的例子来说明配置方式</p>
<pre>
<code class="language-python">from flask import Flask
import datetime
from flask_apscheduler import APScheduler
aps = APScheduler()
class Config(object):
JOBS = [
{
'id': 'job1',
'func': 'scheduler:task',
'args': (1, 2),
'trigger': 'cron',
'day': '*',
'hour': '13',
'minute': '16',
'second': '20'
}
]
SCHEDULER_API_ENABLED = True
def task(a, b):
print(str(datetime.datetime.now()) + ' execute task ' + '{}+{}={}'.format(a, b, a + b))
if __name__ == '__main__':
app = Flask(__name__)
app.config.from_object(Config())
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
app.run(port=8000)
</code></pre>
<p>上述的代码表示，在<em><strong>每天的13:16:20秒</strong></em>启动<code><span class="marker">task()</span></code>函数。其实看配置就能理解意思，一目了然，其中*代表任意的意思。上述代码运行输出如下</p>
<p><img alt="cron-day" class="d-block img-fluid mx-auto" src="/backend/files/1768cron-day.png" /></p>
<h1>使用装饰器定时启动任务</h1>
<p>除了上面通过配置的方式来启动定时任务外，我们还可以使用装饰器的方式来定时启动任务。例子如下所示</p>
<pre>
<code class="language-python">from flask import Flask
from flask_apscheduler import APScheduler
import datetime
class Config(object):
SCHEDULER_API_ENABLED = True
scheduler = APScheduler()
# interval examples
@scheduler.task('interval', id='do_job_1', seconds=30, misfire_grace_time=900)
def job1():
print(str(datetime.datetime.now()) + ' Job 1 executed')
# cron examples
@scheduler.task('cron', id='do_job_2', minute='*')
def job2():
print(str(datetime.datetime.now()) + ' Job 2 executed')
@scheduler.task('cron', id='do_job_3', week='*', day_of_week='sun')
def job3():
print(str(datetime.datetime.now()) + ' Job 3 executed')
@scheduler.task('cron', id='do_job_3', day='*', hour='13', minute='26', second='05')
def job4():
print(str(datetime.datetime.now()) + ' Job 4 executed')
if __name__ == '__main__':
app = Flask(__name__)
app.config.from_object(Config())
# it is also possible to enable the API directly
# scheduler.api_enabled = True
scheduler.init_app(app)
scheduler.start()
app.run(port=8000)
</code></pre>
<p>上述代码的含义如下:</p>
<ol>
<li>job1: 每间隔30s执行一次函数</li>
<li>job2: 每分钟执行一次函数</li>
<li>job3: 每周的星期天执行一次函数</li>
<li>job4: 每天的13:26:05时刻执行一次函数</li>
</ol>
<p>代码输出:</p>
<p><img alt="decrator-aps" class="d-block img-fluid mx-auto" src="/backend/files/5810decrator-aps.png" /></p>
<p>上面就是APScheduler的一些简单用法啦，抽空根据应用场景写一下实用的应用方法。</p>
</content>
<link href="https://2dogz.cn/blog/article/13/" rel="alternate"/>
</entry>
<entry>
<id>12</id>
<title>[Python]记psutil.Process类使用注意事项</title>
<updated>2023-09-27T02:08:19.928701+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>安装psutil模块</h1>
<p>进入你想要安装的Python环境，输入如下命令进行模块安装</p>
<pre>
<code class="language-bash">pip install psutil</code></pre>
<p>如果顺利，那么接下来你就可以使用<span class="marker">psutil</span>模块了。</p>
<h1>问题review</h1>
<p>最近在写一个CI的平台项目，项目的大体要求就是把一些平时需要在终端使用命令行方式的操作，提供一个可视化的web界面，在界面上填写相关信息，点击按钮就可以完成本地命令行的操作。</p>
<p>我采用的策略是通过SSH的方式去连接客户机，然后通过SSH方式去控制客户机的命令行操作。当然其中还涉及到很多技术以及细节，在这里不累述了。</p>
<p>在项目中我使用到了<span class="marker">websocket</span>来使客户端与服务端进行长连接，实现服务端主动推送消息到客户端上。当客户端离开当前页面，服务端的socketio就会自动触发<span class="marker">disconnect</span>事件，在<span class="marker">disconnect</span>事件中我做了如下处理。</p>
<p><strong>存在bug的代码:</strong></p>
<pre>
<code class="language-python">@socketio.on('disconnect', namespace='/manager')
def pty_disconnect():
try:
child_process = psutil.Process(session.get(current_user.username).get('child_pid'))
except psutil.NoSuchProcess as err:
disconnect()
session[current_user.username] = {}
return
if child_process.status() in ('running', 'sleeping'):
child_process.terminate()
session[current_user.username] = {}
print('client disconnect, session clear')
socketio.emit('pty-output', {"output": 'Web Socket连接已断开,请刷新页面重新连接!'}, namespace="/manager")</code></pre>
<p>上述代码描述的就是当客户端断开连接之后，服务端会自动销毁该客户端的子进程，并且清楚保存在服务端的session信息。</p>
<p>一开始的时候，代码运作都很正常，当有一次，我点击了进入了这个页面，然后没做任何操作，转到了另外一个页面中去了，然后我的程序自动终止了。</p>
<p>进入该页面时候，客户端就已经连接到了服务端，因此在客户端退出的时候服务端就会自动触发disconnect事件，然后执行上述代码逻辑。我盘查了一下上述代码的逻辑，我我没有发现哪里存在着不妥当的地方。那为什么我进入页面什么都不做，退出页面的时候，我的整个进程就自动被终止了呢？？</p>
<h1>问题排查</h1>
<p>于是乎，<strong>我祭出bug排除神器 <span class="marker"><em>print()闪亮登场~~~~~ </em></span><em>大家赶紧撒花!!!!</em></strong></p>
<p><strong>加入了print()后的代码如下</strong></p>
<pre>
<code class="language-python">@socketio.on('disconnect', namespace='/manager')
def pty_disconnect():
try:
child_process = psutil.Process(session.get(current_user.username).get('child_pid'))
print('child process is ', child_process)
print('session child process is ', session.get(current_user.username).get('child_pid'))
except psutil.NoSuchProcess as err:
disconnect()
session[current_user.username] = {}
return
if child_process.status() in ('running', 'sleeping'):
child_process.terminate()
session[current_user.username] = {}
print('client disconnect, session clear')
socketio.emit('pty-output', {"output": 'Web Socket连接已断开,请刷新页面重新连接!'}, namespace="/manager")</code></pre>
<p>&nbsp;代码结果输出如下</p>
<blockquote class="m-blockquote">
<p>child process is psutil.Process(pid=15405, name=&#39;python&#39;, status=&#39;running&#39;, started=&#39;16:08:12&#39;)</p>
<p>session child process is None</p>
</blockquote>
<p>session存在的为<code><span class="marker">None</span></code>，这是正确的，但是通过<code><span class="marker">psutil.Process()</span></code> 获取到的居然是我当前程序运行的pid，那就知道了为什么当前程序会自动终止了，因为<code><span class="marker">terminate()</span></code>函数终止了我们的主进程。</p>
<h1>测试</h1>
<p>于是乎，我做了如下的测试。</p>
<p>打开一个终端输入如下代码</p>
<pre>
<code class="language-python">import psutil
import os
os.getpid()
# 24980
psutil.Process(None)
# psutil.Process(pid=24980, name='python', status='running', started='16:44:47')</code></pre>
<p>发现当我们在<code><span class="marker">Process()</span></code>函数中传入None时，就会获取到我们当前主进程的相关信息，这尼玛也太坑了ba~~~ 我不知道这要设计的用意?</p>
<p><img alt="process1" class="d-block img-fluid mx-auto" src="/backend/files/3522psutil-process1.png" /></p>
<p>然后我们在终端中调用<code><span class="marker">terminate()</span></code>方法，结果如下。</p>
<p><img alt="process finish" class="d-block img-fluid mx-auto" src="/backend/files/3124process-finish.png" /></p>
<p>我们可以清楚的看到<em> </em><s><em>Process finished with exit code 143.</em></s></p>
<h1>问题解决</h1>
<p>修改了一下代码逻辑，然后这个bug就消失殆尽啦!</p>
<pre>
<code class="language-python">@socketio.on('disconnect', namespace='/manager')
def pty_disconnect():
try:
child_id = session.get(current_user.username).get('child_pid')
if child_id is not None:
child_process = psutil.Process(session.get(current_user.username).get('child_pid'))
except psutil.NoSuchProcess as err:
disconnect()
session[current_user.username] = {}
return
if child_process.status() in ('running', 'sleeping'):
child_process.terminate()
session[current_user.username] = {}
print('client disconnect, session clear')
socketio.emit('pty-output', {"output": 'Web Socket连接已断开,请刷新页面重新连接!'}, namespace="/manager")</code></pre>
<p><strong><em>Note:</em></strong></p>
<p>我要去看看psutil的文档中有没有说明这个问题，如果没有那么我切不是可以给psutil做个contribution~~~hhhh</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/12/" rel="alternate"/>
</entry>
<entry>
<id>11</id>
<title>[Git]git不常用操作记录(1)</title>
<updated>2023-09-27T02:08:19.928673+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>删除远程仓库中的文件或文件夹</h1>
<p>相信很多人都犯过一个错误，那就是很多信息不应该提交到git仓库中去的，而忘记在<span class="marker"><code>.gitignore</code></span>文件中添加了。比如数据库连接配置文件、隐私文件(第三方Secret)等。不管是公司内容部的gitlab平台，还是github平台，泄露出去都不太好。</p>
<h2>1.删除github中的文件</h2>
<p>在<span class="marker">github</span>中我们好像是没有在网页端找到删除文件的入口(不知道是不是我没找到?如果有请评论区告诉我一下!!xx)，我们可以通过如下命令来删除github上的文件。</p>
<pre>
<code class="language-bash">git rm --cache privacy.inf
git add --al
git commit -m 'delete private file'
git push</code></pre>
<h2>2.删除github中的文件夹</h2>
<p>上一节的命令只是删除单个文件，如果我们需要删除文件夹怎么办呢？很简单加一个 <span class="marker">-r</span>参数即可。</p>
<p><strong>没有删除之前的git仓库</strong></p>
<p><img alt="git repo before" class="d-block img-fluid mx-auto pic" src="/backend/files/3483%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_17.png" /></p>
<pre>
<code class="language-bash">git rm -r --cache .idea/
git add --al
git commit -m 'remove .idea folder'
git push</code></pre>
<p><strong>删除之后的github仓库</strong></p>
<p><img alt="git after" class="d-block img-fluid mx-auto pic" src="/backend/files/5271%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_18.png" /></p>
<h1>忽略本地的修改记录</h1>
<p>有时候我们在使用git pull命令的时候，会出现报错。大概的意思就是你本地有新的修改，请先push然后再更新。</p>
<h2>1.通过合并来覆盖本地修改</h2>
<pre>
<code class="language-bash">git reset --hard
git pull</code></pre>
<p>如果有未跟踪的本地文件，可以使用<code>git clean</code>来移除。通过使用<code>git clean -f</code>来移除未跟踪的文件，<code>-df</code>来删除未跟踪的文件和目录，<code>-xdf</code>来要删除未跟踪或忽略的文件或目录。</p>
<h2>2.隐藏合并</h2>
<p>如果想以某种方式保留本地修改，你可以在pull之前把他们隐藏起来，之后再重新应用</p>
<pre>
<code class="language-bash">git stash
git pull
git stash pop</code></pre>
<h1>同步主仓库</h1>
<p>在公司开发的项目中，经常很多小伙伴一起开发一个项目，然后该项目有一个主仓库(生产环境代码)，每个小伙伴会将主仓库的代码fork到自己的私人仓库中，然后修改、更新提交新的内容，然后提交merge请求将新代码合并到主仓库中。与此同时，我们也需要将主仓库中最新的代码同步到到我们本地仓库中去，我们可以使用如下方式进行。</p>
<ol>
<li>查看本地远程仓库分支
<pre>
<code class="language-bash">git remote -v</code></pre>
</li>
<li>添加主仓库连接
<pre>
<code class="language-bash">git remote add upstream http://gitlab.repository.com/it/reponame.git</code></pre>
<p>upstream 后面的参数就是你主仓库git的连接可以是https方式的也可以是ssh方式的，推荐ssh方式，因为这样我们同步的时候就不需要输入用户名跟密码了。</p>
</li>
<li>
<p>fetch主仓库代码</p>
<pre>
<code class="language-bash">git fetch upstream</code></pre>
</li>
<li>切换分支
<pre>
<code class="language-bash">git checkout master</code></pre>
</li>
<li>merge
<pre>
<code class="language-bash">git merge upstream/master</code></pre>
</li>
<li>私人远程仓库同步
<pre>
<code class="language-bash">git push origin master</code></pre>
<p>&nbsp;</p>
</li>
</ol>
<h1>配置不同的用户名、邮箱</h1>
<p>使用过git工具的都知道使用下面的命令配置本机的git用户名跟邮箱</p>
<pre>
<code class="language-bash">git config --global user.name="username"
git config --global user.email="youemail@gmail.com"</code></pre>
<p>上面的配置仅仅是配置当前本机全局的设置，如果我们有些项目需要使用其他的用户名、邮箱提交我们可以通过下面的步骤来进行配置</p>
<p>首先进入目标项目文件夹中，可以查看到文件夹中有.git隐藏文件夹，进入文件夹我们可以通过<code>cat config</code>查看当前git配置的内容</p>
<pre>
<code class="language-ini">[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[remote "origin"]
url = https://github.com/weijiang1994/university-bbs
fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
remote = origin
merge = refs/heads/main</code></pre>
<p>在这个config文件中我们可以查看到项目远程仓库地址、分支等内容，我们将我们的目标用户名跟邮箱配置在这个配置文件里面后，在每次push该项目的时候使用的就是config中的用户名、邮箱信息了。</p>
<pre>
<code class="language-bash">git config user.name "username"
git config user.email "useremail"</code></pre>
<p>再次通过<span class="marker">cat config</span>查看</p>
<pre>
<code class="language-ini">[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[remote "origin"]
url = https://github.com/weijiang1994/university-bbs
fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
remote = origin
merge = refs/heads/main
[user]
name = weijiang1994
email = 804022023@qq.com</code></pre>
<p>之后我们推送这个项目的时候使用的用户名就是config中的配置信息了</p>
</content>
<link href="https://2dogz.cn/blog/article/11/" rel="alternate"/>
</entry>
<entry>
<id>10</id>
<title>[Python]*args与**kwargs的含义</title>
<updated>2023-09-27T02:08:19.928645+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>我观察到，大部分新的Python程序员都需要花上大量时间理解清楚 <code>*args</code> 和<code>**kwargs</code>这两个魔法变量。那么它们到底是什么?</p>
<p>其实，并不是一定需要将他们下城<code>*args</code>和<code>**kwargs</code>。只有它们前面的<em><strong>*(星号)</strong></em>是必须的，你可以写成*var和**vars，那为什么大家都写成<code>*args</code>和<code>**kwargs</code>呢？那只是一个约定俗成的命名。</p>
<h1>*args的用法</h1>
<p><code>*args</code>主要是在函数定义的时候使用的，如果你的函数中使用了<code>*args</code>这个参数，那么你就可以穿无穷多个参数给定义的函数。举个栗子</p>
<pre>
<code class="language-python">def test_var_args(f_arg, *argv):
print("first normal arg:", f_arg)
for arg in argv:
print("another arg through *argv:", arg)
test_var_args('yasoob', 'python', 'eggs', 'test')</code></pre>
<p>输出结果如下:&nbsp;</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">first normal arg: yasoob<br />
another arg through *argv: python<br />
another arg through *argv: eggs<br />
another arg through *argv: test</div>
<p>我们再来看一个栗子</p>
<pre>
<code class="language-python">def test_args(*args):
ret = 0
for i in args:
ret += i
return ret
sums = test_args(1, 2, 3, 4, 5)
print(sums)
</code></pre>
<p>&nbsp;输出结果如下：</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">15</div>
<p>&nbsp;希望这两个例子解决了你的疑惑，接下来我们看看**kwargs这个参数</p>
<h1>**kwargs的用法</h1>
<p><code>**kwargs</code> 允许你将不定长度的<strong>键值对</strong>, 作为参数传递给一个函数。 如果你想要在一个函数里处理<strong>带名字的参数</strong>, 你应该使用<code>**kwargs</code>。</p>
<p>举一个例子</p>
<pre>
<code class="language-python">def greet_me(**kwargs):
for key, value in kwargs.items():
print("{0} == {1}".format(key, value))
&gt;&gt;&gt; greet_me(name="yasoob")
name == yasoob</code></pre>
<p>现在你可以看出我们怎样在一个函数里, 处理了一个<strong>键值对</strong>参数了。</p>
<p>这就是<code>**kwargs</code>的基础, 而且你可以看出它有多么管用。 接下来让我们谈谈，你怎样使用<code>*args</code> 和 <code>**kwargs</code>来调用一个参数为列表或者字典的函数。</p>
<h1>使用 args 和 *kwargs 来调用函数</h1>
<p>那现在我们将看到怎样使用<code>*args</code>和<code>**kwargs</code> 来调用一个函数。 假设，你有这样一个小函数：</p>
<pre>
<code class="language-python">def test_args_kwargs(arg1, arg2, arg3):
print("arg1:", arg1)
print("arg2:", arg2)
print("arg3:", arg3)</code></pre>
<p>你可以使用<code>*args</code>或<code>**kwargs</code>来给这个小函数传递参数。 下面是怎样做：</p>
<pre>
<code class="language-python"># 首先使用 *args
&gt;&gt;&gt; args = ("two", 3, 5)
&gt;&gt;&gt; test_args_kwargs(*args)
arg1: two
arg2: 3
arg3: 5
# 现在使用 **kwargs:
&gt;&gt;&gt; kwargs = {"arg3": 3, "arg2": "two", "arg1": 5}
&gt;&gt;&gt; test_args_kwargs(**kwargs)
arg1: 5
arg2: two
arg3: 3</code></pre>
<h1>使用时的顺序</h1>
<p>如果你想在函数中同事使用这三种参数，他们的顺序是这样的</p>
<pre>
<code class="language-python">some_func(fargs, *args, **kwargs)</code></pre>
<h1>啥时候使用它们</h1>
<p>这还真的要看你的需求而定。最常见的用例是在写函数装饰器的时候。</p>
<p>此外它也可以用来做猴子补丁(monkey patching)。猴子补丁的意思是在程序运行时(runtime)修改某些代码。 打个比方，你有一个类，里面有个叫<code>get_info</code>的函数会调用一个API并返回相应的数据。如果我们想测试它，可以把API调用替换成一些测试数据。例如：</p>
<pre>
<code class="language-python">import someclass
def get_info(self, *args):
return "Test data"
someclass.get_info = get_info</code></pre>
<h1>在装饰器中使用它们</h1>
<p>我们之前讲过一点点装饰器的内容，现在我们来看看如何在装饰器中使用这两个参数</p>
<p>首先我们定义一个装饰器函数</p>
<pre>
<code class="language-python">import time
def run_time(func):
def wrap():
st = time.time()
result = func()
print('{} function running spend time is {}'.format(func.__name__, time.time() - st))
return result
return wrap</code></pre>
<p>老生常谈，上面定义了一个计算方法运行时间的装饰器。</p>
<p>然后写两个函数并装饰一下。</p>
<pre>
<code class="language-python">@run_time
def test1():
time.sleep(3)
@run_time
def test2():
time.sleep(4)</code></pre>
<p>输出结果如下所示L：&nbsp;</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">test1 function running spend time is 3.0014431476593018<br />
test2 function running spend time is 4.002828359603882</div>
<p>在这里有一个问题，因为我写的两个函数都是不带参数的，但是如果带参数呢。</p>
<pre>
<code class="language-python">@run_time
def test1(a):
print('{} function input parameter is {}'.format(__name__, a))
time.sleep(3)
@run_time
def test2(a):
print('{} function input parameter is {}'.format(__name__, a))
time.sleep(4)
test1(12)
test2(31)</code></pre>
<p>这时候再去装饰函数就会报如下错误</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/1507%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_13.png" />&nbsp;</p>
<p>这是因为我们在装饰函数中没有带参数，这时候我们修改一下装饰器函数如下</p>
<pre>
<code class="language-python">def run_time(func):
def wrap(a):
st = time.time()
result = func(a)
print('{} function running spend time is {}'.format(func.__name__, time.time() - st))
return result
return wrap</code></pre>
<p>再次运行，输出结果如下所示</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">test1 function input parameter is 12<br />
test1 function running spend time is 3.0007827281951904<br />
test2 function input parameter is 31<br />
test2 function running spend time is 4.002350568771362</div>
<p>虽然解决了我们上面的问题，但是如果我需要再定义一个函数，代码如下</p>
<pre>
<code class="language-python">@run_time
def test3(a, b):
print('{}+{}={}'.format(a, b, a + b))
time.sleep(1)</code></pre>
<p>&nbsp;这时候我们在运行代码，会出现如下报错，这是因为我们test3函数有两个参数了，装饰器函数传递的参数不够，所以出现报错了。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/1071%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_14.png" /></p>
<p>这时候，我们的*args与**kwargs就派上用场了。我们将装饰器函数修改为如下</p>
<pre>
<code class="language-python">def run_time(func):
def wrap(*args, **kwargs):
st = time.time()
result = func(*args, **kwargs)
print('{} function running spend time is {}'.format(func.__name__, time.time() - st))
return result
return wrap</code></pre>
<p>再次运行，我们就可以得到正确的结果了。这时，不管你装饰的函数参数有多么的变化，都可以使用这个装饰器来进行装饰。</p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
<pre>
test1 function input parameter is 12
test1 function running spend time is 3.0029850006103516
test2 function input parameter is 31
test2 function running spend time is 4.002876043319702
12+23=35
test3 function running spend time is 1.0011005401611328</pre>
</div>
</content>
<link href="https://2dogz.cn/blog/article/10/" rel="alternate"/>
</entry>
<entry>
<id>9</id>
<title>[Python]flask可插拔视图学习</title>
<updated>2023-09-27T02:08:19.928617+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><p>我们在写flask程序的时候，我们用得最多的是通过视图函数去处理每个请求。也就是说一个视图函数对应一个请求路由或者多个请求路由。比如下面的写法</p>
<pre>
<code class="language-python">from flask import Flask
app = Flask(__name__)
@app.route('/')
@app.route('/index/')
def index():
return 'Hello, welcome to Home page!'</code></pre>
<p>上面的视图函数对应了两个请求url，在flask中我们一般使用这种方法来处理请求。</p>
<h1>可插拔视图</h1>
<p>从Flask0.7版本开始，引入了 可插拔视图，其灵感是来自于Django的通用视图。</p>
<p>与视图函数不同的是，可插拔视图是通过类去实现的，因此我们将它叫做为类视图。我们可以通过自定义类视图，在类中完成对应请求处理。</p>
<h2>1. 继承自<code>flask.views.View</code>&nbsp; 类视图</h2>
<p>加入我们需要在数据库中查询一些数据然后把它们的结果渲染到模板上，你可能会使用如下的写法</p>
<pre>
<code class="language-python">@app.route('/user/get-all/')
def index():
users = User.query.all()
return render_template('uer-list.html', users=users)</code></pre>
<p>上例简单而灵活。但是如果要把这个视图变成一个可以用于其他模型和模板的通用视图， 那么这个视图还是不够灵活。因此，我们就需要引入可插拨的、基于类的视图。第一步， 可以把它转换为一个基础视图:</p>
<pre>
<code class="language-python">from flask.views import View
from flask import Flask
app = Flask(__name__)
class ShowUsers(View):
def dispatch_request(self):
users = User.query.all()
return render_template('users.html', objects=users)
app.add_url_rule('/users/', view_func=ShowUsers.as_view('show_users'))</code></pre>
<p>我们创建的<code>ShowUsers</code>类继承自<code>View</code>类，同时在其中写了一个<code>dispatch_request</code>&nbsp;方法。注意，如果继承自<code>View</code>类，则该方法必须在在子类中实现，否则会报错。</p>
<p>之后我们通过as_view 方法将其转换为一个视图函数。并且通过<code>add_url_rule</code> 方法设置其路由规则。传递给函数的字符串就是最终视图的名称，但是这本身没有什么帮助，我们可以重构一下代码</p>
<pre>
<code class="language-python">from flask.views import View
class ListView(View):
def get_template_name(self):
raise NotImplementedError()
def render_template(self, context):
return render_template(self.get_template_name(), **context)
def dispatch_request(self):
context = {'objects': self.get_objects()}
return self.render_template(context)
class UserView(ListView):
def get_template_name(self):
return 'users.html'
def get_objects(self):
return User.query.all()</code></pre>
<p>我们定义了一个继承自flask.views.View的基类，在这个基类中，我们定义了三个方法 其中&nbsp;<code>get_template_name </code>是子类必须实现的方法。我们在子类UserView中实现它并返回了一个模板文件，同时在子类中我们定义了获取数据的方法get_objects 用于返回数据库中查找数据的结果。</p>
<p>这时类视图的优雅指出就体现出来了。当我们需要获取User的数据的时候，我们自定义UserView然后继承自ListView就可以了，当我们需要获取另外一个对象的数据的时候比如Product，这时候我们定义一个ProductView继承自ListView就可以返回不同的模板以及数据了。</p>
<h2>2. 继承自<code>flask.views.MethodView</code> 类视图</h2>
<p>在互联网的世界中，我们知道存在着很多中请求方式，最常见的POST、GET等，我们可以能会经常写下面这种代码根据请求的方式不同，在视图函数中处理不同的逻辑。</p>
<pre>
<code class="language-python">@app.route('/index/', methods=['GET', 'POST'])
def index():
if request.methods == 'GET':
# do something
return 'get request response'
if request.methods == 'POST':
# do something
return 'post request response'</code></pre>
<p>对于 REST 式的 API 来说，为每种 HTTP 方法提供相对应的不同函数显得尤为有用。使用&nbsp;<a href="https://dormousehole.readthedocs.io/en/latest/api.html#flask.views.MethodView">flask.views.MethodView</a>&nbsp;可以轻易做到这点。在这个类中，每个 HTTP 方法 都映射到一个同名函数（函数名称为小写字母）:</p>
<pre>
<code class="language-python">from flask.views import MethodView
class UserAPI(MethodView):
def get(self):
users = User.query.all()
...
def post(self):
user = User.from_form_data(request.form)
...
app.add_url_rule('/users/', view_func=UserAPI.as_view('users'))</code></pre>
<p>在集成自MethodView的类视图中，我们不必提供&nbsp;<a href="https://dormousehole.readthedocs.io/en/latest/api.html#flask.views.View.methods"><code>methods</code></a>&nbsp;属性，它会自动使用相应 的类方法。</p>
<h1>举个栗子</h1>
<pre>
<code class="language-python">from flask import views, render_template, Flask
class User(views.MethodView):
def get(self, user_id=None):
if user_id is None:
return '返回所有用户'
return '返回单个用户,用户id为{}'.format(user_id)
def post(self):
return '创建一个用户'
def delete(self, user_id):
return '删除了一个用户，用户id为{}'.format(user_id)
from flask import Flask
app = Flask(__name__)
view_func = User.as_view('user')
app.add_url_rule('/user/&lt;int:user_id&gt;/', view_func=view_func, methods=['GET', 'DELETE'])
app.add_url_rule('/user/', view_func=view_func, methods=['GET'])
app.add_url_rule('/user/add/', view_func=view_func, methods=['POST'])
print(app.url_map)
if __name__ == '__main__':
app.run()
</code></pre>
<p>在上述代码中，我们定义了一个User类视图，继承自MethodView类，在其中定义了get、post、delete三个方法。接下来我们对类视图做了url配置，运行该程序在浏览器中输入对应的url，我们可以看到结果。</p>
<p>输入<a href="http://127.0.0.1:5000/user/">http://127.0.0.1:5000/user/</a></p>
<p><img alt="user" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9072%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_10.png" /></p>
<p>输入<a href="http://127.0.0.1:5000/user/1/">http://127.0.0.1:5000/user/1/</a></p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/2084%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_11.png" style="height:152px; width:282px" /></p>
<h1>总结</h1>
<ul>
<li>基于类的视图，能够比较优雅的方式实现很多复杂的不同功能</li>
<li>类视图定义请求方法，需要加类属性：methods = [&#39;GET&#39;]</li>
<li>类视图用装饰器时，不能在类和类方法上直接装饰，因为我们要装饰的是视图函数（也就是最后执行的是调度类函数），View类中帮我们定义了一个增加装饰器的方法，定义类属性 decorators = [装饰器函数名]</li>
</ul>
</content>
<link href="https://2dogz.cn/blog/article/9/" rel="alternate"/>
</entry>
<entry>
<id>7</id>
<title>[Linux]使用crontab定时备份数据库</title>
<updated>2023-09-27T02:08:19.928588+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>crontab介绍</h1>
<p>我们经常使用的是crontab命令是cron table的简写，它是cron的配置文件，也可以叫它作业列表，我们可以在以下文件夹内找到相关配置文件。</p>
<ul>
<li><span class="marker">/var/spool/cron/</span> 目录下存放的是每个用户包括root的crontab任务，每个任务以创建者的名字命名</li>
<li><span class="marker">/etc/crontab</span> 这个文件负责调度各种管理和维护任务。</li>
<li><span class="marker">/etc/cron.d/</span> 这个目录用来存放任何要执行的crontab文件或脚本。</li>
<li>我们还可以把脚本放在<span class="marker">/etc/cron.hourly</span>、<span class="marker">/etc/cron.daily</span>、<span class="marker">/etc/cron.weekly</span>、<span class="marker">/etc/cron.monthly</span>目录中，让它每小时/天/星期、月执行一次。</li>
</ul>
<h1>&nbsp;crontab使用</h1>
<p>输入下面的命令会创建一个以当前用户运行的新cron任务。</p>
<pre>
<code class="language-bash">crontab -e</code></pre>
<p>如果你想要以其他用户运行cron任务，输入下面的命令。</p>
<pre>
<code class="language-bash">sudo crontab -u -e</code></pre>
<p>根据屏幕提示输入数字1-5中的一个，将会出现下面的文本。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/5704%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_8.png" /></p>
<p>每个cron任务的格式如下。</p>
<pre>
<code class="language-bash">&lt; 分钟&gt; &lt; 小时&gt; &lt; 日&gt; &lt; 月&gt; &lt; 星期&gt; &lt; 命令&gt;</code></pre>
<p>下图比较清晰明了</p>
<p><img class="d-block img-fluid mx-auto pic" src="https://2dogz.cn/backend/files/9709image.png" style="height:351px; width:468px" /></p>
<p>crontab的命令构成为 时间+动作，其时间有<strong>分、时、日、月、周</strong>五种，操作符有</p>
<ul>
<li><em><strong>*</strong>&nbsp;取值范围内的所有数字</em></li>
<li><em><strong>/</strong>&nbsp;每过多少个数字</em></li>
<li><em><strong>-</strong>&nbsp;从X到Z</em></li>
<li><em><strong>，</strong>散列数字</em></li>
</ul>
<h1>举几个栗子</h1>
<ul>
<li>每一分钟执行一次命令
<ul>
<li>
<pre>
<code class="language-bash">* * * * * cd /home/</code></pre>
</li>
</ul>
</li>
<li>每天凌晨2点10分钟执行重启命令
<ul>
<li>
<pre>
<code class="language-bash">10 02 * * * reboot</code></pre>
</li>
</ul>
</li>
<li>每隔两天执行一次重启命令
<ul>
<li>
<pre>
<code class="language-bash">* * */2 * * reboot</code></pre>
</li>
</ul>
</li>
</ul>
<h1>定时备份数据库文件</h1>
<p>有了上述的基础我们就可以自己写一个shell脚本来每天定时备份数据库数据了，shell脚本内容如下。</p>
<pre>
<code class="language-bash">#!/bin/bash
date_str=$(date "+%Y-%m-%d")
pwd="123"
echo $date_str
cd /home/ubuntu/data-backup
mysqldump -h localhost -u root --password=$pwd -R -E -e \blog&gt; /home/ubuntu/data-backup/$date_str.sql
</code></pre>
<p>上面代码就是备份数据库的shell脚本，具体的信息根据个人信息进行更改。</p>
<p>然后我们将其将入到crontab中去，这样我们就可以每天定时备份数据库数据，可以最小减少数据损失。</p>
</content>
<link href="https://2dogz.cn/blog/article/7/" rel="alternate"/>
</entry>
<entry>
<id>6</id>
<title>[Python]使用redis存储用户密码修改验证码</title>
<updated>2023-09-27T02:08:19.928559+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>redis是什么</h1>
<p><code>REmote DIctionary Server(Redis)</code> 是一个由Salvatore Sanfilippo写的key-value存储系统。</p>
<p>Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。</p>
<p>它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Hash), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。</p>
<p>详细关于redis的介绍可以去看这里:<a href="https://www.runoob.com/redis/redis-tutorial.html">https://www.runoob.com/redis/redis-tutorial.html</a></p>
<h1>Python使用redis</h1>
<h2>安装 redis 模块</h2>
<p>在python中，如果需要操作redis，那么需要先安装相应的第三方模块，在这里我使用的是<code>python-redis</code>,可以使用下面的命令进行安装。</p>
<pre>
<code class="language-bash">pip install python-redis</code></pre>
<p>测试是否安装成功</p>
<pre>
<code class="language-bash">&gt;&gt;&gt;python
&gt;&gt;&gt;import redis</code></pre>
<p>如果没有报错，则说明redis安装成功。</p>
<h1>简单的python操作redis</h1>
<p>redis 提供两个类 <span class="marker">Redis</span> 和 <span class="marker">StrictRedis</span>, StrictRedis 用于实现大部分官方的<span class="marker">命令</span>，Redis 是 StrictRedis 的<span class="marker">子类</span>，用于向后兼用旧版本。</p>
<p>redis 取出的结果默认是字节，我们可以设定&nbsp;decode_responses=True&nbsp;改成字符串。</p>
<pre>
<code class="language-python">import redis
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
r.set('name', 'runoob') # 设置 name 对应的值
print(r['name'])
print(r.get('name')) # 取出键 name 对应的值
print(type(r.get('name'))) # 查看类型</code></pre>
<p>输入结果:</p>
<blockquote class="m-blockquote">
<pre>
runoob
runoob
&lt;class &#39;str&#39;&gt;
</pre>
</blockquote>
<h1>使用redis存储、验证验证码</h1>
<p>有了上述的先行知识，我们就可以使用redis存储验证码，进行相关的业务逻辑操作了。用户重置密码的流程如下图所示。</p>
<p><img alt="重置密码流程" class="d-block img-fluid mx-auto" src="/backend/files/5564%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_7.png" /></p>
<h2>使用redis存储验证码</h2>
<p>在用户开始了密码重置操作，我们需要将验证码发送到用户的注册邮箱中，此时，redis也应该保存该验证码，并且设置一个过期时间，操作此段时间后，验证码就失效了。代码如下所示:</p>
<pre>
<code class="language-python"># extension.py
import redis
# 使用连接池的方式连接，提高系统性能
pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
rd = redis.Redis(connection_pool=pool)
# auth.py
@auth_bp.route('/password-reset/', methods=['GET', 'POST'])
def reset_password():
email = request.form.get('email')
user = User.query.filter_by(email=email).first()
if not user:
flash('邮箱不存在,请输入正确的邮箱!', 'danger')
return redirect(url_for('.forget_pwd'))
ver_code = generate_ver_code()
# 将验证码设置到redis中,过期时间为10分钟
rd.set(user.id, ver_code, ex=current_app.config['EXPIRE_TIME'])
token = generate_token(user=user, operation=Operations.RESET_PASSWORD)
send_reset_password_email(user=user, token=token, ver_code=ver_code)
flash('验证邮件发送成功，请到邮箱查看然后重置密码!', 'success')
return render_template('main/auth/pwdResetNext.html')
</code></pre>
<h2>使用redis验证验证码</h2>
<p>在完成上面的操作之后，用户的邮箱会收到一个邮件，里面包含有重置密码的连接以及验证码。之后我们就可以使用redis来验证验证码了，代码如下。</p>
<pre>
<code class="language-python">@auth_bp.route('/reset-confirm/', methods=['POST', 'GET'])
def reset_confirm():
if current_user.is_authenticated:
return redirect(url_for('.login'))
form = ResetPwdForm()
if form.validate_on_submit():
email = form.email.data
usr = User.query.filter_by(email=email).first()
# 如果输入的邮箱不存在
if not usr:
flash('邮箱不存在，请输入正确的邮箱~', 'danger')
return render_template('main/auth/resetPwd.html', form=form)
# 如果验证码已经超出了有效时间
if rd.get(usr.id) is None:
flash('验证码已过期.', 'danger')
return render_template('main/auth/resetPwd.html', form=form)
pwd= form.confirm_pwd.data
ver_code = form.ver_code.data
# 如果输入的验证码与redis中的不一致
if ver_code != rd.get(usr.id):
flash('验证码错误')
return render_template('main/auth/resetPwd.html', form=form)
usr.set_password(pwd)
db.session.commit()
flash('密码重置成功!', 'success')
return redirect(url_for('.login'))
return render_template('main/auth/resetPwd.html', form=form)</code></pre>
<p>在上面的代码中，我们可以通过<code>rd.get(usr.id)</code>来获取当前用户的验证码，同时如果用户重复操作，验证码会自动替换成最新的验证码，如果验证码过期，那么通过<code>rd.get(usr.id)</code>的值将会为空。</p>
<p>至此，一个简单的验证码验证就完成了。当然如果真要用在大型项目上，那么不仅仅是这么简单的操作，需要考虑到的东西十分多！！！</p>
<p>同时，redis的功能不仅于此，想想一个场景，在关系数据库中，例如MySQL，如果一张表中的数据变化频率非常的小，同时表中的数据又十分的多了，如果每次访问该表都去进行查询的话，如果数据库优化做的好，那么查询速度还是可观，如果像我这种数据库渣渣的话，那么查询时间肯定又长又臭了。因此我们可以将更新频率不高的数据放入redis缓存中去，毕竟别人是内存性数据库，这数据不是你MySQL能比拟的，但是也需要注意以下几点</p>
<ol>
<li>数据一致性，即缓存数据库中数据应该与MySQL中保持一致，不能出现数据滞后更新等状态</li>
<li>不要缓存那些对数据一致性要求很高的数据</li>
</ol>
<p>上述代码都是个人博客网站的代码片段，如果需要看到效果，可以前往<a href="https://github.com/weijiang1994/Blogin">Blogin源代码</a>。</p>
</content>
<link href="https://2dogz.cn/blog/article/6/" rel="alternate"/>
</entry>
<entry>
<id>5</id>
<title>[Python]使用装饰器统计网站流量</title>
<updated>2023-09-27T02:08:19.928529+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>前提</h1>
<p>在阅读本文之前，你需要知道<code>Python</code>装饰器的一些知识点，同时知道flask框架的基本用法。</p>
<h1>简单的flask应用</h1>
<p>我们用一个简单的flask应用来说明这个流量统计的实现过程。下面我们先下一个简单的flask应用。</p>
<p>整个应用的结构如下所示。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/3367%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_3.png" /></p>
<h2>视图函数</h2>
<p>首先我们构建三个视图函数，如下所示</p>
<pre>
<code class="language-python">@app.route('/')
@statistic_traffic(db, VisitStatistics)
def index():
comments, likes, visits = get_data()
return render_template("index.html", date=date, visits=visits, comments=comments, likes=likes)
@app.route('/comment/')
@statistic_traffic(db, CommentStatistics)
def comment():
comments, likes, visits = get_data()
return render_template("index.html", date=date, visits=visits, comments=comments, likes=likes)
@app.route('/like/')
@statistic_traffic(db, LikeStatistics)
def like():
comments, likes, visits = get_data()
return render_template("index.html", date=date, visits=visits, comments=comments, likes=likes)</code></pre>
<p>三个视图分别对应的是主页、评论、点赞三个页面，简单起见，我们返回都是同一个<code>index.html.</code></p>
<h2>获取数据库实时数据</h2>
<p>其中<code>get_data()</code>函数为获取数据库中实时的数据，具体实现如下所示。</p>
<pre>
<code class="language-python">def get_data():
vst = VisitStatistics.query.filter_by(date=date).first()
cmt = CommentStatistics.query.filter_by(date=date).first()
love = LikeStatistics.query.filter_by(date=date).first()
if vst is None:
visits = 0
else:
visits = vst.times
if cmt is None:
comments = 0
else:
comments = cmt.times
if love is None:
likes = 0
else:
likes = love.times
return comments, likes, visits</code></pre>
<p>在get_data()函数中，我们使用了三个类分别是<span class="marker">VisitStatistics</span>、<span class="marker">CommentStatistics</span>、<span class="marker">LikeStatistics</span>，这三个类都是数据库模型类，通过ORM去操作数据库中的表，简化了我们写SQL语句的步骤。三个模型类的定义如下。</p>
<pre>
<code class="language-python"># 数据库模型
class VisitStatistics(db.Model):
__tablename__ = 'visit_statistics'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
date = db.Column(db.Date, nullable=False)
times = db.Column(db.INTEGER, default=1)
class CommentStatistics(db.Model):
__tablename__ = 'comment_statistics'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
date = db.Column(db.Date, nullable=False)
times = db.Column(db.INTEGER, default=1)
class LikeStatistics(db.Model):
__tablename__ = 'like_statistics'
id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
date = db.Column(db.Date, nullable=False)
times = db.Column(db.INTEGER, default=1)</code></pre>
<h1>统计</h1>
<p>统计流量的主要思想是用户点击某一个连接(视图函数)我们在视图函数内部进行数据库统计数据更新。流程如下。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/3919%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_4.png" /></p>
<h2>一般统计实现</h2>
<p>为了统计流量，我们可以在每个视图函数下面写统计操作，如果我们视图函数比较少的话，那还好重复的内容不是很多，但是如果我们视图函数较多，那这样重复的工作量就比较多了，不太符合Python Zen&nbsp;<em><strong>Simple is better than complex.</strong></em></p>
<pre>
<code class="language-python"># 一般的统计方法
@app.route('/')
def view1():
statistic_traffic()
...
@app.route('/')
def view2():
statistic_traffic()
...
@app.route('/')
def view3():
statistic_traffic()
...</code></pre>
<p>上面仅仅是统计一项内容，如果我们需要统计的项目比较多的话，那么代码更加复杂。</p>
<h2>使用装饰器做统计</h2>
<p>在Python中有东西叫做<code><span class="marker">装饰器</span></code>，其根本是闭包。在开发中装饰器在权限校验、日志记录等方面使用的比较多，它的使用方法如下</p>
<pre>
<code class="language-python">import time
def run_time(func):
def wrap():
st = time.time()
result = func()
print(time.time()-st)
return result
return wrap
@run_time
def test():
time.sleep(3)
</code></pre>
<p>在上面代码中，函数run_time()就是一个装饰器了，我们可以通过它来装饰函数，使得函数增加一些特定的功能。在这里我们使用它装饰了test()函数，那么运行test()函数的时候，就会自动统计该函数的运行时间了。</p>
<p>有了上述基础，我们就可以使用装饰器来做流量统计了，代码如下所示。</p>
<pre>
<code class="language-python">def statistic_traffic(db, obj):
"""
网站今日访问量、评论量、点赞量统计装饰器
:param db: 数据库操作对象
:param obj: 统计模型类别(VisitStatistics,CommentStatistics,LikeStatistics)
:return:
"""
def decorator(func):
@wraps(func)
def decorated_function(*args, **kwargs):
td = datetime.date.today()
vst = obj.query.filter_by(date=td).first()
if vst is None:
new_vst = obj(date=td, times=1)
db.session.add(new_vst)
else:
vst.times += 1
db.session.commit()
return func(*args, **kwargs)
return decorated_function
return decorator</code></pre>
<p>我们在装饰器中实现了上述流程中的流程，在我们要使用统计功能的时候我们将这个装饰器加在视图函数的上方，用户在点击该链接(视图函数)的时候，就自动实现了统计了。</p>
<h1>效果</h1>
<p>使用如下命令运行程序</p>
<pre>
<code class="language-bash">python app.py</code></pre>
<p>打开连接<a href="http://127.0.0.1:500">http://127.0.0.1:500</a>,可以看到如下效果图。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/7067%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_5.png" /></p>
<p>当我们点击下面三个按钮，对应的内容也会出现变化，如下。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/1726%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE_6.png" /></p>
<h1>总结</h1>
<ol>
<li>由于为了实现效果，采用的代码结构非常的简单，而且也存在部分冗余代码；</li>
<li>装饰器神通广大，并不是这么一点点内容就能讲清楚；</li>
<li>欢迎各位评论区讨论，谢谢；</li>
<li>完结～撒花～</li>
<li>项目代码仓库<a href="https://github.com/weijiang1994/traffic/">https://github.com/weijiang1994/traffic/</a></li>
</ol>
</content>
<link href="https://2dogz.cn/blog/article/5/" rel="alternate"/>
</entry>
<entry>
<id>4</id>
<title>[应用部署]使用gunicorn启动flask项目无法读取.env文件问题</title>
<updated>2023-09-27T02:08:19.928501+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>问题</h1>
<p>这个问题实在项目部署的时候出现的，因为在开发的时候使用flask内置的开发环境服务器就足够满足了，但是在实际的生产环境中，development服务器就肯定不会满足要求了。因此，我选择的方案是<code>gunicorn+nginx+supervisor</code>来进行项目部署的。</p>
<p>使用如下命令启动服务</p>
<pre>
<code class="language-bash">gunicorn -w 4 -b 127.0.0.1:5000 wsgi:app</code></pre>
<p>启动后的日志如下，没有任何报错问题</p>
<p><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/1337launch.png" /></p>
<p>于是乎，打开<a href="http://127.0.0.1:5000/">http://127.0.0.1:5000</a>，发现返回<code>500</code>，于是查看日志文件，发现是数据库连接报错，问题如下。</p>
<p><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/2318image-20201012143547145.png" /></p>
<p>上面报错的原因主要是说数据库连接使用了密码登录，但是连接提供的密码是非法的，所以出现权限拒绝的提示。</p>
<h1>排查</h1>
<p>于是去查看数据库配置信息是否正确，发现数据库配置都是正确的。</p>
<p><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/2073image-20201012145433951.png" /></p>
<p>我的配置信息都是保存在<code>.env</code>文件中，flask 通过<code>dotenv</code>会自动加载<code>.env</code>文件中的信息。由于我使用&nbsp;<code>flask run</code>&nbsp;命令可以成功启动服务器，因此<code>.env</code>&nbsp;文件配置应该不会有错误。</p>
<p>因此我感觉有可能是<code>gunicorn</code>&nbsp;没有正确加载<code>.env</code>&nbsp;中的信息，所以导致这些问题的发生。</p>
<p>于是我在<code>setting.py</code>&nbsp;文件中打印出了<code>.env</code>&nbsp;文件中对应数据库键的值，发现都是<code>None</code>，因此可以知道是由于<code>.env</code>&nbsp;文件没有被加在，所以导致读取不到数据库的信息导致了这种错误的发生。</p>
<h1>解决办法</h1>
<p>百度了一圈，没有找到一个相关的问题！！！于是去看<code>gunicorn</code>&nbsp;的官方文档，发现了下面的内容。</p>
<p><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/2221image-20201012150008742.png" /></p>
<p>上图中的意思是，使用<code>gunicorn</code>&nbsp;命令启动服务的时候，如果需要配置环境变量，可以通过<code>-e</code>&nbsp;或者&nbsp;<code>--env</code>&nbsp;的方式来配置，例如：</p>
<pre>
<code class="language-bash">gunicorn -b 127.0.0.1:5000 -e user=123 -e pwd=123</code></pre>
<p>于是使用了上面的方法测试了一下，发现确实不会数据库连接的错误了，但是出现了其他的错误，也是由于没有读取到<code>.env</code>&nbsp;文件中配置信息所导致的。</p>
<p>当下我的项目所配置的环境变量信息不多，可以采用这种方法，但是当环境变量配置变多的时候这种方法可行性就比较低了。</p>
<p>于是我上了谷歌，不得不得感叹谷歌的强大，当我在搜索框键入<code>gunicorn</code>&nbsp;的时候，就自动给我提示<code>.env</code>&nbsp;了，看到这个我心里就知道，肯定有幸运儿跟我一样，遇到过同样的问题，于是乎搜索到了相关的问题，如下。</p>
<p><strong>问题1：</strong></p>
<p><strong><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/4760image-20201012150537361.png" /></strong></p>
<p><strong>问题2：</strong></p>
<p><strong><img alt="" class="d-block img-fluid mx-auto" src="/backend/files/5834image-20201012150707067.png" /></strong></p>
<p>上面所描述的问题基本与我的一致，都是使用<code>gunicorn</code>&nbsp;启动的时候无法读取<code>.env</code>&nbsp;文件中的内容所导致的。</p>
<p>在问题下面也有很多热心网友给了一些解决方案，比如前一节我所提到的加上<code>-e</code>参数，或者修改<code>gunicorn.service</code>&nbsp;配置，指定<code>EnvironmentFile</code>&nbsp;参数。</p>
<p>我感觉第二种方法比较靠谱，但是我的<code>gunicorn</code>&nbsp;是在虚拟环境中运行的，因此第二种方法也做不了。于是往下翻，发现一片名为</p>
<p><em><strong><span class="marker">AUTOMATICALLY LOAD ENVIRONMENT VARIABLES IN FLASK&nbsp;</span></strong></em>的文章。</p>
<p>(可能需要翻墙:<a href="https://prettyprinted.com/tutorials/automatically_load_environment_variables_in_flask">链接</a>)，进去看了一下，作者把问题描述的十分清楚。原话如下：</p>
<p><strong><em>This is because the environment variables are no longer being loaded for us. To load them, we&#39;ll have to use the load_dotenv function from python-dotenv.</em></strong></p>
<p>大概意思就是不会自动加载环境变量，需要我们手动去加载。因此我按照他的方法，在<code>wsgi.py</code>&nbsp;文件中加入下面的代码:</p>
<pre>
<code class="language-python"># wsgi.py
from dotenv import load_dotenv
load_dotenv('.env')</code></pre>
<p>保存，重新运行，我发现还是获取不到环境变量。这他喵的就奇怪了。</p>
<p>于是又在<code>wsgi.py</code>&nbsp;文件里打印出来环境变量值。</p>
<pre>
<code class="language-python"># wsgi.py
import os
print(os.getenv('DATABASE_USER'))
print(os.getenv('DATABASE_PWD'))</code></pre>
<p>神奇的事情发生了，他喵的环境变量值居然不是空，都是<code>.env</code>&nbsp;文件中正确的值。这下就让人很费解了。python</p>
<p>于是乎，返回我的程序配置初始化<code>setting.py</code>&nbsp;文件中添加如下代码，打印信息。</p>
<pre>
<code class="language-python"># setting.py
import os
print('setting ', os.getenv('DATABASE_USER'))
print('setting ', os.getenv('DATABASE_PWD'))</code></pre>
<p>他喵的，这里输出的居然是两个<code>None</code>。</p>
<p>原因大概清楚了，因为<code>setting.py</code>&nbsp;文件执行于&nbsp;<code>wsgi.py</code>&nbsp;文件之前，所以在<code>wsgi.py</code>&nbsp;文件中手动加载环境变量在这里不启作用，于是修改<code>setting.py</code>&nbsp;代码，加入下面两行代码。</p>
<pre>
<code class="language-python"># setting.py
from dotenv import load_dotenv
load_dotenv('.env')</code></pre>
<p>保存，重启，访问，一切正常了！！！</p>
<h1>总结</h1>
<p>关于整个问题的解决方案就是在你的配置文件中手动去加载环境变量使用<code>dotenv</code>中的<code>load_dotenv</code>函数。</p>
<p>但是为什么setting.py文件会在<code>wsgi.py</code>&nbsp;文件执行呢？知道的大哥，可以在评论中留言告诉小弟我一下。</p>
<p><a href="https://github.com/weijiang1994/Blogin">项目的github地址</a></p>
</content>
<link href="https://2dogz.cn/blog/article/4/" rel="alternate"/>
</entry>
<entry>
<id>3</id>
<title>[应用部署]使用supervisor管理web应用出错重启等状态</title>
<updated>2023-09-27T02:08:19.928471+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>安装supervisor</h1>
<p>supervisor是一个采用Python开发的进程管理工具，我们可以使用pip的方式来安装它，同时它也是一个软件，我们可以通过如下命令来安装它。</p>
<pre>
<code>sudo apt-get install supervisor</code></pre>
<blockquote class="m-blockquote">
<p>supervisor只在Linux系统下生效！</p>
</blockquote>
<h1>配置supervisor</h1>
<p>安装完成之后，会自动将其配置文件添加到<code>/etc/supervisor/supervisor.conf</code>文件中，为了便于管理，我们可以在<code>/etc/supervisor/conf.d/</code>目录下新建一个我们自己的配置文件，在这个目录下的配置文件会自动被添加到<code>/etc/supervisor/supervisor.conf</code>文件中去。</p>
<pre>
<code>sudo vim /etc/supervisor/conf.d/blog.conf</code></pre>
<p>在当中输入如下内容。</p>
<pre>
<code>[program:flask-blog-owner]
command=/home/ubuntu/blog/flask-blog-owner/bash.sh
directory=/home/ubuntu/blog/flask-blog-owner
user=root
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true</code></pre>
<ol>
<li><em>program为你的程序名</em></li>
<li><em>command是你要运行的命令，一般是程序启动命令</em></li>
<li><em>你的应用程序的主目录</em></li>
<li><em>user、autostart等是一些常规设置，根据需要可以灵活配置修改</em></li>
</ol>
<h1>bash脚本</h1>
<p>如果你使用的是pipenv创建虚拟环境的话，这一步可以省略直接在上一节command命令改为下面内容。</p>
<pre>
<code class="language-bash">command=pipenv run gunicorn -w 4 wsgi:app</code></pre>
<p>因为我的应用程序中采用了virtualven来创建虚拟环境，所以在项目根目录中创建一个bash脚本</p>
<pre>
<code class="language-bash">#! /bin/bash
cd /home/ubuntu/blog/flask-blog-owner
source venv/bin/activate
exec gunicorn -w 4 wsgi:app
</code></pre>
<p>上述内容根据自己的实际情况进行修改。</p>
<h1>使用supervisor运行管理程序</h1>
<pre>
<code class="language-vbscript">sudo service supervisor restart
sudo supervisorctl</code></pre>
<p>输出如下内容，则表示应用运行成功，你可以在浏览器中访问进行测试。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/9246sendpix8.jpg" /></p>
</content>
<link href="https://2dogz.cn/blog/article/3/" rel="alternate"/>
</entry>
<entry>
<id>2</id>
<title>[应用部署]使用nginx、gunicorn部署Flask项目</title>
<updated>2023-09-27T02:08:19.928436+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>配置gunicorn</h1>
<h2>安装gunicorn</h2>
<p>在虚拟环境中安装安装gunicorn。打开终端输入如下命令</p>
<pre>
<code class="language-bash">pip3 install gunicorn</code></pre>
<h2>使用gunicorn运行项目</h2>
<p>首先，在项目的根目录中新建wsgi.py文件输入如下内容：</p>
<pre>
<code class="language-python">from app import create_app
app = create_app('production')</code></pre>
<p>打开终端输入运行如下命令：</p>
<pre>
<code>gunicorn -w 4 -b 0.0.0.0:5000 wsgi:app</code></pre>
<p>上面命令中，wsgi为你所创建的入口文件，不一定需要是wsgi.py你也可以使用其他的名称，对应的上述命令就需要更改，app所对应的是你的项目代码文件根目录的名称。</p>
<p>之后我们访问你的云服务器的公网IP:5000就也可以看到你的应用首页了。</p>
<p><em><strong>如果你在这里使用了<span class="marker"><code>.env</code> </span>文件去配置一些项目的敏感信息，那么可能会出现一些问题，<a href="https://2dogz.cn/blog/article/4/">解决方案</a>。</strong></em></p>
<h1>使用nginx提供反向代理</h1>
<h2>安装nginx</h2>
<p>在终端中输入如下命令，安装nginx服务器</p>
<pre>
<code>sudo apt-get install nginx</code></pre>
<p>安装完成之后，在浏览器中输入你的云服务器公网IP地址就可以看到如下页面，说明安装成功了。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/6262nginx123.jpg" /></p>
<h2>配置nginx</h2>
<p>修改ngxin默认的配置文件。</p>
<pre>
<code>sudo vim /etc/nginx/sites-available/default</code></pre>
<p>添加如下内容：</p>
<pre>
<code class="language-nginx">server {
listen 80 default_server;
listen [::]:80 default_server;
# SSL configuration
#
# listen 443 ssl default_server;
# listen [::]:443 ssl default_server;
#
# Note: You should disable gzip for SSL traffic.
# See: https://bugs.debian.org/773332
#
# Read up on ssl_ciphers to ensure a secure configuration.
# See: https://bugs.debian.org/765782
#
# Self signed certs generated by the ssl-cert package
# Don't use them in a production server!
#
# include snippets/snakeoil.conf;
# root /var/www/html;
# Add index.php to the list if you are using PHP
# index index.html index.htm index.nginx-debian.html;
server_name 2dogz.cn; # 如果没有域名直接填写本机的公网IP地址
access_log /var/log/nginx/access.log; # 权限日志记录文件
error_log /var/log/nginx/error.log; # 错误日志记录文件
location / {
# First attempt to serve request as file, then
# as directory, then fall back to displaying a 404.
# try_files $uri $uri/ =404;
proxy_pass http://127.0.0.1:8000; # 转发的本地端口连接，后文会讲述
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real_IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /static { # 静态文件缓存
alias /home/ubuntu/blog/flask-blog-owner/app/static/; # 项目的静态文件目录
expires 30d; # 缓存有效期
}
}</code></pre>
<p>在对应的位置添加对应的文本内容就行了，根据实际情况进行修改。</p>
<p>上述文本中不需要加入http块，因为在/etc/nginx/sites-availabel/文件夹下的文件会自动添加到/etc/nginx/nginx.conf的http块当中去。</p>
<h2>测试配置文件是否正确</h2>
<pre>
<code>sudo nginx -t</code></pre>
<p>终端输出如下图所示的结果，说明配置文件没有出错。如若不是，根据实际情况进行错误排查。</p>
<p><img alt="" class="d-block img-fluid mx-auto pic" src="/backend/files/4877sendpix6.jpg" /></p>
<p>重启nginx。</p>
<pre>
<code>sudo service nginx restart</code></pre>
<h1>使用nginx+gunicorn运行应用</h1>
<p>在完成上述配置之后，我们就可以通过nginx+gunicorn运行我们自己的应用了。</p>
<p>进入项目根目录，并激活虚拟环境。</p>
<pre>
<code>gunicorn -w 4 wsgi:app</code></pre>
<h1>踩的坑</h1>
<p>我完成上述步骤之后，访问我服务器的公网地址，可以正常打开网站，但是发现背景图以及一些其他的静态文件没有正确显示，按F12查看，发现出现了403Forbidden错误，查找相关资料，得到以下的解决方案。</p>
<ol>
<li>打开终端输入如下命令
<pre>
<code class="language-bash">sudo vim /etc/nginx/nginx.conf</code></pre>
</li>
<li>修改文件第一行
<pre>
<code class="language-ini">user root;</code></pre>
再次访问发现错误解决了。</li>
</ol>
<p>以上就是使用nginx+gunicorn 部署应用的具体流程了，如有纰漏，欢迎指正。</p>
</content>
<link href="https://2dogz.cn/blog/article/2/" rel="alternate"/>
</entry>
<entry>
<id>1</id>
<title>[Leetcode][简单]设计停车系统</title>
<updated>2023-09-27T02:08:19.928319+00:00</updated>
<author>
<name>Blogin</name>
<email>weijiang1994_1@qq.com</email>
</author>
<content><h1>题目描述</h1>
<p>请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。</p>
<p>请你实现&nbsp;ParkingSystem&nbsp;类：</p>
<ul>
<li>ParkingSystem(int big, int medium, int small)&nbsp;初始化&nbsp;ParkingSystem&nbsp;类，三个参数分别对应每种停车位的数目。</li>
<li>bool addCar(int carType)&nbsp;检车是否有&nbsp;carType&nbsp;对应的停车位。&nbsp;carType&nbsp;有三种类型：大，中，小，分别用数字&nbsp;1，&nbsp;2&nbsp;和&nbsp;3&nbsp;表示。一辆车只能停在&nbsp;&nbsp;carType&nbsp;对应尺寸的停车位中。如果没有空车位，请返回&nbsp;false&nbsp;，否则将该车停入车位并返回&nbsp;true&nbsp;。</li>
</ul>
<p><strong>示例 1：</strong></p>
<div class="m-block-text" style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
<p><strong>输入：</strong><br />
[&quot;ParkingSystem&quot;, &quot;addCar&quot;, &quot;addCar&quot;, &quot;addCar&quot;, &quot;addCar&quot;]<br />
[[1, 1, 0], [1], [2], [3], [1]]<br />
<strong>输出：</strong><br />
[null, true, true, false, false]</p>
<p><strong>解释：</strong><br />
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);<br />
parkingSystem.addCar(1); // 返回 true ，因为有 1 个空的大车位<br />
parkingSystem.addCar(2); // 返回 true ，因为有 1 个空的中车位<br />
parkingSystem.addCar(3); // 返回 false ，因为没有空的小车位<br />
parkingSystem.addCar(1); // 返回 false ，因为没有空的大车位，唯一一个大车位已经被占据了</p>
</div>
<h1>题解</h1>
<p>这道题目是十分的简单的，在leetcode上面的通过率也比较高。下面的代码为题解。</p>
<pre>
<code class="language-python">class ParkingSystem:
def __init__(self, big, medium, small):
self.data = [0, big, medium, small]
def addCar(self, carType):
if self.data[carType] &lt;= 0:
return False
else:
self.data[carType] -= 1
return True
obj = ParkingSystem(1, 1, 0)
print obj.addCar(1)
print obj.addCar(2)
print obj.addCar(3)
print obj.addCar(1)</code></pre>
<p>&nbsp;</p>
</content>
<link href="https://2dogz.cn/blog/article/1/" rel="alternate"/>
</entry>
</feed>