基线:全量源码首提(D1 版本控制落地,含第一轮优化 B1-B4/A1/A4/缩放修复)

This commit is contained in:
dqb-dev
2026-10-01 22:15:22 +08:00
commit 1e65792b09
499 changed files with 204579 additions and 0 deletions
+422
View File
@@ -0,0 +1,422 @@
// 抓取器:抓厂家树/系列规格/价格,按新服务布局落盘(断点续抓,多线程安全)
// 两种价格通道:直连 dq123(默认) / 经内置旧代理 localhost:8081(带会话伪装,命中率高——工具自动启动它)
// 8081 是工具专用端口:node 新服务(元件库网页)占了 8080,两者须能同时跑
// 种子模式:从旧代理 proxy_cache 提取真实查询过的组合(sid→bg 列表),优先按种子形状抓价(重放+单变化)
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
namespace yjktool
{
internal class 抓取器
{
// 域名映射照旧 python 代理
private const string 电数据 = "https://dian.dq123.com/electricData?v=";
private const string 价格口 = "https://dx2.dhub.com.cn/pcprice/default/dx2/interface/webGetPrice?infoJson=";
// 经旧代理(路径同源,代理按前缀转发到真实域名并注入会话头)
private const string 代电数据 = "http://127.0.0.1:8081/electricData?v=";
private const string 代价格口 = "http://127.0.0.1:8081/dx2/pcprice/default/dx2/interface/webGetPrice?infoJson=";
public string 输出根 { get; private set; }
private string ZipDir { get { return Path.Combine(输出根, "dian", "electricData_zips"); } }
private string 价Dir { get { return Path.Combine(输出根, "dx2_webGetPrice"); } }
/// <summary>价格请求是否经旧代理(8081)。树/系列包恒直连(静态资源无会话要求)。</summary>
public bool 经旧代理;
/// <summary>种子组合:旧代理缓存里真实查询过的 (系列→组合串列表),价格抓取优先按种子形状。</summary>
/// <summary>种子表:sid → [bg组合串, t历史时间戳] 列表。
/// 终版机制(实测):命中 = 系列在有效时刻 t 查过(服务器按 sid+t 记录) AND 组合是真实型号——
/// 系列只要有一个种子的 t,即可解锁它全部规格组组合的价格查询;t 用当前时间必返空。</summary>
private Dictionary<string, List<string[]>> 种子 = new Dictionary<string, List<string[]>>();
private int 无t系列数;
private int 无t提示过;
// 进度/日志回调(UI 线程调度由调用方处理)
public Action<string> 日志 { get; set; }
public Action<int, int> 进度 { get; set; } // (当前,总数)
public volatile bool 停止;
public 抓取器(string 输出目录)
{
输出根 = 输出目录;
Directory.CreateDirectory(ZipDir);
Directory.CreateDirectory(价Dir);
// net48 下显式启用 TLS1.2(dq123 全站 https,不设会握手失败)
try { ServicePointManager.SecurityProtocol = ServicePointManager.SecurityProtocol | SecurityProtocolType.Tls12; }
catch { }
ServicePointManager.DefaultConnectionLimit = 32;
}
/// <summary>从缓存/数据目录加载种子(webGetPrice 响应里的 bg 组合串+原始 t 时间戳)。
/// 可多处调用合并(旧代理缓存+元件库网页 data 的现成真价都吃)。返回种子系列数。</summary>
public int 加载种子(string 目录)
{
if (种子 == null) 种子 = new Dictionary<string, List<string[]>>();
try
{
foreach (string f in Directory.GetFiles(目录, "*webGetPrice*.data"))
{
try
{
string body = File.ReadAllText(f);
foreach (System.Text.RegularExpressions.Match m in
System.Text.RegularExpressions.Regex.Matches(body, "\"content\"\\s*:\\s*\"([A-Za-z0-9+/=]+)\""))
{
string decoded;
try { decoded = Encoding.UTF8.GetString(Convert.FromBase64String(m.Groups[1].Value)); }
catch { continue; }
if (string.IsNullOrEmpty(decoded) || decoded.Trim() == "[]") continue;
// ★ JavaScriptSerializer.Deserialize<object> 对顶层数组返回 Object[](不是 ArrayList),
// 按 IEnumerable 遍历两者通吃——之前 as ArrayList 恒 null,种子从来没加载成功过
System.Collections.IEnumerable 条集 = 解析器.Deserialize<object>(decoded) as System.Collections.IEnumerable;
if (条集 == null) continue;
foreach (object o in 条集)
{
var it = o as Dictionary<string, object>;
if (it == null || !it.ContainsKey("sid")) continue;
string sid = Convert.ToString(it["sid"]);
string bg = it.ContainsKey("bg") ? Convert.ToString(it["bg"]) : "";
// ★ t 是 13 位毫秒时间戳:JavaScriptSerializer 把 JSON 整数解析成 double,
// Convert.ToString(double) 会变成科学计数法(1.785401168E+12)拼进 time 服务器不认——
// 必须经 ToDouble→ToInt64 还原成纯数字串
string t = "";
object tv;
if (it.TryGetValue("t", out tv) && tv != null)
{
try { t = Convert.ToInt64(Convert.ToDouble(tv)).ToString(); }
catch { }
}
if (string.IsNullOrEmpty(sid) || string.IsNullOrEmpty(bg) || bg.IndexOf('-') < 0) continue;
if (string.IsNullOrEmpty(t)) continue; // 没 t 的种子重放不了(当前时间必空),跳过
List<string[]> l;
if (!种子.TryGetValue(sid, out l)) { l = new List<string[]>(); 种子[sid] = l; }
if (!l.Any(e => e[0] == bg)) l.Add(new[] { bg, t });
}
}
}
catch { }
}
}
catch { }
return 种子.Count;
}
private void L(string s) { if (日志 != null) 日志(s); }
// ---------- HTTP(简单重试) ----------
private byte[] Get(string url, int timeoutMs)
{
for (int 试 = 0; 试 < 3 && !停止; 试++)
{
try
{
var req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "GET";
req.Timeout = timeoutMs;
req.ReadWriteTimeout = timeoutMs;
req.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0";
req.Referer = "https://www.dq123.com/";
req.Proxy = null;
using (var r = (HttpWebResponse)req.GetResponse())
using (var ms = new MemoryStream())
{
r.GetResponseStream().CopyTo(ms);
return ms.ToArray();
}
}
catch (WebException we)
{
var hr = we.Response as HttpWebResponse;
if (hr != null && (int)hr.StatusCode >= 400 && (int)hr.StatusCode < 500)
return null; // 4xx(404 无此包)不重试,快速跳过
Thread.Sleep(600);
}
catch (Exception) { return null; }
}
return null;
}
// ---------- v 参数(base64 逻辑名去 padding) ----------
private static string V参数(string 逻辑名)
{
string b = Convert.ToBase64String(Encoding.UTF8.GetBytes(逻辑名));
return b.TrimEnd('=');
}
/// <summary>读 ZIP 字节数组里的首个文件文本(JSON)。失败返回 null。</summary>
private static string 读Zip内文(byte[] zip)
{
try
{
using (var ms = new MemoryStream(zip))
using (var z = new ZipArchive(ms))
{
var e = z.Entries[0];
using (var r = new StreamReader(e.Open(), Encoding.UTF8))
return r.ReadToEnd();
}
}
catch { return null; }
}
// ---------- JSON 反序列化(JavaScriptSerializer) ----------
private static readonly System.Web.Script.Serialization.JavaScriptSerializer 解析器 =
new System.Web.Script.Serialization.JavaScriptSerializer { MaxJsonLength = 64 * 1024 * 1024 };
/// <summary>系列包 → 主规格组有序表(aq顺序号→as选项列表)。
/// ★ 实测规则(1122 对照页面真实组合 337-350-15-9-29-30-37 破解):
/// 参与组合的组 = 顶层 c 键里 bc==0 且 p==2 的项;段顺序 = aq 字段升序;
/// bc!=0 / p!=2 的组(附件名称、延时类型等)不参与组合。
/// 系列包名 = 4/z_p/{系列id}.jss(不是 z_seri)。</summary>
private static SortedDictionary<int, List<int>> 规格组(string 系文)
{
var g = new SortedDictionary<int, List<int>>();
try
{
var root = 解析器.Deserialize<Dictionary<string, object>>(系文);
object co;
if (root == null || !root.TryGetValue("c", out co)) return g;
var cArr = co as System.Collections.ArrayList;
if (cArr == null) return g;
foreach (object o in cArr)
{
var 组 = o as Dictionary<string, object>;
if (组 == null) continue;
// ★ 终版规则(SDK Ke 过滤器:z 数组=an==1;两厂实测 725/1122 真实组合段 100% 命中):
// p 各家不同(正泰=1 德力西=2),不能加 p 条件
if (Convert.ToInt32(组.ContainsKey("an") ? 组["an"] : 0) != 1) continue;
int aq = Convert.ToInt32(组.ContainsKey("aq") ? 组["aq"] : 0);
var ar = 组.ContainsKey("ar") ? 组["ar"] as System.Collections.ArrayList : null;
if (ar == null || ar.Count == 0) continue;
var l = new List<int>();
foreach (object oo in ar)
{
var 选项 = oo as Dictionary<string, object>;
if (选项 == null || !选项.ContainsKey("as")) continue;
l.Add(Convert.ToInt32(选项["as"]));
}
if (l.Count > 0 && !g.ContainsKey(aq)) g[aq] = l;
}
}
catch { }
return g;
}
// ---------- 最小 JSON 取值(避免引第三方库;仅取固定结构字段) ----------
private static System.Text.RegularExpressions.MatchCollection 正则匹配(string json, string pattern)
{
return System.Text.RegularExpressions.Regex.Matches(json, pattern);
}
/// <summary>解析厂家树 ZIP 文本 → 叶子系列号(s 字段非 0)列表。</summary>
public static List<string> 树系列(string 树文)
{
var r = new List<string>();
foreach (System.Text.RegularExpressions.Match m in 正则匹配(树文, "\"s\"\\s*:\\s*(\\d+)"))
{
string v = m.Groups[1].Value;
if (v != "0" && !r.Contains(v)) r.Add(v);
}
return r;
}
/// <summary>组合策略(照 preheat 脚本):默认组合 + 每组每选项单独变化。</summary>
private static List<string> 组合(SortedDictionary<int, List<int>> g)
{
if (g.Count == 0) return new List<string>();
var 默认 = g.Values.Select(l => l[0].ToString()).ToList();
var r = new List<string> { string.Join("-", 默认) };
for (int i = 0; i < g.Count; i++)
{
foreach (int ab in g.Values.ElementAt(i).Skip(1))
{
var c = new List<string>(默认) { };
c[i] = ab.ToString();
r.Add(string.Join("-", c));
}
}
return r;
}
// ---------- webGetPrice 哈希(复刻 python json.dumps 分隔符) ----------
private static string PyDumps(string json)
{
// 本场景 JSON 只含 ASCII 字符串/数字/数组/对象,手工重排分隔符即可:
// 把 "," 与 ":" 后补空格(仅结构符,字符串内部不会出现裸的这些符号——base64 内容安全)
var sb = new StringBuilder(json.Length * 2);
bool 引号内 = false;
for (int i = 0; i < json.Length; i++)
{
char c = json[i];
sb.Append(c);
if (c == '"') 引号内 = !引号内;
else if (!引号内 && (c == ',' || c == ':'))
{
char 后 = i + 1 < json.Length ? json[i + 1] : ' ';
if (后 != ' ') sb.Append(' ');
}
}
return sb.ToString();
}
public static string 价格哈希(string infoJsonB64)
{
string json = Encoding.UTF8.GetString(Convert.FromBase64String(infoJsonB64));
// 剥 time 字段("time":123,) —— 手工正则
json = System.Text.RegularExpressions.Regex.Replace(json, "\"time\"\\s*:\\s*\\d+\\s*,?\\s*", "");
json = json.Replace(",}", "}").Replace(",]", "]");
string 稳定 = "infoJson=" + Convert.ToBase64String(Encoding.UTF8.GetBytes(PyDumps(json)));
using (var md5 = MD5.Create())
return BitConverter.ToString(md5.ComputeHash(Encoding.UTF8.GetBytes(稳定))).Replace("-", "").ToLower().Substring(0, 8);
}
// ---------- 抓取主流程 ----------
/// <summary>抓一个厂家:树+全部系列+全部组合价格。返回 (系列数, 价格数)。任何异常不外抛(记日志返回 0)。</summary>
public KeyValuePair<int, int> 抓厂家(string 树id, string 厂名, int 线程数)
{
try
{
return 抓厂家内部(树id, 厂名, 线程数);
}
catch (Exception ex)
{
L("! 厂家 " + 厂名 + " 抓取异常: " + ex.Message);
return new KeyValuePair<int, int>(0, 0);
}
}
private KeyValuePair<int, int> 抓厂家内部(string 树id, string 厂名, int 线程数)
{
// 1) 厂家树(断点:已存在直接读)
string 树zip路径 = Path.Combine(ZipDir, 树id + ".zip");
string 树文 = null;
if (File.Exists(树zip路径))
{
树文 = 读Zip内文(File.ReadAllBytes(树zip路径));
}
if (树文 == null)
{
byte[] z = Get(电数据 + V参数("z_seri/" + 树id + ".jss") + "&t=" + 时间戳(), 20000);
if (z == null || z.Length < 100) { L("× 厂家 " + 厂名 + " 树拉取失败"); return new KeyValuePair<int, int>(0, 0); }
File.WriteAllBytes(树zip路径, z);
树文 = 读Zip内文(z);
Thread.Sleep(50);
}
if (树文 == null) { L("× 厂家 " + 厂名 + " 树解析失败"); return new KeyValuePair<int, int>(0, 0); }
var 系列 = 树系列(树文);
L("▶ " + 厂名 + ": " + 系列.Count + " 个系列");
无t系列数 = 0; 无t提示过 = 0;
// 2) 并发抓系列
var 队列 = new ConcurrentQueue<string>(系列);
var 计数 = new int[2];
var 线程 = new List<Thread>();
for (int i = 0; i < Math.Max(1, 线程数); i++)
{
var t = new Thread(delegate()
{
string sid;
while (!停止 && 队列.TryDequeue(out sid))
{
int 局系 = 0, 局价 = 0;
string szPath = Path.Combine(ZipDir, sid + ".zip");
string 系文 = null;
try
{
系文 = File.Exists(szPath) ? 读Zip内文(File.ReadAllBytes(szPath)) : null;
if (系文 == null)
{
byte[] z = Get(电数据 + V参数("4/z_p/" + sid + ".jss") + "&t=" + 时间戳(), 20000);
if (z != null && z.Length > 100) { File.WriteAllBytes(szPath, z); 系文 = 读Zip内文(z); Thread.Sleep(20); }
}
if (系文 != null && 系文.IndexOf("\"c\"") >= 0)
{
局系 = 1;
// ★ 终版机制(实测):命中 = 系列在有效时刻 t 查过 AND 组合是真实型号。
// 每个系列只要有一个种子的 t,就能解锁它全部规格组组合;无 t 的系列必空,跳过查价。
List<string[]> sd;
bool 有种子 = 种子.TryGetValue(sid, out sd) && sd.Count > 0;
if (!有种子)
{
Interlocked.Increment(ref 无t系列数);
if (无t提示过 == 0)
{
int n = Interlocked.Increment(ref 无t提示过);
if (n == 1)
L("· 提示: 无有效时刻(t)的系列跳过价格查询(服务器对没查过的系列+当前时间必返空)——已跳过 " + sid + " 等");
}
}
else
{
string t种 = sd[0][1]; // 系列任一种子的 t(系列级会话标识,只配自己系列)
// ★ 组合恒用当前系列包规格组生成(默认+单变化):编号与页面渲染同源,查到的价页面必能命中。
// 种子 bg(旧版本编号)不再作基底——跨版本编号混合的组合页面永远点不出来(725 教训:75条仅1条可用)。
var cs = 组合(规格组(系文));
foreach (string c in cs)
{
string info = 构造infoJson(sid, c, t种);
string h = 价格哈希(info);
string 价path = Path.Combine(价Dir, "dx2_pcprice_default_dx2_interface_webGetPrice_" + h + ".data");
if (!File.Exists(价path))
{
string 口 = 经旧代理 ? 代价格口 : 价格口;
byte[] body = Get(口 + info, 20000);
// ★ 空结果不落盘:content="W10="(base64("[]"))或 content="" 都表示该组合厂家无报价,
// 存了也是废数据(旧代理靠运行时合成兜底,新服务只需要真价格)
string 文 = body == null ? null : Encoding.UTF8.GetString(body);
bool 有价 = 文 != null && 文.Length > 30 && 文.Length < 300000
&& 文.IndexOf("\"content\":\"W10=\"") < 0
&& 文.IndexOf("\"content\": \"W10=\"") < 0
&& 文.IndexOf("\"content\":\"\"") < 0
&& 文.IndexOf("\"content\": \"\"") < 0;
if (有价)
{
File.WriteAllBytes(价path, body);
var mb = System.Text.RegularExpressions.Regex.Match(文, "\"bh\"\\s*:\\s*\"?([0-9.]+)");
L(" ¥ 系列" + sid + " 命中真价" + (mb.Success ? " " + mb.Groups[1].Value + " 元" : "") + ": " + c);
}
Thread.Sleep(20);
}
局价++;
}
}
}
}
catch (Exception ex_series)
{
L("· 系列 " + sid + " 异常: " + ex_series.Message);
}
Interlocked.Add(ref 计数[0], 局系);
Interlocked.Add(ref 计数[1], 局价);
if (进度 != null) 进度(0, 0);
}
});
t.IsBackground = true;
线程.Add(t); t.Start();
}
foreach (var t in 线程) t.Join();
if (无t系列数 > 0)
L("· " + 厂名 + ": " + 无t系列数 + " 个系列无有效时刻(t),已跳过价格查询(可先在预热页面浏览这些系列再抓)");
return new KeyValuePair<int, int>(计数[0], 计数[1]);
}
private static long 时间戳() { return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds; }
/// <summary>构造 infoJson 的 base64。t 必须传历史时间戳(种子的原始 t 或兜底 t):
/// 实测服务器只对「真实查过的组合+历史时间戳」返回真价,当前时间必空。</summary>
private static string 构造infoJson(string 系列, string 组合串, string t)
{
// {"s": "1122", "options": ["337-350"], "time": 123, "from": "dx2jsapi"} —— 键序照 SDK
string json = "{\"s\": \"" + 系列 + "\", \"options\": [\"" + 组合串 + "\"], \"time\": " + t + ", \"from\": \"dx2jsapi\"}";
return Convert.ToBase64String(Encoding.UTF8.GetBytes(json));
}
}
}