PHP定时任务获取微信access_token的例子

微信access_token在开发时会变的好像是几分种不一样了，这里我们来看一篇关于PHP定时任务获取微信access_token的例子吧。

最近开发微信公众平台，公众号调用各接口时都需使用access_token，access_token是公众号的全局唯一接口调用凭据，开发时需要进行妥善保存。 access_token有效期为7200秒 ，重复获取将导致上次获取的access_token失效。
由于微信对获取access_token的api调用次数做了限制，建议开发者全局存储与更新access_token，频繁刷新access_token会导致api调用受限，影响自身业务。
那么有什么好的解决access_token存储和刷新的办法呢？ 我的办法是：计划任务定时刷新获取access_token，然后将access_token保存到服务器本地，保存方式可以是文件、数据库或缓存中。
下面我使用PHP来获取access_token，并保存到本地文件中。建立一个access.php，代码如下：
$url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=".AppID."&secret=".AppSecret;
 
$result = http_request($url);
//生成文件，保存token
$dir = __DIR__; //真实路径，crontab命令的php执行在cli模式下，不能正确识别相对路径，所以使用__DIR__
$filename = $dir."/access_token.php";
create_file($filename, $result);
 
function http_request($url,$data = null){
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);
    curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, FALSE);
    if (!empty($data)){
        curl_setopt($curl, CURLOPT_POST, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
    }
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
    $output = curl_exec($curl);
    curl_close($curl);
    return $output;
}
 
//生成文件
function create_file($filename, $content){
    $fp = fopen($filename, "w");
    fwrite($fp, "" . $content);
    fclose($fp);
}
以上代码中AppID和AppSecret这两个常量是由微信公众平台提供，可以登录到微信公众平台的基本配置里获取。获取到的access_token被保存到文件access_token.php中，注意这个文件内容不要被用户访问到。
接下来，我们设置定时任务，我们以Linux的CentOS为例，使用crontab设置计划任务。
5 * * * * /usr/local/bin/php -f /home/web/access.php >> /dev/null 2>&1
以上命令设置了每隔1小时，即每小时的第05分钟执行access.php。
这样，我们就可以保证access_token的正常获取和使用，不用频繁的去刷新微信服务器了。

SSO英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一,下面我们来看看吧。

简单讲一下 SSO 单点登录系统的接入的原理，前提是系统本身有完善的用户认证功能，即基本的用户登录功能，那做起来就很方便了。

SSO 登录请求接口往往是接口加上一个回调地址，访问这个地址会跳转到回调地址并带上一个 ticket 参数，拿着这个 ticket 参数再请求接口可以获取到用户信息，如果存在用户则自动登录，不存在就新增用户并登录。

比如这个 SSO 模型实现了两个方法，一个是获取接口 url，一个是凭 ticket 获取用户信息：

PHP

interface SSOLogin
{
    /**
     * 获取登录用户信息
     * @param $ticket
     * @return mixed
     */
    public function getInfoFromTicket($ticket);

    /**
     * 单点登录授权地址
     * @return mixed
     */
    public function getAuthUrl();
}

再来看看控制器的主要方法，比如回调地址是跳转到控制器 http://www.example.com/sso/check?ticket=xxxx

/**
 * 检测是否单点登录
 * @return bool|string
 */
public function actionCheck()
{
    $ticket = Yii::$app->getRequest()->get('ticket');
    if (!$ticket) {
        return $this->renderAuthError('请先授权', sprintf('<a href="%s">点击登录单点登录系统</a>', SSOlogin::getInstance()->getAuthUrl()));
    }
    $userInfo = SSOlogin::getInstance()->getInfoFromTicket($ticket);
    if (empty($userInfo['username'])) {
        return $this->renderAuthError('请先授权', sprintf('<a href="%s">点击登录单点登录系统</a>', SSOlogin::getInstance()->getAuthUrl()));
    }
 
    $username = $this->getUserName($userInfo['username']);
    $user = User::find()->canLogin()->username($username)->one();
    if (!$user) {
        $newUser = [];
        $newUser['username'] = $userInfo['username'];
        $newUser['email'] = $this->getUserName($userInfo['username']);
        $newUser['role'] = User::ROLE_DEV;
        $newUser['is_email_verified'] = 1;
        $newUser['realname'] = $userInfo['truename'];
        $user = $this->addUser($newUser);
    }
    $isLogin = Yii::$app->user->login($user, 3600 * 24 * 30);
    if ($isLogin) {
        $this->redirect('/task/index');
    }
    return true;
}
大概看看这个控制器逻辑就明白了。SSO 接口起到的作用就是获取用户信息，拿这个用户信息跟系统用户表对比，存在用户则进行登录，不存在创建用户并登录。

这是一个内部的单点系统，集成到后台，可能其他的 SSO 跟这不太一样，但基本原理过程差不多。

多线程爬虫可以用于抓取内容了这个可以提升性能了，这里我们来看php与python 线程池多线程爬虫的例子，具体的代码如下。

php例子

<?php
 
class Connect extends Worker  //worker模式
{
 
public function __construct()
{
 
}
 
public function getConnection()
{
if (!self::$ch)
{
self::$ch = curl_init();
curl_setopt(self::$ch, CURLOPT_TIMEOUT, 2);
curl_setopt(self::$ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt(self::$ch, CURLOPT_HEADER, 0);
curl_setopt(self::$ch, CURLOPT_NOSIGNAL, true);
curl_setopt(self::$ch, CURLOPT_USERAGENT, "Firefox");
curl_setopt(self::$ch, CURLOPT_FOLLOWLOCATION, 1);
}
 
/* do some exception/error stuff here maybe */
 
return self::$ch;
}
 
public function closeConnection()
{
curl_close(self::$ch);
}
 
/**
* Note that the link is stored statically, which for pthreads, means thread local
* */
protected static $ch;
 
}
 
class Query extends Threaded
{
 
public function __construct($url)
{
$this->url = $url;
}
 
public function run()
{
$ch = $this->worker->getConnection();
curl_setopt($ch, CURLOPT_URL, $this->url);
$page = curl_exec($ch);
$info = curl_getinfo($ch);
$error = curl_error($ch);
$this->deal_data($this->url, $page, $info, $error);
 
$this->result = $page;
}
 
function deal_data($url, $page, $info, $error)
{
$parts = explode(".", $url);
 
$id = $parts[1];
if ($info['http_code'] != 200)
{
$this->show_msg($id, $error);
} else
{
$this->show_msg($id, "OK");
}
}
 
function show_msg($id, $msg)
{
echo $id."\t$msg\n";
}
 
public function getResult()
{
return $this->result;
}
 
protected $url;
protected $result;
 
}
 
function check_urls_multi_pthreads()
{
global $check_urls;  //定义抓取的连接
$check_urls = array( 'http://xxx.com' => "xx网",);
$pool = new Pool(10, "Connect", array()); //建立10个线程池
foreach ($check_urls as $url => $name)
{
$pool->submit(new Query($url));
}
$pool->shutdown();
}
 
check_urls_multi_pthreads();

python 多线程

def handle(sid)://这个方法内执行爬虫数据处理
pass
class MyThread(Thread):
"""docstring for ClassName"""
def __init__(self, sid):
Thread.__init__(self)
self.sid = sid
 
def run():
handle(self.sid)
 
threads = []
for i in xrange(1,11):
t = MyThread(i)
threads.append(t)
t.start()
 
for t in threads:
t.join()

python 线程池爬虫

from queue import Queue
from threading import Thread, Lock
import urllib.parse
import socket
import re
import time
 
seen_urls = set(['/'])
lock = Lock()
 
 
class Fetcher(Thread):
    def __init__(self, tasks):
        Thread.__init__(self)
        self.tasks = tasks
        self.daemon = True
 
        self.start()
 
    def run(self):
        while True:
            url = self.tasks.get()
            print(url)
            sock = socket.socket()
            sock.connect(('localhost', 3000))
            get = 'GET {} HTTP/1.0\r\nHost: localhost\r\n\r\n'.format(url)
            sock.send(get.encode('ascii'))
            response = b''
            chunk = sock.recv(4096)
            while chunk:
                response += chunk
                chunk = sock.recv(4096)
 
            links = self.parse_links(url, response)
 
            lock.acquire()
            for link in links.difference(seen_urls):
                self.tasks.put(link)
            seen_urls.update(links)   
            lock.release()
 
            self.tasks.task_done()
 
    def parse_links(self, fetched_url, response):
        if not response:
            print('error: {}'.format(fetched_url))
            return set()
        if not self._is_html(response):
            return set()
        urls = set(re.findall(r'''(?i)href=["']?([^\s"'<>]+)''',
                              self.body(response)))
 
        links = set()
        for url in urls:
            normalized = urllib.parse.urljoin(fetched_url, url)
            parts = urllib.parse.urlparse(normalized)
            if parts.scheme not in ('', 'http', 'https'):
                continue
            host, port = urllib.parse.splitport(parts.netloc)
            if host and host.lower() not in ('localhost'):
                continue
            defragmented, frag = urllib.parse.urldefrag(parts.path)
            links.add(defragmented)
 
        return links
 
    def body(self, response):
        body = response.split(b'\r\n\r\n', 1)[1]
        return body.decode('utf-8')
 
    def _is_html(self, response):
        head, body = response.split(b'\r\n\r\n', 1)
        headers = dict(h.split(': ') for h in head.decode().split('\r\n')[1:])
        return headers.get('Content-Type', '').startswith('text/html')
 
 
class ThreadPool:
    def __init__(self, num_threads):
        self.tasks = Queue()
        for _ in range(num_threads):
            Fetcher(self.tasks)
 
    def add_task(self, url):
        self.tasks.put(url)
 
    def wait_completion(self):
        self.tasks.join()
 
if __name__ == '__main__':
    start = time.time()
    pool = ThreadPool(4)
    pool.add_task("/")
    pool.wait_completion()
    print('{} URLs fetched in {:.1f} seconds'.format(len(seen_urls),time.time() - start))

微信支付api.mch.weixin.qq.com域名解析慢了，导致付款是非常的慢了，那么要如何来解决微信支付慢的问题呢，今天我们就一起来看看吧。

有朋友在阿里云主机实现微信支付逻辑时，发现api.mch.weixin.qq.com的解析实在是太慢了。
因此出现了手动修改/etc/hosts的情况，当然了，哪天微信支付要是换个机房肯定要挂。

我们的机房也有相似的同题，专门记录一下。

代码里用curl来请求微信，经常超时，这时使用wget试验：
[root@01 tmp]# wget api.mch.weixin.qq.com
--2016-06-18 14:51:03--  http://api.mch.weixin.qq.com/
Resolving api.mch.weixin.qq.com...  域名解析很久不出来
测试确认是ipv6问题

给wget加上-4，强制使用ipv4，如果很快，那基本上确定是ipv6惹的祸了。
[root@01 tmp]# wget -4 api.mch.weixin.qq.com
--2016-06-18 17:03:52--  http://api.mch.weixin.qq.com/
Resolving api.mch.weixin.qq.com... 123.151.71.149, 123.151.79.109
Connecting to api.mch.weixin.qq.com|123.151.71.149|:80... connected.
代码分析

专门写个代码来测试ipv6的解析，用到系统函数getaddrinfo:
#include <stdio.h>
#include <string.h>
#include <netdb.h>
#include <iostream>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

using namespace std;

int main() {

    struct addrinfo hints,*answer,*curr,*p;

    int error;

    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_INET6;//AF_UNSPEC; // use AF_INET6 to force IPv6
    hints.ai_socktype = SOCK_STREAM;//SOCK_DGRAM; // SOCK_STREAM

    if ((error = getaddrinfo("api.mch.weixin.qq.com", NULL, &hints, &answer)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(error));
        return 1;
    } else cout <<"Success with a URL\n";

    char ipstr[16];
    for (curr = answer; curr != NULL; curr = curr->ai_next) {
        inet_ntop(AF_INET,&(((struct sockaddr_in *)(curr->ai_addr))->sin_addr),ipstr, 16);
        printf("%s\n", ipstr);
    }

    freeaddrinfo(answer);

    return 0;
}
包含头文件
netdb.h
函数原型
int getaddrinfo( const char hostname, const char service, const struct addrinfo *hints, struct addrinfo **result );
参数说明
hints：可以是一个空指针，也可以是一个指向某个addrinfo结构体的指针，调用者在这个结构中填入关于期望返回的信息类型的暗示。举例来说：如果指定的服务既支持TCP也支持UDP，那么调用者可以把hints结构中的ai_socktype成员设置成SOCK_DGRAM使得返回的仅仅是适用于数据报套接口的信息。而是否ipv6则由ai_family决定。
result：本函数通过result指针参数返回一个指向addrinfo结构体链表的指针。
返回值：0——成功，非0——出错

测试结果

ai_family为ipv6时，只会寻找ipv6的解析结果，一般域名也没设置。ai_family为AF_UNSPEC时，会先ipv6再ipv4的，而api.mch.weixin.qq.com这个域名的ipv6解析出奇的慢（qq.com却不慢，原因见后）。

解决办法

如果是curl，c可以强制指定ipv4，使用curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
其他语言的也参考此法。
测试代码下载

深层原因分析

nslookup -query=AAAA api.mch.weixin.qq.com -debug 是找不到解析的（指定的AAAA就是ipv6），然后会发现一个SOA声明和他的上级weixin.qq.com有一个ipv6的CNAME，到了minorshort.weixin.qq.com，而这域名又是没有ipv6的解析的。
目测ipv6找解析时是在这个SOA和CNAME的地方打圈了，微信的同学们是不是考虑让大伙好过一点，把这些个域名的ipv6设置去掉。
dig @ns-tel1.qq.com weixin.qq.com AAAA

weixin.qq.com.        43200   IN   SOA  ns-tel1.qq.com. webmaster.qq.com. 1293502040 300 600 86400 300