devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

关于微信小程序爬虫关于token自动更新问题_微信公众号 爬虫的token

作者：笔触狂放9 | 2024-04-14 20:28:59

赞

踩

微信公众号 爬虫的token

　　现在很多的app都很喜欢在微信或者支付宝的小程序内做开发，毕竟比较方便、安全、有流量、不需要再次下载app，好多人会因为加入你让他下载app他会扭头就走不用你的app，毕竟做类似产品的不是你一家。

　　之前做过很多微信小程序的爬虫任务，今天做下记录，防止很久不用后就会忘记，微信小程序分为两大类：

　　1、是不需要登录的（这种的话不做分析，毕竟没什么反爬）

　　2、需要登录的

　　　　2.1 登录一次之后token永久有效

　　　　2.2 登录一次token几分钟内到几小时内失效

　　　　　　2.2.1 登录后一段时间后token时候需要再次调用微信内部方法生成code去换取token（本次主要做的）

　　　　　　2.2.2 跟2.2.1类似，然后又加了一道校验，比如图片验证码，这个类似于微信公众号的茅台预约那种（本次不做分析）

　　微信小程序的登录其实跟其他的web登录不太一样，一般的web登录或者是app登录基本上就是用户名+密码+验证码（图片或者短信）就可以，微信的逻辑是假如你需要登录的话需要获得用户的授权，之后调用微信的内部方法生成一个code，code只能用一次之后就实效，微信解释这个code有效期是5分钟左右。

　　这里是具体流程：https://developers.weixin.qq.com/community/develop/doc/000c2424654c40bd9c960e71e5b009?highLine=code

　　之前爬取过的一个小程序他的反爬是token有效期一个小时，然后单次token可用大概100次左右，当单个token使用次数或者单小时内使用次数超过100次就直接封号处理，24小时内也有频率控制，所以就需要我每小时一次每小时一次的去获取token，当然，因为我是个程序猿，所以我不能每小时手动的去获取这个token，比较这不是我们的风格。

　　这里需要的是python+fiddler+appium+模拟器，大致的思路是通过appium去操控模拟器模拟点击微信的小程序，定期的去做点击，然后fiddler去从请求的头部信息中获取到token，之后写到本地文件中，然后python程序定时的去判断这个本地文件是否进行了更新，更新了的话通过正则来获取到token_list之后去最后一个，因为有可能是当前保存的token已经失效了，小程序还会再次去拿这个token尝试请求一下，假如失效了会调用微信的内部方法生成code来换取token，我这里的爬虫主代码是运行在服务器的，所有又增加了Redis来存储token。

　　一、微信模拟点击

　　微信按照需求条件时间频率模拟点击、滑动、退出等操作，以下的ding_talk的send_msg是增加的钉钉发送消息，此处不再添加，有需求的可以自己查看钉钉机器人文档或者依据自己的需求调整自己的消息提醒。

  1. import time
  2. import logging
  3.  
  4. from appium import webdriver
  5. from ding_talk import send_msg
  6. from handle_file import EnToken
  7. from conf.dbr import RedisClient
  8. from selenium.webdriver.common.by import By
  9. from selenium.webdriver.support.ui import WebDriverWait
  10. from selenium.webdriver.support import expected_conditions as EC
  11. from config import *
  12.  
  13. LOG_FORMAT = "%(asctime)s - %(levelname)s - line:%(lineno)s - msg:%(message)s"
  14. logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
  15. # logging.FileHandler(filename='app.log', encoding='utf-8')
  16.  
  17.  
  18. # 微信获取en token
  19. class WeChat(object):
  20.     def __init__(self):
  21.         """
  22.         初始化
  23.         """
  24.         # 驱动配置
  25.         self.desired_caps = {
  26.             'platformName': PLATFORM,
  27.             'deviceName': DEVICE_NAME,
  28.             'appPackage': APP_PACKAGE,
  29.             'appActivity': APP_ACTIVITY,
  30.             'noReset': True
  31.         }
  32.         self.driver = webdriver.Remote(DRIVER_SERVER, self.desired_caps)
  33.         self.wait = WebDriverWait(self.driver, TIMEOUT)
  34.         self.hours_en = 60 * 60 * 1.1  # en控制1.1小时模拟点击一次
  35.         self.date_start_en = time.time()  # en开始时间
  36.         self.date_end_en = 0  # en超过此时间后再次运行
  37.         # self.date_end_en = self.date_start_en + self.hours_en  # en超过此时间后再次运行
  38.         self.week = 60 * 60 * 24 * 7  # 按照周的频率对xd进行token更新
  39.         self.week_start_xd = time.time()  # xd的开始时间
  40.         self.week_end_xd = 0  # 根据周控制频率控制再次开启时间
  41.         self.week_start_xiu = time.time()  # xd的开始时间
  42.         self.week_end_xiu = 0  # 根据周控制频率控制再次开启时间
  43.  
  44.     def login(self):
  45.         """
  46.         登录微信
  47.         :return:
  48.         """
  49.         # 登录按钮
  50.         a = time.time()
  51.         try:
  52.             login = self.wait.until(EC.presence_of_element_located((By.ID, 'com.tencent.mm:id/f34')))
  53.             login.click()
  54.         except Exception as e:
  55.             # print(e)
  56.             logging.info(f'failed login {e}')
  57.         b = time.time() - a
  58.         # print('点击登录', b)
  59.         logging.info(f'click login,use time {b}')
  60.         # 手机输入
  61.         try:
  62.             phone = self.wait.until(EC.presence_of_element_located((By.ID, 'com.tencent.mm:id/bem')))
  63.             phone.set_text(USERNAME)
  64.         except Exception as e:
  65.             # print(e)
  66.             logging.info(f'something wrong{e}')
  67.         c = time.time() - a - b
  68.         # print('手机号输入', c)
  69.         logging.info(f'send keys phone nums use time {c}')
  70.         # 下一步
  71.         try:
  72.             next = self.wait.until(EC.element_to_be_clickable((By.ID, 'com.tencent.mm:id/dw1')))
  73.             next.click()
  74.         except Exception as e:
  75.             logging.info(f'something wrong{e}')
  76.         d = time.time() - a - b - c
  77.         logging.info(f'click next bottom use time {c}')
  78.         # 密码
  79.         password = self.wait.until(EC.presence_of_element_located((By.XPATH, '//*[@text="请填写微信密码"]')))
  80.         password.set_text(PASSWORD)
  81.         e = time.time() - a - b - c - d
  82.         logging.info(f'send keys password use time {e}')
  83.         # 提交
  84.         # submit = self.wait.until(EC.element_to_be_clickable((By.ID, 'com.tencent.mm:id/dw1')))
  85.         submit = self.wait.until(EC.element_to_be_clickable((By.XPATH, '//*[@text="登录"]')))
  86.         submit.click()
  87.         f = time.time() - a - b - c - d - e
  88.         logging.info(f'commit password use time {f}')
  89.  
  90.     def run(self):
  91.         """
  92.         入口
  93.         :return:
  94.         """
  95.         # 滑动之后等待出现en小程序
  96.         self.slide_down()
  97.         time.sleep(10)
  98.         # 点击进入en小程序
  99.  
  100.         self.touch_en()
  101.         if self.week_end_xd < self.week_start_xd:
  102.             self.week_start_xd = time.time()
  103.             self.week_end_xd = self.week_start_xd + self.week
  104.             print('xd点击')
  105.             self.touch_xd()
  106.  
  107.         elif self.week_end_xiu < self.week_start_xiu:
  108.             self.week_end_xiu = time.time() + self.week
  109.             print('xiu')
  110.             self.touch_xiu()
  111.  
  112.         time.sleep(10)
  113.         # 退出小程序
  114.         self.driver_closed()
  115.         print('driver closed')
  116.         emt = EnToken()
  117.         token_res = emt.token_2_redis()
  118.         if not token_res:
  119.             print('需要发送失败消息')
  120.             return False
  121.         return True
  122.  
  123.     def slide_down(self):
  124.         """
  125.         滑动微信屏幕之后点击小程序
  126.         :return:
  127.         """
  128.         window_size_phone = self.driver.get_window_size()
  129.         # print(window_size_phone)
  130.         phone_width = window_size_phone.get('width')
  131.         phone_height = window_size_phone.get('height')
  132.         # print(phone_width, phone_height)
  133.         time.sleep(15)
  134.         x1 = phone_width * 0.5
  135.         y1 = phone_height * 0.7
  136.         y2 = phone_height * 0.26
  137.         # print('准备向下滑动')
  138.         logging.info(f'prepare slide down')
  139.         a = time.time()
  140.         self.driver.swipe(x1, y2, x1, y1, 2050)
  141.         # print('向下滑动完成', time.time() - a)
  142.         logging.info(f'slide down success use time {time.time() - a}')
  143.  
  144.     def touch_en(self):
  145.         """
  146.         每次进来之后都需要判断是否到了时间，若时间到了之后才可执行点击操作
  147.         :param : en 代表en; xd 代表xd; xiu 代表xiu.
  148.         :return: None 无返回值
  149.         """
  150.         print(self.date_end_en, time.time())
  151.         if self.date_end_en < time.time():  # 此时的时候已经超时，需要再次从新进行点击
  152.             print('en模拟点击')
  153.             # 从新定义开始结束时间
  154.             print(self.date_end_en, time.time())
  155.             self.date_end_en = time.time() + self.hours_en  # 再次更改end time为n小时后
  156.             print(self.date_end_en, time.time())
  157.             try:
  158.                 # print('id定位en')
  159.                 en_app = self.wait.until(
  160.                     EC.presence_of_element_located((By.XPATH, f"//android.widget.TextView[@text='textname…']")))
  161.                 # en_master = self.wait.until(EC.presence_of_element_located((By.ID, 'com.tencent.mm:id/hu')))
  162.                 # en_master = self.wait.until(
  163.                 # EC.presence_of_element_located((By.XPATH, "//android.widget.TextView[@text='textname']")))
  164.                 en_app.click()
  165.                 logging.info(f'located by app_name en')
  166.             except Exception as error:
  167.                 # print(e, 'id定位失败')
  168.                 logging.info(f'failed located by id:{error}')
  169.             time.sleep(20)
  170.             # 关闭小程序按钮点击
  171.             print('close the en app')
  172.             close_button = self.wait.until(EC.presence_of_element_located((By.XPATH, f"//android.widget.FrameLayout[2]/android.widget.ImageButton")))
  173.             close_button.click()
  174.             print('点击了关闭小程序')
  175.  
  176.     def touch_xd(self):
  177.         """
  178.         需要考虑是否已经登录状态还是需要再次登录
  179.         :return:
  180.         """
  181.         # 点击后进入到小程序
  182.         logging.info('click app xd')
  183.         xd_app = self.wait.until(EC.presence_of_element_located((By.XPATH, "//android.widget.TextView[@text='textname']")))
  184.         xd_app.click()
  185.         time.sleep(20)
  186.         # 页面出现需要获取到你的定位的时候需要点击允许
  187.         print('点击确认获取当前位置')
  188.         self.driver.tap([(510, 679)], 500)
  189.  
  190.         # 点击进入到个人中心
  191.         time.sleep(10)
  192.         logging.info('click personal xd')
  193.         self.driver.tap([(540, 1154)], 500)
  194.         # 点击快速登录进行登录
  195.         time.sleep(10)
  196.         logging.info('click login xd')
  197.         self.driver.tap([(270, 1030)], 500)
  198.         # 点击同意获取头像信息
  199.         time.sleep(10)
  200.         logging.info('同意获取头像等相关信息')
  201.         self.driver.tap([(510, 775)], 500)
  202.         time.sleep(20)
  203.         # 关闭小程序按钮点击
  204.         print('close the guaishou app')
  205.         close_button = self.wait.until(
  206.             EC.presence_of_element_located((By.XPATH, f"//android.widget.FrameLayout[2]/android.widget.ImageButton")))
  207.         close_button.click()
  208.         print('结束')
  209.         time.sleep(30)
  210.  
  211.     def touch_xiu(self):
  212.         """
  213.         xiu模拟点击，需要考虑是否需要登录状态下
  214.         :return:
  215.         """
  216.         # 点击后进入到小程序
  217.         logging.info('click app xiu')
  218.         xiu_app = self.wait.until(EC.presence_of_element_located((By.XPATH, "//android.widget.TextView[@text='xiu']")))
  219.         xiu_app.click()
  220.         # 若页面显示需要确认获取当前位置的话需要点击确认
  221.         logging.info('click confirm xiu')
  222.         time.sleep(15)
  223.         confirm_loc = self.wait.until(
  224.             EC.presence_of_element_located((By.XPATH, "//android.widget.Button[@text='确定']")))
  225.         confirm_loc.click()
  226.         # 点击个人中心
  227.         logging.info('click personal xiu')
  228.         time.sleep(5)
  229.         try:
  230.             personal = self.wait.until(
  231.                 EC.presence_of_element_located((By.XPATH, "//android.view.View[@content-desc='个人中心']")))
  232.             personal.click()
  233.         except Exception as e:
  234.             print(e)
  235.         # 点击快速登录进行登录
  236.         logging.info('click login xiu')
  237.         time.sleep(5)
  238.         try:
  239.             login = self.wait.until(EC.presence_of_element_located((By.XPATH, "//android.view.View[@content-desc='立即登录']")))
  240.             login.click()
  241.         except Exception as e:
  242.             print('xiu已经登录，不需要再次点击确认登录')
  243.         time.sleep(30)
  244.  
  245.     def driver_closed(self):
  246.         self.driver.quit()
  247.  
  248.  
  249. if __name__ == '__main__':
  250.     conn_r = RedisClient(db=10)
  251.     count_1 = 0
  252.     # start_time = time.time()
  253.     # end_time = time.time() + 60 * 60 * 1
  254.     we_chat = WeChat()
  255.     try:
  256.         while 1:
  257.             if conn_r.r_size() < 3:  # 监控Redis情况，当Redis中无数据后开始运行一次
  258.                 res = we_chat.run()  # 操作微信做操作点击en小程序生成token
  259.                 if not res:
  260.                     count_1 += 1
  261.                     if count_1 > 10:
  262.                         break  # 当失败十次之后跳出循环
  263.                 # 此处增加限制，每次生成token之后一个小时后才会产生新的token，防止一个token多次使用导致被封号
  264.                 time.sleep(60*60)
  265.             else:
  266.                 time.sleep(60*60)  # 当有数据的时候等待五分钟
  267.             we_chat.driver = webdriver.Remote(DRIVER_SERVER, we_chat.desired_caps)
  268.             we_chat.wait = WebDriverWait(we_chat.driver, TIMEOUT)
  269.     except Exception as e:
  270.         msg = f'业务报警：' \
  271.             f'\n en获取token出现问题' \
  272.             f'\n{e}'
  273.         send_msg(msg)
  274.         # print(e, type(e))
  275.         logging.info(msg)
  276.  
  277. weixin.py
  1. import os
  2.  
  3. # 平台
  4. PLATFORM = 'Android'
  5.  
  6. # 设备名称 通过 adb devices -l 获取
  7. DEVICE_NAME = 'MI_9'
  8.  
  9. # APP路径
  10. APP = os.path.abspath('.') + '/weixin.apk'
  11.  
  12. # APP包名
  13. APP_PACKAGE = 'com.tencent.mm'
  14.  
  15. # 入口类名
  16. APP_ACTIVITY = '.ui.LauncherUI'
  17.  
  18. # Appium地址
  19. DRIVER_SERVER = 'http://localhost:4723/wd/hub'
  20. # 等待元素加载时间
  21. TIMEOUT = 10
  22.  
  23. # 微信手机号密码
  24. USERNAME = 'wechatname'
  25. PASSWORD = 'wechatpwd'
  26.  
  27. # 滑动点
  28. FLICK_START_X = 300
  29. FLICK_START_Y = 300
  30. FLICK_DISTANCE = 700
  31.  
  32. config.py

以下是处理文件，将token获取到后放到Redis中，或者你可以依照你的想法调整

  1. import re
  2. import os
  3. import logging
  4.  
  5. from conf.dbr import RedisClient
  6.  
  7. LOG_FORMAT = "%(asctime)s - %(levelname)s - line:%(lineno)s - msg:%(message)s"
  8. logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT)
  9.  
  10.  
  11. # 处理en token到Redis
  12. class EnToken(object):
  13.     def __init__(self):
  14.         # self.token_path = 'F:\\en.txt'
  15.         # self.token_path = 'F:\\xiu.txt'
  16.         # self.token_path = 'F:\\xd.txt'
  17.         self.conn = RedisClient(db=10)  # 解析日维度价格
  18.         self.conn_en = RedisClient(db=9)  # 解析当前经纬度范围内店铺点位
  19.  
  20.     # 处理en token文件，从文件中读取到token之后只取最后一个，取到之后删除本地文件
  21.     @staticmethod
  22.     def handle_en_txt():
  23.         token_dict = {}
  24.         path_token_list = [
  25.             ('en', '>(e.*?)-->'),
  26.             ('xd', 'headers-->(.*?)-->'),
  27.             ('xiu', r'>(\d+)-->'),
  28.                       ]
  29.         for i in path_token_list:
  30.             token_path = f'F:\\{i[0]}.txt'
  31.             token_re = i[-1]
  32.             if os.path.exists(token_path):
  33.                 with open(token_path, mode='r', encoding='utf-8') as f:
  34.                     token_str = f.read()
  35.                     # print(token_str)
  36.                     # token_list = re.findall('>(e.*?)-->', token_str)
  37.                     # token_list = re.findall('>(Q.*?)-->', token_str)
  38.                     # token_list = re.findall('>(\d+)-->', token_str)
  39.                     token_list = re.findall(token_re, token_str)
  40.                     print(token_list)
  41.                     if token_list:
  42.                         token = token_list[-1]
  43.                         print(token)
  44.                         token_dict[i[0]] = token
  45.                 os.remove(token_path)  # 删除掉
  46.             # return token
  47.         else:
  48.             # print('file_en_dont_exit')
  49.             logging.info('file_en_dont_exit')
  50.         return token_dict
  51.  
  52.     # 将token放到Redis中
  53.     def token_2_redis(self):
  54.         """
  55.         假如token存在的话 则根据token的最后几位做key放入到Redis中
  56.         :return:
  57.         """
  58.         token_dict = self.handle_en_txt()
  59.         print(token_dict)
  60.         if token_dict:
  61.             for token_items in token_dict.items():
  62.                 token_key = token_items[0]
  63.                 token_val = token_items[-1]
  64.                 self.conn.set(token_key, token_val, over_time=None)
  65.                 # self.conn.set(token_key, token, over_time=60*65)  # 设置有效时长65分钟之后失效
  66.                 # self.conn_en.set(token_key, token, over_time=60*65)  # 设置有效时长65分钟之后失效
  67.                 logging.info(f'token success {token_key,token_val}')
  68.             return True
  69.         else:
  70.             logging.info('token dons"t exist')
  71.         self.conn.close()
  72.         self.conn_en.close()
  73.  
  74.  
  75. if __name__ == '__main__':
  76.     en = EnToken()
  77.     en.token_2_redis()
  78.  
  79. handle_file.py

　　二、配置fiddler获取请求头的信息写到本地文件

修改fiddlerscript添加以下内容，在做数据请求的以下增加下面内容

  1. if (oSession.oRequest["Host"]=="这里是请求的host") {
  2.                     var filename = "F:\en.txt";
  3.                     var curDate = new Date();
  4.                     var logContent = 'en' + "[" + curDate.toLocaleString() +  "]";
  5.                     var sw : System.IO.StreamWriter;
  6.                     if (System.IO.File.Exists(filename)){
  7.                           sw = System.IO.File.AppendText(filename);
  8.                           sw.Write(logContent + 'oSession.oRequest.headers-->'  + oSession.oRequest.headers['x-wx-token'] + '-->' + oSession.oRequest.headers  +'\n');
  9.                           // sw.Write("Request header:" + "\n" +  oSession.oRequest.headers);
  10.                           // sw.Write(wap_s + '\n\n')
  11.                     }
  12.                     else{
  13.                           sw = System.IO.File.CreateText(filename);
  14.                           sw.Write(logContent + 'oSession.oRequest.headers-->'  + oSession.oRequest.headers['x-wx-token'] + '-->' + '\n');
  15.                           // sw.Write("Request header:" + "\n" +  oSession.oRequest.headers);
  16.                           // sw.Write(wap_s + '\n\n')
  17.                     }
  18.                     sw.Close();
  19.                     sw.Dispose();
  20.              }
  21.  
  22. fiddler

　　三、主爬虫业务代码

　　此处按照自己的需求逻辑调整自己的业务代码。

 本文章同步发表于博客园

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/423970
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号