ohayo's blog

苏州图书馆wifi认证

2025-06-04T02:49:41.000Z

苏州图书馆wifi认证之旅

上个月月底去苏州图书馆自习(看HLE vs T1)，难受的是流量在来苏州的路上用的已经差不多了，而苏州图书馆wifi的portal认证验证码却无法收到。想着以后可能经常会来这里自习，还是尝试破解一下吧。

绕过portal认证

抱着试试看的心态，先试了理工科大学生必经之路之用53端口绕过校园网认证。没想到在连接上图书馆的公共wifi后，用dig命令发现53端口竟然是开放的。

这种方案原理很简单，wifi可以转发dns请求，我们只需要一台服务器，把全部的请求伪装成dns请求发给服务器，服务器解包后请求正常网站，再把回应打包成dns回应回复给我们，我们再拆包就可以了。dns2tcp的方案网上有很多实现，这里因为博主不想用服务器的原因就没有使用这种方案。

F12大法

在poral认证页面，除了手机验证码认证外，没有其他选项了。一般的公共wifi都会照顾一些特殊群体，开放一些特殊认证，例如访客认证、注册用户认证等等。这些认证可能因为鉴权不严格让我们钻空子。

F12打开控制台，在大致看了一下前端代码后，果然不出所料。除了手机号认证外，还有微信认证、邮箱认证、快速认证等等。

function pcweixin_auth() {
	var userMac = $("#userMac").val();
	var ssid = $("#ssid").val();
	var userip = $("#userip").val();
	var port = imc_portal_function_readByodServerHttpPort();
	var ip;
	// æ ¹æ®å®¢æ·ç«¯ipæ¯v4è¿æ¯v6æ¥è¯¢å¯¹åºå½¢å¼çå¾®ä¿¡æå¡å¨å°å
	var ipVersion = imc_portal_function_getClientIPVersion();
	if (ipVersion == IP_VERSION_V4) {
		ip = imc_portal_function_readWeixinAddress();
	} else if (ipVersion == IP_VERSION_V6) {
		ip = "[" + imc_portal_function_readWeixinAddressIPv6() + "]";
	}
	var authUrl = "http://" + ip + ":" + port + "/weixin/wifiCode.jsp?ssid=" + ssid + "&userip=" + userip + "&usermac=" + userMac;
	window.location.replace(authUrl);
}

function weixin_auth() {
	if (!imc_portal_function_ifQuickAuth()) {
		var r = f_preLoginForInputPanel();
		if (!r) {
			return false;
		}
	}

	var showWechat = true;

	var data;
	$.ajax({
		url: "/portal/pws?t=wechatAuth",
		type: "POST",
		cache: false,
		async: false,
		dataType: "text",
		data: $("#form1").serializeArray(),
		beforeSend: function() {
			i_p_f_pageLoading("start");
		},
		success: function(json) {
			data = json;
		},
		error: function(x, y, z) {
		},
		complete: function() {
			i_p_f_pageLoading("complete");
			if (data == null) {
				alert($("#id_text_networkerror").val());
				return false;
			} else {
				var json = eval("(" + i_p_f_base64DecodeAndUrlDecode(data) + ")");
				if (json.resultCode != 0) {
					alert($("#id_text_phone_invalid").val());
					showWechat = false;
				}
			}
		}
	});

	if (!showWechat) {
		return false;
	}


	var phone = $("#id_userName").val();
	var userMac = $("#userMac").val();
	var ssid = $("#ssid").val();
	var userip = $("#userip").val();
	var port = imc_portal_function_readByodServerHttpPort();
	var ip;
	// æ ¹æ®å®¢æ·ç«¯ipæ¯v4è¿æ¯v6æ¥è¯¢å¯¹åºå½¢å¼çå¾®ä¿¡æå¡å¨å°å
	var ipVersion = imc_portal_function_getClientIPVersion();
	if (ipVersion == IP_VERSION_V4) {
		ip = imc_portal_function_readWeixinAddress();
	} else if (ipVersion == IP_VERSION_V6) {
		ip = "[" + imc_portal_function_readWeixinAddressIPv6() + "]";
	}
	var authUrl = "http://" + ip + ":" + port + "/weixin/wifi2.jsp?phone=" + phone + "&ac%2Dip=10%2E100%2E63%2E1&ssid=http%3A%2F%2F1%2E1%2E1%2E1&user%2Dipaddress=NECSE%2DWIFI&uaddress=10%2E100%2E68%2E127&umac=d0c637a6ecf3";
	window.open(authUrl);
}

直接在控制台中调用这两个函数后，发现imc_portal_function_readWeixinAddress函数返回的是null，微信认证还没有接入。顺着imc_portal_function_readWeixinAddress发现了访客的注册地址。

function imc_portal_function_readWeixinAddress() {
    return 'null';
}

function imc_portal_function_readWeixinAddressIPv6() {
    return 'null';
}

function imc_portal_function_readHttpPortIMC() {
    return 'null';
}
function imc_portal_function_getClientIPVersion() {

    return 4;
}
function imc_portal_function_goForgotPwd() {

    window.location.href = "http://10.211.183.232:9066/ssvui/selfservice/mail/forgetPassword.html?sourcePage=portal&nasRedirectUrl=" + window.location.href;
}

function imc_portal_function_goModify() {
    return "/portal/page/modifyPwdAlone.jsp" + window.location.search;
}
function imc_portal_function_guestRegister() {

    window.location.href = "http://10.211.183.232:9066/ssvui/selfservice/preregister/guestPreregister.html?fromPortalService=true&nasRedirectUrl=" + window.location.href;
}
function imc_portal_function_inodeDownload() {

    window.location.href = "http://10.211.183.232:9066/ssvui/selfservice/preregister/clientDown.html";
}

非常幸运，访客认证的地址http://10.211.183.232:9066/ssvui/selfservice/preregister/guestPreregister.html可以访问，并且注册没有进行检测。随便填了一个信息就可以注册使用wifi了。
访客wifi告知仅一天有效期且仅限一台设备。当天发现手机和电脑可以同时使用。隔了两天又去了图书馆，居然没失效诶，还能继续用。

其实这个后台渗透进去非常容易，因为可以上网了就没有往下继续进行了。

下策（未实践）

通过arp中间人攻击，截获其他设备的数据包，把其他人的认证信息拿到自己用。
直接问其他人，让我用用你的。(黑客的最佳实践)

没必要的软路由

2024-04-29T14:35:48.000Z

前言

小学到初二，家里的网线从宽带我世界的电话拨号，升级到了光纤，我的游戏事业也如日中天，形势一片大好之际，我爸妈把网线掐了，直到高中毕业，在此期间我攻坚克难、不畏艰险，先后破解了邻居家的WiFi密码，掉包率极高，在电竞黄金期，摧毁了我的电竞梦想。

毕业后，第一次租房30m宽带，100块才能使用50m，恰好当时拿下了switch，下个塞尔达都要等一天，看直播不能玩游戏。直接给我整破防了。。。

家里一定要有好的网络体验！

以下是我认为好的网络体验。

switch等学习机能全速下载
全家设备能透明进行科学上网
网络延迟要低，dns不能泄露
稳定！稳定！稳定！

不值得的软路由

混迹在各个论坛，经常会刷到软路由、n1等等帖子，通过这些帖子的描述，软路由其实就是一个功耗低一点的小电脑，通常会刷成openwrt、爱快这些系统，光猫网线连上它而后一起放入弱电箱，软路由再连路由器。

软路由玩法

软路由的配置可以自定义，通常要比路由器的配置高很多，举个例子，这些老哥通常会整一个x86的cpu、4g内存、128g存储的配置。然后在软路由里面安装docker、科学上网等工具，充当一个小服务器使用。

比如它安装了科学上网，因为路由器的数据包要经过它，在软路由这一跳，会完成科学代理操作，这就实现了家中网络都能无感科学上网。

功耗低费电少，cpu性能好，加上家里带宽一般都比较大，docker里面跑一些薅羊毛脚本，挂载alist等网盘，亦或是各种骚操作，完成可以充当服务器使用。

每每看到这些帖子，我都忍不住想要去捡点这些垃圾，猛猛吃上几口。直到我了解到近年来mtk的arm cpu愈发强大，今非昔比。

硬路由足矣！

硬路由其实就是我们平时所使用的路由器，早期路由器的cpu十分拉跨，忙中偷闲基本不可能，处理网络数据包都费劲。现在路由器cpu已经足够好了，且支持硬件加速。如此一来，软路由多了一跳，还没硬件加速，岂不是多次一举。

硬路由玩法

硬路由出厂的系统，基本都是基于openwrt做的深度魔改，主打一个稳定。想要安装科学上网等插件，是不可能滴。因此必须获得它的ssh权限，才能做老系统不敢做之事。

本科期间搞了一台红米ax6，那台路由器，刷了openwrt之后，上网体验也是极好的，运行一些插件后，cpu完全能妥妥应对，只是没有2.5G口、不能玩docker等（因为存储小，无法扩容），略感遗憾。

23年8月痛下死手，买了TP的6088，512MB运存， 64MB闪存，2个2.5G口，4个千兆，一个USB，配置在700的价位还算不错。usb接口可以插上ssd来增加存储，之后就能使用docker了。

到手第一天，根据6088vpn漏洞，刷了ImmortalWrt，加上了一块128g的ssd，装了docker一些乱起八糟的插件，体验上并不好，毕竟只有512MB内存，加上很多插件存在一些bug，引起cpu飙升。

在路由器上跑docker，是不可取的，all in one + 中心化，一旦路由器某个服务出现问题，家里直接没网。最终只保留了mosdns，wireguard，homeproxy以及自己用shell写的ddns。十分稳定，mtk确实可以，平均负载基本都是0。

插件吐槽

这里不得不插一嘴，插件的选择，其实openwrt很稳定的，搞懂之后，结合自己的路由器和一些老哥的前车之鉴做一些小调整，上网体验没得说。

很多不稳定是插件导致的，比如最早我使用的openclash，因为fakeip导致平时网络工具经常无法正常使用，像ping等，折腾了许久配置，前前后后redirect等方案都在openclash上进行了尝试，然而还是会在使用几天后，莫名的国内访问延迟上涨，跳点大。甚至去读了一部分metaclash源码，写的很一般。后来换成了pw，pw更是卧龙凤雏，开启大陆优化，国内延迟会降到没开pw时的大小，和openclash一样，大概2天左右，就会跳点变大，cpu飙升。
结合日志，加上cpu和内存根本没到瓶颈，也不是mosdns的问题，不得其解。

后来看到了sing-box内核，简单测试了一下，占用和性能都比clash要好，就选择了基于sing-box的homeproxy，仅仅踩了一些分流的坑，界面上也要简洁很多。国内速度和没开代理一样，用的bwg gia hy2，没感觉有晚高峰什么的，一直很流畅稳定。
（分流的坑是因为GPT网页开启了http/3，如果不开启udp服务器代理或者不禁用它，就无法正常使用。

docker的需求都交给了腾讯云，通过ipv6 wireguard回家访问，而且硬路由还有硬件加速，实在想不出，软路由有什么好的，还多了一跳。

总结

路由器今非昔比，路由器有10胜，软路由有10败。

路由器有硬件加速，软路由没有，此乃一胜。
路由器已经一胜了，软路由零胜，此乃二胜。
路由器已经二胜了，软路由零胜，此乃三胜。
路由器已经三胜了，软路由零胜，此乃四胜。
路由器已经四胜了，软路由零胜，此乃五胜。
路由器已经五胜了，软路由零胜，此乃六胜。
路由器已经六胜了，软路由零胜，此乃七胜。
路由器已经七胜了，软路由零胜，此乃八胜。
路由器已经八胜了，软路由零胜，此乃九胜。
路由器已经九胜了，软路由零胜，此乃十胜。

用shell写一个ddns

2023-09-17T12:40:56.000Z

DDNS

假设有这样一种场景，有台服务器的IP每个一段时间会变化，而我们访问这台机器时，就可能因为这台机器的IP发生了变化，导致不能访问，必须到那台机器上，获取到新的IP地址才能进行访问，这十分的痛苦。

DNS可以把IP和domain(域名)进行映射，让我们可以通过域名就可以找到IP，然后对机器进行访问，如此一来，当服务器IP发生变化时，我们只需要把域名的DNS解析换成新的IP，其他设备用域名访问服务器，就感知不到IP发生了变化。可是手动档换DNS解析并不是一个好主意。

DDNS(Dynamic DNS)可以动态解析IP，当检测到IP发生了变化，就会自动换DNS解析，竟有此等技术，方可高枕无忧。

用shell实现一个simple DDNS

DDNS实现方案很多，最简单粗暴的莫过于

获取本地IP
获取域名IP
比较IP是否相同，如果相同就使用API更新DNS
定时运行上面步骤

shell方案中所用工具

dig｜nslookup等DNS查询工具获取域名IP 。
ip｜ipconfig等命令获取到本机IP。
curl发送网络请求，进行更换DNS解析

# 这是ipv6的例子

ipv6_address=$(ip -6 addr show br-lan | awk '/inet6 .*global/{gsub(/\/[0-9]+/, "", $2); print $2}')

ipv6_older=$(dig AAAA baidu.com +short)

if [ "$ipv6_address" != "$ipv6_older" ]; then
        echo $ipv6_address
        curl -u "xxx"
fi

最后再用crontab -e，添加一个定时任务，完结撒花。

vector日志采集-快速开始

2023-09-10T14:07:48.000Z

本文默认已经有一丢丢lua基础

vector 采集流程

vector官网给出的三步走战略，结合具体配置，设置采集源头—>进行数据转换—>保存转换好的数据。

# 从哪采集
[sources.generate_syslog]
type = "demo_logs"
format = "syslog"
count = 100

# 数据转换
[transforms.remap_syslog]
inputs = [ "generate_syslog"]  # 转换的输入来自generate_syslog过程的返回值
type = "remap"
source = '''
  structured = parse_syslog!(.message)
  . = merge(., structured)
'''

#保存到哪
[sinks.emit_syslog]
inputs = ["remap_syslog"] # 保存的输入来自remap_syslog过程的返回值
type = "console"          # 把结果直接输出到终端上
encoding.codec = "json"

这相当的友好，除了toml配置，你还能使用json或者~~需要游标卡尺的~~yaml。

采集实战

采集源头（sources）和保存到哪（sinks）设置起来很容易，官网给出了相关的文档，你能看到很多sources、sink以及我们即将重点实战的数据转换（transforms）。

实战案例背景

假设有一个程序会通过syslog输出日志，我们需要采集含有ohayo字符串的日志，并把它保存到一个文件中。

采集源头：syslog
数据转换需求：含有ohayo字符串的日志
保存：文件

vector 采集配置

采集源头，监听本机的/dev/log套接字，syslog与vector会通过这个套接字进行进程间通信。

[sources.syslog_1]
type = "socket"      # 类型采用套接字方式
mode = "unix_stream" # 采用unix流的方式
path = "/dev/log"    # 监听套接字路径

数据转换，这里我使用的是lua，vector官网在极力推它们的remap，甚至给出lua5.4比remap慢了60% && lua只能在运行时才会出现问题，这不安全的恐怖言论。
O(2n)、O(3n)都是O(n)，长板凳、矮板凳都是板凳。根据剃刀原理…这就是我选lua的理由。

PS: remap在面对格式规范的日志输出，要比lua更加方便。而且在启动vector时会进行静态检查。

让我们先看一下，lua怎么在vector中转换数据的吧！下图是官网文档。

vector需要我们在配置中注册三个函数，init | process | shutdown，第一条日志来的时候，会执行init函数，然后会执行process，当转换结束时，会执行shutdown。
注意，init只有在第一条日志来的时候才执行，shutdown在关闭时执行，而process在每条日志来的时候都会执行。

结合配置格式填写如下

[transforms.milestone_syslog_2]
  # General
type = "lua" # 转换类型lua
version = "2" # 转换api版本，1已经被弃用了。
inputs = ["milestone_syslog_1"] # 从采集源头获取数据
search_dirs = ["scripts"]       # lua导包的搜寻路径。这里是相对路径./scripts
source = "rd = require('record')"  # 引入资源，这里面可以写代码哦
hooks.process = "rd.process"       # 注册 process函数

-- @filename record.lua
local M = {}

function M.process(event, emit)
	if string.find(event.log.message) then
		emit(event)
	end
end

return M

解释一下，vector会把每一个从source采集日志，包装成一个table，日志的内容可以用event.log.message获取，emit函数会把event结构的table发送到sink存储层进行保存。
保存的内容是 event.log，这个table的格式如下。

接着设置保存，从转换层（transform）拿到数据，编码成text，设置保存路径即可。

[sinks.milestone_record_file]
type = "file"
inputs = ["milestone_syslog_2"]
idle_timeout_secs = 30
encoding.codec = "text"
path = "/tmp/vector-%Y-%m-%d.log"

完整配置文件如下

[sources.syslog_1]
type = "socket"      # 类型采用套接字方式
mode = "unix_stream" # 采用unix流的方式
path = "/dev/log"    # 监听套接字路径

[transforms.milestone_syslog_2]
  # General
type = "lua" # 转换类型lua
version = "2" # 转换api版本，1已经被弃用了。
inputs = ["milestone_syslog_1"] # 从采集源头获取数据
search_dirs = ["scripts"]       # lua导包的搜寻路径。这里是相对路径./scripts
source = "rd = require('record')"  # 引入资源，这里面可以写代码哦,这个lua文件是自己写的哦。
hooks.process = "rd.process"       # 注册 process函数

[sinks.milestone_record_file]
type = "file"
inputs = ["milestone_syslog_2"]
idle_timeout_secs = 30
encoding.codec = "text"
path = "/tmp/vector-%Y-%m-%d.log"

sudo vector --config xxx.toml就可以进行采集了。

总结

如果你对lua有一定了解，那么这篇文章就够了，你可以在转换层做全部事情。BTW，官网文档对各种API写的相当全，比较不错的参看。本文对快速开始使用vector来说已经足够了，如果你的日志是标准内容，请首选remap，快是真的快。

openwrt插件篇-openclash&adguardhome

2023-09-03T12:59:49.000Z

DNS（Domain Name System），网络域名系统。可以把它对应手机里的联系人，通过联系人的名字就可以找到电话号码，也能通过手机号找到对应联系人的信息，从而能够准确给特定人拨打电话或者发短信等等。而DNS会把网络域名转换成ip，也能把ip转换成网络域名。

AdguardHome

AdguardHome 是一个本地DNS转发器，同时能过滤广告或者网站等，GitHub开源。下文简称为ADHome。
值得庆幸的是，ADHome在openwrt上也能用，首先说一下这个软件能带来哪些好处。

在上图，浏览一个网站时，会先进行DNS查询，获取网站的IP，这个过程十分慢，会极大影响上网体验，其次在我们连接到Wi-Fi上网时，很可能我们正在使用的设备DNS会被劫持，也就是说不是8.8.8.8|1.1.1.1等公共的DNS服务器，它可能是某个老油条自己搭建的一个，同时把你想访问的网站ip，换成他设定的，这就十分的危险了。

把DNS默认设置为ADHome的DNS服务端口，你的每一条DNS请求都会走ADHome的DNS服务，就可以防止DNS被劫持，同时为ADHome设置一些公共的DNS服务器上游，在收到DNS请求时，它会并发向这些上游DNS服务器请求，根据你的选择，可以返回最快的，也可以是其他情况。

如此说来，ADHome兼并smartdns等软件的功能，同时还具备过滤功能，可以设置黑名单来屏蔽广告等。没有理由不装！！！openwrt链接

以下是我的dns备用

# 上游服务器
114.114.114.114
223.5.5.5
180.76.76.76
1.1.1.1
8.8.8.8
8.8.4.4
117.50.10.10
180.184.1.1
101.101.101.101
https://public.dns.iij.jp/dns-query
https://dns.google/dns-query
https://1.1.1.1/dns-query

去广告用的是anti-ad公开的广告库—>传送

openclash

openclash是clash的openwrt版本，安装完meta内核，基本和电脑端的规则兼容，一套规则，全平台使用，还是很不错滴。
就不过多写这个了。

openclash+ADHome

这才是硬路由的终极方案，openclash劫持53端口的DNS转发，同时将openclash的DNS上游设置为ADHome。
如此一来，DNS请求—>53端口DNS—>openclash—>ADHome。

openclash配置如下，其中8053为ADHome服务端口。

ADHome配置如下

DNS测速对比

根据使用情况，smartdns与ADHome dns查询速度基本一致，这里对比的是smartdns与正常情况下的DNS。
速率对比是玄学，主要用途是为了防止DNS被劫持。

正常情况如下

使用smartdns情况如下

尽管dns查询速度这块是玄学，实际使用上来说，提升是有的，搭配openclash秒开YouTube。

最后不得不说6088这款路由器，真滴强，openclash➕ADHome等应用一点压力都没。

想把博客从hexo转移到hugo，之前改的配置，都不记得改了那里，很难受，算了，先这样吧，等11.11买完新电脑，再迁移吧。

tl6088刷机之旅

2023-08-27T15:16:59.000Z

最近又换了一台路由器，TP-link-6088，因为上个月买了台switch，无论怎么换DNS，下载速度依旧感人至深。转手就把小米AX6000卖了，其实小米AX6000已经能满足我的日常的绝大需求，唯一缺点就是自由度不够，迟来的switch打破昔日的平静。

为啥选择tl6088？

对，这是个好问题，身为一个小垃圾佬，先后了解很多路由器，结合我的需求，要能刷openwrt，运行内存至少要512，CPU要好一些，处理网络数据包的同时，要留有余地去跑一些第三方服务。闪存要高一些，至少64。
最重要的是价格一定要便宜！！！
如此这般，候选路由器1号----红米ax6000，2号----tl6088，3号----tl6080。
红米ax6000在配置上几乎与6088完全一样，加上是米家的路由器，再熟悉不过，可惜没有2.5G网口，惨遭淘汰。
6088和6080，jd搞活动，价格相差不大，最终选择了6088，6百多拿下。

刷机openwrt

tp家的路由器和米家的不一样，我看很多论坛上说tp的刷机过程比较繁琐。之前玩的红米ax6，刷机已经很繁琐了。我敲，这不会又是一个通宵吧。

还好小马过河，实际比红米ax6省事不少，利用6088的vpn漏洞，注入刷机包，再通过tftp服务，把recover传入，整体过程一气呵成，大概20分钟，就刷完了。

具体的参考文章可以看===>这篇文章，作者很谨慎，传输的文件都加了md5验证文件唯一性，胆大心细，十分nice。

配置openwrt

家里的电线光猫，全国通用密码，直接8080端口找到老web地址，把宽带账号&&密码记下来，删除第三个路由模式，创建一个桥接模式，钩上端口，最后关闭光猫的DHCP。

openwrt这边就容易多了，我用的是wan6接口拨号上网，其他默认就行。最后设置完Wi-Fi密码，把国家代码改成AU，澳大利亚提高无线功率。

插件

openwrt最好玩儿的地方。

我目前安装的插件

open clash
smartdns
upnp
uu加速器

smartdns具有很好的dns查询效果，自己设置完上游dns后，网页打开能快不少，不是吹的。

smartdns作为openclash的上游dns，有很好的加速效果，upnp就不用多说了，必装插件，打游戏嗖嗖滴。

uu加速器，害，一个臭打游戏的插件，加速主机，要什么小黑盒，都没用。

简单记录一下新路由器的之旅，openwrt还有很多地方不懂，这周会开始逐步搞懂，最后记录一个通用的图文配置，以备不时之需。

唉，这周之前不到2刀买的域名过期了，导致我一堆的服务都歇菜了，azure for student 订阅也没多少了，希望黑5能找到好机子，下周会先配置完nvim，然后研究一下ws协议等，没有这些东西，程序员简直没法生活啊。抽空会更新c语言&&汇编。

skynet源码学习（粗略版）

2023-06-04T04:46:57.000Z

本文从skynet的main入口开始，梳理skynet运行流程，中间很多东西不会解释，必要的一些细节还是会解释滴，旨在梳理清楚skynet如何工作、启动skynet项目，发生了什么？后续将带着以下问题开始。

skynet服务如何工作？skynet服务是什么？
服务之间如何传递信息？
一个服务如何启动？

btw，本文需要有一定的c语言基础、lua基础以及较为重要的lua与c交互的相关知识。

main入口

main函数首先，检测了配置文件，配置节点，TSD，初始化skynet环境，设置信号量。

struct lua_State *L = luaL_newstate();
luaL_openlibs(L);   // link lua lib
int err =  luaL_loadbufferx(L, load_config, strlen(load_config), "=[skynet config]", "t");
assert(err == LUA_OK);
lua_pushstring(L, config_file);
err = lua_pcall(L, 1, 1, 0);
if (err) {
	fprintf(stderr,"%s\n",lua_tostring(L,-1));
	lua_close(L);
	return 1;
}

_init_env(L);
config.thread =  optint("thread",8);
config.module_path = optstring("cpath","./cservice/?.so");
config.harbor = optint("harbor", 1);
config.bootstrap = optstring("bootstrap","snlua bootstrap");
config.daemon = optstring("daemon", NULL);
config.logger = optstring("logger", NULL);
config.logservice = optstring("logservice", "logger");
config.profile = optboolean("profile", 1)
lua_close(L);

main中创建了一个lua栈，把配置文件的内容压入栈里，通过lua脚本，设置到skynet环境中。

#加载config的lua脚本
 static const char * load_config = "\
	local result = {}\n\
	local function getenv(name) return assert(os.getenv(name), [[os.getenv() failed: ]] .. name) end\n\
	local sep = package.config:sub(1,1)\n\
	local current_path = [[.]]..sep\n\
	local function include(filename)\n\
		local last_path = current_path\n\
		local path, name = filename:match([[(.*]]..sep..[[)(.*)$]])\n\
		if path then\n\
			if path:sub(1,1) == sep then	-- root\n\
				current_path = path\n\
			else\n\
				current_path = current_path .. path\n\
			end\n\
		else\n\
			name = filename\n\
		end\n\
		local f = assert(io.open(current_path .. name))\n\
		local code = assert(f:read [[*a]])\n\
		code = string.gsub(code, [[%$([%w_%d]+)]], getenv)\n\
		f:close()\n\
		assert(load(code,[[@]]..filename,[[t]],result))()\n\
		current_path = last_path\n\
	end\n\
	setmetatable(result, { __index = { include = include } })\n\
	local config_name = ...\n\
	include(config_name)\n\
	setmetatable(result, nil)\n\
	return result\n\
";

后续就可以通过skynet环境读取到配置文件的信息啦。

config.thread =  optint("thread",8);
config.module_path = optstring("cpath","./cservice/?.so");
config.harbor = optint("harbor", 1);
config.bootstrap = optstring("bootstrap","snlua bootstrap");
config.daemon = optstring("daemon", NULL);
config.logger = optstring("logger", NULL);
config.logservice = optstring("logservice", "logger");
config.profile = optboolean("profile", 1);

我们拿config.thread = optint("thread",8);举例，后面optstring都是类似的。

static int
optint(const char *key, int opt) {
	const char * str = skynet_getenv(key);
	//如果配置文件没有配置这个key，就用默认的参数，在optint("thread",8)中就是8.
	if (str == NULL) {
		char tmp[20];
		sprintf(tmp,"%d",opt);
		skynet_setenv(key, tmp); //把默认的参数写入skynet环境中。
		return opt;
	}
	return strtol(str, NULL, 10);//配置文件中有key的配置，把字符串转int值返回。
}

加载完配置文件后，会关闭临时用的lua栈，然后来到最重要的环节----根据配置，启动skynet。

skynet_start(&config);// <==我们主要通过这个，就可以知道skynet的启动流程了
skynet_globalexit();

启动流程

skynet_start中，首先也注册了信号量，紧接着检测是否设置为守护进程。

后面的部分，才是我们主要分析的地方。
这个函数首先进行了节点、handle、消息队列、模块、定时器、socket的初始化以及开启性能分析。

skynet_harbor_init(config->harbor);
skynet_handle_init(config->harbor);
skynet_mq_init();
skynet_module_init(config->module_path);
skynet_timer_init();
skynet_socket_init();
skynet_profile_enable(config->profile);

我们知道skynet中服务地址的构成。高八位是节点地址，低24位是服务地址。

而skynet_harbor_init仅仅只做了一件事，把高8位设置为配置文件的节点号。

void
skynet_harbor_init(int harbor) {
	HARBOR = (unsigned int)harbor << HANDLE_REMOTE_SHIFT;
}

在skynet_handle_init中主要为了，初始化一张全局handle操作的地址表H。
skynet_mq_init中创建一个全局队列。
skynet_module_init中创建了一个全局模块表，这样可以避免模块重复加载等等。

struct modules {
	int count;
	struct spinlock lock;
	const char * path;
	struct skynet_module m[MAX_MODULE_TYPE];
};

skynet_timer_init中创建了一个全局定时器，用于更新时间。
skynet_socket_init中根据定时器提供的当前时间创建了一个socket_server，用与管理socket相关操作。

接下来skynet启动了第一个服务——日志服务。

struct skynet_context *ctx = skynet_context_new(config->logservice, config->logger);
if (ctx == NULL) {
	fprintf(stderr, "Can't launch %s service\n", config->logservice);
	exit(1);
}

skynet_handle_namehandle(skynet_context_handle(ctx), "logger");

我们主要分析skynet_context_new这个函数，而skynet_handle_namehandle函数非常简单，它的作用是给服务起个名字，并插入到handle全局表H中，这里不过多展开了。

skynet_context_new函数首先会查询服务的模块名。

struct skynet_module * mod = skynet_module_query(name);

if (mod == NULL)
	return NULL;
//skynet_module_query

这里需要分析一下mod 查询函数

struct skynet_module * 
skynet_module_query(const char * name) {
	// _query会去全局模块表M中找，看之前是否打开过该模块。如果打开过直接返回。
	struct skynet_module * result = _query(name);
	if (result)
		return result;

	SPIN_LOCK(M)

	result = _query(name); // double check
	//如果之前没有打开过，会去设置的模块路径中查找对应的模块，进行打开。
	if (result == NULL && M->count < MAX_MODULE_TYPE) {
		int index = M->count;
		void * dl = _try_open(M,name);
		if (dl) {
			M->m[index].name = name;
			M->m[index].module = dl;

			if (open_sym(&M->m[index]) == 0) {
				M->m[index].name = skynet_strdup(name);
				M->count ++;
				result = &M->m[index];
			}
		}
	}

	SPIN_UNLOCK(M)
	//打开成功返回skynet_module*，否则是NULL
	return result;
}

模块打开后，会对模块实例化。

void *inst = skynet_module_instance_create(mod);
if (inst == NULL)
	return NULL;
struct skynet_context * ctx = skynet_malloc(sizeof(*ctx));

实例化会调用模块中的回调函数。

void * 
skynet_module_instance_create(struct skynet_module *m) {
	if (m->create) {
		return m->create();
	} else {
		return (void *)(intptr_t)(~0);
	}
}

这里有一个问题，这个回调函数m->create()怎么来的。
这个回调函数的绑定是在查询阶段调用open_sym函数实现的。

static void *
get_api(struct skynet_module *mod, const char *api_name) {
	size_t name_size = strlen(mod->name);
	size_t api_size = strlen(api_name);
	char tmp[name_size + api_size + 1];
	memcpy(tmp, mod->name, name_size);
	memcpy(tmp+name_size, api_name, api_size+1);
	char *ptr = strrchr(tmp, '.');
	if (ptr == NULL) {
		ptr = tmp;
	} else {
		ptr = ptr + 1;
	}
	return dlsym(mod->module, ptr);
}

static int
open_sym(struct skynet_module *mod) {
	mod->create = get_api(mod, "_create");
	mod->init = get_api(mod, "_init");
	mod->release = get_api(mod, "_release");
	mod->signal = get_api(mod, "_signal");
	return mod->init == NULL;
}

接着回到服务的创建函数，下面都是对服务的初始化。

ctx->mod = mod;
ctx->instance = inst;
ATOM_INIT(&ctx->ref , 2);
ctx->cb = NULL;
ctx->cb_ud = NULL;
ctx->session_id = 0;
ATOM_INIT(&ctx->logfile, (uintptr_t)NULL);

ctx->init = false;
ctx->endless = false;

ctx->cpu_cost = 0;
ctx->cpu_start = 0;
ctx->message_count = 0;
ctx->profile = G_NODE.profile;
// Should set to 0 first to avoid skynet_handle_retireall get an uninitialized handle
ctx->handle = 0;	
ctx->handle = skynet_handle_register(ctx); //注册一个handle地址

紧接着重点来了，服务创建了一个消息队列，并调用模块的初始化函数，对其进行初始化，如果初始化成功，就把这个服务的消息队列推入skynet的全局中并返回ctx，否则创建服务失败，释放相关资源。

struct message_queue * queue = ctx->queue = skynet_mq_create(ctx->handle);
// init function maybe use ctx->handle, so it must init at last
context_inc();

CHECKCALLING_BEGIN(ctx)
int r = skynet_module_instance_init(mod, inst, ctx, param);
CHECKCALLING_END(ctx)
if (r == 0) {
	struct skynet_context * ret = skynet_context_release(ctx);
	if (ret) {
		ctx->init = true;
	}
	skynet_globalmq_push(queue);
	if (ret) {
		skynet_error(ret, "LAUNCH %s %s", name, param ? param : "");
	}
	return ret;
} else {
	skynet_error(ctx, "FAILED launch %s", name);
	uint32_t handle = ctx->handle;
	skynet_context_release(ctx);
	skynet_handle_retire(handle);
	struct drop_t d = { handle };
	skynet_mq_release(queue, drop_message, &d);
	return NULL;
}

这里的函数都不难理解，就不做展开了。

到这里一个服务就创建好了，可以得到结论，服务其实就是一个skynet_context结构体。

接下来到了bootstrap(ctx, config->bootstrap);这步，这步的作用是启动的服务，这行代码，连接lua层，比较难，放到最后再说，不妨先理解为启动其他服务。

线程创建

在各个服务都创建好后，到了start(config->thread);，就开始创建服务的处理线程了。
这里要先用几个图解释一下。
当服务创建好后，它的消息队列会push到skynet全局队列GQ中。
而服务本身有一个skynet_message队列，这个队列是存放其他服务发的消息的。

全局队列中的每个消息队列对应一个服务，而其他服务发送需要处理的消息在消息队列中的skynet_message队列中。需要注意的是，全局队列是链表的形式，而skynet_message队列是数组循环队列。

start(config->thread);会创建很多工作线程，这些工作线程从GQ中，抢消息队列，如果消息队列中有消息，就用消息队列对应服务的回调函数处理这条消息。

下面开始从源码分析这些线程是怎么创建与工作的。
在创建这些工作线程之前，先创建了监视器、定时器、socket三个线程，而监视器线程中有与工作线程数量对应的skynet_monitor监视器。
这里的在创建定时器和socket线程时也传入了监视器实例，主要目的是为了通过监视器实例来控制工作线程。

pthread_t pid[thread+3];

struct monitor *m = skynet_malloc(sizeof(*m));
memset(m, 0, sizeof(*m));
m->count = thread;
m->sleep = 0;

m->m = skynet_malloc(thread * sizeof(struct skynet_monitor *));
int i;
for (i=0;i<thread;i++) {
	m->m[i] = skynet_monitor_new();
}
if (pthread_mutex_init(&m->mutex, NULL)) {
	fprintf(stderr, "Init mutex error");
	exit(1);
}
if (pthread_cond_init(&m->cond, NULL)) {
	fprintf(stderr, "Init cond error");
	exit(1);
}

create_thread(&pid[0], thread_monitor, m);
create_thread(&pid[1], thread_timer, m);
create_thread(&pid[2], thread_socket, m);

而后才创建了工作线程，在创建工作线程时，对每个线程附加了权重还传入了对应的skynet_monitor监视器。这个权重稍后解释。

static int weight[] = { 
	-1, -1, -1, -1, 0, 0, 0, 0,
	1, 1, 1, 1, 1, 1, 1, 1, 
	2, 2, 2, 2, 2, 2, 2, 2, 
	3, 3, 3, 3, 3, 3, 3, 3, };
struct worker_parm wp[thread];
for (i=0;i<thread;i++) {
	wp[i].m = m;
	wp[i].id = i;
	if (i < sizeof(weight)/sizeof(weight[0])) {
		wp[i].weight= weight[i];
	} else {
		wp[i].weight = 0;
	}
	create_thread(&pid[i+3], thread_worker, &wp[i]);
}

for (i=0;i<thread+3;i++) {
	pthread_join(pid[i], NULL); 
}

不妨看看thread_worker做了什么。

首先通过获取权重，并通过全局监视器获取skynet_monitor监视器。当监视器没有离开时，重复循环。

static void *
thread_worker(void *p) {
	struct worker_parm *wp = p;
	int id = wp->id;
	int weight = wp->weight;
	struct monitor *m = wp->m;
	struct skynet_monitor *sm = m->m[id];
	skynet_initthread(THREAD_WORKER);
	struct message_queue * q = NULL;
	while (!m->quit) {
		q = skynet_context_message_dispatch(sm, q, weight);
		if (q == NULL) {
			if (pthread_mutex_lock(&m->mutex) == 0) {
				++ m->sleep;
				// "spurious wakeup" is harmless,
				// because skynet_context_message_dispatch() can be call at any time.
				if (!m->quit)
					pthread_cond_wait(&m->cond, &m->mutex);
				-- m->sleep;
				if (pthread_mutex_unlock(&m->mutex)) {
					fprintf(stderr, "unlock mutex error");
					exit(1);
				}
			}
		}
	}
	return NULL;
}

其中skynet_context_message_dispatch函数是关键。

这个函数首先从全局队列GQ中获取消息队列。然后从消息队列中获取handle，再从handle中获取到服务上下文。

if (q == NULL) {
	q = skynet_globalmq_pop();
	if (q==NULL)
		return NULL;
}
uint32_t handle = skynet_mq_handle(q);

struct skynet_context * ctx = skynet_handle_grab(handle);
if (ctx == NULL) {
	struct drop_t d = { handle };
	skynet_mq_release(q, drop_message, &d);
	return skynet_globalmq_pop();
}

之后就是对消息队列中skynet_message队列进行处理，这里可以知道，权重的作用。

权重	消息处理数量
-1	1条
0	全部消息
1	一半消息
2	1/4消息
3	1/8消息

int i,n=1;
struct skynet_message msg;

for (i=0;i<n;i++) {
	if (skynet_mq_pop(q,&msg)) {
		skynet_context_release(ctx);
		return skynet_globalmq_pop();
	} else if (i==0 && weight >= 0) {
		n = skynet_mq_length(q);
		n >>= weight;
	}
	int overload = skynet_mq_overload(q);
	if (overload) {
		skynet_error(ctx, "May overload, message queue length = %d", overload);
	}

	skynet_monitor_trigger(sm, msg.source , handle);

	if (ctx->cb == NULL) {
		skynet_free(msg.data);
	} else {
		dispatch_message(ctx, &msg);
	}

	skynet_monitor_trigger(sm, 0,0);
}

这里的监视器触发函数skynet_monitor_trigger，主要是为了防止服务死循环。

void 
skynet_monitor_trigger(struct skynet_monitor *sm, uint32_t source, uint32_t destination) {
	sm->source = source;
	sm->destination = destination;
	ATOM_FINC(&sm->version);
}

void 
skynet_monitor_check(struct skynet_monitor *sm) {
	if (sm->version == sm->check_version) {
		if (sm->destination) {
			skynet_context_endless(sm->destination);
			skynet_error(NULL, "A message from [ :%08x ] to [ :%08x ] maybe in an endless loop (version = %d)", sm->source , sm->destination, sm->version);
		}
	} else {
		sm->check_version = sm->version;
	}
}

在监视器线程中，会不断检查工作线程的skynet_monitor。

static void *
thread_monitor(void *p) {
	struct monitor * m = p;
	int i;
	int n = m->count;
	skynet_initthread(THREAD_MONITOR);
	for (;;) {
		CHECK_ABORT
		for (i=0;i<n;i++) {
			skynet_monitor_check(m->m[i]);
		}
		for (i=0;i<5;i++) {
			CHECK_ABORT
			sleep(1);
		}
	}

	return NULL;
}

再次回到工作线程中的skynet_context_message_dispatch函数，在服务有注册回调函数时，会调用dispatch_message进行处理，而这个函数会调用服务的回调进行消息处理。

static void
dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) {
	assert(ctx->init);
	CHECKCALLING_BEGIN(ctx)
	pthread_setspecific(G_NODE.handle_key, (void *)(uintptr_t)(ctx->handle));
	int type = msg->sz >> MESSAGE_TYPE_SHIFT;
	size_t sz = msg->sz & MESSAGE_TYPE_MASK;
	FILE *f = (FILE *)ATOM_LOAD(&ctx->logfile);
	if (f) {
		skynet_log_output(f, msg->source, type, msg->session, msg->data, sz);
	}
	++ctx->message_count;
	int reserve_msg;
	if (ctx->profile) {
		ctx->cpu_start = skynet_thread_time();
		reserve_msg = ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz);
		uint64_t cost_time = skynet_thread_time() - ctx->cpu_start;
		ctx->cpu_cost += cost_time;
	} else {
		reserve_msg = ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz);
	}
	if (!reserve_msg) {
		skynet_free(msg->data);
	}
	CHECKCALLING_END(ctx)
}

如此，服务如何运行的问题就基本解决了。就是通过这些工作线程不断从GQ中获取服务的消息队列，再调用服务注册的回调函数处理消息。

让我们回到bootstrap(ctx, config->bootstrap);服务启动这部分。

服务启动

bootstrap函数如下，举个例子，传入的是默认参数日志服务和snlua bootstrap

static void
bootstrap(struct skynet_context * logger, const char * cmdline) {
	int sz = strlen(cmdline);
	char name[sz+1];
	char args[sz+1];
	int arg_pos; 
	sscanf(cmdline, "%s", name);  
	arg_pos = strlen(name);
	if (arg_pos < sz) {
		while(cmdline[arg_pos] == ' ') {
			arg_pos++;
		}
		strncpy(args, cmdline + arg_pos, sz);
	} else {
		args[0] = '\0';
	}
	struct skynet_context *ctx = skynet_context_new(name, args);
	if (ctx == NULL) {
		skynet_error(NULL, "Bootstrap error : %s\n", cmdline);
		skynet_context_dispatchall(logger);
		exit(1);
	}
}

这个函数会执行struct skynet_context *ctx = skynet_context_new("snlua", "bootstrap");创建一个snlua服务。
snlua全名是skynet lua，它是作者自定义的lua虚拟机。
创建时，会建一个lua栈，并初始化变量。

struct snlua {
	lua_State * L;
	struct skynet_context * ctx;
	size_t mem;
	size_t mem_report;
	size_t mem_limit;
	lua_State * activeL;
	ATOM_INT trap;
};
struct snlua *
snlua_create(void) {
	struct snlua * l = skynet_malloc(sizeof(*l));
	memset(l,0,sizeof(*l));
	l->mem_report = MEMORY_WARNING_REPORT;
	l->mem_limit = 0;
	l->L = lua_newstate(lalloc, l);
	l->activeL = NULL;
	ATOM_INIT(&l->trap , 0);
	return l;
}
int

snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
	int sz = strlen(args);
	char * tmp = skynet_malloc(sz);
	memcpy(tmp, args, sz);
	skynet_callback(ctx, l , launch_cb);
	const char * self = skynet_command(ctx, "REG", NULL);
	uint32_t handle_id = strtoul(self+1, NULL, 16);
	// it must be first message
	skynet_send(ctx, 0, handle_id, PTYPE_TAG_DONTCOPY,0, tmp, sz);
	return 0;
}

这个服务的重点在于初始化操作，它首先通过skynet_callback函数设置了自己的回调函数为launch_cb，还拿具体例子，这个参数是默认参数"bootstrap"。
const char * self = skynet_command(ctx, "REG", NULL);这段代码如果最后的参数会NULL或\0返回服务的handle，如果.name则给服务注册名字。
而uint32_t handle_id = strtoul(self+1, NULL, 16);这里的self+1是因为self是16进制字符串，第一位是:。
最后向自己发一条消息，让工作线程去处理它。

static struct command_func cmd_funcs[] = {
	{ "TIMEOUT", cmd_timeout },
	{ "REG", cmd_reg },
	{ "QUERY", cmd_query },
	{ "NAME", cmd_name },
	{ "EXIT", cmd_exit },
	{ "KILL", cmd_kill },
	{ "LAUNCH", cmd_launch },
	{ "GETENV", cmd_getenv },
	{ "SETENV", cmd_setenv },
	{ "STARTTIME", cmd_starttime },
	{ "ABORT", cmd_abort },
	{ "MONITOR", cmd_monitor },
	{ "STAT", cmd_stat },
	{ "LOGON", cmd_logon },
	{ "LOGOFF", cmd_logoff },
	{ "SIGNAL", cmd_signal },
	{ NULL, NULL },
};

const char * 
skynet_command(struct skynet_context * context, const char * cmd , const char * param) {
	struct command_func * method = &cmd_funcs[0];
	while(method->name) {
		if (strcmp(cmd, method->name) == 0) {
			return method->func(context, param);
		}
		++method;
	}

	return NULL;
}

static const char *
cmd_reg(struct skynet_context * context, const char * param) {
	if (param == NULL || param[0] == '\0') {
		sprintf(context->result, ":%x", context->handle);
		return context->result;
	} else if (param[0] == '.') {
		return skynet_handle_namehandle(context->handle, param + 1);
	} else {
		skynet_error(context, "Can't register global name %s in C", param);
		return NULL;
	}
}

当工作线程拿到这条信息时，就会回调launch_cb函数，这里有把snlua服务的回调函数设置为NULL了，这是因为snlua只进行一次运行初始化即可，这里设置为NULL，可以保护服务初始化，而后续会把回调设置成其他。

static int
launch_cb(struct skynet_context * context, void *ud, int type, int session, uint32_t source , const void * msg, size_t sz) {
	assert(type == 0 && session == 0);
	struct snlua *l = ud;
	skynet_callback(context, NULL, NULL);
	int err = init_cb(l, context, msg, sz);
	if (err) {
		skynet_command(context, "EXIT", NULL);
	}

	return 0;
}

继续调用init_cb，这是snlua的核心，它通过lua与c的交互，设置了环境，为了统计时间，重置了协程函数，同时设置了lua寻找模块的路径。

static int
init_cb(struct snlua *l, struct skynet_context *ctx, const char * args, size_t sz) {
	lua_State *L = l->L;
	l->ctx = ctx;
	lua_gc(L, LUA_GCSTOP, 0);
	lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
	lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
	luaL_openlibs(L);
	luaL_requiref(L, "skynet.profile", init_profile, 0);

	int profile_lib = lua_gettop(L);
	// replace coroutine.resume / coroutine.wrap
	lua_getglobal(L, "coroutine");
	lua_getfield(L, profile_lib, "resume");
	lua_setfield(L, -2, "resume");
	lua_getfield(L, profile_lib, "wrap");
	lua_setfield(L, -2, "wrap");

	lua_settop(L, profile_lib-1);

	lua_pushlightuserdata(L, ctx);
	lua_setfield(L, LUA_REGISTRYINDEX, "skynet_context");
	luaL_requiref(L, "skynet.codecache", codecache , 0);
	lua_pop(L,1);

	lua_gc(L, LUA_GCGEN, 0, 0);

	const char *path = optstring(ctx, "lua_path","./lualib/?.lua;./lualib/?/init.lua");
	lua_pushstring(L, path);
	lua_setglobal(L, "LUA_PATH");
	const char *cpath = optstring(ctx, "lua_cpath","./luaclib/?.so");
	lua_pushstring(L, cpath);
	lua_setglobal(L, "LUA_CPATH");
	const char *service = optstring(ctx, "luaservice", "./service/?.lua");
	lua_pushstring(L, service);
	lua_setglobal(L, "LUA_SERVICE");
	const char *preload = skynet_command(ctx, "GETENV", "preload");
	lua_pushstring(L, preload);
	lua_setglobal(L, "LUA_PRELOAD");

	lua_pushcfunction(L, traceback);
	assert(lua_gettop(L) == 1);

	const char * loader = optstring(ctx, "lualoader", "./lualib/loader.lua");

	int r = luaL_loadfile(L,loader);
	if (r != LUA_OK) {
		skynet_error(ctx, "Can't load %s : %s", loader, lua_tostring(L, -1));
		report_launcher_error(ctx);
		return 1;
	}
	lua_pushlstring(L, args, sz);
	r = lua_pcall(L,1,0,1);
	if (r != LUA_OK) {
		skynet_error(ctx, "lua loader error : %s", lua_tostring(L, -1));
		report_launcher_error(ctx);
		return 1;
	}
	lua_settop(L,0);
	if (lua_getfield(L, LUA_REGISTRYINDEX, "memlimit") == LUA_TNUMBER) {
		size_t limit = lua_tointeger(L, -1);
		l->mem_limit = limit;
		skynet_error(ctx, "Set memory limit to %.2f M", (float)limit / (1024 * 1024));
		lua_pushnil(L);
		lua_setfield(L, LUA_REGISTRYINDEX, "memlimit");
	}
	lua_pop(L, 1);

	lua_gc(L, LUA_GCRESTART, 0);

	return 0;
}

这其中最重要是下面段代码。这段代码首先加载了loader.lua这个lua服务加载器，利用这个加载器去加载lua服务。

//获取loader.lua的路径
const char * loader = optstring(ctx, "lualoader", "./lualib/loader.lua");
//加载loader.lua,r是加载结果
int r = luaL_loadfile(L,loader);
if (r != LUA_OK) {
	skynet_error(ctx, "Can't load %s : %s", loader, lua_tostring(L, -1));
	report_launcher_error(ctx);
	return 1;
}
//把参数bootstrap压入栈中，准备传入loader中
lua_pushlstring(L, args, sz);
//加载bootstrap服务。
r = lua_pcall(L,1,0,1);
if (r != LUA_OK) {
	skynet_error(ctx, "lua loader error : %s", lua_tostring(L, -1));
	report_launcher_error(ctx);
	return 1;
}

如下是loader.lua的代码，第一部分，是找到对应服务文件，并加载它。第二部分是设置lua的包寻找路径，最后调用main函数启动这个服务。

local args = {}
for word in string.gmatch(..., "%S+") do
	table.insert(args, word)
end

SERVICE_NAME = args[1]

local main, pattern

local err = {}
for pat in string.gmatch(LUA_SERVICE, "([^;]+);*") do
	local filename = string.gsub(pat, "?", SERVICE_NAME)
	local f, msg = loadfile(filename)
	if not f then
		table.insert(err, msg)
	else
		pattern = pat
		main = f
		break
	end
end

if not main then
	error(table.concat(err, "\n"))
end

LUA_SERVICE = nil
package.path , LUA_PATH = LUA_PATH
package.cpath , LUA_CPATH = LUA_CPATH

local service_path = string.match(pattern, "(.*/)[^/?]+$")

if service_path then
	service_path = string.gsub(service_path, "?", args[1])
	package.path = service_path .. "?.lua;" .. package.path
	SERVICE_PATH = service_path
else
	local p = string.match(pattern, "(.*/).+$")
	SERVICE_PATH = p
end

if LUA_PRELOAD then
	local f = assert(loadfile(LUA_PRELOAD))
	f(table.unpack(args))
	LUA_PRELOAD = nil
end

_G.require = (require "skynet.require").require

main(select(2, table.unpack(args)))

然后我们从lua层反过来看，还用上例bootstrap这个服务，服务代码如下。

local skynet = require "skynet"
local harbor = require "skynet.harbor"
local service = require "skynet.service"
require "skynet.manager"	-- import skynet.launch, ...

skynet.start(function()
	local standalone = skynet.getenv "standalone"

	local launcher = assert(skynet.launch("snlua","launcher"))
	skynet.name(".launcher", launcher)

	local harbor_id = tonumber(skynet.getenv "harbor" or 0)
	if harbor_id == 0 then
		assert(standalone ==  nil)
		standalone = true
		skynet.setenv("standalone", "true")

		local ok, slave = pcall(skynet.newservice, "cdummy")
		if not ok then
			skynet.abort()
		end
		skynet.name(".cslave", slave)

	else
		if standalone then
			if not pcall(skynet.newservice,"cmaster") then
				skynet.abort()
			end
		end

		local ok, slave = pcall(skynet.newservice, "cslave")
		if not ok then
			skynet.abort()
		end
		skynet.name(".cslave", slave)
	end

	if standalone then
		local datacenter = skynet.newservice "datacenterd"
		skynet.name("DATACENTER", datacenter)
	end
	skynet.newservice "service_mgr"

	local enablessl = skynet.getenv "enablessl"
	if enablessl then
		service.new("ltls_holder", function ()
			local c = require "ltls.init.c"
			c.constructor()
		end)
	end

	pcall(skynet.newservice,skynet.getenv "start" or "main")
	skynet.exit()
end)

其中很重要的就是这个local launcher = assert(skynet.launch("snlua","launcher"))。
当我们去创建新服务，或者是初始化lua服务，都会给launcher这个服务发消息，它不仅仅充当着启动器的角色。

function skynet.init_service(start)
	local function main()
		skynet_require.init_all()
		start()
	end
	local ok, err = xpcall(main, traceback)
	if not ok then
		skynet.error("init service failed: " .. tostring(err))
		skynet.send(".launcher","lua", "ERROR")
		skynet.exit()
	else
		skynet.send(".launcher","lua", "LAUNCHOK")
	end
end


function skynet.newservice(name, ...)
	return skynet.call(".launcher", "lua" , "LAUNCH", "snlua", name, ...)
end

而当创建新服务时，launcher服务会调用LAUNCH函数，然后再调用launch_service，而后又调用skynet.launch。

function command.LAUNCH(_, service, ...)

    launch_service(service, ...)

    return NORET

end
local function launch_service(service, ...)
	local param = table.concat({...}, " ")
	local inst = skynet.launch(service, param)
	local session = skynet.context()
	local response = skynet.response()
	if inst then
		services[inst] = service .. " " .. param
		instance[inst] = response
		launch_session[inst] = session
	else
		response(false)
		return
	end
	return inst
end

function skynet.launch(...)
	local addr = c.command("LAUNCH", table.concat({...}," "))
	if addr then
		return tonumber(string.sub(addr , 2), 16)
	end
end

而skynet.launch会调用skynet.core中的command，执行LAUNCH。会在cmd_launch函数中创建snlua加载类似于bootsrtap等lua服务。每个lua服务都会创建一个snlua虚拟机，lua服务之间形成沙盒，通过工作线程进行交互信息，信息在每个服务的结构体中，传递消息也仅仅是指针，这样的效率十分的高。

static struct command_func cmd_funcs[] = {
	{ "TIMEOUT", cmd_timeout },
	{ "REG", cmd_reg },
	{ "QUERY", cmd_query },
	{ "NAME", cmd_name },
	{ "EXIT", cmd_exit },
	{ "KILL", cmd_kill },
	{ "LAUNCH", cmd_launch },
	{ "GETENV", cmd_getenv },
	{ "SETENV", cmd_setenv },
	{ "STARTTIME", cmd_starttime },
	{ "ABORT", cmd_abort },
	{ "MONITOR", cmd_monitor },
	{ "STAT", cmd_stat },
	{ "LOGON", cmd_logon },
	{ "LOGOFF", cmd_logoff },
	{ "SIGNAL", cmd_signal },
	{ NULL, NULL },
};

const char * 
skynet_command(struct skynet_context * context, const char * cmd , const char * param) {
	struct command_func * method = &cmd_funcs[0];
	while(method->name) {
		if (strcmp(cmd, method->name) == 0) {
			return method->func(context, param);
		}
		++method;
	}

	return NULL;
}

static const char *
cmd_launch(struct skynet_context * context, const char * param) {
	size_t sz = strlen(param);
	char tmp[sz+1];
	strcpy(tmp,param);
	char * args = tmp;
	char * mod = strsep(&args, " \t\r\n");
	args = strsep(&args, "\r\n");
	struct skynet_context * inst = skynet_context_new(mod,args);
	if (inst == NULL) {
		return NULL;
	} else {
		id_to_hex(context->result, inst->handle);
		return context->result;
	}
}

这就是lua服务的创建过程。

但是回到skynet.start这个函数中，服务启动时会先调用skynet.core中的callback函数。

function skynet.start(start_func)
	c.callback(skynet.dispatch_message)
	init_thread = skynet.timeout(0, function()
		skynet.init_service(start_func)
		init_thread = nil
	end)
end

callback函数对应lcommand函数，函数首先从 Lua 堆栈中获取服务上下文和一个布尔值 forward。然后，检查堆栈上的第一个参数是否是一个函数，这个函数就是要设置为回调函数的 Lua 函数。从结果上，lcommand最后一定会把之前设置为NULL的回调，设回成_cb。而这个函数的作用就是设置lua服务的回调函数。

	luaL_Reg l[] = {
		{ "send" , lsend },
		{ "genid", lgenid },
		{ "redirect", lredirect },
		{ "command" , lcommand },
		{ "intcommand", lintcommand },
		{ "addresscommand", laddresscommand },
		{ "error", lerror },
		{ "harbor", lharbor },
		{ "callback", lcallback },
		{ "trace", ltrace },
		{ NULL, NULL },
	};
	
static int
lcallback(lua_State *L) {
	struct skynet_context * context = lua_touserdata(L, lua_upvalueindex(1));
	int forward = lua_toboolean(L, 2);
	luaL_checktype(L,1,LUA_TFUNCTION);
	lua_settop(L,1);
	struct callback_context * cb_ctx = (struct callback_context *)lua_newuserdatauv(L, sizeof(*cb_ctx), 2);
	cb_ctx->L = lua_newthread(L);
	lua_pushcfunction(cb_ctx->L, traceback);
	lua_setiuservalue(L, -2, 1);
	lua_getfield(L, LUA_REGISTRYINDEX, "callback_context");
	lua_setiuservalue(L, -2, 2);
	lua_setfield(L, LUA_REGISTRYINDEX, "callback_context");
	lua_xmove(L, cb_ctx->L, 1);

	skynet_callback(context, cb_ctx, (forward)?(_forward_pre):(_cb_pre));
	return 0;
}

static int
_cb_pre(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
	struct callback_context *cb_ctx = (struct callback_context *)ud;
	clear_last_context(cb_ctx->L);
	skynet_callback(context, ud, _cb);
	return _cb(context, cb_ctx, type, session, source, msg, sz);
}

static int
_forward_pre(struct skynet_context *context, void *ud, int type, int session, uint32_t source, const void *msg, size_t sz) {
	struct callback_context *cb_ctx = (struct callback_context *)ud;
	clear_last_context(cb_ctx->L);
	skynet_callback(context, ud, forward_cb);
	return forward_cb(context, cb_ctx, type, session, source, msg, sz);
}
static int
forward_cb(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
	_cb(context, ud, type, session, source, msg, sz);
	// don't delete msg in forward mode.
	return 1;
}

在_cb中处理lua服务的数据。

static int
_cb(struct skynet_context * context, void * ud, int type, int session, uint32_t source, const void * msg, size_t sz) {
	struct callback_context *cb_ctx = (struct callback_context *)ud;
	lua_State *L = cb_ctx->L;
	int trace = 1;
	int r;
	lua_pushvalue(L,2);

	lua_pushinteger(L, type);
	lua_pushlightuserdata(L, (void *)msg);
	lua_pushinteger(L,sz);
	lua_pushinteger(L, session);
	lua_pushinteger(L, source);

	r = lua_pcall(L, 5, 0 , trace);

	if (r == LUA_OK) {
		return 0;
	}
	const char * self = skynet_command(context, "REG", NULL);
	switch (r) {
	case LUA_ERRRUN:
		skynet_error(context, "lua call [%x to %s : %d msgsz = %d] error : " KRED "%s" KNRM, source , self, session, sz, lua_tostring(L,-1));
		break;
	case LUA_ERRMEM:
		skynet_error(context, "lua memory error : [%x to %s : %d]", source , self, session);
		break;
	case LUA_ERRERR:
		skynet_error(context, "lua error in error : [%x to %s : %d]", source , self, session);
		break;
	};

	lua_pop(L,1);

	return 0;
}

目前就看到这里，在分析过程中，存在很多值得深入的细节，好在网上已经有很多资料，可以找到。再遇感兴趣点的时候，会再次更新。

ubuntu一些应用

2023-05-27T09:14:19.000Z

背景

在公司实习时，用的环境是Linux，之前配置的大多是Linux服务器相关的比较多，忽略了很多应用带来的体验。于是打算写一下自己平时比较喜欢的几个Linux应用，方便以后自己配置环境。

本文使用的环境是wsl2.0下的Ubuntu22.04.

oh-my-zsh

oh-my-zsh是zsh终端的插件，可以给zsh换主题，加强zsh的体验。
Ubuntu默认是使用的bash，需要先安装zsh。

sudo apt update
sudo apt install zsh -y

#安装oh-my-zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

在安装过程中，你可能需要科学上网，这里我用的是clash lan代理。
比如默认使用的是bash终端。

vim ~/.bashrc

#在最后一行添加，具体根据clash配置调整
host_ip=192.168.1.104
export http_proxy="http://$host_ip:7890"
export https_proxy="http://$host_ip:7890"

#重写加载终端
source ~/.bashrc

这样之后再安装zsh等等，也可以给zsh配置中加入这条。

我最喜欢的主题是gentoo

vim ~/.zshrc
#把theme换成gentoo
ZSH_THEME="gentoo"

简洁美观，还显示git分支。

安装lua

推荐使用lua官网Lua: download进行安装，以确保安装的是最新版本。

curl -R -O http://www.lua.org/ftp/lua-5.4.6.tar.gz
tar zxf lua-5.4.6.tar.gz
cd lua-5.4.6
make linux test
sudo make install

安装luarocks

luarocks是lua一个很好用的第三方包管理工具，推荐官网安装LuaRocks - The Lua package manager以确保是最新版本。

因为我是自己编译安装的lua，和apt等命令行安装的路径可能不同，这里要知道lua的安装路径是哪里，不然luarocks不能和lua匹配，各种问题接踵而来。

在安装lua时可以看到安装目录。

wget https://luarocks.org/releases/luarocks-3.9.2.tar.gz
tar zxpf luarocks-3.9.2.tar.gz
cd luarocks-3.9.2

#安装需要的第三方软件
sudo apt install unzip -y
#设置为和lua一样的安装路径（在同一级文件夹下）
./configure --with-lua=/usr/local --with-lua-include=/usr/local/include
make && sudo make install

可以安装penlight库进行一些测试

vim test.lua

local class = require "pl.class"
class.Dog()

function Dog:_init(name)

        self.name = name
end

function Dog:say()
        print("wow,wow,wow, i am " .. self.name)
end

local i = Dog("zhu")

i:say()

设计模式-23种（二）

2023-04-23T12:25:31.000Z

组件协同模式

现代软件专业分工之后的第一个结果是「框架与应用程序的划分」，「组件协作」模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时的常用模式。
下面是组件协同模式的三种典型模式。

Template Method（模板方法）

模板方法，就像高中老师讲的做题步骤一样，比如高考卷里的圆锥曲线题。

先设直线方程
把直线方程代入圆锥曲线
利用求根公式的定理，算出 $x_{1}+x_{2},x_{1}*x_{2}$
…
很多时候，题目都可以用这样一个通用的模板方法来解决，只需换掉一丢丢的不同，大致步骤都是一样。

在代码编程中，模板方法就使用的相当多，通常，子类只需要重写父类给出的「可重写的方法」即可。

//base class
class Library{

public:

    //稳定 template method

    void Run(){

        Step1();

        if (Step2()) { //支持变化 ==> 虚函数的多态调用

            Step3();

        }

        for (int i = 0; i < 4; i++){

            Step4(); //支持变化 ==> 虚函数的多态调用

        }
        Step5();

    }

    virtual ~Library(){ }

protected:

    void Step1() { //稳定

        //.....

    }
    void Step3() {//稳定

        //.....

    }
    void Step5() { //稳定

        //.....

    }

    virtual bool Step2() = 0;//变化

    virtual void Step4() =0; //变化

};

这个例子中base类给出了两个纯虚函数，我们可以override这两个函数，做一些符合自己的变化。

在调用的时候只需如下即可。

int main(){
	Library * app = new Application(); //Application 是Library的子类，并且重写了两个纯虚虚函数
	app->run();
}

熟悉安卓开发的同学，应该非常熟悉，很多时候，都是重写一个函数，例如生命周期的resume，stop函数等等，系统会自动调用，你重写之后的方法，是不是很神奇嘞，其中的奥秘就是这样捏。

总结

定义：「定义一个操作中的算法的骨架（稳定），而将一些步骤延迟（变化）到子类中。Template Method使得子类可以不改变（复用）一个算法的结构即可重定义（override重写）该算法的某些特定步骤」

下面是它的结构图。

模板方法是不是很好用，不要你调用我！让我来调用你。

Strategy（策略模式）

策略模式特别像模板方法。举个栗子，就能马上明白。

比如应用程序切换语言。
语言可能以后还会添加，可能有些人会这样写程序。

enum Language{
	ZH_CN,
	ENGLISH
};

int main(){
	Language cur_set_lang = get_cur_lang();
	if(cur_set_lang==ZH_CN){
		...//中文处理
	}else if(cur_set_lang==ENGLISH){
		...//英文处理
	}
}

试想一下，我们现在要增加另一门语言，比如台湾繁体。在上述代码里，就要在枚举类型中添加，同时还要在main函数中的if判断中增加新的处理。
当项目大起来时，直接修改，往往会令人抓狂。这十分的不优雅。

策略模式，就可以很好的解决这个问题。
可以看出来，每个if中都要对相应的语言做处理，我们可以给它抽象出来。

class Language{
public:
	virtual void process()=0;
	virtual ~Language(){}
};

天啊，看到这里，相比你已经知道了后续部分了，没错就像模板方法一样。

//中文类cpp文件
class Chinese:public Language{
	virtual void process()override{
		...//中文处理
	}
	virtual ~Chinese(){
		...//相关资源释放
	}
};

//英文类cpp文件
class English:public Language{
	virtual void process()override{
		...//英文处理
	}
	virtual ~English(){
		...//相关资源释放
	}
};

如此这般，添加新语言，只需要创建一个新的class类文件即可，避免了直接在源码上修改。
调用过程也变的简洁明了。

//值得一提的是，一般会与工厂方法一起使用，因为工厂方法还没介绍，先不要啦。
int main(){
	Language* cur_set_lang = get_cur_lang();
	cur_set_lang->process();
}

总结

定义：「定义一系列算法，把它们一个个封装起来，并且使他们可互相替换（变化）。该模式使得算法可独立于使用它的客户程序（稳定）而变化（扩展，子变化）。」

结构如下

策略模式，可以很好的解决if else 这种没有止境或者不确定后续是否还会添加其他选项的代码，实在是妙啊。

Observe | Event（观察者模式）

观察者一般都是站在第三方角度上，observe中文有着「观察」的意思，而Event有着「事件」的意思，从字面意思上直观了解，不是那么容易懂。举个例子，当一个程序跑起来了，我们想看一下中间过程中发生的情况，这时我们就可以插入一段「代码（像Log）」可以让我们观察程序中间过程中的执行情况，也可以把这个观察，说成一种事件，「观察程序中间过程」事件。

比如一个分割文件的程序，我们想加一个进度条来显示实时进度，先来看一个简单的例子。

//main.cpp
class MainForm : public Form

{

    TextBox* txtFilePath;

    TextBox* txtFileNumber;

    ProgressBar* progressBar;

  

public:

    void Button1_Click(){

        string filePath = txtFilePath->getText();

        int number = atoi(txtFileNumber->getText().c_str());

        FileSplitter splitter(filePath, number, progressBar);
        splitter.split();

    }

};

在上面这段代码里，我们像FileSplitter类中传入了一个进度条实例来显示进度。
如果我们的FileSplitter类如下。

//FileSplitter.cpp
class FileSplitter

{

    string m_filePath;

    int m_fileNumber;

    ProgressBar* m_progressBar;

public:

    FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :

        m_filePath(filePath),

        m_fileNumber(fileNumber),

        m_progressBar(progressBar){

    }

    void split(){


        //1.读取大文件
        //2.分批次向小文件中写入

        for (int i = 0; i < m_fileNumber; i++){

            //...

            float progressValue = m_fileNumber;

            progressValue = (i + 1) / progressValue;

            m_progressBar->setValue(progressValue);
        }
    }

};

这样写没毛病，让我们试想一下，如果此时我们再加一个进度条，比如在终端上打印进度信息，或者再加几个观察进度程序，如此上面的FileSplitter类将不能满足我们的要求。

『我们有时需要让一个类引起的变化，通知到其他一个或多个类。』

继续之前的例子，按照我们的要求，当FileSplitter类变化时，其中我们加入的多个进度条类也会发生变化，也就是说FileSplitter类变化会通知其他进度条类。

这些需要FileSplitter类应该具有一些共同的函数等，可以把这些东西给抽象为一个接口。
例如这样

class IProgress{

public:

    virtual void DoProgress(float value)=0;

    virtual ~IProgress(){}

};

此时FileSplitter类就要这样修改了

class FileSplitter

{

    string m_filePath;

    int m_fileNumber;

    List<IProgress*>  m_iprogressList; // 抽象通知机制，支持多个观察者

public:

    FileSplitter(const string& filePath, int fileNumber) :

        m_filePath(filePath),

        m_fileNumber(fileNumber){

    }


    void split(){

        //1.读取大文件
        //2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++){

            //...
            float progressValue = m_fileNumber;

            progressValue = (i + 1) / progressValue;

            onProgress(progressValue);//发送通知
        }
    }

    void addIProgress(IProgress* iprogress){

        m_iprogressList.push_back(iprogress);

    }


    void removeIProgress(IProgress* iprogress){

        m_iprogressList.remove(iprogress);
    }


protected:

    virtual void onProgress(float value){

        auto itor=m_iprogressList.begin();
        while (itor != m_iprogressList.end() )

            (*itor)->DoProgress(value); //更新进度条

            itor++;
        }

    }

};

我们用一个vector容器存储需要通知的类，这些需要通知的类，需要继承IProgress接口，并且实现其中的纯虚函数，如此，我们就可以这样很方便的完成需求。
调用如下

class MainForm : public Form, public IProgress

{

    TextBox* txtFilePath;

    TextBox* txtFileNumber;
    ProgressBar* progressBar;
public:

    void Button1_Click(){

        string filePath = txtFilePath->getText();

        int number = atoi(txtFileNumber->getText().c_str());
        ConsoleNotifier cn;
        FileSplitter splitter(filePath, number);

        splitter.addIProgress(this); //订阅通知

        splitter.addIProgress(&cn)； //订阅通知

        splitter.split();

        splitter.removeIProgress(this);

    }

    virtual void DoProgress(float value)override{

        progressBar->setValue(value);

    }

};

class ConsoleNotifier : public IProgress {

public:

    virtual void DoProgress(float value)override{

        cout << ".";

    }

};

总结

定义：「定义对象间的一种一对多（变化）的依赖关系，以便当一个对象（subject）的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。」

结构如下

是不是有种学到啦的感觉，观察者模式，可以让一个类通知许多类的改变，仅仅把这些的共同地方抽象出来，就可以让代码变的健壮起来。

单一职责模式

在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。

下面介绍两种经典的单一职责模式可以很快帮助我们理解。

Decorator（装饰器模式）

比如我们要做一个基于TCP的文件传输的小工具，IO方面，我们肯定需要处理文件流、网络流，甚至可能需要对这些流进行加密，或者对流进行缓存。

那么如果我们这些写，先抽象一个Stream的抽象类，包含read(),seek(),write() 三种方法。

class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    virtual ~Stream(){}
};

很容易就会想到文件流、网络流继承Stream。

class FileStream{
public：
    virtual char Read(int number){
		    ...
    }
    virtual void Seek(int position){
		    ...
    }
    virtual void Write(char data){
		    ...
    }
    virtual ~Stream(){}
};

class NetworkStream{
public：
    virtual char Read(int number){
		    ...
    }
    virtual void Seek(int position){
		    ...
    }
    virtual void Write(char data){
		    ...
    }
    virtual ~Stream(){}
};

假设现在我们需要加密流和缓存流，新手一般会这样写。

class CryptoFileStream :public FileStream{

public:
    virtual char Read(int number){
        //额外的加密操作...
        FileStream::Read(number);//读文件流
    }

    virtual void Seek(int position){
        //额外的加密操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class CryptoNetworkStream : :public NetworkStream{
public:
    virtual char Read(int number){
        //额外的加密操作...
        NetworkStream::Read(number);//读网络流
    }

    virtual void Seek(int position){
        //额外的加密操作...
        NetworkStream::Seek(position);//定位网络流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        NetworkStream::Write(data);//写网络流
        //额外的加密操作...
    }
};

//-------------------
//缓存流
class BufferFileStream:public FileStream{
	...
};
class BufferNetworkStream:public FileStream{
	...
};

现在，回头看一下代码，很明显，每当我们去添加一个扩展功能类，比如反转流，这样就要再继承 FileStream、NetworkStream写两个类，或者当我们去添加一个流，比如内存流，这样就要继承内存流去写很多扩展类。

假设，FileStream、NetworkStream这样的类有N个，加密流这样的扩展有M个，那么一共要写 $1+N+N*M$ 个。

不难发现，在扩展类中，实现的东西都相同，很容易联系到多态。那么扩展类就可以写成下面这样，比如CryptoStream类。

class CryptoStream :public Stream{
Stream* stream;
public:
	CryptoStream(Stream* s):stream(s){	
	}
    virtual char Read(int number){
        //额外的加密操作...
        stream->Read(number);//读文件流
    }

    virtual void Seek(int position){
        //额外的加密操作...
        stream->Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream->Write(data);//写文件流
        //额外的加密操作...
    }
};

如此我们就可以省下很多重复的代码，只需要 $1+N+M$ ，非常nice。但是当我写出BufferStream类时，你会发现这其中又可以提出来共同的成员。

class BufferStream :public Stream{
Stream* stream;
public:
	BufferStream(Stream* s):stream(s){	
	}
	...
};

可以看到stream这个成员变量重复了，可以把这个给抽出来，单独写成一个类。

DecoratorStream: public Stream{
protected:
    Stream* stream;//...
    DecoratorStream(Stream * stm):stream(stm){

    }

};

这样在以后写扩展类时，继承这个DecoratorStream，既可以清楚意图，又减少了代码的重复。
例如BufferStream类就可以写成下面这样。

class BufferStream : public DecoratorStream{

public:

    BufferStream(Stream* stm):DecoratorStream(stm){

    }

    //...

};

调用程序如下

void Process(){
    //运行时装配
    FileStream* s1=new FileStream();
    CryptoStream* s2=new CryptoStream(s1);
    BufferStream* s3=new BufferedStream(s1);
    BufferStream* s4=new BufferedStream(s2);
}

总结

定义：动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）

结构如下

仔细想想，其实CryptoFileStream继承FileStream是不合理的，因为前者仅仅是后者的一个扩展，并没有is a的关系，也不朝着同一个方向变化。

Bridge（桥模式）

桥模式与装饰器模式十分相似，都是为了解决继承使得类数量爆炸增长的问题。

举个例子，现在要开发一个即时通讯软件，新手一般会先抽象一个类。
比如

class Messager{
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;
    
    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    virtual ~Messager(){}

};

这很不错，PC和mobile端继承Messager，后续再继承pc类开发pc上的不同版本，例如lite，prefect版本等等。

class PCMessagerBase : public Messager{
public:
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //*********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};

class MobileMessagerBase : public Messager{

public:
    ...

};

接着写一下PC端的版本。

class PCMessagerLite : public PCMessagerBase {
public:
    virtual void Login(string username, string password){
        PCMessagerBase::Connect();
        //........
    }

    virtual void SendMessage(string message){
        PCMessagerBase::WriteText();
        //........
    }

    virtual void SendPicture(Image image){
        PCMessagerBase::DrawShape();
        //........
    }
};

  
  
  

class PCMessagerPerfect : public PCMessagerBase {
public:
    virtual void Login(string username, string password){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::Connect();
        //........
    }

    virtual void SendMessage(string message){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::WriteText();
        //........
    }

    virtual void SendPicture(Image image){
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::DrawShape();
        //........
    }
};

这仅仅是PC端的，如果算上mobile端，又要加上两个业务类，加一个Linux平台，可能就要一个Linux base类，和两个业务类。
假如有N个平台，M个版本，那么总共就要写 $1+N+N*M$ 个类，想想就十分可怕。

学习过上一节，很自然就会想「能不能使用多态来代替这个继承」。

首先我们先把Messager类分开，因为pc base类与mobile base类，仅仅实现了基础的部分，并没有实现login这些功能。

class Messager{
protected:
     MessagerImp* messagerImp;//...
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;

    virtual ~Messager(){}

};

  
class MessagerImp{
public:
    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;

    virtual MessagerImp(){}

};

下面只需让pc base类与mobile base类去实现MessagerImp接口，而业务类继承Messager类。

class PCMessagerImp : public MessagerImp{

public:
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};


class MobileMessagerImp : public MessagerImp{
public:
	...
};

class MessagerLite :public Messager {
public:
    virtual void Login(string username, string password){
        messagerImp->Connect();
        //........
    }

    virtual void SendMessage(string message){
        messagerImp->WriteText();
        //........
    }

    virtual void SendPicture(Image image){
        messagerImp->DrawShape();
        //........
    }

};

class MessagerPerfect  :public Messager 
public:
    virtual void Login(string username, string password){
        messagerImp->PlaySound();
        //********
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        messagerImp->PlaySound();
        //********
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        messagerImp->PlaySound();
        //********
        messagerImp->DrawShape();

        //........

    }

};

这样类的数量就缩短到了 $1+N+M$ .
调用主程序，可以写成如下格式。

PCMessagerImp * pc = new PCMessagerImp();
Messager* mp = new MessagerPerfect(pc);
Messager* ml = new MessagerLite(pc);

总结

定义：将抽象部分（业务功能）与实现部分（平台实现）分离，使它们都可以独立地变化。

结构如下

桥模式与装饰器模式，都有异曲同工之妙，都是将继承换为多态，总而避免了类数量的急剧增长。

对象创建模式

通过“对象创建” 模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。

简单来说，就是让这个类文件中new的对象，像virtual函数那样，晚绑定。
也就是依赖倒置原则，不依赖与实现，应该依赖与抽象。

如果一个类文件中，有一处实现，那么可能在以后的过程中，就要去改这个类文件。

设计模式-八大设计原则（一）

2023-04-22T10:16:45.000Z

「你所用的面向对象，空有招式，但无内涵」

只学招式，不学心法，武功瓶颈难以突破，更有甚者潜心修炼，数十年如一日，却不及他人一个月，走火入魔，此举实在是得不偿失。
你是否想如同杨过那样，年纪轻轻就已经成为武林大侠，即使郭靖一样的资质，也可以在短期内，上能九天揽月，下能五洋抓鳖。是的，你妹看错！

设计模式

只要你学过java、python或者是cpp等任意一门面向对象语言，23种设计模式代码部分都能看懂。代码部分都能理解，直接开始上手干它，不就完了吗？非也非也，小伙子，这些代码只是辅助理解23种设计模式是如何解决日常编程问题的，其中真经要诀不可得也。
所以嘞，在学习设计模式时，我们要关注『如何使用设计模式八大原则分析问题，解决问题』，而不是用什么设计模式。

如能理解八大原则，坚持数日，大事可成矣。

依赖倒置原则（DIP）

高层模块（稳定）不应该依赖于低层模块（变化），二者都应该依赖于抽象
抽象不应该依赖于实现细节（变化），实现细节应该依赖于抽象（稳定）

开放封闭原则（OCP）

对扩展开放，对更改封闭
类模块应该是可扩展的，但是不可修改的

单一职责原则（SRP）

一个类应该仅有一个引起他变化的原因
变化的方向隐含着类的职责

Liskov替换原则（LSP）

子类必须能够替换它们的基类（IS-A）
继承表达类型抽象

接口隔离原则（ISP）

不应该强迫客户程序依赖它们不用的方法
接口应该小而完备

优先使用对象组合，而不是类继承

类继承通常为“白箱复用”，对象组合通常为“黑箱复用”
继承在某种程度上继承了很多基类的函数，破坏了封装性，子类父类的耦合度过高
用对象组合只要求被组合的对象具有良好的接口定义即可

封装变化点

使用封装来创建对象之间的分界点，让设计者可以在分界点的一侧进行修改，而不会对另一侧产生不良影响，实现对象之间的松耦合。

针对接口编程，不要针对实现编程

不将变量类型声明为某个特定的具体类，而声明为某个接口类
客户程序无需知晓对象的具体类型，只需要知道对象所具有的接口即可
减少系统中各部分的依赖关系，从而实现“高内聚、低耦合”的类设计方案

在以后的分析中，比如代码，要先看违背了哪些原则，再去看哪些变化、哪些稳定，之后利用23种方法，问题便迎刃而解。