Analyse du code source du robot Mobike

PHPz

Libérer： 2017-04-04 10:40:34

original

2505 Les gens l'ont consulté

Les deux premiers articles analysaient pourquoi j'avais récupéré l'interface de Mobike et à la suite de données analyse, cet article fournit directement du code source exécutable pour l'apprentissage.

Déclaration :
Ce robot est uniquement destiné à des fins d'apprentissage et de recherche. Veuillez ne pas l'utiliser à des fins illégales. c'est votre propre responsabilité.

Si vous n'avez pas la patience de lire l'article, merci de directement :

git clone https://github.com/derekhe/mobike-crawler
python3 crawler.py

Copier après la connexion

N'oubliez pas de lui donner une étoile. si ça vous plaît !

Structure des répertoires

analyse - jupyter pour l'analyse des données
afflux -importer - importer vers influxdb, mais je ne l'ai pas bien fait avant
modules - module proxy
web - module d'affichage graphique en temps réel, c'était juste pour apprendre réagir Veuillez voir les résultats ici
crawler.py - code principal du robot
.
importToDb.py - Importer dans la base de données postgres pour analyse
sql.sql - Créer une table sql
start.sh - Script exécuté en continu

Idée

Le code principal est placé dans crawler.py, les données sont d'abord stockées dans le sqlite 3, puis exporté vers un fichier csv pour économiser de l'espace.

L'API de Mobike renvoie les vélos dans une zone carrée. Je peux capturer toute la grande zone en les déplaçant pièce par pièce. .

gauche,haut,droite,bas définit la plage rampante, qui se trouve actuellement à l'intérieur de l'autoroute périphérique de la ville de Chengdu et de la place. zone au sud de Nanhu. offset définit l'intervalle d'exploration. Il est désormais basé sur 0.002 et peut être exploré dans les 15 minutes sur le serveur DigitalOcean 5$

    def start(self):
        left = 30.7828453209
        top = 103.9213455517
        right = 30.4781772402
        bottom = 104.2178123382

        offset = 0.002

        if os.path.isfile(self.db_name):
            os.remove(self.db_name)

        try:
            with sqlite3.connect(self.db_name) as c:
                c.execute('''CREATE TABLE mobike
                    (Time DATETIME, bikeIds VARCHAR(12), bikeType TINYINT,distId INTEGER,distNum TINYINT, type TINYINT, x DOUBLE, y DOUBLE)''')
        except Exception as ex:
            pass

Copier après la connexion

Ensuite, 250 fils de discussion ont été lancés. Quant à vous qui me demandez pourquoi je n'ai pas utilisé de coroutines, humph~~ Je ne l'ai pas appris à l'époque~~~ C'est en fait possible, et c'est peut-être plus efficace. . Élevé.

Puisque les données doivent être dédupliquées pour éliminer les doublons entre les petites zones carrées, le dernier group_data fait exactement cela. Le code API est ici. Pour l'interface API du mini programme, créez-en simplement quelques-uns.

variables

et c'est très simple.

        executor = ThreadPoolExecutor(max_workers=250)
        print("Start")
        self.total = 0
        lat_range = np.arange(left, right, -offset)
        for lat in lat_range:
            lon_range = np.arange(top, bottom, offset)
            for lon in lon_range:
                self.total += 1
                executor.submit(self.get_nearby_bikes, (lat, lon))

        executor.shutdown()
        self.group_data()

Copier après la connexion

Enfin, vous voudrez peut-être demander : les adresses IP fréquentes ne sont-elles pas bloquées ? En fait, Mobike a des restrictions de vitesse d'accès IP, mais la façon de les déchiffrer est très simple, qui consiste à utiliser un grand nombre de proxys.

J'ai un pool d'agents, avec en gros plus de 8 000 agents chaque jour. Obtenez ce pool de proxy directement dans ProxyProvider et fournissez une fonction de sélection

    def get_nearby_bikes(self, args):
        try:
            url = "https://mwx.mobike.com/mobike-api/rent/nearbyBikesInfo.do"

            payload = "latitude=%s&longitude=%s&errMsg=getMapCenterLocation" % (args[0], args[1])

            headers = {
                'charset': "utf-8",
                'platform': "4",
                "referer":"https://servicewechat.com/wx40f112341ae33edb/1/",
                'content-type': "application/x-www-form-urlencoded",
                'user-agent': "MicroMessenger/6.5.4.1000 NetType/WIFI Language/zh_CN",
                'host': "mwx.mobike.com",
                'connection': "Keep-Alive",
                'accept-encoding': "gzip",
                'cache-control': "no-cache"
            }

            self.request(headers, payload, args, url)
        except Exception as ex:
            print(ex)

Copier après la connexion

pour sélectionner au hasard les 50 meilleurs proxys. Veuillez noter que mon pool de proxys est

mis à jour

toutes les heures, mais la liste de proxys de jsonblob fournie dans le code n'est qu'un exemple, et la plupart devraient être invalides après une période de temps. . Un mécanisme de notation par proxy est utilisé ici. Au lieu de sélectionner les agents directement au hasard, j'ai trié les agents en fonction de leurs scores. Chaque demande réussie entraînera l'ajout de points, tandis qu'une demande erronée entraînera la déduction de points. De cette manière, l’agent offrant la meilleure rapidité et la meilleure qualité peut être sélectionné en peu de temps. Vous pouvez le sauvegarder et l'utiliser la prochaine fois si nécessaire.

En utilisation réelle, sélectionnez le proxy via proxyProvider.pick() puis utilisez-le. S'il y a des problèmes avec le proxy, utilisez directement proxy.fatal_error() pour baisser le score, afin que ce proxy ne soit pas sélectionné à l'avenir.

class ProxyProvider:
    def init(self, min_proxies=200):
        self._bad_proxies = {}
        self._minProxies = min_proxies
        self.lock = threading.RLock()

        self.get_list()

    def get_list(self):
        logger.debug("Getting proxy list")
        r = requests.get("https://jsonblob.com/31bf2dc8-00e6-11e7-a0ba-e39b7fdbe78b", timeout=10)
        proxies = ujson.decode(r.text)
        logger.debug("Got %s proxies", len(proxies))
        self._proxies = list(map(lambda p: Proxy(p), proxies))

    def pick(self):
        with self.lock:
            self._proxies.sort(key = lambda p: p.score, reverse=True)
            proxy_len = len(self._proxies)
            max_range = 50 if proxy_len > 50 else proxy_len
            proxy = self._proxies[random.randrange(1, max_range)]
            proxy.used()

            return proxy

Copier après la connexion

D'accord, c'est essentiellement ça~~~ Étudiez les autres codes par vous-même~~~

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!