但是很多时候我们需要为 ViewSet 中的某个 Action 指定不同的 Serializer。 比如在 UserViewSet中有一个修改密码的 Action：change_password，我们需要单独为它指定一个 ChangePasswordSerializer。

根据官方文档，我们可以这样做，重写 ViewSet 类的 get_serializer_class 方法，自己实现判断逻辑返回需要的 Serializer。

1
2
3
4

def get_serializer_class(self):
if self.action == "change_password":
return ChangePasswordSerializer
return super(UserViewSet, self).get_serializer_class()

这样在 change_password 方法中我们就可以直接通过 self.get_serializer() 得到 ChangePasswordSerializer 对象了。

但是这不是一个优雅的解决方法，我们应该劲量避免代码中出现硬编码！！！

为了优雅的解决这个问题，我们需要实现一个方法装饰器和一个 Mixin 类。

首先是一个装饰器，用于为 Action 指定 Serializer。

1
2
3
4
5
6

def action_serializer(serializer):
"""用于为 Action 指定 Serializer 类的装饰器"""
def decorator(func):
func.serializer_class = serializer
return func
return decorator

接下来是一个 Mixin 类，重写 get_serializer_class 方法，返回使用了 action_serializer 装饰器修饰的 Action 的 Serializer 类即可。

1
2
3
4
5
6
7

class ActionSerializerMixin(object):
"""使用 Action 指定 Serializer 的 Mixin 类"""
def get_serializer_class(self):
action = getattr(self, self.action)
if hasattr(action, "serializer_class"):
return action.serializer_class
return super(ActionSerializerMixin, self).get_serializer_class()

这样在我们的 UserViewSet 中，代码就可以简化成这样了，十分优雅。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class UserViewSet(ActionSerializerMixin, # ActionSerializerMixin类必须放在多重继承的第一个
                    mixins.ListModelMixin,
                    mixins.RetrieveModelMixin,
                    mixins.UpdateModelMixin,
                    viewsets.GenericViewSet):

queryset = User.objects.all()
serializer_class = UserSerializer # 其他Action默认的serializer
permission_classes = (permissions.IsAuthenticated, IsOwnerOrReadOnly, )

    @action_serializer(ChangePasswordSerializer) # 使用装饰器为change_password指定单独的Serializer
@action(detail=False, methods=["POST"])
def change_password(self, request):
"""修改密码 Action"""
pass

 

其实还有一个更简单的方法

但是我暂时没有仔细看APIView类的源码，不确定在实例化ViewSet以后修改serializer_class属性会不会造成什么问题。

这个方法就是直接在装饰器中修改ViewSet对象的serializer_class属性，这样就只需要向action方法添加一个装饰器就能实现我们想要的功能了。

1
2
3
4
5
6
7
8
9

from functools import wraps
def action_serializer(serializer):
    def decorator(func):
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            self.serializer_class = serializer
            return func(self, *args, **kwargs)
        return wrapper
    return decorator

问题描述
　　《审美的历程》课上有n位学生，帅老师展示了m幅画，其中有些是梵高的作品，另外的都出自五岁小朋友之手。老师请同学们分辨哪些画的作者是梵高，但是老师自己并没有答案，因为这些画看上去都像是小朋友画的……老师只想知道，有多少对同学给出的答案完全相反，这样他就可以用这个数据去揭穿披着皇帝新衣的抽象艺术了（支持帅老师^_^）。
　　答案完全相反是指对每一幅画的判断都相反。
输入格式
　　第一行两个数n和m，表示学生数和图画数；
　　接下来是一个n*m的01矩阵A：
　　如果aij=0，表示学生i觉得第j幅画是小朋友画的；
　　如果aij=1，表示学生i觉得第j幅画是梵高画的。
输出格式
　　输出一个数ans：表示有多少对同学的答案完全相反。
样例输入
　　3 2
　　1 0
　　0 1
　　1 0
样例输出
　　2
样例说明
　　同学1和同学2的答案完全相反；
　　同学2和同学3的答案完全相反；
　　所以答案是2。
数据规模和约定
　　对于50%的数据：n<=1000；
　　对于80%的数据：n<=10000；
　　对于100%的数据：n<=50000，m<=20。

这道题困扰了我很久，原理上看不难，但是注意有时长限制。

时间限制：1.0s

尝试了很多次都无法拿到满分，问题都出在运行超时上。

最后总结出三个关键点：

1. 一定要使用位运算，不要通过遍历每个同学的每个答案来进行比较。
2. 使用Map储存每种答案出现的次数，同样用于避免过多的遍历次数。
3. 这是最关键的一点：不要使用Scanner来读取输入，自己实现nextInt()函数，直接读取输入流。否则一定会超时！！

以下是我最终的代码：

得分：100
CPU使用时间：453ms
内存使用：27.44MB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import java.util.*;

public class Main {

public static int nextInt() {
int num = 0, read;
try {
while ((read = System.in.read()) != -1) {
if (Character.isDigit(read)) {
num = read - '0';
while ((read = System.in.read()) != -1)
if (Character.isDigit(read)) {
num = (num * 10) + (read - '0');
} else {
break;
}
break;
}
}
} catch (Exception e) {
}
return num;
}

public static void main(String[] args) {
int s = nextInt();
int p = nextInt();
Map<Integer, Integer> map = new HashMap<>();
for (int i=0; i<s; i++){
int n = 0;
for (int j = 0; j < p; j++) {
n = (n << 1) + nextInt();
}
// 记录下相同答案出现的次数
map.put(n, map.containsKey(n) ? map.get(n)+1 : 1);
}
int max = (1 << p) - 1;
int count = 0;
for (Map.Entry<Integer, Integer> entry: map.entrySet()){
int k1 = entry.getKey();
int k2 = (~k1) & max; // 取反运算，得到完全相反的答案
Integer v2 = map.get(k2);
if (v2 != null){
count += v2 * entry.getValue();
}
}
System.out.println(count / 2); // 除2是为了去掉重复计数
}

}

在修改自定义User模型的信息后，点击保存按钮提交Form时，提示email字段不能为空。

这是因为我们的UserAdmin类继承自django.contrib.auth.admin.UserAdmin，在父类UserAdmin的form中将email字段定义为了required，即必填字段。

通过继承django.contrib.auth.forms.UserChangeForm类，并在__init__方法中对email字段属性进行修改，可以实现我们想要的效果。

1
2
3
4
5
6

from django.contrib.auth.forms import UserChangeForm

class UserForm(UserChangeForm):
def __init__(self, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
self.fields["email"].required = False

这样在保存时就不会提示email字段不能为空了。

但是测试中发现，如果不填写email字段内容，保存后发现email字段的值变成了空字符串，而不是None，但是我们在自定义User模型中指定了email字段null=True，即我们期望的它应该是一个空值None。

经过调试后发现，在django.contrib.admin.options.ModelAdmin类的_changeform_view方法代码中，调用form.is_valid()方法后，email字段的值发生了变化。

1
2
3
4
5
6
7
8
9
10
11

# django.contrib.admin.options.ModelAdmin

ModelForm = self.get_form(request, obj)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid(): # 这句以后email字段值发生了变化
form_validated = True
new_object = self.save_form(request, form, change=not add)
else:
form_validated = False
new_object = form.instance

于是顺藤摸瓜，找到django.forms.models.BaseModelForm类中_post_clean方法，发现在此方法中调用了Model实例的full_clean方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# django.forms.models.BaseModelForm

try:
self.instance = construct_instance(self, self.instance, opts.fields, opts.exclude)
except ValidationError as e:
self._update_errors(e)

try:
self.instance.full_clean(exclude=exclude, validate_unique=False)
except ValidationError as e:
self._update_errors(e)

# Validate uniqueness if needed.
if self._validate_unique:
self.validate_unique()

继续跟进发现在自定义User模型的父类AbstractUser中，实现了clean方法，并且对email字段的值进行了修改。

1
2
3
4
5

# django.contrib.auth.models.AbstractUser

def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)

这里调用的normalize_email是django.contrib.auth.base_user.BaseUserManager中实现的一个静态方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# django.contrib.auth.base_user

class BaseUserManager(models.Manager):

@classmethod
def normalize_email(cls, email):
"""
Normalize the email address by lowercasing the domain part of it.
"""
email = email or '' # 就是这句话导致email值为None时被替换成了空字符串
try:
email_name, domain_part = email.strip().rsplit('@', 1)
except ValueError:
pass
else:
email = email_name + '@' + domain_part.lower()
return email

所以我们只需要自己实现一个UserManager类并继承BaseUserManager类，并重写normalize_email方法。

1
2
3
4
5
6

from django.contrib.auth.models import BaseUserManager

class UserManager(BaseUserManager):
@classmethod
def normalize_email(cls, email):
return super().normalize_email(email) or None

这样，当提交Form中缺少email值时，就能正确的把email字段值保存为None了。

现在我的项目在原有网站基础上需要另外提供一套API，只需要简单的一点拓展就可以在现有session和auth应用基础上实现基于Token的认证。

在自己的app下创建middleware.py文件，写一个自己的class，继承django.contrib.session.middleware模块下的SessionMiddleware类，并且重写process_request方法。

1
2
3
4
5
6
7
8
9
10
11
12

from django.conf import settings
from django.contrib.sessions.middleware import SessionMiddleware

class SessionTokenMiddleware(SessionMiddleware):

    def process_request(self, request):
        # 尝试从请求头中获取 Session Key
        session_key = request.META.get("HTTP_" + getattr(settings, "ACCESS_TOKEN_NAME", "Access-Token").replace("-","_").upper())
        if not session_key:
            super().process_request(request)
        else:
            request.session = self.SessionStore(session_key)

在处理请求时，先尝试从请求头中对应字段获取Token，即Session Key，并通过Session引擎获取Session对象。
如果请求头中没有包含Token字段，则调用父类方法。

最后，在登陆API的view中调用auth模块login方法后，从request中获取Session Key放入到响应体中即可。

这里因为是用了 REST-Framework 的 ViewSet，所以需要通过request.stream获取原始Django的HttpRequest对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@list_route(methods=["post"], permission_classes=[permissions.AllowAny])
def login(self, request):
"""
登陆API

通过手机号和密码进行登陆验证
"""
serializer = UserSerializer(data=request.data)
if serializer.authenticate():
login(request, serializer.authenticated_user)
response_data = {
getattr(settings, "ACCESS_TOKEN_NAME", "Access-Token"): request.stream.session.session_key,
"Expires": int((time.time() + request.stream.session.get_expiry_age()) * 1000)
}
response_data.update(serializer.data)
return Response(data=response_data, status=status.HTTP_200_OK)
else:
logout(request)
return Response(data=serializer.errors, status=status.HTTP_400_BAD_REQUEST)

听起来很有意思，打算使用 Python 的 selenium 包配合无界面浏览器 PhantomJS 来实现。

要注意较新版本的 selenium 已经不再支持 PhantomJS，需安装较老版本的 selenium。

模拟登陆使用 requests 包的 Session 类，然后将 cookie 添加到 WebDriver 里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

session = requests.session()
res = session.post(url=LOGIN_URL, data=payload)
cookies = session.cookies.get_dict()

driver = webdriver.PhantomJS()
driver.implicitly_wait(10) # 设置连接超时时间为 10 秒。

for i in cookies:
driver.add_cookie({
"name": i,
"value" : cookies[i],
"path": "/",
"domain": DOMAIN # domain 和 path 参数是必须的，否则会报错。
})

需要截图的页面内有两个 iframe，而 iframe 内容是由页面上点击某个菜单链接时动态加载的。

所以我们在页面加载结束以后执行 JS 语句模拟点击菜单链接，网页引入了 JQuery，可以很方便的使用。

1
2

driver.get(CONTENT_URL)
driver.execute_script("$('a.menu').first().click()")

此时 iframe 开始加载，但是如果马上执行网页截图的话，iframe 可能还没有完成加载，所以我们等待想要截图的内容加载完成以后再执行截图。

这里可以方便的使用 selenium 提供的 WebDriverWait 类，用以阻塞式地循环判断条件是否成立，直到条件成立才会继续执行下面的代码。

1
2
3
4
5
6
7
8
9

# 在代码中引入 WebDriverWait 类
# from selenium.webdriver.support.wait import WebDriverWait

# WebDriverWait 对象的 until 方法参数需传入一个函数，并将会循环调用这个函数用于检测条件是否成立，直到函数返回 True 时才继续执行下面的代码。
# 这里为了方便，将一个 lambda 匿名函数作为 until 方法的参数传入。
condition = lambda x: driver.execute_script("return document.getElementsByTagName('iframe')[1].contentDocument.getElementsByTagName('table').length") > 0

# WebDriverWait 类构造函数第一个参数为 WebDriver 对象，第二个参数是超时时间（秒），如果超过该事件条件还未成立，将会抛出一个异常。
WebDriverWait(driver, 5).until(condition)

当条件成立时，执行网页截图，返回图片内容的字节数组。

1

screenshot = driver.get_screenshot_as_png()

最后，将图片内容写入到响应体中返回，完工。

1. Fragment 中的 onAttach 方法没有被调用

在 Android 5.0 (API 21) 系统手机上测试时 App 抛出了空指针异常，而在其他测试机（均等于或高于 Android 6.0）上运行正常。
经排查发现时 Fragment 中的 OnAttach 方法没有被调用。

原来 Android 在 API 23 以后重载了 Fragment 中的 OnAttach 方法。
之前的

1
2
3
4

@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
}

被重载为了

1
2
3
4

@Override
public void onAttach(Context context) {
    super.onAttach(context);
}

而我在继承 Fragment 的类中只重写了第二个方法，也就是 API 23 以后的方法。
所以我们复写的 OnAttach 方法在 API 21 的手机上没有被调用。

只需要复写 onAttach(Activity activity) 方法，并且添加一句 SDK 版本判断。

1
2
3
4
5
6
7

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
// Do something...
}
}

问题解决。

2. 华为手机上 Logcat 全部显示 some logs have been lost

在一部华为手机上（Huawei GR3 HWTAG-L6753）上测试时 App 发生了 Crash，奇怪的是查看文件没有生成 CrashLog 文件。
于是连上 ADB 查看 Logcat，发现输出的全是

W/AEE : some logs have been lost

根据 StackOverflow 上的回答 android - Huawei, logcat not showing the log for my app? - Stack Overflow

Dial
*#*#2846579#*#*
and you will see a hidden menu. Go to the Project Menu > Background Setting > Log setting and define the log availability (log switch) and level (log level setting).

在拨号界面拨号 *#*#2846579#*#* 进入隐藏菜单开启 Log 输出以后，就能正常查看 Logcat 信息了。
（经测试开启后不需要重启手机，评论中有人提到部分手机重启手机将重置此设置）

自己写了一个静态地图控件，遇到了需要判断触摸点是否位于多边形指定区域内的问题。

网上资料很多，主流方法是利用光投射算法。Point in polygon - Wikipedia

CSDN上有一篇文章把原理讲的非常详细 点在多边形内算法——判断一个点是否在一个复杂多边形的内部

参考 StackOverFlow 上一个回答的写法，翻译成 JAVA 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
 * 利用光投射算法计算点是否在多边形内
 * 
 * @param point 需要判断的点的坐标
 * @param vertices 多边形按顺时针或逆时针顺序的顶点坐标集合
 * @return 点是否在多边形内
 */
public static boolean isPointInPolygon(PointF point, List<PointF> vertices) {
boolean contains = false;
for(int i = 0, j = vertices.size() - 1; i < vertices.size(); j = i++) {
if(((vertices.get(i).y >= point.y) != (vertices.get(j).y >= point.y)) &&
   (point.x <= (vertices.get(j).x - vertices.get(i).x) * (point.y - vertices.get(i).y) / (vertices.get(j).y - vertices.get(i).y) + vertices.get(i).x))
contains = !contains;
}
return contains;
}

为了方便使用，我将它封装到了我的 Polygon 类里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

public class Polygon {

    public static class Builder {
        private List<PointF> vertices = new ArrayList<>();
        public Polygon.Builder addVertice(PointF point){
            this.vertices.add(point);
            return this;
        }
        public Polygon build(){
            if (vertices.size() < 3) {
                throw new RuntimeException("Polygon must have at least 3 points");
            }
            return new Polygon(this.vertices);
        }
    }

    private List<PointF> vertices;

    public Polygon(List<PointF> vertices){
        this.vertices = vertices;
    }
    public Polygon() {
        this.vertices = new ArrayList<>();
    }

    public static Builder Builder(){
        return new Polygon.Builder();
    }

    public void setVertices(List<PointF> vertices) {
        this.vertices = vertices;
    }
    public List<PointF> getVertices() {
        return vertices;
    }

    public Path getPolygonPath(){
        int i = 0;
        Path path = new Path();
        for (PointF point : vertices) {
            if (i == 0) path.moveTo(point.x, point.y);
            else path.lineTo(point.x, point.y);
            i++;
        }
        path.close();
        return path;
    }

    public boolean contains(List<PointF> points){
        for (PointF point: points){
            if (!contains(point))
                return false;
        }
        return true;
    }
    public boolean contains(PointF point){
        return Polygon.isPointInPolygon(point, this.vertices);
    }

    /**
     * 利用光投射算法计算点是否在多边形内
     *
     * @param point 需要判断的点的坐标
     * @param vertices 多边形按顺时针或逆时针顺序的顶点坐标集合
     * @return 点是否在多边形内
     */
    public static boolean isPointInPolygon(PointF point, List<PointF> vertices) {
        boolean contains = false;
        for(int i = 0, j = vertices.size() - 1; i < vertices.size(); j = i++) {
            if(((vertices.get(i).y >= point.y) != (vertices.get(j).y >= point.y)) &&
                    (point.x <= (vertices.get(j).x - vertices.get(i).x) * (point.y - vertices.get(i).y) / (vertices.get(j).y - vertices.get(i).y) + vertices.get(i).x))
                contains = !contains;
        }
        return contains;
    }

}

在这里将动态生成的 Excel 文档保存到服务器，并重定向到静态文件链接显然不是一个合适的做法。

所以我们需要直接将 openpyx 生成的 Excel 文档写入到 Django 的 HttpResponse 对象响应体中。

查阅 openpyxl 的文档以后，并没有找到有用的信息，所以直接从源码入手。

在这篇文章中，我将把源码分析的过程详细的展现出来，并总结出完美的解决方案。

我们先从 openpyxl.workbook.workbook 模块下的 Workbook 类入手，找到平时我们用来保存 Excel 文档的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def save(self, filename):
"""Save the current workbook under the given `filename`.
Use this function instead of using an `ExcelWriter`.

.. warning::
When creating your workbook using `write_only` set to True,
you will only be able to call this function once. Subsequents attempts to
modify or save the file will raise an :class:`openpyxl.shared.exc.WorkbookAlreadySaved` exception.
"""
if self.read_only:
raise TypeError("""Workbook is read-only""")
if self.write_only:
save_dump(self, filename)
else:
save_workbook(self, filename)

可以看到在一般情况下调用这个方法时，实际上会调用的是 save_workbook 这个函数，这个函数在 openpyxl.writer.excel 模块中定义。

1

from openpyxl.writer.excel import save_workbook

那我们就要来看看这个模块里还定义了什么东西。

打开这个文件，突然眼前一亮，这里还定义了一个叫做 save_virtual_workbook 的函数，作者在注释里写到 “Return an in-memory workbook, suitable for a Django response.” ，看来这就是我们要找的东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def save_virtual_workbook(workbook,):
"""Return an in-memory workbook, suitable for a Django response."""
temp_buffer = BytesIO()
archive = ZipFile(temp_buffer, 'w', ZIP_DEFLATED, allowZip64=True)

writer = ExcelWriter(workbook, archive)

try:
writer.write_data()
finally:
archive.close()

virtual_workbook = temp_buffer.getvalue()
temp_buffer.close()
return virtual_workbook

这个函数将 Excel 文档写入到内存，返回一个字节数组。

Django 的 HttpResponse 类构造方法可以接受一个字节数组作为响应体，所以我们可以这样写。

1
2
3
4
5
6
7
8
9

from django.http import HttpResponse
from openpyxl import Workbook
from openpyxl.writer.excel import save_virtual_workbook

workbook = Workbook()

# ......

response = HttpResponse(content=save_virtual_workbook(workbook), content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')

这样就可以很简单的实现将 Excel 文档写入到响应体中了。

指定中文文件名时遇到问题可以参考我之前的一篇文章 Django 返回流文件时使用中文文件名的问题

但是！还没有结束，我认为还可以有更优雅的解决方案。

查阅 Django 文档，发现在 HttpResponse 类的说明下有这样一句：“you can use response as a file-like object.”，并给了一段示例代码。看来 HttpResponse 对象可以直接作为一个 file-like 对象，像对文件对象一样进行写入操作。

Excel 文档的 .xlsx 文件实际上是一个 ZIP 格式的压缩包，在 openpyxl.writer.excel 模块的 save_workbook 函数中是使用 Python 自带的 zipfile 模块来创建的文件。

1

archive = ZipFile(filename, 'w', ZIP_DEFLATED, allowZip64=True)

查阅 zipfile 模块文档知道 ZipFile 类构造方法的第一个参数可以接受一个文件路径字符串、path-like 对象或是一个 file-like 对象。

太好了，看来我们可以直接把 Django 的 HttpResponse 对象传入到 ZipFile 的构造方法，让 ZipFile 对象直接往 HttpResponse 的响应体中写入内容。

我们当然可以在调用 openpyxl.writer.excel 模块的 save_workbook 函数时，直接将 HttpResponse 对象传入，就像这样。

1
2
3
4
5
6
7
8
9

from django.http import HttpResponse
from openpyxl import Workbook

workbook = Workbook()

# ......

response = HttpResponse(content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
workbook.save(response)

但是继续来读 openpyxl 的源码，发现在调用 save_workbook 函数时，创建了一个 ExcelWriter 对象，并调用了它的 save 方法。

1
2
3
4

def save(self, filename):
"""Write data into the archive."""
self.write_data()
self._archive.close()

在 save 方法的最后，调用了我们传入的 HttpResponse 对象的 close 方法，而查阅 Django 源码发现在 HttpResponse 的基类 HttpResponseBase 的 close 方法处注释着，该方法应该由 WSGI 服务器在处理完请求以后调用。

1
2
3
4
5
6
7
8
9
10

# The WSGI server must call this method upon completion of the request.
# See http://blog.dscpl.com.au/2012/10/obligations-for-calling-close-on.html
def close(self):
for closable in self._closable_objects:
try:
closable.close()
except Exception:
pass
self.closed = True
signals.request_finished.send(sender=self._handler_class)

所以为了优雅，我们还是把调用 close 方法的工作交还给 WSGI 服务器来做吧。

最终的解决方案

我们来自己实现一个 save_workbook 函数，用于将 openpyxl 的 Workbook 生成 Excel 文档，并写入到 Django 的 HttpResponse 对象响应体中。

1
2
3
4
5
6
7

from openpyxl.writer.excel import ExcelWriter
from zipfile import ZipFile, ZIP_DEFLATED

def save_workbook_response(workbook, response):
archive = ZipFile(response, 'w', ZIP_DEFLATED, allowZip64=True)
writer = ExcelWriter(workbook, archive)
writer.write_data()

这样，我们只需要在创建 HttpResponse 对象后，调用我们自己实现的 save_workbook_response 函数，将 openpyxl 的 Workbook 对象和 HttpResponse 对象一起传入，就可以生成 Excel 文档并写入到响应体中了。

1
2
3
4
5
6
7
8
9

from django.http import HttpResponse
from openpyxl import Workbook

workbook = Workbook()

# ......

response = HttpResponse(content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
save_workbook_response(workbook, response)

使用 requestAnimationFrame 将会把动画帧渲染周期交给浏览器统一调度，实现更好的性能优化。

可是微信小程序并没有支持这个 Api，在模拟器上测试可以正常运行，可在真机上运行时会报错，没有这个方法。

所以我们只得想办法自己来模拟这个 Api 所做的工作。

requestAnimationFrame 能够将原本零散的帧渲染序列进行梳理，使得页面上所有动画帧都在同一周期进行渲染，以最大化利用系统资源。

一般浏览器的渲染周期为 60 次每秒，即每次间隔大约 16 毫秒。因此我们只需要写一段代码，来将渲染周期控制在 16 毫秒，就能够模拟出 requestAnimationFrame 的效果了。

1
2
3
4
5
6
7
8
9
10
11
12
13

var lastFrameTime = 0;
// 模拟 requestAnimationFrame
var doAnimationFrame = function (callback) {
var currTime = new Date().getTime();
var timeToCall = Math.max(0, 16 - (currTime - lastFrameTime));
var id = setTimeout(function () { callback(currTime + timeToCall); }, timeToCall);
lastFrameTime = currTime + timeToCall;
return id;
};
// 模拟 cancelAnimationFrame
var abortAnimationFrame = function (id) {
clearTimeout(id)
}

现在就可以像使用 requestAnimationFrame 和 cancelAnimationFrame 一样使用 doAnimationFrame 和 abortAnimationFrame 了。

在测试的过程中发现了一个问题，无论我怎么在响应头中添加 Content-Disposition 指定文件名，在 Chrome 浏览器中访问的时候返回的文件名始终是按 url 的最后一段自动生成的文件名，而将文件名改成英文以后又是正常的。

猜测应该是字符串编码的问题，http 响应头中字符应该按照 url 百分号编码。

修改为以下代码后，终于能够正常显示中文文件名了。

1
2
3
4

# Python3
from urllib.parse import quote
...
response['Content-Disposition'] = 'attachment; filename={0}.xlsx'.format(quote(filename))

Python2 中的 quote 方法引入位置有所不同，代码如下：

1
2
3
4
5

# Python2
from urllib import quote
...
# 向下兼容 Python2.6 以前的格式化字符串
response['Content-Disposition'] = 'attachment; filename=%s.xlsx' % quote(filename)

计划页面有两个 canvas，一个用来实时绘制上半部分的天气动画，一个用来绘制中间的气温趋势折线图。

上半部分天气动画在不同的天气下有不同的效果，比如不同强度的降雨会有相应的雨滴从上面落下，阴天多云的时候顶部会有云朵在漂浮，多云转晴的话后面再加上个太阳。

降雨的动画不难，无非就是随机生成一些雨滴对象，每一帧实时更新位置即可。

关键在云朵的动画上，我们需要生成随机宽高的椭圆形云朵，并且云朵沿着随机椭圆轨迹运动。

根据高中数学学习的关于椭圆方程的知识，我们知道，中心点位于点 (h,k) 的椭圆方程为：

a 为半长轴，b 为半短轴。在这里可以简单理解成 a 为椭圆宽的 1/2，b 为椭圆高的 1/2。

可是仅通过这个方程我们还没办法写出动画算法，因为无法计算出 x,y 在任意时刻的值。

还好，维基百科给了我们另一个公式：

这是椭圆的参数方程，其中 t 为椭圆中心点到椭圆上任意一点所确定的直线与x
轴的夹角，可以通过三角函数计算出在任意角度时点 (x,y) 的坐标。

有了这个公式就好办了，代码走起！

我们先封装一个生成指定范围内随机数的方法，方便后面使用。

1
2
3

function random(min, max) {
return Math.random() * (max - min) + min;
}

好了，现在我们来写一个云的类，就叫做 Cloud。

按照我们的设想，云应该是一个绕椭圆轨迹运动的椭圆。所以我们需要给 Cloud 对象传入一个运动轨迹中点，然后让 Cloud 对象在初始化的时候随机生成一些变量，然后在每一帧的时候更新自己的位置并且绘制到 canvas 上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

function Cloud() { }
Cloud.prototype = {
init: function (x, y) {
this.x = x // 椭圆运动轨迹中点 x
this.y = y // 椭圆运动轨迹中点 y
this.a = random(20, 25) // 椭圆运动轨迹 a
this.b = random(5, 15) // 椭圆运动轨迹 b
this.h = random(60, 80) // 云的高
this.w = random(90, 120) // 云的宽
this.color = 'rgba(255,255,255,0.3)'
this.t = random(0,Math.PI * 2) // 运动起始角度
this.v = random(0.1, 0.5) // 运动角速度
this.d = random(0,2) > 1 ? true : false // 运动方向
},
draw: function () {
ctx.setFillStyle(this.color)
// 绘制椭圆
fillEllipse(ctx, this.x + this.a * Math.cos(this.t), this.y + this.b * Math.sin(this.t), this.w / 2, this.h / 2)
this.update() // 更新下一帧的位置
},
update: function () {
if (this.d) {
this.t = this.t < Math.PI * 2 ? this.t += this.v : 0
} else {
this.t = this.t > 0 ? this.t -= this.v : Math.PI * 2
}
}
}

代码很简单，我们给了 Cloud 类三个方法。

在实例化 Cloud 对象的时候，调用 init 方法，传入云朵所围绕运动的椭圆轨迹中点坐标，并且随机生成一系列的随机变量。

在每一帧的时候调用 Cloud 对象的 draw 方法，通过角度 t 计算出新的绘制坐标，并在 canvas 上绘制一个云朵。

然后 Cloud 对象内部调用自己的 update 方法，根据自己的角速度变量计算出下一帧的角度 t。

接下来开始绘制椭圆

在 draw 方法内，我们调用了一个名叫 fillEllipse 的方法，按照设想，我们可以传入椭圆的中点坐标、a 和 b 来绘制出一个椭圆。
现在我们来用代码实现这个方法。

这里我首先想到的是利用之前的椭圆参数方程，沿着椭圆绘制出一条路径，然后填充路径即可。（后来发现这是一个坑，详见后文）

1
2
3
4
5
6
7
8
9
10
11
12

function fillEllipse(ctx, x, y, a, b) {
let dt = 1 / Math.max(a, b) // 绘制时的角度增量 Δt
ctx.beginPath()
ctx.moveTo(x + a, y) // 移动到起始点
for (let t = 0; t < Math.PI * 2; t += dt) {
// x=h+a*cos(t)
// y=k+b*sin(t)
ctx.lineTo(x + a * Math.cos(t), y + b * Math.sin(t))
}
ctx.closePath()
ctx.fill()
}

代码很简单，先粗略的计算出一个合适的角度增量 Δt，然后循环计算角度 t 从 0 增加到 2π 过程中的每一个点的坐标，绘制出一条路径，然后填充路径。

效果如下：

这时遇到了问题，在微信开发工具上模拟的时候效果很不错，可是当放到真机上测试的时候发现，为什么云的运动速度变得异常的缓慢。

根据我们之前的绘制原理，每一次的增量移动是在每一帧的时候完成的，而不是根据时间增量所计算的。所以移动的速度会直接和帧率挂钩，当帧率大的时候，位置增量更新的就更快，反之就会更慢。

我在绘制的时候是采用的每绘制一帧间隔 16 毫秒，即约 60 帧每秒。
为了查看实际的帧率，我在每一帧的绘制方法里面加上了这样一句：

1
2
3

let now = new Date()
let fps = Math.round(1000 / (now - last)) // 帧率 FPS
last = now

这样通过每一帧绘制的实际间隔时间，计算出当前的帧率，然后把这个数字绘制在 canvas 上。（高频率的输出不应使用 console.log()，会非常影响性能。）

结果如下：

可以看到，实际的帧率在 20-30 帧每秒之间浮动，远远低于设定的 60 帧每秒。
CPU 使用率和内存占用也是出乎意料的非常高。

查看前面的代码，不难发现，问题一定是出在了绘制椭圆的那个方法上。

每秒 60 次循环计算出椭圆上各个点的位置并绘制路径，计算量非常之大，并且大量的路径数据添加到上下文中，导致内存占用也开始飙升。

显然，这个方法一定是不可行的！

开始填坑…

查阅小程序的开发文档以后，其中一个 canvas 的 Api 让我看到了希望。

canvasContext.scale(scaleWidth, scaleHeight)
定义：在调用scale方法后，之后创建的路径其横纵坐标会被缩放。多次调用scale，倍数会相乘。
参数：scaleWidth 和 scaleHeight 分别为横纵坐标缩放的倍率。

我们只需要计算出椭圆在横纵坐标上相较于正圆的缩放倍率，调用 scale 方法后，再绘制一个正圆，不就可以画出需要的椭圆形状了吗。

而绘制正圆的方法非常简单，用 arc 方法直接绘制一个完整的圆形路径即可。

代码如下：

1
2
3
4
5
6
7
8
9
10
11

function fillEllipseByScale(ctx, x, y, a, b) {
let r = Math.max(a,b) // 取 a,b 中的大者作为圆形的半径
let scaleX = a / r // 横坐标缩放倍率
let scaleY = b / r // 纵坐标缩放倍率
ctx.scale(scaleX, scaleY) // 设置缩放
ctx.beginPath()
ctx.arc(x, y, r, 0, 2 * Math.PI) // 绘制圆形
ctx.closePath()
ctx.scale(1 / scaleX, 1 / scaleY) // 缩放回正常倍率
ctx.fill()
}

这样每次绘制椭圆只会向 canvas 上下文中添加少量的动作，计算量也大大降低。

我们再用同一台手机运行，测试一下实际帧率。

可以看到，这次帧率稳定在了 63 帧，与我们所设置的帧绘制间隔一致了，CPU 使用率和内存占用也降低到了之前的一半，性能有了很大的提升。

为了方便管理，我决定写一个 Shell 脚本来控制 uWSGI 服务器的启动和停止。

这样以后项目中如果需要同时启动别的进程，也可以通过简单修改 Shell 脚本来实现对整个项目的一键控制。

首先把 uWSGI 服务器的各项选项参数写入到 ini 文件，并设置守护进程。

然后编写 Shell 脚本如下（dino 为项目简称）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

#!/bin/bash

usage="Usages: dino [start|stop|restart|status]"

if [ ! -n "$1" ]
then
        echo "$usage";
        exit 0
fi

process="dino_uwsgi"

run_start_cmd(){
        `/usr/bin/uwsgi --ini /home/dennic/dino_uwsgi.ini`
}

is_exist(){
        if [ $(ps -ef | grep -c ${process}) -gt 1 ]
        then
                return 1
        else
                return 0
        fi
}

is_running(){
        is_exist
        if [ $? == 1 ]
        then
                echo -e "\033[32mdino uWSGI service is running!\033[0m";
                return 1
        else
                echo -e "\033[33mdino uWSGI service is not running!\033[0m"
                return 0
        fi
}

kill_all(){
        echo -e "shutting down dino uWSGI service ...... \c"
        pids=$(ps x | grep ${process} | grep -v grep | awk '{print $1}')
        for pid in $pids
        do
                `kill -9 $pid`
        done
        sleep 1
        is_exist
        if [ $? == 0 ]
        then
                echo -e "\033[32m[OK]\033[0m";
                return 1
        else
                echo -e "\033[31m[Fail]\033[0m"
                return 0
        fi
}

start_service(){
        run_start_cmd
        echo -e "Starting dino uWSGI service      ...... \c";
        sleep 1
        is_exist
        if [ $? == 1 ]
        then
                echo -e "\033[32m[OK]\033[0m";
                return 1
        else
                echo -e "\033[31m[Fail]\033[0m"
                return 0
        fi
}

cmd=$1

# start
if [ $cmd = start ]
then
        is_running;
        if [ $? == 0 ]
        then
                start_service
        fi

# status
elif [ $cmd = status ];then
        is_running

# stop
elif [ $cmd = stop ];then
        kill_all

# restart
elif [ $cmd = restart ];then
        is_running
        if [ $? == 1 ]
        then
                kill_all
                if [ $? == 1 ]
                then
                        start_service
                fi
        else
                start_service
        fi

else
        echo "$usage";
fi

将 Shell 脚本保存为 dino.sh，并且创建软连接到 /usr/bin/dino

尝试运行脚本：

首先是添加常用的用户，以 Git 为例：

装机自带了 Git，先 yum 更新一下：

1

yum update -y git

接下来新建一个名为 git 的用户：

1

useradd -d /home/git -m git

这里的 -d 选项指定了此用户的主目录为 /home/git ， -m 选项表示如果目录不存在则新建目录。

然后就要开始对 git 用户进行一些安全相关的设置。

因为只需要在常用的电脑上操作远程仓库，所以开启 SSH 的 RSA 公钥认证登陆，并关闭 git 用户的密码登陆功能。

修改 /etc/ssh/sshd_config 文件，这里我使用的是 vim 文本编辑器。

1
2
3
4

HostKey /etc/ssh/ssh_host_rsa_key               # 主机私钥文件位置
RSAAuthentication yes                           # 开启 RSA 认证
PubkeyAuthentication yes                        # 开启公钥认证
AuthorizedKeysFile      .ssh/authorized_keys    # 认证公钥文件位置

找到并修改以上 4 条设置，如果被#号注释掉了，删除前面的#号。

然后再文件末尾添加：

1
2

Match User git, Group git
        PasswordAuthentication no

这样就开启了 SSH 的 RSA 公钥认证，并禁用了 git 用户的密码认证登陆功能。

认证公钥文件为用户主目录下的 .ssh/authorized_keys 。

接下来 cd 到 git 用户的主目录，创建 .ssh 目录和 authorized_keys 文件，并设置权限。

1
2
3
4
5

cd /home/git
mkdir .ssh
touch .ssh/authorized_keys
chmod 700 -R .ssh
chown -R git:git .ssh

然后编辑 /home/git/.ssh/authorized_keys 文件，将需要登陆的电脑的 RSA 公钥写入进来，每行一个。
并重启 ssh 服务:

1

/etc/init.d/sshd restart

最后，
因为 git 用户仅用于使用 git 服务器上的管理远程仓库，所以我们应该让 git 用户的终端指向 git-shell。

1

usermod -s /usr/bin/git-shell git

现在就可以轻松的在自己的电脑上使用 git 管理服务器上的远程仓库了~