日常开发技术收集积累

扫描连接WIFI

高并发场景设计

设计一个高并发秒杀场景需要考虑以下几个方面

在高并发场景下，常用的可任务队列

基于Windows的Kafka有关环境搭建、以及使用.NET环境开发的案例代码与演示

关于个性化推荐

远程桌面解决断开后UI交互问题

微信还能接入HTTP协议？定制微信机器人，做消息推送，AI聊天

如何防止线上活动优惠券被仿

免费地图解决方案

多媒体开发知识积累

正片叠底（Multiply）和滤色（Screen）是两种基本的混合模式

Puppeteer相关技术收集

Puppeteer 简介

Puppeteer一些高级玩儿法

通过API将图片上传到免费图床-遇见图床

防止恶意访问攻击

各大地图厂商收费，免费解决方案

所谓的支付宝/微信支付“云面签”原理

C#框架相关笔记

大型分布式系统设计初版

直播App架构

扫描连接WIFI

生成播放视频的URL的二维码，用户扫描开始播放视频，播放完后展示连接WIFI二维码，用户手动扫码连接

小程序实现设置WIFI

/**

 * 页面的初始数据

 */

data: {

  wifiname:'wifi商家',

  ssid: '@Ruijie-sDE3D',

  bssid: '0',

  password: '12345678',

},

/**

 * 生命周期函数--监听页面加载

 */

onLoad: function (options) {

    console.log("111",options)

    var wifiname = options.wifiname

  var qssid = options.alias;

//   var qbssid = options.bssid;

  var qpassword = options.wifipass;

  this.setData({

    wifiname:wifiname,

    ssid: qssid,

    // bssid: qbssid,

    password: qpassword

  })

var that = this

},

/**

 * 点击连接按钮触发

 */

connectWifi: function() {

  const that = this;

  wx.showToast({

    title: '请稍等',

    icon: 'loading',

    duration: 500//持续的时间

  })

  that.startWiFi();

},

/**

 * 加载WiFi模块

 */

startWiFi: function() {

  const that = this;

  wx.startWifi({

    complete: (res) => {

      that.connected();

    },

  })

},

/**

 * 连接WiFi

 */

connected: function() {

  const that = this; 

  wx.connectWifi({

    SSID: that.data.ssid,

    // BSSID: that.data.bssid,

    password: that.data.password,

    success: () => {

      wx.showToast({

        title: 'WiFi连接成功',

      })

      // 跳转至成功页面

      wx.redirectTo({

        url: '/pages/success/success',

      })

    },

    fail: (res) => {

      that.errorDialog(res);

    }

  })

},

/**

 * 连接失败弹窗

 * @param {错误返回} res 

 */

errorDialog: function(res) {

  const that = this;

  wx.showModal({

    title: '连接失败',

    content: '连接失败请打开wifi或复制连接',

    confirmText: '复制密码',

    success (res) {

      if (res.confirm) {

        that.copyPassword();

      } else if (res.cancel) {

        console.log('cancel')

      }

    },

    fail(res) {

      wx.showToast({

        title: res.errMsg,

      })

    }

  });

},

/**

 * 复制密码到剪贴板

 */

copyPassword: function() {

  const that = this;

  wx.setClipboardData({

    data: that.data.password,

    success (res) {

      wx.getClipboardData({

        success (res) {

          console.log(res.data);

        }

      })

    }

  })

},

/**

 * 生命周期函数--监听页面初次渲染完成

 */

onReady: function () {

},

/**

 * 生命周期函数--监听页面显示

 */

onShow: function () {

},

/**

 * 生命周期函数--监听页面隐藏

 */

onHide: function () {

},

/**

 * 生命周期函数--监听页面卸载

 */

onUnload: function () {

},

/**

 * 页面相关事件处理函数--监听用户下拉动作

 */

onPullDownRefresh: function () {

},

/**

 * 页面上拉触底事件的处理函数

 */

onReachBottom: function () {

},

/**

 * 用户点击右上角分享

 */

onShareAppMessage: function () {

}

高并发场景设计

设计一个高并发秒杀场景需要考虑以下几个方面

1.数据库设计：选择适合高并发场景的数据库，如使用关系型数据库时可以采用分库分表的方式来提高数据库的读写性能。可以使用缓存技术来减轻数据库的压力，如使用Redis缓存热门商品信息。

2.队列系统：引入消息队列系统可以有效地削峰填谷，平衡请求的处理速度和系统的承载能力。秒杀请求可以先进入消息队列，再由后台异步处理，避免直接对数据库进行高并发的读写操作。

3.缓存优化：使用缓存来存储热门商品的库存信息，减少对数据库的频繁访问。可以使用分布式缓存，如Redis，来提高读取速度。

4.分布式系统：采用分布式架构来分担系统的负载，将请求分散到多个服务器上进行处理。可以使用负载均衡技术，如Nginx，进行请求的分发，保证每个服务器的压力均衡。

5.限流与排队：为了保护系统的稳定性，可以对请求进行限流，限制每秒的请求数量。同时，可以为每个用户分配一个唯一的标识符，通过排队系统来控制用户的访问顺序，避免系统被过多的请求拖垮。

6.异步处理：将秒杀请求的处理过程异步化，如使用消息队列、多线程等方式，保证请求的快速响应，避免阻塞其他请求的处理。

7.前端优化：通过前端技术，如CDN加速、页面静态化等，减少对后端的请求，提高用户访问的响应速度。可以采用前端缓存技术，如Local Storage，将商品信息缓存在前端，减少对后端的请求次数。

8.安全措施：为避免恶意请求和刷单行为，可以引入验证码、IP限制、用户身份验证等安全措施，保障系统的公平性和安全性。

以上是设计高并发秒杀场景的一些思路，具体的设计方案还需根据实际需求和系统架构进行详细的规划和实施。

在高并发场景下，常用的可靠任务队列

1.RabbitMQ：RabbitMQ是一个流行的开源消息队列系统，支持多种消息传输协议，如AMQP、MQTT等。它具有高可靠性、可持久化、分布式和高并发处理能力，适用于各种异步任务和消息传递场景。Kafka是一个分布式的发布-订阅消息系统，能够支撑海量数据的数据传递。在离线和实时的消 息处理业务系统中，Kafka都有广泛的应用。Kafka将消息持久化到磁盘中，并对消息创建了备份保证了 数据的安全。Kafka在保证了较高的处理速度的同时，又能保证数据处理的低延迟和数据的零丢失。

2.Apache Kafka：Kafka是一个分布式的流处理平台，也可以用作可靠的消息队列。Kafka以高吞吐量、持久性和可扩展性而闻名，适用于大规模数据处理和实时流处理场景。

3.Redis：Redis是一个内存中的数据结构存储系统，也可以用作消息队列。它支持发布/订阅模式和列表数据结构，可用于处理高并发的任务队列。

4.Apache ActiveMQ：ActiveMQ是一个基于Java的开源消息队列系统，支持多种消息传输协议，如AMQP、STOMP等。它具有高可用性、可靠性和扩展性，适用于异步任务处理和分布式系统集成。

5.Amazon Simple Queue Service (SQS)：SQS是亚马逊提供的一项托管消息队列服务，具有高度可靠性和可伸缩性。它支持标准队列和先入先出队列，适用于分布式系统和云计算环境。

这些可靠任务队列都具有不同的特点和适用场景，选择适合自己项目需求的队列系统需要综合考虑系统架构、可用性、性能要求和开发语言等因素。

总结

1：吞吐量较低：Kafka和RabbitMQ都可以。

2：吞吐量高：Kafka

以下是一个使用C#操作Kafka的可靠任务队列的简单示例：

首先，你需要安装NuGet包来引入Kafka相关库。使用Visual Studio的话，可以通过NuGet包管理器添加以下两个包：

Confluent.Kafka：提供了Kafka的客户端库。

Confluent.Kafka.Serialization：提供了Kafka消息的序列化和反序列化支持。

接下来，可以使用以下代码示例来创建一个生产者（Producer）和一个消费者（Consumer）：

using Confluent.Kafka;

using System;

using System.Threading;

class Program

{

    static void Main(string[] args)

    {

        string bootstrapServers = "localhost:9092"; // Kafka服务器地址和端口

        string topic = "my-topic"; // Kafka主题名称

        // 生产者

        var producerConfig = new ProducerConfig { BootstrapServers = bootstrapServers };

        using (var producer = new ProducerBuilder<Null, string>(producerConfig).Build())

        {

            // 发送消息

            var message = new Message<Null, string> { Value = "Hello Kafka" };

            var deliveryReport = producer.ProduceAsync(topic, message).Result;

            Console.WriteLine($"Message delivered to {deliveryReport.TopicPartitionOffset}");

            // 等待消息发送完成

            producer.Flush(TimeSpan.FromSeconds(10));

        }

        // 消费者

        var consumerConfig = new ConsumerConfig

        {

            BootstrapServers = bootstrapServers,

            GroupId = "my-group",

            AutoOffsetReset = AutoOffsetReset.Earliest

        };

        using (var consumer = new ConsumerBuilder<Ignore, string>(consumerConfig).Build())

        {

            // 订阅主题

            consumer.Subscribe(topic);

            CancellationTokenSource cts = new CancellationTokenSource();

            Console.CancelKeyPress += (_, e) =>

            {

                e.Cancel = true; // 阻止进程退出

                cts.Cancel();

            };

            try

            {

                // 消费消息

                while (true)

                {

                    var consumeResult = consumer.Consume(cts.Token);

                    Console.WriteLine($"Received message: {consumeResult.Message.Value}");

                }

            }

            catch (OperationCanceledException)

            {

                // 用户取消操作

            }

            finally

            {

                consumer.Close();

            }

        }

    }

}

在这个示例中，我们创建了一个生产者来发送消息到指定的Kafka主题，然后创建了一个消费者来订阅该主题并接收消息。你可以根据自己的需求进行扩展和修改。

请确保将bootstrapServers设置为你的Kafka服务器地址和端口，将topic设置为你要使用的主题名称。此外，你还可以根据实际需求配置其他的Kafka相关参数。

这只是一个简单的示例，实际使用中可能需要更多的错误处理和配置。你可以参考Confluent.Kafka库的文档和示例来深入了解C#操作Kafka的更多功能和用法。

原理

人员标签，信息标签，人员和信息标签的匹配

人员和信息的标签定时更改

以人员看信息多的同一标签做人员标签（点赞，评论做加权）

信息标签也是以看的人多的共同标签打标签

定时多长时间对信息和个人打标签，何时信息标签打完毕

实现

信息发布预热期，作者自己打的标签，首推送关注者，再次符合标签的人员

远程桌面解决断开后UI交互问题

query session  

tscon rdp-tcp#0 /dest:console

给机器人分配一个远程账户，登录进去后执行连接到本地

日常维护的用另一个远程账户

微信还能接入HTTP协议？定制微信机器人，做消息推送，AI聊天

此项目的开源主页

3.9.2.23版本微信

百度网盘点击下载

提取码：1234  

如何防止线上活动优惠券被仿

可在二维码加上加密的时间戳和个人信息等，时间验证个人信息验证，同时也可让用户输入密码验证使用优惠券

免费地图解决方案

国家地理信息公共服务平台 天地图

www.tianditu.gov.cn/

凯立德官网

www.careland.com.cn/

维智物联全域定位

http://lothub.newayz.com/

图炫（aimap.gl）地图可视化

http://location-dev.newayz.com/aimap-gl-v2/docs/

多媒体开发知识积累

正片叠底（Multiply）和滤色（Screen）是两种基本的混合模式

正片叠底（Multiply）和滤色（Screen）是两种基本的混合模式，分别用于使图片变暗和变亮。它们之间的组合还可以形成更复杂的混合模式，如叠加（Overlay）和柔光（Soft Light）。

正片叠底 —— 就是把两层图像的像素相乘，最后会得到一个更暗的图像。这个模式是对称的，也就是说交换基色和混合色得到的结果是一样的。

，其中a是基色，b是混合色。

滤色 —— 首先把两层图像的像素值取互补数，然后将它们相乘，最后再去互补数。这和正片叠底得到的结果是相反的。它会得到一个更亮的图像。

，其中a是基色，b是混合色。

叠加 —— 结合了正片叠底和滤色两种混合模式。基色中亮色的部分会更加亮，而暗色的部分会更暗。

，其中a是基色，b是混合色

Puppeteer相关技术收集

Puppeteer 简介

1、Puppeteer 简介

Puppeteer 是一个node库，他提供了一组用来操纵Chrome的API, 通俗来说就是一个 headless chrome浏览器 (当然你也可以配置成有UI的，默认是没有的)。既然是浏览器，那么我们手工可以在浏览器上做的事情 Puppeteer 都能胜任, 另外，Puppeteer 翻译成中文是”木偶”意思，所以听名字就知道，操纵起来很方便，你可以很方便的操纵她去实现：

1） 生成网页截图或者 PDF 
2） 高级爬虫，可以爬取大量异步渲染内容的网页 
3） 模拟键盘输入、表单自动提交、登录网页等，实现 UI 自动化测试 
4） 捕获站点的时间线，以便追踪你的网站，帮助分析网站性能问题

如果你用过 PhantomJS 的话，你会发现她们有点类似，但Puppeteer是Chrome官方团队进行维护的，用俗话说就是”有娘家的人“，前景更好。

2、运行环境

查看 Puppeteer 的官方 API 你会发现满屏的 async, await 之类，这些都是 ES7 的规范，所以你需要：

1. Nodejs 的版本不能低于 v7.6.0, 需要支持 async, await.
2. 需要最新的 chrome driver, 这个你在通过 npm 安装 Puppeteer 的时候系统会自动下载的

npm install puppeteer --save

3、基本用法

先开看看官方的入门的 DEMO

const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://example.com');
await page.screenshot({path: 'example.png'});
await browser.close();
})();

上面这段代码就实现了网页截图，先大概解读一下上面几行代码：

1. 先通过 puppeteer.launch() 创建一个浏览器实例 Browser 对象
2. 然后通过 Browser 对象创建页面 Page 对象
3. 然后 page.goto() 跳转到指定的页面
4. 调用 page.screenshot() 对页面进行截图
5. 关闭浏览器

是不是觉得好简单？ 反正我是觉得比 PhantomJS 简单，至于跟 selenium-webdriver 比起来， 那更不用说了。下面就介绍一下 puppeteer 的常用的几个 API。

3.1 puppeteer.launch(options)

使用 puppeteer.launch() 运行 puppeteer，它会 return 一个 promise，使用 then 方法获取 browser 实例， 当然高版本的 的 nodejs 已经支持 await 特性了，所以上面的例子使用 await 关键字，这一点需要特殊说明一下，Puppeteer 几乎所有的操作都是 异步的, 为了使用大量的 then 使得代码的可读性降低，本文所有 demo 代码都是用 async, await 方式实现。这个 也是 Puppeteer 官方推荐的写法。对 async/await 一脸懵逼的同学狠狠的戳这里

options 参数详解

3.2 Browser 对象

当 Puppeteer 连接到一个 Chrome 实例的时候就会创建一个 Browser 对象，有以下两种方式：

Puppeteer.launch 和 Puppeteer.connect.

下面这个 DEMO 实现断开连接之后重新连接浏览器实例

const puppeteer = require('puppeteer');
puppeteer.launch().then(async browser => {
// 保存 Endpoint，这样就可以重新连接 
 Chromiumconst browserWSEndpoint = browser.wsEndpoint();
 // 从Chromium 断开连接
 browser.disconnect();
 // 使用endpoint 重新和 Chromiunm 建立连接
 const browser2 = await puppeteer.connect({browserWSEndpoint});
 // Close Chromium
 await browser2.close();});

Browser 对象 API

好了，Puppeteer 的API 就不一一介绍了，官方提供的详细的 API， 戳这里

4、Puppeteer 实战

了解 API 之后我们就可以来一些实战了，在此之前，我们先了解一下 Puppeteer 的设计原理，简单来说 Puppeteer 跟 webdriver 以及 PhantomJS 最大的 的不同就是它是站在用户浏览的角度，而 webdriver 和 PhantomJS 最初设计就是用来做自动化测试的，所以它是站在机器浏览的角度来设计的，所以它们 使用的是不同的设计哲学。举个栗子，加入我需要打开京东的首页并进行一次产品搜索，分别看看使用 Puppeteer 和 webdriver 的实现流程：

Puppeteer 的实现流程：

1. 打开京东首页
2. 将光标 focus 到搜索输入框
3. 键盘点击输入文字
4. 点击搜索按钮

webdriver 的实现流程：

1. 打开京东首页
2. 找到输入框的 input 元素
3. 设置 input 的值为要搜索文字
4. 触发搜索按钮的单机事件

个人感觉 Puppeteer 设计哲学更符合任何的操作习惯，更自然一些。

下面我们就用一个简单的需求实现来进行 Puppeteer 的入门学习。这个简单的需求就是：

在京东商城抓取10个手机商品，并把商品的详情页截图。

首先我们来梳理一下操作流程

1. 打开京东首页
2. 输入“手机”关键字并搜索
3. 获取前10个商品的 A 标签，并获取 href 属性值，获取商品详情链接
4. 分别打开10个商品的详情页，截取网页图片

要实现上面的功能需要用到查找元素，获取属性，键盘事件等，那接下来我们就一个一个的讲解一下。

4.1 获取元素

Page 对象提供了2个 API 来获取页面元素

(1). Page.$(selector) 获取单个元素，底层是调用的是 document.querySelector() , 所以选择器的 selector 格式遵循 css 选择器规范

let inputElement = await page.$("#search", input => input);
//下面写法等价
let inputElement = await page.$('#search');

(2). Page.$$(selector) 获取一组元素，底层调用的是 document.querySelectorAll(). 返回 Promise(Array(ElemetHandle)) 元素数组.

const links = await page.$$("a");
//下面写法等价
const links = await page.$$("a", links => links);

最终返回的都是 ElemetHandle 对象

4.2 获取元素属性

Puppeteer 获取元素属性跟我们平时写前段的js的逻辑有点不一样，按照通常的逻辑，应该是现获取元素，然后在获取元素的属性。但是上面我们知道 获取元素的 API 最终返回的都是 ElemetHandle 对象，而你去查看 ElemetHandle 的 API 你会发现，它并没有获取元素属性的 API.

事实上 Puppeteer 专门提供了一套获取属性的 API， Page.$eval() 和 Page.$$eval()

(1). Page.$$eval(selector, pageFunction[, …args]), 获取单个元素的属性，这里的选择器 selector 跟上面 Page.$(selector) 是一样的。

const value = await page.$eval('input[name=search]', input => input.value);
const href = await page.$eval('#a", ele => ele.href);
const content = await page.$eval('.content', ele => ele.outerHTML);

4.3 执行自定义的 JS 脚本

Puppeteer 的 Page 对象提供了一系列 evaluate 方法，你可以通过他们来执行一些自定义的 js 代码，主要提供了下面三个 API

(1). page.evaluate(pageFunction, …args) 返回一个可序列化的普通对象，pageFunction 表示要在页面执行的函数， args 表示传入给 pageFunction 的参数， 下面的 pageFunction 和 args 表示同样的意思。

const result = await page.evaluate(() => {	
return Promise.resolve(8 * 7);
});
console.log(result); // prints "56"

这个方法很有用，比如我们在获取页面的截图的时候，默认是只截图当前浏览器窗口的尺寸大小，默认值是800x600，那如果我们需要获取整个网页的完整 截图是没办法办到的。Page.screenshot() 方法提供了可以设置截图区域大小的参数，那么我们只要在页面加载完了之后获取页面的宽度和高度就可以解决 这个问题了。

(async () => {	
const browser = await puppeteer.launch({headless:true});
const page = await browser.newPage();
await page.goto('https://jr.dayi35.com'); 
await page.setViewport({width:1920, height:1080});	
const documentSize = await page.evaluate(() => {	
return {
	width: document.documentElement.clientWidth,
	height : document.body.clientHeight,
	}
   })
await page.screenshot({path:"example.png", clip : {x:0, y:0, width:1920, height:documentSize.height}});	
await browser.close();
})();

(2). Page.evaluateHandle(pageFunction, …args) 在 Page 上下文执行一个 pageFunction, 返回 JSHandle 实体

const aWindowHandle = await page.evaluateHandle(() => Promise.resolve(window));
//aindowHandle Handle for the window object. 
const aHandle = await page.evaluateHandle('document'); // Handle for the 'document'.

从上面的代码可以看出，page.evaluateHandle() 方法也是通过 Promise.resolve 方法直接把 Promise 的最终处理结果返回， 只不过把最后返回的对象封装成了 JSHandle 对象。本质上跟 evaluate 没有什么区别。

下面这段代码实现获取页面的动态（包括js动态插入的元素） HTML 代码.

const aHandle = await page.evaluateHandle(() => document.body);
const resultHandle = await page.evaluateHandle(body => body.innerHTML, aHandle);
console.log(await resultHandle.jsonValue());
await resultHandle.dispose();

(3). page.evaluateOnNewDocument(pageFunction, …args), 在文档页面载入前调用 pageFunction, 如果页面中有 iframe 或者 frame, 则函数调用 的上下文环境将变成子页面的，即iframe 或者 frame, 由于是在页面加载前调用，这个函数一般是用来初始化 javascript 环境的，比如重置或者 初始化一些全局变量。

4.4 Page.exposeFunction

除此上面三个 API 之外，还有一类似的非常有用的 API， 那就是 Page.exposeFunction，这个 API 用来在页面注册全局函数，非常有用：

因为有时候需要在页面处理一些操作的时候需要用到一些函数，虽然可以通过 Page.evaluate() API 在页面定义函数，比如：

const docSize = await page.evaluate(()=> {	
function getPageSize() {	
	return {
	width: document.documentElement.clientWidth,
	height : document.body.clientHeight,
	}
      }
   return getPageSize();
   });

但是这样的函数不是全局的，需要在每个 evaluate 中去重新定义，无法做到代码复用，在一个就是 nodejs 有很多工具包可以很轻松的实现很复杂的功能 比如要实现 md5 加密函数，这个用纯 js 去实现就不太方便了，而用 nodejs 却是几行代码的事情。

下面代码实现给 Page 上下文的 window 对象添加 md5 函数：

const puppeteer = require('puppeteer');
const crypto = require('crypto');
puppeteer.launch().then(async browser => {
const page = await browser.newPage();
page.on('console', msg => console.log(msg.text));
await page.exposeFunction('md5', text =>
  crypto.createHash('md5').update(text).digest('hex')
 );
await page.evaluate(async () => {
// use window.md5 to compute hashes
const myString = 'PUPPETEER';
const myHash = await window.md5(myString);
console.log(`md5 of ${myString} is ${myHash}`);});
await browser.close();
});

可以看出，Page.exposeFunction API 使用起来是很方便的，也非常有用，在比如给 window 对象注册 readfile 全局函数：

const puppeteer = require('puppeteer');
const fs = require('fs');
puppeteer.launch().then(async browser => {
const page = await browser.newPage();
page.on('console', msg => console.log(msg.text));
await page.exposeFunction('readfile', async filePath => {
return new Promise((resolve, reject) => {
fs.readFile(filePath, 'utf8', (err, text) => {
if (err)
 reject(err);
else
resolve(text);
});
});
});
await page.evaluate(async () => {
// use window.readfile to read contents of a file
const content = await window.readfile('/etc/hosts');
console.log(content);
});
await browser.close();
});

5、Page.emulate 修改模拟器(客户端)运行配置

Puppeteer 提供了一些 API 供我们修改浏览器终端的配置

1. Page.setViewport() 修改浏览器视窗大小
2. Page.setUserAgent() 设置浏览器的 UserAgent 信息
3. Page.emulateMedia() 更改页面的CSS媒体类型，用于进行模拟媒体仿真。 可选值为 “screen”, “print”, “null”, 如果设置为 null 则表示禁用媒体仿真。
4. Page.emulate() 模拟设备，参数设备对象，比如 iPhone, Mac, Android 等

page.setViewport({width:1920, height:1080}); //设置视窗大小为 1920x1080
page.setUserAgent('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36');
page.emulateMedia('print'); //设置打印机媒体样式

除此之外我们还可以模拟非 PC 机设备, 比如下面这段代码模拟 iPhone 6 访问google：

const puppeteer = require('puppeteer');
const devices = require('puppeteer/DeviceDescriptors');
const iPhone = devices['iPhone 6'];
puppeteer.launch().then(async browser => {
const page = await browser.newPage();
await page.emulate(iPhone);
await page.goto('https://www.google.com'); 
// other actions...
await browser.close();});

Puppeteer 支持很多设备模拟仿真，比如Galaxy, iPhone, IPad 等，想要知道详细设备支持，请戳这里 DeviceDescriptors.js.

6、键盘和鼠标

键盘和鼠标的API比较简单，键盘的几个API如下：

• keyboard.down(key[, options]) 触发 keydown 事件
• keyboard.press(key[, options]) 按下某个键，key 表示键的名称，比如 ‘ArrowLeft’ 向左键，详细的键名映射请戳这里
• keyboard.sendCharacter(char) 输入一个字符
• keyboard.type(text, options) 输入一个字符串

• keyboard.up(key) 触发 keyup 事件

• 
  

• page.keyboard.press("Shift"); //按下 Shift 键

• page.keyboard.sendCharacter('嗨');

• page.keyboard.type('Hello'); // 一次输入完成

• page.keyboard.type('World', {delay: 100}); // 像用户一样慢慢输入

• 鼠标操作：

• mouse.click(x, y, [options]) 移动鼠标指针到指定的位置，然后按下鼠标，这个其实 mouse.move 和 mouse.down 或 mouse.up 的快捷操作
• mouse.down([options]) 触发 mousedown 事件，options 可配置:
• options.button 按下了哪个键，可选值为[left, right, middle], 默认是 left, 表示鼠标左键
• options.clickCount 按下的次数，单击，双击或者其他次数
• delay 按键延时时间
• mouse.move(x, y, [options]) 移动鼠标到指定位置， options.steps 表示移动的步长
• mouse.up([options]) 触发 mouseup 事件

7、另外几个有用的 API

Puppeteer 还提供几个非常有用的 API， 比如：

7.1 Page.waitFor 系列 API

• page.waitFor(selectorOrFunctionOrTimeout[, options[, …args]]) 下面三个的综合 API
• page.waitForFunction(pageFunction[, options[, …args]]) 等待 pageFunction 执行完成之后
• page.waitForNavigation(options) 等待页面基本元素加载完之后，比如同步的 HTML, CSS, JS 等代码
• page.waitForSelector(selector[, options]) 等待某个选择器的元素加载之后，这个元素可以是异步加载的，这个 API 非常有用，你懂的。

比如我想获取某个通过 js 异步加载的元素，那么直接获取肯定是获取不到的。这个时候就可以使用 page.waitForSelector 来解决：

await page.waitForSelector('.gl-item'); //等待元素加载之后，否则获取不到异步加载的元素

const links = await page.$$eval('.gl-item > .gl-i-wrap > .p-img > a', links => {

return links.map(a => {

return {

href: a.href.trim(),

name: a.title

}

});

});

其实上面的代码就可以解决我们最上面的需求，抓取京东的产品，因为是异步加载的，所以使用这种方式。

7.2 page.getMetrics()

通过 page.getMetrics() 可以得到一些页面性能数据， 捕获网站的时间线跟踪，以帮助诊断性能问题。

• Timestamp 度量标准采样的时间戳
• Documents 页面文档数
• Frames 页面 frame 数
• JSEventListeners 页面内事件监听器数
• Nodes 页面 DOM 节点数
• LayoutCount 页面布局总数
• RecalcStyleCount 样式重算数
• LayoutDuration 所有页面布局的合并持续时间
• RecalcStyleDuration 所有页面样式重新计算的组合持续时间。
• ScriptDuration 所有脚本执行的持续时间
• TaskDuration 所有浏览器任务时长
• JSHeapUsedSize JavaScript 占用堆大小
• JSHeapTotalSize JavaScript 堆总量

8、总结和源码

本文通过一个实际需求来学习了 Puppeteer 的一些基本的常用的 API， API 的版本是 v0.13.0-alpha. 最新邦本的 API 请参考 Puppeteer 官方API.

总的来说，Puppeteer 真是一款不错的 headless 工具，操作简单，功能强大。用来做UI自动化测试，和一些小工具都是很不错的。

下面贴上我们开始的需求实现源码，仅供参考：

//延时函数
function sleep(delay) {
return new Promise((resolve, reject) => {
setTimeout(() => {
try {
resolve(1)
} catch (e) {
reject(0)
}
}, delay)
})
}

const puppeteer = require('puppeteer');
puppeteer.launch({
ignoreHTTPSErrors:true,
headless:false,slowMo:250,
timeout:0}).then(async browser => {

let page = await browser.newPage();
await page.setJavaScriptEnabled(true);
await page.goto("https://www.jd.com/");
const searchInput = await page.$("#key");
await searchInput.focus(); //定位到搜索框
await page.keyboard.type("手机");
const searchBtn = await page.$(".button");
await searchBtn.click();
await page.waitForSelector('.gl-item'); //等待元素加载之后，否则获取不异步加载的元素
const links = await page.$$eval('.gl-item > .gl-i-wrap > .p-img > a', links => {
return links.map(a => {
return {
href: a.href.trim(),
title: a.title
}
});
});
page.close();

const aTags = links.splice(0, 10);
for (var i = 1; i < aTags.length; i++) {
page = await browser.newPage()
page.setJavaScriptEnabled(true);
await page.setViewport({width:1920, height:1080});
var a = aTags[i];
await page.goto(a.href, {timeout:0}); //防止页面太长，加载超时

//注入代码，慢慢把滚动条滑到最底部，保证所有的元素被全部加载
let scrollEnable = true;
let scrollStep = 500; //每次滚动的步长
while (scrollEnable) {
scrollEnable = await page.evaluate((scrollStep) => {
let scrollTop = document.scrollingElement.scrollTop;
document.scrollingElement.scrollTop = scrollTop + scrollStep;
return document.body.clientHeight > scrollTop + 1080 ? true : false
}, scrollStep);
await sleep(100);
}
await page.waitForSelector("#footer-2014", {timeout:0}); //判断是否到达底部了
let filename = "images/items-"+i+".png";
//这里有个Puppeteer的bug一直没有解决，发现截图的高度最大只能是16384px， 超出部分被截掉了。
await page.screenshot({path:filename, fullPage:true});
page.close();
}

browser.close();
});

await page.setUserAgent(fake.user_agent())

可以看到 HTTP 状态码 为 403（403 Forbidden），即使我们设置了 User-Agent，美团依然能够检测到 WebDriver。

Pyppeteer 的 Page 对象有一个 evaluateOnNewDocument 方法，可以在每次加载网页的时候执行某个语句，此处执行将 WebDriver 隐藏的命令

browser = await launch({headless: False,

                            args: ['--disable-infobars']

                            })

    page = await browser.newPage()

    await page.setUserAgent(fake.user_agent())

    await page.evaluateOnNewDocument('function(){Object.defineProperty(navigator, "webdriver", {get: () => undefined})}')

    await page.goto(URL, options={'timeout': 10000})

    await asyncio.sleep(412)

    await browser.close()

Puppeteer一些高级玩儿法

用户数据持久化

平时访问网站时关键 Cookies 已经保存到本地浏览器，因此下次登录时可以直接读取并保持登录状态，这些信息保存在用户目录下，其不仅包含浏览器的基本配置信息，还有一些 Cache、Cookies 等信息，若能在浏览器启动时读取这些信息，则可以恢复一些历史记录以及登录状态信息。

Pyppeteer 提供了实现手段，即在启动的时候设置 userDataDir：

import asyncio

from faker import Faker

from pyppeteer import launch

fake = Faker()

URL = 'https://www.zhihu.com/'

async def main():

    browser = await launch({'headless': False,

                            'args': ['--disable-infobars'],

                            'userDataDir': './userdata'

                            })

    page = await browser.newPage()

    await page.setViewport({'width': 1530, 'height': 800})

    await page.setUserAgent(fake.user_agent())

    await page.evaluateOnNewDocument('function(){Object.defineProperty(navigator, "webdriver", {get: () => undefined})}')

    await page.goto(URL, options={'timeout': 10000})

    await asyncio.sleep(412)

    await browser.close()

if __name__ == '__main__':

    asyncio.get_event_loop().run_until_complete(main())

第一次启动时先手动登录：

登录后相关信息会保存在用户目录下，下次登录时即可直接读取：

此后再启动，无需重新登录（除非 Cookies 过期）。

Browser

launch 方法返回的是 Browser 对象（浏览器对象），即 Browser 类的一个实例，其拥有许多用于操作浏览器的方法。

无痕模式

无痕模式的好处就是环境干净，不与其他的浏览器示例共享 Cache、Cookies 等内容，其开启方式可以通过 createIncognitoBrowserContext 方法，其返回一个 context 对象，用其创建新选项卡：

import asyncio

from faker import Faker

from pyppeteer import launch

fake = Faker()

URL = 'https://gz.meituan.com/meishi/'

async def main():

    browser = await launch({'headless': False,

                            'args': ['--disable-infobars'],

                            'userDataDir': './userdata'

                            })

    context = await browser.createIncognitoBrowserContext()

    page = await context.newPage()

    await page.setViewport({'width': 1530, 'height': 800})

    await page.setUserAgent(fake.user_agent())

    await page.evaluateOnNewDocument('function(){Object.defineProperty(navigator, "webdriver", {get: () => undefined})}')

    await page.goto(URL, options={'timeout': 10000})

    await asyncio.sleep(412)

    await browser.close()

if __name__ == '__main__':

    asyncio.get_event_loop().run_until_complete(main())

通过Puppeteer实现滚动加载 

/* 引入相关 工具 */

const fs = require('fs')

const cheerio = require('cheerio')

const puppeteer = require('puppeteer')

/* 定义函数 */

let getListData = async function(Category) {

 /* 初始化 puppeteer*/

 const browser = await puppeteer.launch({

  executablePath: 'D:\\chrome-win\\chrome.exe',//把项目中的这个chrome-win文件夹放到D盘根目录

  headless: false //这个是 是否打开chrome可视化窗口 true是不打开 false是打开

 })

 //获取page实例

 const page = await browser.newPage()

 //我这里是通过 入参传过来的 分类来判断抓取相应页面的数据

 let url = ''

 switch (Category) {

  case '0':

   url = 'https://www.toutiao.com/ch/news_game/'

   break;

  case '1':

   url = 'https://www.toutiao.com/ch/news_entertainment/'

   break;

  case '2':

   url = 'https://www.toutiao.com/ch/news_history/'

   break;

  case '3':

   url = 'https://www.toutiao.com/ch/news_finance/'

   break;

 }

 //打开页面

 await page.goto(url)

 //定义页面内容及Jquery

 var content , $

 /* 页面滚动方法 */

 async function scrollPage(i) {

  content = await page.content();

  $ = cheerio.load(content);

  /*执行js代码（滚动页面）*/

  await page.evaluate(function () {

   /* 这里做的是渐进滚动，如果一次性滚动则不会触发获取新数据的监听 */

   for (var y = 0; y <= 1000*i; y += 100) {

    window.scrollTo(0,y)

   }

  })

  // 获取数据列表

  const li = $($('.feedBox').find('ul')[0]).find('li')

  return li

 }

 let i = 0

 let li = await scrollPage(++i)

 //如果数据列表 不够30 则一直获取

 while (li.length < 30) {

  li = await scrollPage(++i)

 }

 let data = {

   list: []

 }

 /* 封装返回的数据*/

 li.map(function (index,item) {

  $(item).find('img').attr('src') != undefined ?

   data.list.push({

    src: $(item).find('img').attr('src'),

    title: $($(item).find('.title')).text(),

    source:$($(item).find('.source')).text(),

    href:$($(item).find('.title')).attr('href')

   }):''

 })

 //顺手存入本地文件

 fs.writeFileSync('tt.JSON',JSON.stringify(data))

 fs.writeFileSync('tt.html',content)

 /* 关闭 puppeteer*/

 await browser.close()

  return data

}

module.exports = getListData

通过API将图片上传到免费图床-遇见图床

通过API将图片上传到免费图床-遇见图床

C# async 函数

public async static void GetInfoAsync()

 {

     Task<bool> task = Task.Run<bool>(() =>

     {

         Thread.Sleep(10000); //模拟耗时

         return true;

     });

     //以下两种方式

     bool taskResult1 = await task;  //内部自己执行了GetAwaiter() 

     bool taskResult = task.GetAwaiter().GetResult();  //自己手动执行Awaiter(), 但是阻塞UI

Console.WriteLine(taskResult);

 }

一个上传文件的例子

async Task<string> UpFile()

        {

            System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();

            var content = new MultipartFormDataContent();

            //添加字符串参数，参数名为qq

            //content.Add(new StringContent("123456"), "qq");

            string path = "g:\\1.png";// Path.Combine(System.Environment.CurrentDirectory, "1.png");

            //添加文件参数，参数名为files，文件名为123.png

            var fileContent = new ByteArrayContent(System.IO.File.ReadAllBytes(path));

            fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");

            content.Add(fileContent, "image", "123.png");

            content.Add(new StringContent("chaoneng"), "apiType");

            content.Add(new StringContent("14ff9ab178c34097ff171964fdb166f4"), "token");

            var requestUri = new Uri("https://www.hualigs.cn/api/upload"); //"https://www.hualigs.cn/api/upload";

            ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3

| SecurityProtocolType.Tls

| (SecurityProtocolType)0x300 //Tls11

| (SecurityProtocolType)0xC00; //Tls12

            var response = await client.PostAsync(requestUri, content);

            string url = "";

            if (response.IsSuccessStatusCode)

            {

                Console.WriteLine("上传成功！");

                var result = response.Content.ReadAsStringAsync().Result;

                //MessageBox.Show(result);

                try

                {

                    Hashtable m_HH = JsonHelper.JsonStrToOBJ<Hashtable>(result);

                    if (m_HH.ContainsKey("code"))

                    {

                        string code = m_HH["code"].ToString();

                        if (code == "200")

                        {

                            if (m_HH.ContainsKey("data"))

                            {

                                Hashtable m_dataHH = JsonHelper.OBJToType<Hashtable>(m_HH["data"]);

                                if (m_dataHH.ContainsKey("url"))

                                {

                                    Hashtable m_urlHH = JsonHelper.OBJToType<Hashtable>(m_dataHH["url"]);

                                    if (m_urlHH.ContainsKey("distribute"))

                                    {

                                        Console.WriteLine(m_urlHH["distribute"].ToString());

                                        //MessageBox.Show(m_urlHH["distribute"].ToString());

                                        url = m_urlHH["distribute"].ToString();

                                    }

                                }

                                else

                                {

                                    MessageBox.Show("数据解析异常:" + result);

                                }

                            }

                            else

                            {

                                MessageBox.Show("数据解析异常:" + result);

                            }

                        }

                        else

                        {

                            string str = "错误码：" + code;

                            if (m_HH.ContainsKey("msg"))

                            {

                                str += "," + m_HH["msg"].ToString();

                            }

                            MessageBox.Show(str);

                        }

                    }

                    else

                    {

                        MessageBox.Show("数据解析异常:" + result);

                    }

                }

                catch

                {

                }

            }

            else

            {

                MessageBox.Show("上传异常");

            }

            /*

            Task<string> task = Task.Run<string >(() =>

            {

                return url;

            });

             */

            return url;

        }

        async private void button29_Click(object sender, EventArgs e)

        {

            string str = await UpFile();

            MessageBox.Show(str);

        }

防止恶意访问攻击

写一个异常访问ip清洗工具，1、同一时刻60s内请求超过60以上直接封禁该ip 100分钟，2、禁止所有国外ip和港、澳、台等地方IP。3、放进来的ip 随机进行滑块验证机器人，没通过的直接放入验证ip队列，该ip请求必须通过验证才会被从验证队列释放。4、静态媒体资源可以放到公共免费平台 用url跨站调用。5、网站只暴露一个入口，该页面加入js验证用户是否是机器人的算法，通过算法 请求后台生成jwt加密失效密钥，token通过cookie存在用户端，token有效期内可以浏览网站其他页面，负责跳转首页面。

各大地图厂商收费，免费解决方案

如果只用地图展示类，3种都满足，天地图有些丑罢了，凯立德和WAYZ和高德的风格蛮像；

如果有导航类需求那就凯立德了；

如果有设备需要接入定位，那WAYZ更方便接入

用天地图就好了，国家的，免费

所谓的支付宝/微信支付“云面签”原理

市面上最近流行所谓的“云免签”，只需要收款人在其提供云免签服务的平台上传支付宝/微信二维码，不需要收款人在PC端或手机上安装监控支付宝/微信支付结果通知的程序，然后由云端来帮助监控支付结果。

研究了一下各种“云免签”方案，大致分为几种方案：

1、微信店员模式

收款人作为店主，让收款人添加提供云免签服务的平台的微信号为店员，由于店主收款消息都会自动通知店员，因此只需要在店员端监听支付结果就行，不需要店主始终在线。

由于支付宝只允许一个店员属于一个店主，因此此种模式对支付宝成本过高。

2、监听支付宝/微信网页端模式

提供云免签服务的平台获取支付宝/微信PC网页版扫码登陆二维码，让收款人扫码登陆，提供云免签服务的平台在服务器端通过扫收款人账单来获取支付结果。

3、支付宝当面支付+当面付分账功能

这些方案还有诸多细节需要考虑，例如怎么自动化通过店员请求、怎样保持支付宝/微信登陆状态等等。

C#框架相关笔记

返回状态码

StatusCode = 200;

ctx.Response.StatusCode = StatusCode;//验证通过调用

ctx.Response.End();

大型分布式系统设计初版

大型分布式系统设计初版

人员数据落到各个节点，新数据落的规则按一致性hash决定见后面

业务数据落到各个节点，新数据落的规则按地理位置范围和表数据量和hash落到那个节点具体见后

中心业务数据地理位置库分布规则表

业务数据保存两份，按地理位置保存 按人员保存

用户共享数据节点如角色等 业务数据共享节点如栏目等

用户的归宿 如群 谁创建群，群数据落点在那个用户节点

所有的新落点按一致性hash权重获得

所有节点多个从库

关于共享数据的缓存，角色 栏目等

各区数据中心

节点ID规则   uuid+数据中心id+节点编号

数据中心所拥有的数据节点服务 调用节点服务认证

redis 数据缓存服务

redis 消息服务

Redis分布式锁

数据级缓存，页面级缓存

数据库节点服务 对应所在数据中心

根据用户id或接入IP或业务数据id 获得数据链接节点根据数据中心

栏目归宿 共享 角色 地理范围 权限 看 发 回复 购买

获得web模块的页面部分html

用户访问过程

未登录状态访问：

主gate服务根据用户IP引导用户访问最近的相对闲置web节点，根据用户的地理位置拉取相应范围内栏目及数据（根据地理位置获得数据中心，根据数据中心获得相对闲置的数据服务节点 拉取数据）

用户切换地理位置同上只是位置不再通过IP而根据用户选择引导用户访问最近相对闲置的web 节点后续相同

用户登陆访问

根据全局用户名对应的用户ID获得用户信息所在数据中心获得数据节点服务拉取用户基础数据及权限数据，根据地理位置拉取业务栏目数据流程如上

信息发布，在地理位置所在数据中心拿取相对闲置的数据库节点添加数据，同时往用户所在数据节点添加相应数据，数据回复交易等类式 回复记录节点交易等与记录关联数据位于同一数据节点

直播App架构