Flask后端开发(二) - 功能实现和项目总结

小枕头你别跑

Flask后端开发(二) - 功能实现和项目总结


目录

• Flask后端开发(二) - 功能实现和项目总结
  
  
  
  • 1. 功能1：修改文件参数值
    
    
    
    • 1.1. 获取网页端传参
      
    • 1.2. 读取文件
      
      
      
      • 1.2.1. 一般文件读取方式
        
      • 1.2.2. 特殊文件 —— mlx文件
        
      • 1.2.3. 特殊文件 —— .xlx文件
        
      
      
    • 1.3. 查找数据修改位置，替换数据
      
    
    
  • 2. 功能2：读取结果数据
    
    
    
    • 2.1. 实时数据展示如何存储相关数据？
      
    • 2.2. 读取相关数据，整理、打包、传递
      
      
      
      • 2.2.1. 读取.mat文件
        
      • 2.2.2. 读取.xlsx文件
        
      • 2.2.3. 读取.txt/.log文件
        
      
      
    
    
  • 3. 功能3：运行liunx命令行
    
    
    
    • 3.1. 远程连接服务器
      
    • 3.2. 执行liunx命令
      
    • 3.3. 多线程执行
      
    • 3.4. 实时读取liunx命令的输出数据
      
    • 3.5. 随时终止liunx命令的执行
      
    
    
  • 4. 其他收获
    
    
    
    • 4.1. 异常处理
      
    • 4.2 日志生成
      
    • 4.3 环境部署
      
    • 4.4. vscode远程连接服务器
      
    
    
  • 5. 项目感受
    
  • 6. 后记
    
  
  

前情回顾
Flask后端开发(一)-基础知识和前期准备
1. 功能1：修改文件参数值

针对文件参数值的修改，具体流程如下：

• 前端接收用户修改的数据，传递给后端；
  
• 后端接口接收数据之后，读取对应文件；
  
• 定位修改位置，替换数据；
  
• 返回修改结果给前端。
  

1.1. 获取网页端传参

前端传递参数的方式有两种，一种是GET，一种是POST，具体可参考Flask后端开发(一)-基础知识和前期准备
后端接收数据主要使用flask中的request模块，具体代码如下：

1. #包导入
2. from flask import request
4. #前后端协商好传递数据的名称之后，后端根据参数名进行接收
5. if request.method == "POST":
6.     userID= str(request.form.get("userID"))
7. elif request.method == "GET":
8.     userID= str(request.args.get("userID"))
10. #如果需要额外处理，例如字符串"a,b,c"需要转换为列表["a","b","c"]，可以使用split函数
11. BSD= (request.form.get("BSD")).split(",")
13. #注：上述是代码片段，而非完整代码，一般后端接收数据写在接口函数中

复制代码

1.2. 读取文件

1.2.1. 一般文件读取方式

一般文件包括.txt、.c、.log等文件，其内容读取主要使用python中file模块的open函数，具体代码如下：

1. path= "文件路径"
2. with open(path, "r",encoding='utf8') as file:
3.     file_content = file.read()
4. #整个文件内容存储在file_content中

复制代码

关于file模块的具体使用，可参考我的这篇博客:【python技巧】文本文件的读写操作。
1.2.2. 特殊文件 —— mlx文件

本项目的一个特殊之处就是需要处理.mlx文件（实时脚本文件），这是matlab中的一种文件格式，其内容是二进制的，无法直接读取。因此，在本文当中，解决方案是将.mlx文件手动转换为.m文件，然后再读取.m文件的内容（真的很笨蛋，但是有效）。
对于.m文件，则可以按照一般文件的读取方式进行读取。
1.2.3. 特殊文件 —— .xlx文件

本项目中还会涉及到表格文件的数据读写，这里使用的是xlrd模块，具体代码如下：

1. #包导入
2. import xlrd
5. #查找对应文件内容
6. file_path="文件路径"
7. #打开表格
8. wb = xlrd.open_workbook(file_path)
9. ws = wb.sheet_by_name('Sheet1')
10. #按行读取，返回给前端一个行列表：
11. n_rows = ws.nrows#获取行数
12. for i in range(2,n_rows):#按行读取，进行筛选，第一行是表头，第二行开始是数据
13.     get_value=ws.cell(i,3).value#获取第i行第3列的数据

复制代码

1.3. 查找数据修改位置，替换数据

本项目的需求是修改文件中的对应参数，涉及很多代码行的参数修改，因此，需要根据变量名查找相关位置。

• 定位
  根据pytho字符串中的find函数查找变量名所在的位置，参考博客如下Python find()方法，具体代码如下：
  

1. # 其中file_content是文件内容，变量名是需要查找的变量名
2. ## 1. 调度类型
3. start_index_1 = file_content.find(
4.      "simParameters.SchedulingType ="
5. )
6. end_index_1 = file_content.find(
7.      "simParameters.NumUEs =",
8.      start_index_1,
9. )  # 这之间修改schedulingtype的取值
10. ## 2. UESpeed
11. start_index_2 = file_content.find(
12.      "simParameters.UESpeed =", end_index_1
13. )
14. end_index_2 = file_content.find(
15.      "% Validate the UE positions",
16.      start_index_2,
17. )
18. ## 3. max_RB
19. start_index_3 = file_content.find(
20.      "simParameters.NumRBs =", end_index_2
21. )
22. end_index_3 = file_content.find(
23.      "simParameters.SCS =",
24.      start_index_3,
25. )
26. ## 4. SCS
27. start_index_4 = file_content.find(
28.      "simParameters.SCS =", end_index_3
29. )
30. end_index_4 = file_content.find(
31.      "simParameters.DLCarrierFreq =",
32.      start_index_4,
33. )

复制代码

这部分的下标定位情况，可参考我的此篇博客：【python技巧】替换文件中的某几行

• 替换
  在本项目中使用的全文替换，具体代码结构如下：
  

1. # 1. 读取文件
2. path = "文件路径"
3. with open(path, "r",encoding='utf-8') as file:
4. file_content = file.read()
6. # 2. 定位
7. start_index_1 = file_content.find("simParameters.UEPosition =")
8. end_index_1 = file_content.find("simParameters.UESpeed =",start_index_1)  # 这之间修改ue_position的取值
9. start_index_2 = file_content.find("simParameters.Position = ", end_index_1)
10. end_index_2 = file_content.find("csirsConfig = nrCSIRSConfig", start_index_2)
12. if (start_index_1 == -1 or end_index_1 == -1 or start_index_2 == -1 or end_index_1 == -1):
13.   return jsonify({"Error": "找不到对应的参数位置"})
15. # 3.更新参数值
16. updated_content = (
17.   file_content[:start_index_1]
18.   + "simParameters.UEPosition = "
19.   + str(UE_position)
20.   + ";\n")
21. updated_content += file_content[end_index_1:start_index_2]
22. updated_content += "simParameters.Position = "+str(gNB_position)+";% Position of gNB in (x,y,z) coordinates"
23. updated_content += file_content[end_index_2:]
25. # 4. 更新文件
26. if updated_content != "":
27.     with open(path, "w",encoding="utf-8") as file:
28.         file.write(updated_content)
29.     msg = "成功改变相关文件参数\n"
30.     return jsonify({"Sueecess": msg})

复制代码

2. 功能2：读取结果数据

2.1. 实时数据展示如何存储相关数据？

本项目中matlab会使用作图程序实时展示每个时隙的运行结果，但是这个作图程序无法显示在网页端，因此，考虑将数据存储在文件中，然后通过网页端读取文件中的数据，进行展示。
实时数据的存储代码需要手动添加，在matlab每次作图调用的函数中添加如下matlab代码：

1. date_str=datestr(now,31);
2. new_str = replace(date_str,' ','_');
3. new_str=replace(new_str,':','');#添加时间戳
4. filename=sprintf('./文件夹名/file_name_%s.mat',new_str);#定义文件存储相对位置
5. save(filename,"需要存储的变量名");#存储变量

复制代码

2.2. 读取相关数据，整理、打包、传递

2.2.1. 读取.mat文件

根据添加的代码，将会得到若干个.mat文件，需要读取.mat文件的内容并整理成前端需要的格式。
在本文中，是定义一个文件夹名为A，每个时隙的实时数据存储为一个.mat文件，文件名为file_name_时间戳.mat，因此需要读取文件夹A下的所有.mat文件。
在python中读取.mat文件的具体代码如下：

1. #1.包导入
2. import os
3. import scipy.io as sio
5. #2. 读取数据
6. file_list=os.listdir("./文件夹名/")#读取文件夹下所有文件名称，形成列表
7. list_1=[]
8. list_2=[]
9. for file in file_list:#遍历文件列表
10.     file_content= sio.loadmat(f"./文件夹/{file}")#读取文件内容
11.     #这里的写法是根据我的.mat文件结构来的，如果不一样，需要根据自己的文件结构进行修改
12.     list_1.append(file_content["之前存储的变量名"][0].tolist())
13.     list_2.append(file_content["之前存储的变量名"][1].tolist())
14. #之后得到的list_1和list_2就是前端需要的数据
16. #3. 传递给前端
17. result={
18.     "list_1或者其他变量名":list_1,
19.     "list_2或者其他变量名":list_2,
20. }
21. return jsonify(result)#数据打包为json格式，传递给前端

复制代码

2.2.2. 读取.xlsx文件

在项目中，还需要读取.xlsx文件，这里使用的是xlrd模块，具体代码如下：

1. ##包导入
2. import xlrd
4. # 1. 读取文件
5. file_path="文件路径"
6. #打开表格
7. wb = xlrd.open_workbook(file_path)
8. ws = wb.sheet_by_name('Sheet1')
10. #数据读取
11. list_1=[]
12. list_2=[]
13. n_rows = ws.nrows#获取行数
14. for i in range(2,n_rows):#按行读取，进行筛选
15.    list_1.append(float(ws.cell(i,7).value))
16.    list_2.append(float(ws.cell(i,7).value))
17. #之后得到的list_1和list_2就是前端需要的数据
19. #3. 传递给前端
20. result={
21.     "list_1或者其他变量名":list_1,
22.     "list_2或者其他变量名":list_2,
23. }
24. return jsonify(result)#数据打包为json格式，传递给前端

复制代码

2.2.3. 读取.txt/.log文件

在项目中，还需要读取某些文本文件，例如日志文件存储的相关数据，这里使用的是file模块，具体数据读取需要用到正则表达式相关知识，可参考博客【python技巧】文本处理-re库字符匹配，具体代码如下：

1. ##方式1：要查找的内容为：“serveraddr = xxx"，需要提取xxx
2. path= "文件路径"
3. with open(path, "r") as file:  
4.    for line in file:
5.        if "serveraddr" in line:
6.            serveraddr_match = re.search(r'serveraddr\s*=\s*"([^"]+)"', line)
7.            serveraddr = serveraddr_match.group(1) if serveraddr_match else ""
9.        elif "serverport" in line:
10.            serverport_match = re.search(r'serverport\s*=\s*"(\d+)"', line)
11.            serverport = (
12.                int(serverport_match.group(1)) if serverport_match else 0
13.            )
15. ##方式2：要查找的内容为：“itemxx: 数据1;数据2;数据3；”，需要提取xxx
16. path= "文件路径"
17. with open(path, "r") as file:
18.     lines = file.readlines()  # 一次读取并存入lines中，行列表
20. for line in lines:  # 查找lines中包含item的行
21.     if item in line:  # 待查找的条目，提取关键数据
22.         line = line.strip("\n")  # 去掉换行符
23.         dataInOneLine = line.split(";")  # 分割数据
24.         dataInOneLine[0] = dataInOneLine[0].split(":")[1]  # 去掉item部分
25.         for i in range(0, len(dataInOneLine)):  # 去掉空格
26.             dataInOneLine[i] = dataInOneLine[i].strip()
27.         break  # 找到目标行，跳出循环
28. # 行遍历完成，得到行遍历结果dataInOneLine列表，存储关键数据
29. line_content_list = {
30.     "itemName": item,
31.     "数据项1": dataInOneLine[0],
32.     "数据项2": dataInOneLine[1],
33.     "数据项3": dataInOneLine[2],
34. }
35. # 将字典存入result_list，result_list中存储多条目的关键数据
36. result_list.append(line_content_list)

复制代码

3. 功能3：运行liunx命令行

这是本项目较难的一个功能点，需要使用python程序连接服务器，然后执行liunx命令，运行编译指令和matlab代码，并且需要将liunx命令的输出结果实时返回给前端。
3.1. 远程连接服务器

远程服务器连接使用的是paramiko模块，先使用pip install paramiko下载模块，具体代码如下：

1. import paramiko
3. #创建ssh连接，可以复用的公共函数
4. def create_ssh_client(ip, port, username, password):
5.     ssh_client = paramiko.SSHClient()
6.     ssh_client.load_system_host_keys()
7.     ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
8.     ssh_client.connect(ip, port, username, password)#连接服务器
9.     return ssh_client
11. #调用方式：
12. gnb_ssh_client = create_ssh_client(gnb_ip, gnb_port, gnb_username, gnb_password)
13. ue_ssh_client = create_ssh_client(ue_ip, ue_port, ue_username, ue_password)

复制代码

【注意事项】:为了避免之后命令行执行可能存在的权限问题和密码输入问题，推荐使用root身份进行ssh连接。
3.2. 执行liunx命令

一般来说，使用paramiko的invoke_shell函数，然后使用send函数发送命令，使用recv函数接收命令执行结果，具体代码如下：

1. import paramiko
3. def execute_command(ssh_client, command, output_lines):
4.     channel = ssh_client.invoke_shell()
5.     channel.send(command + '\n')
6.     while not channel.exit_status_ready():
7.         time.sleep(1)

复制代码

而关于command的具体写法，这里我简单介绍一下：

• 单行命令：
  直接字符串赋值即可：
  

1. cmd="cd /home'

复制代码

• 多行命令：
  

1. cmd1="cd /home"
2. cmd2="ls"
3. cmd3="其他指令"
4. cmd=cmd1+";"+cmd2+";"+cmd3+"\n"#这样拼接之后，一次性发送给服务器就能按顺序执行多条命令

复制代码

• 特殊命令——matlab脚本文件运行
  pyhton文件通过远程服务器连接执行matlab脚本文件，这里使用的是matlab -r命令，具体命令如下：
  

1. cmd="cd 脚本文件对应文件夹"+";"+"matlab -nodesktop -nosplash -r 脚本文件名，不需要带.m后缀"

复制代码

• 特殊命令——服务器文件复制
  在服务器A的命令端，需要复制得到服务器B的相关文件，这里使用的是scp命令，具体命令如下：
  

1. cmd="sshpass -p 服务器B的密码 scp -P 服务器B的端口 root@服务器B的IP:服务器内的文件路径(例如 /home/user/copy_file.txt) 想要复制在服务器A中的文件位置，例如`/home/user/`"
2. #sshpass是为了避免scp命令需要输入密码，这里直接将密码写在命令中

复制代码

• 特殊命令——文件权限修改
  在服务器A的命令端修改相关文件权限，从而能够被读写，这里使用的是chmod命令，具体命令如下：
  

1. cmd="chmod 777 文件路径"

复制代码

3.3. 多线程执行

为了实现下文的实时读取输出和随时终止命令，都需要使用多线程方式，从而让终端在执行命令行的时候，还能够接收python发送的新请求，返回终端信息或者执行终止操作。
实现多线程需要用到threading模块，具体代码如下：

1. #包导入
2. import threading
3. #全局变量定义
4. gnb_ssh_client = None
5. ue_ssh_client = None
6. gnb_output_lines = []
7. ue_output_lines = []
8. execution_in_progress = False  # 用于标识执行是否正在进行中
10. @model_name.route("/start_process", methods=["POST"])
11. #需要异步多线程的处理方式
12. def start_process():
13.     global gnb_ssh_client, ue_ssh_client, execution_in_progress,gnb_output_lines,ue_output_lines
15.     #前端传递参数
16.     #cmd定义
18.     #cmd拼接
19.     gnb_command="("+cmd1_gnb+";"+cmd2_gnb+";)"
20.     ue_command="(+"scp2ue_cmd_2+";"+cmd0_ue+";"+cmd1_ue+";"+cmd2_ue+";)"
21.     #连接ssh
22.     if gnb_ssh_client is None:
23.         gnb_ssh_client = create_ssh_client(gnb_ip, gnb_port, gnb_username, gnb_password)
25.     if ue_ssh_client is None:
26.         ue_ssh_client = create_ssh_client(ue_ip, ue_port, ue_username, ue_password)
28.     #执行命令
29.     gnb_output_lines=[]#先清空命令行输出
30.     ue_output_lines=[]
31.     gnb_thread = threading.Thread(target=execute_command, args=(gnb_ssh_client, gnb_command, gnb_output_lines, "gnb"))
32.     ue_thread = threading.Thread(target=execute_command, args=(ue_ssh_client, ue_command, ue_output_lines, "ue"))
34.     execution_in_progress = True
35.     gnb_thread.start()
36.     ue_thread.start()
38.     return jsonify({"success": "Execution started.","execution_in_progress":execution_in_progress})
39. #ssh连接的公用函数
40. def create_ssh_client(ip, port, username, password):
41.     ssh_client = paramiko.SSHClient()
42.     ssh_client.load_system_host_keys()
43.     ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
44.     ssh_client.connect(ip, port, username, password)
45.     return ssh_client
47. #命令执行的公用函数:注意和前文的代码区别，添加了多线程相关代码
48. def execute_command(ssh_client, command, output_lines, identifier):
49.     channel = ssh_client.invoke_shell()
50.     output_thread = threading.Thread(target=get_output, args=(channel, output_lines, identifier))
51.     output_thread.start()
53.     channel.send(command + '\n')
55.     while not channel.exit_status_ready():
56.         time.sleep(1)
58.     # 等待输出线程完成
59.     output_thread.join()

复制代码

3.4. 实时读取liunx命令的输出数据

按照多线程的方式执行代码之后，如何才能实时获取命令行的输出数据呢？
首先我们介绍一下整个命令行执行过程中，前后端所进行的操作：

• step1：
  
  
  
  • 前端：发送命令行执行请求；
    
  • 后端：调用命令行执行的接口(例如/start_process)
    
  • 服务器：建立ssh连接，执行命令行；
    
  
  
• step2：
  
  
  
  • 前端：按照一定的时间间隔，发送数据请求；
    
  • 后端：调用数据请求的接口(例如/get_output)
    
  • 服务器：继续执行命令，命令行输出数据被存储在全局变量中；
    
  
  
• step3：
  
  
  • 前端：发送终止命令行执行请求；
    
  • 后端：调用终止命令行执行的接口(例如/stop_process)
    
  • 服务器：终止命令行执行，关闭ssh连接。
    
  
  

因此，此处的实时读取命令行输出数据，就是在step2中，前端按照一定的时间间隔，发送数据请求，后端调用数据请求的接口，返回命令行输出数据。具体代码如下：

1. @model_name.route('/get_output', methods=['POST', 'GET'])
2. def get_output():#读取全局变量内容即可
3.     global gnb_output_lines, ue_output_lines
5.     gnb_output = "\n".join(gnb_output_lines)
6.     ue_output = "\n".join(ue_output_lines)
8.     return jsonify({
9.         "gnb_output": gnb_output,
10.         "ue_output": ue_output
11.     })
13. def execute_command(ssh_client, command, output_lines, identifier):
14.     channel = ssh_client.invoke_shell()
15.     output_thread = threading.Thread(target=get_output, args=(channel, output_lines, identifier))#这一步是关键，将命令行输出数据存储在全局变量中
16.     output_thread.start()
18.     channel.send(command + '\n')
20.     while not channel.exit_status_ready():
21.         time.sleep(1)
23.     # 等待输出线程完成
24.     output_thread.join()
26. def get_output(channel, output_lines, identifier):#核心代码，将命令行执行的输出数据存储在全局变量中，需要和上文的`execute_command`函数配合使用
27.     while not channel.exit_status_ready():
28.         if channel.recv_ready():
29.             output = channel.recv(1024).decode('utf-8')
30.             lines = output.split('\n')
31.             for line in lines:
32.                 if line.strip():
33.                     formatted_line = f"[{identifier}]：{line.strip()}"
34.                     #print(formatted_line)
35.                     output_lines.append(formatted_line)

复制代码

3.5. 随时终止liunx命令的执行

这个功能是为了避免指令执行无法自行终止，需要用户手动选择结束仿真。
在多线程的命令行执行中，前端发送请求，而后端在原有ssh连接的基础上，发送终止命令，具体代码如下：

1. @model_name.route('/stop_process', methods=['POST'])
2. def stop_process():
3.     global gnb_ssh_client, ue_ssh_client, execution_in_progress
5.     if not execution_in_progress:#如果没有命令行执行，返回错误信息
6.         return jsonify({"error": "No execution in progress.","execution_in_progress":execution_in_progress})
8.     if ue_ssh_client is not None:#断开ued的ssh连接
9.         stop_execution(ue_ssh_client)
10.         ue_ssh_client.close()
11.         ue_ssh_client = None
13.     if gnb_ssh_client is not None:#断开gnb的ssh连接
14.         stop_execution(gnb_ssh_client)
15.         gnb_ssh_client.close()
16.         gnb_ssh_client = None
18.     execution_in_progress = False
20.     return jsonify({"success": "Execution stopped.","execution_in_progress":execution_in_progress})
22. #终止指令执行的公用函数
23. def stop_execution(ssh_client):
24.     ssh_client.invoke_shell().send('\x03')  # 发送Ctrl+C来终止命令

复制代码

4. 其他收获

4.1. 异常处理

在后端程序执行过程中，可能会出现各种checked exeption，这类异常需要程序员进行捕获，不然则会影响程序的运行，产生报错，而这里我们可以将这些异常捕获之后，将信息作为返回值传递给前端，从而让用户知道程序运行成功与否。
具体代码结构如下：

1. @model_name.route('/function_name', methods=['POST'])
2. def function_name():
3.     try:
4.        #程序运行代码
5.     except Exception as e:
6.        return jsonify({"error": str(e)})
7.     finally:
8.        #程序运行结束后的代码，例如return jsonify({"success": "Execution stopped."})

复制代码

4.2 日志生成

在上一篇博客中，我们提到了分模块的flask项目结构，而日志部分的处理，需要在主文件app.py中。添加如下代码：

1. import logging
3. log_filename = 'app.log'  # 日志文件名
4. log_level = logging.DEBUG  # 日志级别
5. log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'  # 日志格式
7. # 配置日志
8. logging.basicConfig(filename=os.path.join(os.path.dirname(__file__), log_filename), level=log_level, format=log_format)

复制代码

则可以在程序运行过程中，将日志信息存储在app.log文件中，相关报错信息也会存储在该文件中，方便程序员进行调试。
4.3 环境部署

当我们在本地进行程序开发之后，需要将程序部署到服务器上，而迁移到服务器上或者别人的电脑上，需要安装相关的环境。在这种情况下，我们可以将自己开发用到的包进行打包，然后在服务器上进行安装，具体步骤如下：

• 将当前环境中的包信息存储在requirements.txt文件中，存储在当前文件夹目录下
  

pip freeze > requirements.txt

• 将整个项目文件打包之后，其他人可使用如下命令进行安装：
  

pip install -r requirements.txt

4.4. vscode远程连接服务器

当我们在服务器上部署完项目代码之后，可能会经过多次测试和调试，因此代码会不断被修改，且会被无数次的运行，如果每次都是本地修改＋服务器部署运行，实在有些不够优雅，因此，我们可以试着把自己的本地编辑器连接到服务器上，这样就可以在本地进行服务器端代码的修改，然后直接在服务器上运行，这样就可以避免每次修改都需要部署的麻烦。
我在项目中使用的是vscode，具体步骤如下：

• 插件安装：Remote-SSH
  
• 选择新建远程，输入ssh连接信息
  
  
  
  
  
• 连接之后选择想要编辑的项目文件夹，即可在本地编辑器中进行服务器端代码的修改；
  
• 调试的时候可使用vscode进行运行、部署；
  

具体的配置细节，可参考博客
5. 项目感受

• 项目的文件读写、服务器连接等都是非常有趣的功能，多线程解决实时输出算是一个较大的技术难点；
  
• 项目本身难度不大，主要难点在于理解业务本身，如果有相对应的业务文档，可能开发效率会更高一点；
  
• 后端开发部分也需要了解基本的前端知识，例如前后端数据传递、前端页面的渲染等，这样才能更好的理解前端的需求，从而更好的进行后端开发；
  
• 项目对接需要良好的文档编辑能力和沟通能力；
  
• 相关业务的具体实现，也是体现个人智慧的时刻，具体的开发技术和解决问题的智慧都是必不可少的，开发技术是工具，而我们需要用自己已有的工具去实现某些功能，这是一种思维方式，也是一种能力。，当然，技术会的越多，能用的工具越多，解决问题的思路就不会被限制；
  
• 总会有开发者不会的东西，这是一个学习的过程，重点在于不断地学习，虚心请教和快速掌握。
  

6. 后记

如果觉得我写得还算不错，不妨点赞关注一波走起~
想看更多博文，请访问我的各平台主页:博客园  /  CSDN  /  51CTO  /  掘金论坛  /  知乎

来源:https://www.cnblogs.com/CrazyPixel/p/17796888.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！