艾瑞可erik • Posts by "undefined" categories

『uni-app、小程序』蓝牙连接、读写数据全过程

Mon, 25 Aug 2025 15:42:00 +0800

开发工具：HBuilder X 3.4.7.20220422
uni-app + Vue3
以安卓App的方式运行（iOS和小程序同理）

思路

蓝牙收发数据的逻辑和我们常用的 AJAX 进行的网络请求是有一丢丢不同的。
其中较大的区别是：蓝牙接收数据不是那么的稳定，相比起网络请求，蓝牙更容易出现丢包的情况。
在开发中，AJAX 发起的请求不管成功还是失败，浏览器基本都会给你一个答复。但 uni-app 提供的 api 来看，蓝牙接收数据会显得更加 “异步” 。

大致思路

使用蓝牙进行数据传输的大概思路如下：

初始化：打开蓝牙模块
搜寻：检测附近存在的设备
连接：找到目标设备进行
监听：开启监听功能，接收其他设备传过来的数据
发送指令：不管发送数据还是读取数据，都可以理解为向外发送指令

初始化阶段

使用蓝牙之前，需要初始化蓝牙模块，这是最最最开始就要做的！

使用 uni.openBluetoothAdapter 这个 api 就可以初始化蓝牙模块。其他
蓝牙相关 API 必须在 uni.openBluetoothAdapter 调用之后使用。否则 API 会返回错误（ errCode=10000 ）。

作者：德育处主任
链接：https://juejin.cn/post/7093171532318375950
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

代码示例

<template>
    <view>
        <button @click="initBlue">初始化蓝牙</button>
    </view>
</template>

<script setup>

// 【1】初始化蓝牙
function initBlue() {
    uni.openBluetoothAdapter({
        success(res) {
            console.log('初始化蓝牙成功')
            console.log(res)
        },
        fail(err) {
            console.log('初始化蓝牙失败')
            console.error(err)
        }
    })
}
</script>

如果你手机开启了蓝牙，点击页面上的按钮后，控制台就会输出如下内容

1	{"errMsg":"openBluetoothAdapter:ok"}

如果手机没开启蓝牙，就会返回如下内容

1	{"errMsg":"openBluetoothAdapter:fail not available","code":10001}

10001代表当前蓝牙适配器不可用。

如果你的控制台能打印出 {“errMsg”:”openBluetoothAdapter:ok”} 证明第一步已经成功了。

接下来可以开始搜索附近蓝牙设备。

搜寻附近设备

这一步需要2个 api 配合完成。所以可以分解成以下2步：

开启搜寻功能：uni.startBluetoothDevicesDiscovery
监听搜寻到新设备：uni.onBluetoothDeviceFound

开发蓝牙相关功能时，操作逻辑更像是推送，所以“开启搜索”和“监听新设备”是分开操作的。

uni.startBluetoothDevicesDiscovery 可以让设备开始搜索附近蓝牙设备，但这个方法比较耗费系统资源，建议在连接到设备之后就使用 uni.stopBluetoothDevicesDiscovery 停止继续搜索。

uni.startBluetoothDevicesDiscovery 方法里可以传入一个对象，该对象接收几个参数，但初学的话我们只关注 success 和 fail。如果你的项目中硬件佬有提供 service 的 uuid 给你的话，你也可以在 services 里传入。其他参数可以查看官方文档的介绍。

在使用 uni.startBluetoothDevicesDiscovery （开始搜索）后，可以使用 uni.onBluetoothDeviceFound 进行监听，这个方法里面接收一个回调函数。

代码示例

<template>
    <view>
        <scroll-view
            scroll-y
            class="box"
        >
            <view class="item" v-for="item in blueDeviceList">
                <view>
                    <text>id: {{ item.deviceId }}</text>    
                </view>
                <view>
                    <text>name: {{ item.name }}</text>  
                </view>
            </view>
        </scroll-view>
        
        <button @click="initBlue">初始化蓝牙</button>
        
        <button @click="discovery">搜索附近蓝牙设备</button>

    </view>
</template>

<script setup>
import { ref } from 'vue'

// 搜索到的蓝牙设备列表
const blueDeviceList = ref([])

// 【1】初始化蓝牙
function initBlue() {
    uni.openBluetoothAdapter({
        success(res) {
            console.log('初始化蓝牙成功')
            console.log(res)
        },
        fail(err) {
            console.log('初始化蓝牙失败')
            console.error(err)
        }
    })
}

// 【2】开始搜寻附近设备
function discovery() {
    uni.startBluetoothDevicesDiscovery({
        success(res) {
            console.log('开始搜索')
            
            // 开启监听回调
            uni.onBluetoothDeviceFound(found)
        },
        fail(err) {
            console.log('搜索失败')
            console.error(err)
        }
    })
}

// 【3】找到新设备就触发该方法
function found(res) {
    console.log(res)
    blueDeviceList.value.push(res.devices[0])
}
</script>

<style>
.box {
    width: 100%;
    height: 400rpx;
    box-sizing: border-box;
    margin-bottom: 20rpx;
    border: 2px solid dodgerblue;
}
.item {
    box-sizing: border-box;
    padding: 10rpx;
    border-bottom: 1px solid #ccc;
}
button {
    margin-bottom: 20rpx;
}
</style>

上面代码的逻辑是，如果开启 “寻找附近设备” 功能成功，接着就开启 “监听寻找到新设备的事件” 。

搜索到的设备会返回以下数据：

{
    "devices": [{
        "deviceId": "B4:10:7B:C4:83:14",
        "name": "蓝牙设备名",
        "RSSI": -58,
        "localName": "",
        "advertisServiceUUIDs": ["0000FFF0-0000-1000-8000-00805F9B34FB"],
        "advertisData": {}
    }]
}

每监听到一个新的设备，我都会将其添加到蓝牙设备列表(blueDeviceList) 里，最后讲这个列表的数据渲染到页面上。

连接目标设备

连接目标设备只需要1个 api 就能完成。但根据文档提示，我们连接后还需要关闭 “搜索附近设备” 的功能，这个很好理解，既然找到了，再继续找就是浪费资源。

流程如下：

获取设备ID：根据 uni.onBluetoothDeviceFound 回调，拿到设备ID
连接设备：使用设备ID进行连接 uni.createBLEConnection
停止搜索：uni.stopBluetoothDevicesDiscovery

我给每条搜索到的蓝牙结果添加一个 click 事件，会向目标设备发送连接请求。
我的设备名称是 leihou ，所以我点击了这条。

代码示例

<template>
    <view>
        <scroll-view
            scroll-y
            class="box"
        >
            <view class="item" v-for="item in blueDeviceList" @click="connect(item)">
                <view>
                    <text>id: {{ item.deviceId }}</text>    
                </view>
                <view>
                    <text>name: {{ item.name }}</text>  
                </view>
            </view>
        </scroll-view>
        
        <button @click="initBlue">初始化蓝牙</button>
        
        <button @click="discovery">搜索附近蓝牙设备</button>

    </view>
</template>

<script setup>
import { ref } from 'vue'

// 搜索到的蓝牙设备列表
const blueDeviceList = ref([])

// 【1】初始化蓝牙
function initBlue() {
    uni.openBluetoothAdapter({
        success(res) {
            console.log('初始化蓝牙成功')
            console.log(res)
        },
        fail(err) {
            console.log('初始化蓝牙失败')
            console.error(err)
        }
    })
}

// 【2】开始搜寻附近设备
function discovery() {
    uni.startBluetoothDevicesDiscovery({
        success(res) {
            console.log('开始搜索')
            // 开启监听回调
            uni.onBluetoothDeviceFound(found)
        },
        fail(err) {
            console.log('搜索失败')
            console.error(err)
        }
    })
}

// 【3】找到新设备就触发该方法
function found(res) {
    console.log(res)
    blueDeviceList.value.push(res.devices[0])
}

// 蓝牙设备的id
const deviceId = ref('')

// 【4】连接设备
function connect(data) {
    console.log(data)

    deviceId.value = data.deviceId

    uni.createBLEConnection({
        deviceId: deviceId.value,
        success(res) {
            console.log('连接成功')
            console.log(res)
            // 停止搜索
            stopDiscovery()
        },
        fail(err) {
            console.log('连接失败')
            console.error(err)
        }
    })
}

// 【5】停止搜索
function stopDiscovery() {
    uni.stopBluetoothDevicesDiscovery({
        success(res) {
            console.log('停止成功')
            console.log(res)
        },
        fail(err) {
            console.log('停止失败')
            console.error(err)
        }
    })
}
</script>

<style>
.box {
    width: 100%;
    height: 400rpx;
    box-sizing: border-box;
    margin-bottom: 20rpx;
    border: 2px solid dodgerblue;
}
.item {
    box-sizing: border-box;
    padding: 10rpx;
    border-bottom: 1px solid #ccc;
}
button {
    margin-bottom: 20rpx;
}
</style>

连接成功后在控制台会输出

1	{"errMsg":"createBLEConnection:ok"}

在连接成功后就立刻调用 uni.stopBluetoothDevicesDiscovery 方法停止继续搜索附近其他设备，停止成功后会输出

1	{"errMsg":"stopBluetoothDevicesDiscovery:ok"}

监听

在连接完设备后，就要先开启监听数据的功能。这样才能接收到发送读写指令后设备给你回调的信息。

要开启监听，首先需要知道蓝牙设备提供了那些服务，然后通过服务获取特征值，特征值会告诉你哪个可读，哪个可写。最后根据特征值进行消息监听。

步骤如下：

获取蓝牙设备服务：uni.getBLEDeviceServices
获取特征值：uni.getBLEDeviceCharacteristics
开启消息监听：uni.notifyBLECharacteristicValueChange
接收消息监听传来的数据：uni.onBLECharacteristicValueChange

正常情况下，硬件佬会提前把蓝牙设备的指定服务还有特征值告诉你。

比如我这个设备的蓝牙服务是：0000FFE0-0000-1000-8000-00805F9B34FB

特征值是：0000FFE1-0000-1000-8000-00805F9B34FB

第一步，获取蓝牙服务

<template>
    <view>
        <!-- 省略上一步的代码 -->
        <button @click="getServices">获取蓝牙服务</button>
    </view>
</template>

<script setup>
import { ref } from 'vue'

// 省略上一步的代码……

// 【6】获取服务
function getServices() {
    uni.getBLEDeviceServices({
        deviceId: deviceId.value, // 设备ID，在上一步【4】里获取
        success(res) {
            console.log(res)
        },
        fail(err) {
            console.error(err)
        }
    })
}
</script>

此时点击按钮，将会获取到已连接设备的所有服务。

我的设备有以下几个服务。你在工作中拿到的服务uuid 和我的是不一样的，数量也不一定相同。

可以发现，我拿到的结果里有 0000FFE0-0000-1000-8000-00805F9B34FB 这条服务。

{
    "services": [{
        "uuid": "00001800-0000-1000-8000-00805F9B34FB",
        "isPrimary": true
    }, {
        "uuid": "00001801-0000-1000-8000-00805F9B34FB",
        "isPrimary": true
    }, {
        "uuid": "0000180A-0000-1000-8000-00805F9B34FB",
        "isPrimary": true
    }, {
        "uuid": "0000FFF0-0000-1000-8000-00805F9B34FB",
        "isPrimary": true
    }, {
        "uuid": "0000FFE0-0000-1000-8000-00805F9B34FB",
        "isPrimary": true
    }],
    "errMsg": "getBLEDeviceServices:ok"
}

第二步，获取指定服务的特征值

获取特征值，需要传设备ID 和服务ID。

在上两步我拿到了设备ID 为 B4:10:7B:C4:83:14，服务ID 为 0000FFE0-0000-1000-8000-00805F9B34FB。

<template>
    <view>
        <!-- 省略前面几步代码 -->
        <button @click="getCharacteristics">获取特征值</button>
    </view>
</template>

<script setup>
import { ref } from 'vue'

// 省略前面几步代码

// 【7】获取特征值
function getCharacteristics() {
    uni.getBLEDeviceCharacteristics({
        deviceId: deviceId.value, // 设备ID，在【4】里获取到
        serviceId: '0000FFE0-0000-1000-8000-00805F9B34FB', // 服务UUID，在【6】里能获取到
        success(res) {
            console.log(res)
        },
        fail(err) {
            console.error(err)
        }
    })
}
</script>

最后成功输出

{
    "characteristics": [{
        "uuid": "0000FFE1-0000-1000-8000-00805F9B34FB",
        "properties": {
            "read": true,
            "write": true,
            "notify": true,
            "indicate": false
        }
    }],
    "errMsg": "getBLEDeviceCharacteristics:ok"
}

characteristics 字段里保存了该服务的所有特征值，我的设备这个服务只有1个特征值，并且读、写、消息推送都为 true。

你的设备可能不止一条特征值，需要监听那条特征值这需要你和硬件佬协商的（通常也是硬件佬直接和你说要监听哪条）。

第三、四步，开启消息监听并接收消息监听传来的数据

根据已经拿到的设备ID、服务ID、特征值，就可以开启对应的监听功能。

使用 uni.notifyBLECharacteristicValueChange 开启消息监听；

并在 uni.onBLECharacteristicValueChange 方法触发监听到的消息。

<template>
    <view>
        <!-- 省略前面几步代码 -->
        <button @click="notify">开启消息监听</button>
    </view>
</template>

<script setup>
import { ref } from 'vue'

// 省略前面几步代码

// 【8】开启消息监听
function notify() {
    uni.notifyBLECharacteristicValueChange({
        deviceId: deviceId.value, // 设备ID，在【4】里获取到
        serviceId: '0000FFE0-0000-1000-8000-00805F9B34FB', // 服务UUID，在【6】里能获取到
        characteristicId: '0000FFE1-0000-1000-8000-00805F9B34FB', // 特征值，在【7】里能获取到
        success(res) {
            console.log(res)
            
            // 接受消息的方法
            listenValueChange()
        },
        fail(err) {
            console.error(err)
        }
    })
}

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
  const hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('')
}

// 将16进制的内容转成我们看得懂的字符串内容
function hexCharCodeToStr(hexCharCodeStr) {
    var trimedStr = hexCharCodeStr.trim();
    var rawStr = trimedStr.substr(0, 2).toLowerCase() === "0x" ? trimedStr.substr(2) : trimedStr;
    var len = rawStr.length;
    if (len % 2 !== 0) {
            alert("存在非法字符!");
            return "";
    }
    var curCharCode;
    var resultStr = [];
    for (var i = 0; i < len; i = i + 2) {
            curCharCode = parseInt(rawStr.substr(i, 2), 16);
            resultStr.push(String.fromCharCode(curCharCode));
    }
    return resultStr.join("");
}

// 【9】监听消息变化
function listenValueChange() {
    uni.onBLECharacteristicValueChange(res => {
        // 结果
        console.log(res)
        
        // 结果里有个value值，该值为 ArrayBuffer 类型，所以在控制台无法用肉眼观察到，必须将该值转换为16进制
        let resHex = ab2hex(res.value)
        console.log(resHex)

        // 最后将16进制转换为ascii码，就能看到对应的结果
        let result = hexCharCodeToStr(resHex)
        console.log(result)
    })
}
</script>

listenValueChange 方法是用来接收设备传过来的消息。

上面的例子中，res 的结果是

{
    "deviceId": "B4:10:7B:C4:83:14",
    "serviceId": "0000FFE0-0000-1000-8000-00805F9B34FB",
    "characteristicId": "0000FFE1-0000-1000-8000-00805F9B34FB",
    "value": {}
}

设备传过来的内容就放在 value 字段里，但因为该字段的类型是 ArrayBuffer，所以无法在控制台用肉眼直接观察。于是就通过 ab2hex 方法将该值转成 16进制，最后再用 hexCharCodeToStr 方法将 16进制转成 ASCII码。

我从设备里发送一段字符串过来：leihou

App端收到的数据转成 16进制后的结果：6c6569686f75

再从 16进制转成 ASCII码后的结果：leihou

发送指令

终于到最后一步了。

从 uni-app 和微信小程序提供的蓝牙api 来看，发送指令只要有2个方法：

uni.writeBLECharacteristicValue：向低功耗蓝牙设备特征值中写入二进制数据。
uni.readBLECharacteristicValue：读取低功耗蓝牙设备的特征值的二进制数据值。

这里需要理清一个概念，本节的内容为 “发送指令” ，也就是说，从你的app或小程序向其他蓝牙设备发送指令，而这个指令分2种情况，一种是你要发送一些数据给蓝牙设备，另一种情况是你叫蓝牙设备给你发点信息。

uni.writeBLECharacteristicValue

这两种情况我们需要分开讨论，先讲uni.writeBLECharacteristicValue 。

uni.writeBLECharacteristicValue 从文档可以看出，这个 api 是可以发送一些数据给蓝牙设备，但发送的值要转成 ArrayBuffer 。

<template>
    <view>
        <!-- 省略前面几步代码 -->
        <button @click="send">发送数据</button>
    </view>
</template>

<script setup>
import { ref } from 'vue'

// 省略前面几步代码

// 【10】发送数据
function send() {
    // 向蓝牙设备发送一个0x00的16进制数据
    
    let msg = 'hello'
    
    const buffer = new ArrayBuffer(msg.length)
    const dataView = new DataView(buffer)
    // dataView.setUint8(0, 0)
    
    for (var i = 0; i < msg.length; i++) {
      dataView.setUint8(i, msg.charAt(i).charCodeAt())
    }
    
    uni.writeBLECharacteristicValue({
      deviceId: deviceId.value, // 设备ID，在【4】里获取到
      serviceId: '0000FFE0-0000-1000-8000-00805F9B34FB', // 服务UUID，在【6】里能获取到
      characteristicId: '0000FFE1-0000-1000-8000-00805F9B34FB', // 特征值，在【7】里能获取到
      value: buffer,
      success(res) {
        console.log(res)
      },
      fail(err) {
        console.error(err)
      }
    })
}
</script>

此时，如果 uni.writeBLECharacteristicValue 走 success ，证明你已经把数据向外成功发送了，但不代表设备一定就收到了。

通常设备收到你发送过去的信息，会返回一条消息给你，而这个回调消息会在 uni.onBLECharacteristicValueChange 触发，也就是第【9】步那里。但这是蓝牙设备那边控制的，你作为前端佬，人家“已读不回”你也拿人家没办法。

uni.readBLECharacteristicValue

在 “监听” 部分，我们使用了 uni.getBLEDeviceCharacteristics 获取设备的特征值，我的设备提供的特征值支持 read ，所以可以使用 uni.readBLECharacteristicValue 向蓝牙设备发送一条 “读取” 指令。然后在 uni.onBLECharacteristicValueChange 里可以接收设备发送过来的数据。

<template>
    <view>
        <!-- 省略前面几步代码 -->
        <button @click="read">读取数据</button>
    </view>
</template>

<script setup>
import { ref } from 'vue'

// 省略前面几步代码

// 【11】读取数据
function read() {
    uni.readBLECharacteristicValue({
        deviceId: deviceId.value,
        serviceId: serviceId.value,
        characteristicId: characteristicId.value,
        success(res) {
            console.log('读取指令发送成功')
            console.log(res)
        },
        fail(err) {
            console.log('读取指令发送失败')
            console.error(err)
        }
    })
}
</script>

使用 “读取” 的方式向设备发送指令，是不需要另外传值的。

此时我的设备返回 00

这个数据是硬件那边设置的。

在日常工作中，uni.readBLECharacteristicValue 的作用主要是读取数据，但使用场景不算很多。

我在工作中遇到的场景是：蓝牙设备提供了几个接口，而且传过来的数据比较大，比如传图片给app这边。我就会先用 uni.writeBLECharacteristicValue 告诉设备我现在需要取什么接口的数据，然后用 uni.readBLECharacteristicValue 发送读取数据的请求，如果数据量比较大，就要重复使用 uni.readBLECharacteristicValue 进行读取。比如上面的例子，我读第一次的时候返回 00 ，读第二次就返回 01 ……

最后再提醒一下，uni.readBLECharacteristicValue 只负责发送读取的请求，并且里面的 success 和 fail 只是返回你本次发送请求的动作是否成功，至于对面的蓝牙设备有没有收到这个指令你是不清楚的。

最后需要通过 uni.getBLEDeviceCharacteristics 监听设备传过来的数据。

完整代码

<template>
    <view>
        <scroll-view
            scroll-y
            class="box"
        >
            <view class="item" v-for="item in blueDeviceList" @click="connect(item)">
                <view>
                    <text>id: {{ item.deviceId }}</text>    
                </view>
                <view>
                    <text>name: {{ item.name }}</text>  
                </view>
            </view>
        </scroll-view>
        
        <button @click="initBlue">1 初始化蓝牙</button>
        
        <button @click="discovery">2 搜索附近蓝牙设备</button>
        
        <button @click="getServices">3 获取蓝牙服务</button>
        
        <button @click="getCharacteristics">4 获取特征值</button>
        
        <button @click="notify">5 开启消息监听</button>
        
        <button @click="send">6 发送数据</button>
        
        <button @click="read">7 读取数据</button>
        
        <view class="msg_x">
            <view class="msg_txt">
                监听到的内容：{{ message }}
            </view>
            <view class="msg_hex">
                监听到的内容（十六进制）：{{ messageHex }}
            </view> 
        </view> 

    </view>
</template>

<script setup>
import { ref } from 'vue'

// 搜索到的蓝牙设备列表
const blueDeviceList = ref([])

// 【1】初始化蓝牙
function initBlue() {
    uni.openBluetoothAdapter({
        success(res) {
            console.log('初始化蓝牙成功')
            console.log(res)
        },
        fail(err) {
            console.log('初始化蓝牙失败')
            console.error(err)
        }
    })
}

// 【2】开始搜寻附近设备
function discovery() {
    uni.startBluetoothDevicesDiscovery({
        success(res) {
            console.log('开始搜索')
            // 开启监听回调
            uni.onBluetoothDeviceFound(found)
        },
        fail(err) {
            console.log('搜索失败')
            console.error(err)
        }
    })
}

// 【3】找到新设备就触发该方法
function found(res) {
    console.log(res)
    blueDeviceList.value.push(res.devices[0])
}

// 蓝牙设备的id
const deviceId = ref('')

// 【4】连接设备
function connect(data) {
    console.log(data)
    
    deviceId.value = data.deviceId // 将获取到的设备ID存起来
    
    uni.createBLEConnection({
        deviceId: deviceId.value,
        success(res) {
            console.log('连接成功')
            console.log(res)
            // 停止搜索
            stopDiscovery()
            uni.showToast({
                title: '连接成功'
            })
        },
        fail(err) {
            console.log('连接失败')
            console.error(err)
            uni.showToast({
                title: '连接成功',
                icon: 'error'
            })
        }
    })
}

// 【5】停止搜索
function stopDiscovery() {
    uni.stopBluetoothDevicesDiscovery({
        success(res) {
            console.log('停止成功')
            console.log(res)
        },
        fail(err) {
            console.log('停止失败')
            console.error(err)
        }
    })
}

// 【6】获取服务
function getServices() {
    // 如果是自动链接的话，uni.getBLEDeviceServices方法建议使用setTimeout延迟1秒后再执行
    uni.getBLEDeviceServices({
        deviceId: deviceId.value,
        success(res) {
            console.log(res) // 可以在res里判断有没有硬件佬给你的服务
            uni.showToast({
                title: '获取服务成功'
            })
        },
        fail(err) {
            console.error(err)
            uni.showToast({
                title: '获取服务失败',
                icon: 'error'
            })
        }
    })
}

// 硬件提供的服务id，开发中需要问硬件佬获取该id
const serviceId = ref('0000FFE0-0000-1000-8000-00805F9B34FB')

// 【7】获取特征值
function getCharacteristics() {
    // 如果是自动链接的话，uni.getBLEDeviceCharacteristics方法建议使用setTimeout延迟1秒后再执行
    uni.getBLEDeviceCharacteristics({
        deviceId: deviceId.value,
        serviceId: serviceId.value,
        success(res) {
            console.log(res) // 可以在此判断特征值是否支持读写等操作，特征值其实也需要提前向硬件佬索取的
            uni.showToast({
                title: '获取特征值成功'
            })
        },
        fail(err) {
            console.error(err)
            uni.showToast({
                title: '获取特征值失败',
                icon: 'error'
            })
        }
    })
}

const characteristicId = ref('0000FFE1-0000-1000-8000-00805F9B34FB')

// 【8】开启消息监听
function notify() {
    uni.notifyBLECharacteristicValueChange({
        deviceId: deviceId.value, // 设备id
        serviceId: serviceId.value, // 监听指定的服务
        characteristicId: characteristicId.value, // 监听对应的特征值
        success(res) {
            console.log(res)
            listenValueChange()
            uni.showToast({
                title: '已开启监听'
            })
        },
        fail(err) {
            console.error(err)
            uni.showToast({
                title: '监听失败',
                icon: 'error'
            })
        }
    })
}

// ArrayBuffer转16进度字符串示例
function ab2hex(buffer) {
  const hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('')
}

// 将16进制的内容转成我们看得懂的字符串内容
function hexCharCodeToStr(hexCharCodeStr) {
    var trimedStr = hexCharCodeStr.trim();
    var rawStr = trimedStr.substr(0, 2).toLowerCase() === "0x" ? trimedStr.substr(2) : trimedStr;
    var len = rawStr.length;
    if (len % 2 !== 0) {
            alert("存在非法字符!");
            return "";
    }
    var curCharCode;
    var resultStr = [];
    for (var i = 0; i < len; i = i + 2) {
            curCharCode = parseInt(rawStr.substr(i, 2), 16);
            resultStr.push(String.fromCharCode(curCharCode));
    }
    return resultStr.join("");
}

// 监听到的内容
const message = ref('')
const messageHex = ref('') // 十六进制

// 【9】监听消息变化
function listenValueChange() {
    uni.onBLECharacteristicValueChange(res => {
        console.log(res)
        let resHex = ab2hex(res.value)
        console.log(resHex)
        messageHex.value = resHex
        let result = hexCharCodeToStr(resHex)
        console.log(String(result))
        message.value = String(result)
    })
}

// 【10】发送数据
function send() {
    // 向蓝牙设备发送一个0x00的16进制数据
    let msg = 'hello'
    
    const buffer = new ArrayBuffer(msg.length)
    const dataView = new DataView(buffer)
    // dataView.setUint8(0, 0)
    
    for (var i = 0; i < msg.length; i++) {
      dataView.setUint8(i, msg.charAt(i).charCodeAt())
    }
    
    uni.writeBLECharacteristicValue({
      deviceId: deviceId.value,
      serviceId: serviceId.value,
      characteristicId: characteristicId.value,
      value: buffer,
      success(res) {
        console.log('writeBLECharacteristicValue success', res.errMsg)
            uni.showToast({
                title: 'write指令发送成功'
            })
      },
        fail(err) {
            console.error(err)
            uni.showToast({
                title: 'write指令发送失败',
                icon: 'error'
            })
        }
    })
}

// 【11】读取数据
function read() {
    uni.readBLECharacteristicValue({
        deviceId: deviceId.value,
        serviceId: serviceId.value,
        characteristicId: characteristicId.value,
        success(res) {
            console.log(res)
            uni.showToast({
                title: 'read指令发送成功'
            })
        },
        fail(err) {
            console.error(err)
            uni.showToast({
                title: 'read指令发送失败',
                icon: 'error'
            })
        }
    })
}
</script>

<style>
.box {
    width: 98%;
    height: 400rpx;
    box-sizing: border-box;
    margin: 0 auto 20rpx;
    border: 2px solid dodgerblue;
}
.item {
    box-sizing: border-box;
    padding: 10rpx;
    border-bottom: 1px solid #ccc;
}
button {
    margin-bottom: 20rpx;
}

.msg_x {
    border: 2px solid seagreen;
    width: 98%;
    margin: 10rpx auto;
    box-sizing: border-box;
    padding: 20rpx;
}

.msg_x .msg_txt {
    margin-bottom: 20rpx;
}
</style>

开发语言应用场景与学习方向解析

Mon, 18 Aug 2025 23:19:00 +0800

以下是针对主流开发语言（PHP、Go、Rust、C、C++、Java、C#、Qt）的应用场景、优劣势及学习方向的综合分析，结合技术特性和行业实践整理而成：

📊 一、语言对比概览表

语言	主要应用场景	关键优势	典型劣势
PHP	中小型Web开发、CMS系统	开发快、易入门、框架丰富	性能中等、安全风险需管控
Go	云原生、分布式服务、工具开发	高并发、编译高效、部署简单	生态较小、GUI支持弱
Rust	系统编程、安全敏感型基础设施	内存安全、零成本抽象、高性能	学习曲线陡、编译慢
C	操作系统、嵌入式、硬件驱动	极致性能、硬件级控制	手动内存管理、易出安全漏洞
C++	游戏引擎、高频交易、大型系统	高性能、多范式支持、生态成熟	复杂难精、迭代缓慢
Java	企业应用、Android开发、大数据	跨平台、生态强大、稳定性高	内存占用高、启动慢
C#	Unity游戏、企业桌面应用、IoT	强类型系统、IDE强大、语法优雅	跨平台能力弱于Java
Qt	跨平台GUI、工业控制界面	界面美观、信号槽机制、跨平台一致	库体积大、商业授权复杂

🔍 二、分语言详解

1. PHP

应用场景：动态网站（如WordPress）、电商平台（Magento）、API服务。
- 优势：
  - 开发速度极快，语法简单，LAMP/LNMP生态成熟。
  - 社区资源丰富（如Laravel框架）。
- 劣势：
  - 默认性能低于编译型语言，需配合Swoole扩展优化。
  - 历史代码存在SQL注入等安全隐患，需严格遵循规范。
- 学习方向：
  - 掌握现代框架（Laravel/Symfony），学习异步扩展（Swoole），强化安全实践（如PSR标准）。

2. Go

应用场景：Docker/Kubernetes云原生生态、微服务、高并发API。
- 优势：
  - Goroutine轻量级并发模型，编译为单二进制文件，部署便捷。
  - 内置垃圾回收和标准库（如HTTP/JSON处理）。
- 劣势：
  - 依赖管理（go mod）仍待完善，缺乏泛型历史遗留问题（1.18后已支持）。
  - 图形界面生态薄弱，不适合桌面GUI开发。
- 学习方向：
  - 深入并发模型（Channel模式），学习云原生工具链（K8s+Grpc），掌握性能调优。

3. Rust

应用场景：操作系统（如Redox）、浏览器引擎（Servo）、区块链底层。
- 优势：
  - 所有权机制保障内存/线程安全，零运行时开销媲美C++。
  - 模式匹配和错误处理（Result/Option）提升代码健壮性。
- 劣势：
  - 学习曲线陡峭（生命周期标注难度高），编译时间长。
  - 生态较新，企业级框架少于Java/C#。
- 学习方向：
  - 精读《The Rust Book》，实战WebAssembly或系统工具开发，参与开源贡献。

4. C

应用场景：Linux内核、单片机固件、数据库引擎（如SQLite）。
- 优势：
  - 无运行时依赖，直接操作硬件，性能极致优化。
  - 语法简洁，是后续语言（C++/Go）的设计基础。
- 劣势：
  - 手动内存管理易导致泄漏/溢出，缺乏现代抽象机制。
  - 项目规模扩大后维护成本激增。
- 学习方向：
  - 深入指针与内存管理，学习Linux系统编程，掌握调试工具（Valgrind/GDB）。

5. C++

应用场景：游戏引擎（Unreal）、高频交易系统、CAD软件。
- 优势：
  - 零成本抽象（模板元编程），多范式支持（OOP/泛型/函数式）。
  - STL提供高效数据结构，兼容C生态。
- 劣势：
  - 语法复杂（如移动语义），旧代码迭代困难（兼容性负担）。
  - 安全漏洞风险（如缓冲区溢出）高于Java/C#。
- 学习方向：
  - 掌握现代标准（C++17/20），学习性能优化（内存池/并发模型），熟悉Qt框架结合开发。

6. Java

应用场景：企业级后台（Spring生态）、Android应用、Hadoop大数据。
- 优势：
  - JVM跨平台特性，GC减少手动内存负担，生态完备（Maven/Spring）。
  - 多线程支持成熟（JUC包），监控工具（JMX/Arthas）完善。
- 劣势：
  - 启动慢，内存占用高（需堆配置优化），语法冗长。
- 学习方向：
  - 精通JVM机制（类加载/GC算法），学习微服务框架（Spring Cloud），掌握异步编程（CompletableFuture）。

7. C#

应用场景：Unity3D游戏开发、Windows桌面应用（WPF）、工业IoT。
- 优势：
  - LINQ简化数据查询，异步编程（async/await）模型优雅。
  - Visual Studio提供顶级开发体验（调试/重构）。
- 劣势：
  - 跨平台能力弱于Java（.NET Core已改善但生态仍不足）。
- 学习方向：
  - 深入.NET Core跨平台开发，学习Unity引擎整合，掌握设计模式（MVVM）。

8. Qt（C++框架）

应用场景：工业控制界面、跨平台桌面软件（WPS/Linux桌面）。
- 优势：
  - 信号槽机制简化事件处理，QML支持动态UI设计。
  - 一次开发多平台部署（Windows/Linux/macOS）。
- 劣势：
  - 库体积大（影响小型设备），商业项目需付费授权。
- 学习方向：
  - 学习C++基础后专攻Qt Widgets/QML，掌握跨平台编译（CMake）。

💎 三、总结建议

追求开发效率：选PHP（Web快速迭代）或Go（微服务）。
需要高性能与安全：用Rust（系统层）或C++（游戏/高频场景）。
企业级/跨平台：Java（后台/Android）或C#（Windows/Unity）。
嵌入式/GUI：C（硬件层）搭配Qt（界面层）。

学习优先级：根据目标领域选择：

Web开发：PHP → Go → Rust（WASM）。
系统/嵌入式：C → C++ → Rust。
全栈/企业应用：Java → C# → Go。

注：语言生态持续演进（如Go泛型、Rust异步），需结合最新技术动态调整学习重点。

Spark、Hive、Hadoop选择与组合使用指南

Fri, 25 Jul 2025 21:36:00 +0800

在构建大数据平台时，Spark、Hive 和 Hadoop 的关系是互补协作而非互斥。选择哪种技术以及如何组合取决于你的具体需求（数据量、处理速度、查询复杂度、成本、团队技能）。以下是如何选择和结合使用的指南：

核心定位与区别

Hadoop (主要指 HDFS + MapReduce/YARN):
- 定位： 分布式存储(HDFS) + 基础资源管理和批处理框架(MapReduce/YARN)。
- 优势：
  - 高可靠、高容错的分布式存储 (HDFS): 存储海量数据的基石。
  - 成熟的资源管理 (YARN): 协调集群资源（CPU, 内存）供上层应用（Spark, MapReduce, Hive on MR/Tez）使用。
  - 极高的可扩展性和成本效益： 能在廉价硬件上构建大规模集群。
- 劣势： MapReduce 计算模型速度慢（尤其迭代计算、交互式查询），编程相对复杂。
Hive:
- 定位： 构建在 Hadoop 之上的数据仓库框架。
- 优势：
  - 类 SQL 接口 (HiveQL): 极大降低了使用门槛，让熟悉 SQL 的分析师和工程师能处理大数据。
  - 强大的元数据管理 (Metastore): 管理表结构、分区、数据类型等，是数据治理的关键。
  - 批处理优化： 将 SQL 查询转换为 MapReduce/Tez/Spark 作业执行。
- 劣势： 传统上基于 MapReduce/Tez，延迟较高，不适合低延迟交互式查询或流处理（虽然有 LLAP 和 Hive on Spark 改进）。
Spark:
- 定位： 统一的、高性能的分布式计算引擎。
- 优势：
  - 极快的速度： 基于内存计算、DAG 执行引擎、高度优化的执行计划，比 MapReduce 快几个数量级。
  - 统一引擎： 支持批处理(Spark SQL)、流处理(Spark Streaming, Structured Streaming)、机器学习(MLlib)、图计算(GraphX)。
  - 易用的 API： 提供 Scala, Java, Python, R 等多种语言的 API，开发效率高。
  - 灵活的部署： 可以在 YARN (Hadoop), Mesos, Kubernetes 或 Standalone 模式上运行。
  - 与 Hive 集成： 可以直接读取 Hive Metastore 中的元数据，运行 HiveQL 查询（Spark SQL）。
- 劣势： 对内存要求较高，纯内存计算成本可能高于基于磁盘的 MapReduce（但速度优势通常远超成本差异）；非常复杂的计算可能需要更精细的内存调优。

如何选择？

存储层：
- HDFS 通常是默认和基石选择： 如果你需要存储 PB 级甚至 EB 级数据，要求高容错、高可靠、成本效益，HDFS 几乎是必选项。它是 Spark 和 Hive 最常见的数据来源和存储目的地。
- 替代方案： 云存储（S3, GCS, ADLS）越来越流行，它们提供无限扩展、按需付费、高可用性，并且 Spark/Hive 都支持直接读写。选择云存储通常能简化运维。
计算引擎：
- 需要极致的处理速度（批处理、流处理、迭代算法、机器学习）？
  - 首选 Spark： 它在绝大多数计算场景下都远快于 MapReduce/Tez。
- 主要需求是使用熟悉的 SQL 进行批处理分析和报表，团队 SQL 技能强？
  - Hive 是很好的起点： 利用其强大的元数据管理和 SQL 接口。但强烈建议将执行引擎配置为 Spark (Hive on Spark)，而不是 MapReduce 或 Tez，以获得显著的性能提升。
  - Spark SQL： 也可以直接使用 Spark SQL 来执行 SQL 查询，它同样支持 HiveQL 语法（兼容 Hive Metastore），性能通常优于 Hive on Spark。如果你已经在用 Spark 做其他事情（如 ETL, ML），Spark SQL 是更统一的选择。
- 需要亚秒级响应的交互式查询？
  - Hive LLAP： Hive 的 Live Long and Process 模式提供内存缓存和守护进程，加速查询。
  - Spark Thrift Server / JDBC/ODBC Server： 允许 BI 工具通过标准接口连接 Spark SQL 进行交互式查询。
  - 专用交互式引擎： 如 Presto, Impala, Druid 等（这些通常也依赖 HDFS/S3 存储和 Hive Metastore）。
- 需要实时/准实时流处理？
  - Spark Structured Streaming： 首选的统一引擎方案。
  - Flink： 另一个强大的流处理引擎（Spark 和 Flink 是当前流处理的主流）。
- 需要做机器学习或图计算？
  - Spark MLlib / GraphX： Spark 的内置库提供了丰富的功能。
元数据管理：
- Hive Metastore (HMS) 是事实标准： 无论你主要使用 Hive、Spark SQL 还是其他查询引擎（Presto, Impala），强烈建议使用 Hive Metastore 来集中管理表结构、分区、数据类型、存储位置等元数据。这保证了不同引擎对数据有一致的视图，是数据治理的基础。Spark 原生支持读写 Hive Metastore。

典型的组合使用模式

经典批处理数据仓库 (Hive-Centric):
- 存储: HDFS 或 S3/GCS/ADLS
- 元数据: Hive Metastore
- ETL/计算：
  - 传统/基础版： Hive on MapReduce/Tez (利用 HiveQL 编写 ETL 和查询逻辑)
  - 现代/高效版：* Hive on Spark (HiveQL -> Spark Job) 或 Spark SQL** (Spark API/SQL -> Spark Job)
- 查询： Hive CLI/Beeline (执行 HiveQL)，Spark SQL Thrift Server (支持 BI 工具连接)
- 场景： 传统的 T+1 数据报表，大规模历史数据分析。
高性能统一分析平台 (Spark-Centric):
- 存储: HDFS 或 S3/GCS/ADLS
- 元数据: Hive Metastore (Spark SQL 直接读写 HMS)
- 计算： Spark 作为核心引擎
  - 批处理 ETL: 使用 Spark DataFrame/Dataset API 或 Spark SQL 清洗、转换、加载数据到 Hive 表。
  - 流处理: 使用 Spark Structured Streaming 处理 Kafka 等数据源，结果写入 Hive 表或直接供下游使用。
  - 交互式查询: 通过 Spark Thrift Server 支持 BI 工具连接 Spark SQL。
  - 机器学习: 使用 Spark MLlib 训练模型。
- 资源管理: YARN (Hadoop) 或 Kubernetes
- 场景： 需要融合批处理、流处理、机器学习、交互式查询等多种工作负载的现代数据平台。Hive Metastore 提供了统一的数据目录。
云原生数据湖：
- 存储: S3, GCS, ADLS (对象存储)
- 元数据: Hive Metastore (托管服务如 AWS Glue Data Catalog 是 HMS 的兼容实现)
- 计算：
  - Serverless SQL 查询： AWS Athena, Google BigQuery (直接查询 S3/GCS 数据，利用 Glue Catalog 或类似元数据)
  - 自定义处理： Spark on EMR/Dataproc/Databricks/Synapse (进行复杂的 ETL、ML、流处理，读写对象存储和元数据服务)
- 场景： 利用云服务的弹性、按需付费特性，减少基础设施运维负担。Spark 处理复杂任务，Serverless SQL 处理即席查询。

总结与关键建议

HDFS/对象存储是基石： 选择适合你的分布式存储（HDFS 或云存储）。
Hive Metastore 是核心枢纽： 务必使用 Hive Metastore 或兼容服务（如 AWS Glue）来统一管理元数据，这是打通不同计算引擎的关键。
Spark 是首选计算引擎： 对于绝大多数需要速度的计算任务（批处理、流处理、ML、交互式SQL），优先选择 Spark 替代传统的 MapReduce/Tez。
Hive 的价值在于 SQL 接口和 Metastore： 即使主要用 Spark，Hive 的 Metastore 必不可少，HiveQL 接口对于重度 SQL 用户依然有价值（但底层执行应配置为 Spark）。
Hadoop YARN 是可选的资源管理器： Spark 可以运行在 YARN、Kubernetes 或 Standalone 上。如果已有 Hadoop 集群，YARN 是自然选择；新建集群，Kubernetes 越来越流行。
组合是常态： 几乎没有大型平台只使用其中一种技术。典型组合是：(HDFS/S3) + (Hive Metastore) + (Spark for Processing) + (可选 Hive for SQL interface / LLAP for interactive)。

简而言之：

存储数据用什么？ HDFS 或云存储 (S3/GCS/ADLS)。
管理表结构用什么？ Hive Metastore (或云服务如 Glue Catalog)。
跑 ETL、流处理、机器学习、快速 SQL 用什么？ Spark (Spark Core, Spark SQL, Structured Streaming, MLlib)。
想用熟悉的 SQL 做批处理分析，或者需要加速交互查询？ 可以使用 Hive (但配置 Hive on Spark 或 Hive LLAP)，或者直接用 Spark SQL + Thrift Server。

根据你的具体场景（数据规模、延迟要求、处理类型、团队技能、预算、云或本地）来调整这些组件的权重和配置。对于新项目，以 Spark 为核心计算引擎，结合 Hive Metastore 和 HDFS/云存储，是最常见且高效的起点。

virtualbox与hyper-v的冲突

Tue, 22 Jul 2025 17:10:00 +0800

因为最近在学鸿蒙开发，开发电脑一直用的deepin系统，DevEcoStudio不支持linux系统，用了win兼容引擎还是不行。没办法，只好装了virtualbox来运行win10。

在virtualbox中安装好win10也装了，DevEcoStudio运行后，虚拟机一直提示hyper-v未开启。但是，明明开启了，怎么办？难打VT-X和hyper-v有冲突？查查资料，找到了解决办法。

1.关闭 Win10 虚拟机，在 Deepin 终端执行：

    VBoxManage modifyvm "虚拟机名称" --nested-hw-virt on

2.修改虚拟机设置

打开 VirtualBox 管理界面 → 选择 Win10 虚拟机 → 设置 → 系统 → 加速：
- 半虚拟化接口选择 Hyper-V4；
- 勾选启用嵌套分页（Nested Paging）；
- 处理器数量 ≥ 2（若物理 CPU 核心足够）5。

3.开启win的hyper-v。

pushd "%~dp0"
dir /b %SystemRoot%\servicing\Packages\*Hyper-V*.mum >hyper-v.txt
for /f %%i in ('findstr /i . hyper-v.txt 2^>nul') do dism /online /norestart /add-package:"%SystemRoot%\servicing\Packages\%%i"
del hyper-v.txt
Dism /online /enable-feature /featurename:Microsoft-Hyper-V-All /LimitAccess /ALL

自己在win中创建txt文件，把代码复制进去，然后把后缀改成bat以管理原的方式运行。结束后重启就可以了。

PLC基础概念与应用场景详解

Fri, 11 Jul 2025 22:12:00 +0800

自学PLC是完全可行的！关键在于系统化的学习路径+动手实践。以下是为你整理的 「零基础自学PLC全攻略」，结合多年工业自动化经验总结，帮你少走弯路：

一、自学必备基础准备

电工知识（必须掌握）
- 看懂电路图、继电器控制原理（启保停/正反转）
- 了解传感器（NPN/PNP接线）、接触器、开关电源等元件
计算机操作
- 文件管理、软件安装、基础调试能力
逻辑思维能力
- 能分析“IF…THEN…”条件逻辑

💡 重要提示：若电工基础薄弱，先学习 《电工上岗证》 内容（推荐b站“电工大吴”系列视频）

📚 二、分阶段学习路线（附资源）

▶ 阶段1：PLC核心概念筑基（1-2周）

学习重点：
- PLC工作原理（输入-处理-输出循环）
- 硬件组成（CPU/IO模块/电源/总线）
- 进制转换（二进制/十六进制）
推荐资源：
- 书籍：《PLC编程从入门到精通》（廖常初著）
- 视频：B站“工控自习室”《PLC原理10讲》（免费）

▶ 阶段2：编程语言实战（重点！3-6周）

语言	学习建议	仿真软件
梯形图(LD)	先掌握！80%基础项目用此语言	西门子TIA Portal（博途）学习版
功能块(FBD)	学习标准功能块（定时器/计数器）	三菱GX Works2 模拟器
结构化文本(ST)	有C语言基础再学	Codesys V3.5（免费）

✨ 关键练习：
① 电机正反转控制
② 三级传送带联动
③ 水箱液位PID调节（模拟量）

▶ 阶段3：硬件实操（核心环节！）

低成本方案（总预算＜500元）：

  graph LR
  A[淘宝二手PLC] --> B[三菱FX1S-20MR ≈200元]
  B --> C[按钮开关套装 50元]
  C --> D[继电器模块 30元]
  D --> E[USB编程线 40元]

虚拟方案（零硬件）：
- Factory IO（3D仿真软件）+ TIA Portal 联动实验
- 模拟真实场景：传送带分拣/智能仓储/电梯控制

▶ 阶段4：工业通信与高级应用（2-3个月）

通信协议：Modbus RTU（必学）、CANopen
HMI入门：用威纶通MT8071IE做简易控制界面
SCADA基础：组态王/力控组态软件数据采集

🔧 三、避坑指南（血泪经验！）

❌ 错误路线：一开始就钻研西门子S7-1500（复杂度高打击信心）
✅ 正确路线：国产PLC入门（信捷/汇川）→ 三菱FX系列 → 西门子S7-1200
🚫 勿踩的坑：
1. 不练案例直接看手册 → 效率极低
2. 忽视PLC接地 → 烧毁模块风险
3. 未备份程序直接修改 → 导致设备停机

🌐 四、持续进阶资源

类型	推荐资源
故障排查	《PLC故障诊断与维护》PDF + 抖音“工控老张说维修”
行业案例	中华工控网论坛案例区（真实项目程序下载）
认证体系	西门子S7-1200认证工程师（可在线考）
开源项目	GitHub搜索“PLC Project”学习产线控制源码

🚀 五、就业能力转化建议

打造作品集：
- 用Factory IO录制控制仿真视频
- 自制PLC控制台（淘宝钣金箱+元器件组装）
参与项目：
- 接简单外包：设备改造/小型非标自动化（智造家平台）
- 加入工控侠客行等社群做志愿者项目

php架构方面的设计与思考（三）

Wed, 09 Jul 2025 01:37:00 +0800

PHP微服务架构终极整合方案:

  graph TD
      A[客户端] --> B{Kong网关}
      B -->|路由| C[用户服务]
      B -->|路由| D[订单服务]
      B -->|路由| E[支付服务]

      C -->|注册| F[Consul集群]
      D -->|注册| F
      E -->|注册| F

      C -->|配置| G[Apollo]
      D -->|配置| G
      E -->|配置| G

      D -->|消息| H[RabbitMQ集群]
      H --> E
      H --> I[通知服务]

      F --> J[Prometheus]
      G --> J
      H --> J
      J --> K[Grafana]

      L[Jaeger] --> M[服务追踪]

基础设施快速部署
Docker Compose 全栈配置

version: '3.8'

services:
  # 注册中心
  consul-server:
    image: consul:1.15
    ports: ["8500:8500"]
    command: "agent -server -bootstrap-expect=1 -ui -client 0.0.0.0"

  # API网关
  kong:
    image: kong:3.4
    depends_on: [consul-server]
    environment:
      KONG_DATABASE: "off"
      KONG_DECLARATIVE_CONFIG: "/etc/kong/kong.yml"
      KONG_PROXY_ACCESS_LOG: "/dev/stdout"
      KONG_ADMIN_ACCESS_LOG: "/dev/stdout"
      KONG_PROXY_ERROR_LOG: "/dev/stderr"
    ports: ["8000:8000", "8001:8001"]
    volumes:
      - ./kong:/etc/kong

  # 配置中心
  apollo:
    image: apolloconfig/apollo-portal:2.1.0
    ports: ["8070:8070"]
    environment:
      SPRING_DATASOURCE_URL: "jdbc:mysql://apollo-db:3306/ApolloPortalDB"

  # 消息队列
  rabbitmq:
    image: rabbitmq:3.11-management
    ports: ["5672:5672", "15672:15672"]
    environment:
      RABBITMQ_DEFAULT_USER: "admin"
      RABBITMQ_DEFAULT_PASS: "secret"

  # 监控系统
  prometheus:
    image: prom/prometheus:v2.47
    ports: ["9090:9090"]
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

核心服务PHP实现包

composer.json 关键依赖

{
  "require": {
    "php": ">=8.2",
    "ext-swoole": "*",
    "ext-redis": "*",
    "ext-amqp": "*",

    "sensiolabs/consul-php-sdk": "^2.0",
    "guzzlehttp/guzzle": "^7.8",
    "php-amqplib/php-amqplib": "^3.2",
    "resilience-php/resilience-php": "^1.3",
    "apolloconfig/apollo-client": "^2.0"
  }
}

服务注册与发现完整实现

服务注册（bootstrap.php）

use SensioLabs\Consul\ServiceFactory;

$consul = new ServiceFactory(['base_uri' => 'http://consul-server:8500']);

// 自动获取本机IP
$ip = trim(shell_exec("hostname -i"));

// 注册服务
$consul->get(AgentInterface::class)->registerService([
    'ID' => 'order-service-'.gethostname(),
    'Name' => 'order-service',
    'Address' => $ip,
    'Port' => 8000,
    'Check' => [
        'HTTP' => "http://{$ip}:8000/health",
        'Interval' => '5s',
        'Timeout' => '2s',
        'DeregisterCriticalServiceAfter' => '30s'
    ],
    'Tags' => ['v2', 'primary']
]);

// 健康检查端点
$app->get('/health', function() {
    check_database();
    check_redis();
    return json_response(['status' => 'UP']);
});

服务发现与负载均衡

class ServiceDiscovery {
    private static $cache = [];
    private static $ttl = 5; // 缓存5秒

    public static function getInstance(string $service): string {
        $now = time();

        // 缓存有效期内直接返回
        if (isset(self::$cache[$service]) && 
            $now - self::$cache[$service]['timestamp'] < self::$ttl) {
            return self::selectInstance(self::$cache[$service]['instances']);
        }

        // 从Consul获取新实例
        $instances = $consul->getCatalog()->service($service)->json();
        self::$cache[$service] = [
            'instances' => $instances,
            'timestamp' => $now
        ];

        return self::selectInstance($instances);
    }

    private static function selectInstance(array $instances): string {
        // 加权随机算法
        $total = array_sum(array_column($instances, 'Weight'));
        $rand = mt_rand(1, $total);
        $current = 0;

        foreach ($instances as $instance) {
            $current += $instance['Weight'];
            if ($rand <= $current) {
                return "http://{$instance['ServiceAddress']}:{$instance['ServicePort']}";
            }
        }
    }
}

统一配置中心接入

Apollo配置监听

$apollo = new \ApolloClient\Client([
    'config_server' => 'http://apollo:8070',
    'app_id' => 'order-service',
    'cluster' => 'default'
]);

// 初始化配置
$mysqlConfig = $apollo->get('mysql');
DB::connect($mysqlConfig);

// 动态监听
$apollo->listen(['mysql', 'redis'], function($namespace, $config) {
    switch ($namespace) {
        case 'mysql':
            DB::reconnect($config);
            break;
        case 'redis':
            Redis::setConfig($config);
            break;
    }

    Logger::info("Config updated: $namespace");
});

服务通信完整方案

同步调用（HTTP）

class HttpServiceClient {
    use CircuitBreaker;

    public function call(string $service, string $endpoint, array $data) {
        return $this->protect(function() use ($service, $endpoint, $data) {
            $baseUrl = ServiceDiscovery::getInstance($service);
            $client = new GuzzleHttp\Client([
                'base_uri' => $baseUrl,
                'timeout' => 2.0
            ]);

            return $client->post($endpoint, [
                'json' => $data,
                'headers' => [
                    'X-Trace-Id' => Trace::getId()
                ]
            ]);
        }, function() { // 降级处理
            return ['status' => 'degraded'];
        });
    }
}

异步通信（RabbitMQ）

class EventPublisher {
    private $channel;

    public function __construct() {
        $conn = new AMQPStreamConnection('rabbitmq', 5672, 'admin', 'secret');
        $this->channel = $conn->channel();

        // 声明死信交换器
        $this->channel->exchange_declare('dlx', 'direct', false, true);
        $this->channel->queue_declare('dlq', false, true);
        $this->channel->queue_bind('dlq', 'dlx');
    }

    public function publish(string $event, array $data) {
        $this->channel->tx_select();

        try {
            $message = new AMQPMessage(json_encode($data), [
                'delivery_mode' => AMQPMessage::DELIVERY_MODE_PERSISTENT,
                'message_id' => Uuid::uuid4(),
                'timestamp' => time()
            ]);

            $this->channel->basic_publish($message, 'events', $event);
            DB::table('outbox')->insert(['message_id' => $message->get('message_id')]);
            $this->channel->tx_commit();
        } catch (Exception $e) {
            $this->channel->tx_rollback();
            throw $e;
        }
    }
}

服务降级熔断策略

多级降级配置

class DegradeManager {
    private static $levels = [
        'order-service' => [
            'full' => ['threshold' => 0.95, 'fallback' => 'cache'],
            'cache' => ['threshold' => 0.8, 'fallback' => 'readonly'],
            'readonly' => ['threshold' => 0.5, 'fallback' => 'static']
        ]
    ];

    public static function handle(string $service, callable $func) {
        $status = self::getServiceStatus($service);

        try {
            switch ($status) {
                case 'full':
                    return $func();
                case 'cache':
                    return Cache::remember("fallback:$service", 60, $func);
                case 'readonly':
                    if ($_SERVER['REQUEST_METHOD'] === 'GET') {
                        return $func();
                    }
                    throw new DegradeException('只读模式');
                case 'static':
                    return ['status' => 'degraded'];
            }
        } catch (Exception $e) {
            self::recordFailure($service);
            return self::handle($service, $func); // 自动降级
        }
    }

    private static function getServiceStatus(string $service): string {
        $failureRate = Prometheus::getFailureRate($service);

        foreach (self::$levels[$service] as $level => $config) {
            if ($failureRate <= $config['threshold']) {
                return $level;
            }
        }

        return 'static';
    }
}

监控与告警配置

Prometheus指标收集

class Metrics {
    private static $counter;

    public static function init() {
        $registry = new CollectorRegistry(new InMemory());

        self::$counter = $registry->registerCounter(
            'php', 
            'http_requests_total', 
            'Total HTTP requests',
            ['method', 'endpoint', 'status']
        );

        // 暴露指标端点
        $app->get('/metrics', function() use ($registry) {
            $renderer = new RenderTextFormat();
            return $renderer->render($registry->getMetricFamilySamples());
        });
    }

    public static function countRequest($method, $path, $status) {
        self::$counter->inc([
            $method, 
            preg_replace('/\d+/', '{id}', $path),
            $status
        ]);
    }
}

// 在中间件中调用
$app->addMiddleware(function($req, $handler) {
    $start = microtime(true);
    $response = $handler->handle($req);
    $duration = microtime(true) - $start;

    Metrics::countRequest(
        $req->getMethod(),
        $req->getUri()->getPath(),
        $response->getStatusCode()
    );

    return $response;
});

生产环境部署建议

服务注册中心：
- 部署3节点Consul集群
- 启用ACL和TLS加密
- 设置自动备份策略

API网关：
- Kong集群 + Nginx负载均衡
- 启用JWT插件和速率限制
- 配置WAF规则防止攻击
配置中心：
- Apollo多环境隔离（DEV/TEST/PROD）
- 敏感配置加密存储
- 设置配置变更审批流程
消息队列：
- RabbitMQ镜像队列
- 设置合理的TTL和死信策略
- 监控队列积压情况
监控系统：
- Prometheus联邦集群
- Grafana统一看板
- 关键指标告警（P99延迟>500ms，错误率>1%）

完整架构调用流程示例

客户端请求 → Kong网关（认证+限流）

网关查询Consul获取订单服务实例
订单服务处理时：
- 从Apollo获取当前配置
- 通过HTTP调用支付服务（带熔断）
- 发送消息到RabbitMQ
支付服务消费消息后：
- 更新数据库
- 记录Prometheus指标
- 推送结果到通知服务
全链路追踪数据上报Jaeger

php 架构方面的设计与思考（二）

Sun, 06 Jul 2025 23:45:22 +0800

基于之前的架构设计，进一步提供完整的可落地方案：

一、服务注册中心增强实现（Consul + PHP）

健康检查与自动注销

// 服务注册时增加健康检查端点
$consul->get(AgentInterface::class)->registerService([
    'ID' => 'payment-service-'.uniqid(),
    'Name' => 'payment-service',
    'Tags' => ['primary', 'v2'],
    'Address' => get_current_ip(),
    'Port' => 8000,
    'Check' => [
        'HTTP' => 'http://'.get_current_ip().':8000/health',
        'Interval' => '5s',
        'Timeout' => '2s',
        'DeregisterCriticalServiceAfter' => '30s'
    ]
]);

// PHP健康检查端点实现
$app->get('/health', function() {
    return json_encode([
        'status' => 'UP',
        'db_connected' => DB::connection()->getPdo() ? true : false,
        'redis_connected' => Redis::ping() ? true : false,
        'load' => sys_getloadavg()[0]
    ]);
});

服务发现负载均衡

class ServiceLocator {
    private static $services = [];

    public static function getInstance($serviceName) {
        if (!isset(self::$services[$serviceName]) || count(self::$services[$serviceName]) == 0) {
            $instances = $consul->getCatalog()->service($serviceName)->json();
            self::$services[$serviceName] = array_map(
                fn($s) => new Instance($s['ServiceAddress'], $s['ServicePort']),
                $instances
            );
        }

        // 使用加权随机算法选择实例
        $totalWeight = array_sum(array_map(fn($i) => $i->weight, self::$services[$serviceName]));
        $rand = mt_rand(1, $totalWeight);

        foreach (self::$services[$serviceName] as $instance) {
            $rand -= $instance->weight;
            if ($rand <= 0) {
                return $instance;
            }
        }
    }

    // 定时刷新服务列表
    public static function refresh() {
        swoole_timer_tick(30000, function() {
            foreach (array_keys(self::$services) as $name) {
                $instances = $consul->getCatalog()->service($name)->json();
                self::$services[$name] = $instances;
            }
        });
    }
}

二、API 网关深度集成（Kong + OpenResty）

动态路由配置

#lua
-- kong/plugins/dynamic-router/handler.lua
local DynamicRouterHandler = {
    PRIORITY = 1000,
    VERSION = "1.0"
}

function DynamicRouterHandler:access(conf)
    -- 从Consul获取最新服务实例
    local res, err = kong.request.make({
        method = "GET",
        url = "http://consul:8500/v1/catalog/service/" .. kong.request.get_header("X-Service-Name")
    })

    if not res then
        kong.log.err("Consul request failed: ", err)
        return kong.response.exit(503)
    end

    local instances = cjson.decode(res.body)
    if #instances == 0 then
        return kong.response.exit(404, { message = "Service unavailable" })
    end

    -- 更新上游目标
    local ok, err = kong.admin_api.post("/upstreams/service-"..conf.service_name.."/targets", {
        target = instances[1].ServiceAddress..":"..instances[1].ServicePort,
        weight = 100
    })
end

return DynamicRouterHandler

PHP 插件开发示例（JWT 验证）

// kong/plugins/jwt-validator/validate.php
<?php

$token = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
if (!preg_match('/Bearer\s+(.*)$/i', $token, $matches)) {
    header('HTTP/1.1 401 Unauthorized');
    exit;
}

$jwt = $matches[1];
$userInfo = AuthService::validateJWT($jwt);

if (!$userInfo) {
    header('HTTP/1.1 403 Forbidden');
    exit;
}

// 将用户信息传递给上游服务
header('X-User-Id: ' . $userInfo['id']);
header('X-User-Roles: ' . implode(',', $userInfo['roles']));

三、配置中心完整方案（Apollo + PHP）

配置监听长轮询

class ApolloWatcher {
    private $client;
    private $callbacks = [];

    public function __construct() {
        $this->client = new \ApolloClient\Client([...]);
        $this->startWatch();
    }

    public function watch($namespace, callable $callback) {
        $this->callbacks[$namespace][] = $callback;
    }

    private function startWatch() {
        swoole_timer_tick(1000, function() {
            foreach ($this->callbacks as $namespace => $cbs) {
                $notifications = $this->client->getNotifications([$namespace]);

                if ($notifications[$namespace] > $this->versions[$namespace] ?? 0) {
                    $config = $this->client->getConfig($namespace);

                    foreach ($cbs as $cb) {
                        $cb($config);
                    }

                    $this->versions[$namespace] = $notifications[$namespace];
                }
            }
        });
    }
}

// 使用示例
$watcher = new ApolloWatcher();
$watcher->watch('application', function($config) {
    Redis::set('app_config', json_encode($config));
});

配置加密存储

class SecureConfig {
    private $key;

    public function __construct() {
        $this->key = file_get_contents('/etc/apollo/key.pem');
    }

    public function get($key) {
        $encrypted = Apollo::get($key);
        return openssl_decrypt(
            base64_decode($encrypted),
            'aes-256-cbc',
            $this->key,
            0,
            substr($this->key, 0, 16)
        );
    }
}

四、服务总线可靠消息方案（RabbitMQ）

消息事务与确认

// 生产者端
$channel->tx_select();
try {
    $msg = new AMQPMessage($data, [
        'delivery_mode' => AMQPMessage::DELIVERY_MODE_PERSISTENT,
        'message_id' => uniqid()
    ]);

    $channel->basic_publish($msg, 'orders');
    DB::table('outbox')->insert(['message_id' => $msg->get('message_id')]);
    $channel->tx_commit();
} catch (Exception $e) {
    $channel->tx_rollback();
    Metrics::counter('publish_failed')->inc();
}

// 消费者端
$channel->basic_consume('orders', '', false, false, false, false,
    function($msg) {
        try {
            processOrder($msg->body);
            $msg->ack();

            // 幂等处理
            if (!DB::table('processed_messages')->where('msg_id', $msg->get('message_id'))->exists()) {
                DB::table('processed_messages')->insert([
                    'msg_id' => $msg->get('message_id'),
                    'processed_at' => now()
                ]);
            }
        } catch (Exception $e) {
            $msg->nack(true); // 重新入队
        }
    }
);

死信队列配置

// 声明死信交换器
$channel->exchange_declare('dlx', 'direct', false, true, false);
$channel->queue_declare('dlq', false, true, false, false);
$channel->queue_bind('dlq', 'dlx', 'dead');

// 主队列配置
$channel->queue_declare('orders', false, true, false, false, false, [
    'x-dead-letter-exchange' => 'dlx',
    'x-dead-letter-routing-key' => 'dead',
    'x-message-ttl' => 600000 // 10分钟后进入DLQ
]);

五、服务降级完整策略

多级降级方案

class OrderService {
    const DEGRADE_LEVELS = [
        'full' => 0,    // 正常服务
        'readonly' => 1, // 只读模式
        'cache' => 2,    // 返回缓存数据
        'static' => 3    // 返回静态页面
    ];

    public function getOrder($id) {
        $level = CircuitBreaker::getStatus('order-service');

        switch ($level) {
            case self::DEGRADE_LEVELS['full']:
                return DB::table('orders')->find($id);

            case self::DEGRADE_LEVELS['readonly']:
                if (request()->isMethod('GET')) {
                    return DB::table('orders')->find($id);
                }
                throw new DegradeException('只读模式');

            case self::DEGRADE_LEVELS['cache']:
                return Cache::remember("order:$id", 60, function() use ($id) {
                    return DB::table('orders')->find($id) ?? [];
                });

            case self::DEGRADE_LEVELS['static']:
                return [
                    'id' => $id,
                    'status' => 'degraded',
                    'message' => '系统繁忙，请稍后查看订单状态'
                ];
        }
    }
}

自动降级规则配置

# degradation-rules.yaml
services:
  order-service:
    failure_threshold: 50%  # 失败率阈值
    slow_call_threshold: 2000ms  # 慢调用阈值
    minimum_calls: 20  # 最小调用量
    sliding_window: 60s  # 统计窗口
    wait_duration: 300s  # 半开状态等待时间

    fallbacks:
      - condition: "error instanceof TimeoutException"
        action: "return cachedData()"
      - condition: "error instanceof DBException"
        action: "switchToReadonlyMode()"

六、部署架构优化方案

Kubernetes 部署模板

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    spec:
      containers:
      - name: php
        image: my-registry/order-service:v1.2
        ports:
        - containerPort: 8000
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
        envFrom:
        - configMapRef:
            name: apollo-config
---
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: order-service
  annotations:
    consul.hashicorp.com/service-name: order-service
spec:
  ports:
  - port: 8000
    targetPort: 8000
  selector:
    app: order-service

监控告警配置

# prometheus-rules.yml
groups:
- name: php-services
  rules:
  - alert: HighErrorRate
    expr: sum(rate(http_requests_total{status=~"5.."}[1m])) by (service) / sum(rate(http_requests_total[1m])) by (service) > 0.05
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "High error rate on {{ $labels.service }}"
      description: "Error rate is {{ $value }}"

  - alert: ServiceDown
    expr: up{job="php-services"} == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "{{ $labels.instance }} is down"

七、开发环境工具链

本地调试方案：

# 使用docker-compose启动依赖服务
docker-compose -f dev-env.yml up consul rabbitmq apollo

# 使用Xdebug远程调试
PHP_IDE_CONFIG="serverName=my-service" php -dxdebug.mode=debug \
-dxdebug.client_host=host.docker.internal \
-dxdebug.client_port=9003 \
-dxdebug.start_with_request=yes \
artisan serve

API 文档生成：

/**
 * @OA\Post(
 *     path="/orders",
 *     tags={"Orders"},
 *     @OA\RequestBody(
 *         @OA\JsonContent(ref="#/components/schemas/OrderRequest")
 *     ),
 *     @OA\Response(
 *         response=201,
 *         description="Order created",
 *         @OA\JsonContent(ref="#/components/schemas/Order")
 *     ),
 *     @OA\Response(
 *         response=503,
 *         description="Service degraded",
 *         @OA\JsonContent(ref="#/components/schemas/Error")
 *     )
 * )
 */
public function createOrder(Request $request) {
    // ...
}

性能测试工具：

# 使用wrk进行压力测试
wrk -t4 -c100 -d60s --latency http://localhost:8000/api/orders

# 生成火焰图
php -dxdebug.profiler_enable=1 -dxdebug.profiler_output_dir=/tmp \
-dxdebug.profiler_output_name=cachegrind.out.%p artisan serve

关键优化点总结

服务发现：采用 Consul 集群+健康检查+客户端缓存，实现秒级服务状态更新

消息可靠：通过事务消息+死信队列+幂等处理保障消息不丢失
配置管理：Apollo 长轮询+加密存储+版本回溯实现安全配置中心
降级策略：多级降级（全功能 → 只读 → 缓存 → 静态）保障核心链路
可观测性：Prometheus 指标+Jaeger 追踪+ELK 日志三位一体监控

php架构方面的设计与思考（一）

Sat, 05 Jul 2025 11:00:00 +0800

PHP的微服务架构设计，涵盖服务注册中心、服务调度、服务降级、服务网关、服务配置、服务总线等核心模块的完整梳理和实现方案：

graph TD
    A[服务网关] --> B[服务注册中心]
    A --> C[服务配置中心]
    D[服务提供者] --> B
    E[服务消费者] --> B
    F[服务总线] --> D
    F --> E
    G[服务调度器] --> F
    H[降级管理器] --> C

一、架构核心模块与实现技术选型

模块	推荐技术	PHP对接方式	特点
服务注册中心	Consul、Nacos	HTTP API/PHP客户端库	支持健康检查、服务发现
服务网关	Kong、APISIX	Nginx代理/PHP插件	动态路由、限流、认证
服务配置中心	Apollo、Nacos	HTTP长轮询/PHP SDK	配置热更新、版本管理
服务总线	RabbitMQ、Kafka	PHP扩展(php-amqplib/rdkafka)	异步解耦、可靠消息
服务调度	Workerman/Swoole	原生PHP支持	协程调度、高性能
服务降级	ResiliencePHP	Composer库	熔断、限流、降级
分布式追踪	Jaeger、Zipkin	OpenTracing-PHP	全链路监控

二、各模块具体实现方案

服务注册中心（Consul + PHP）

// 安装Consul PHP客户端：composer require sensiolabs/consul-php-sdk
use SensioLabs\Consul\ServiceFactory;
use SensioLabs\Consul\Services\AgentInterface;

$consul = new ServiceFactory([
    'base_uri' => 'http://consul-server:8500',
]);

// 服务注册
$consul->get(AgentInterface::class)->registerService([
    'ID' => 'order-service-001',
    'Name' => 'order-service',
    'Address' => '192.168.1.101',
    'Port' => 8000,
    'Check' => [
        'HTTP' => 'http://192.168.1.101:8000/health',
        'Interval' => '10s'
    ]
]);

// 服务发现
$services = $consul->getCatalog()->service('order-service')->json();
$instances = array_map(fn($s) => "{$s['ServiceAddress']}:{$s['ServicePort']}", $services);

API网关（Kong + PHP）

# Kong配置示例
  location /api/ {
    access_by_lua_block {
      -- PHP认证插件
      local res = ngx.location.capture("/auth.php?token="..ngx.var.arg_token)
      if res.status ~= 200 then
        ngx.exit(401)
      end
    }

    proxy_pass http://php-upstream;
    proxy_set_header X-Service-Name $route_name;
  }

配置中心（Apollo + PHP）

// 使用apollo-client-php
$client = new \ApolloClient\Client([
    'config_server' => 'http://apollo-config:8080',
    'app_id' => 'user-service',
    'cluster' => 'default',
]);

// 获取配置
$mysqlConfig = $client->get('mysql.connection');

// 监听配置变更
$client->listen(function($key, $value) {
    if ($key === 'feature_toggle') {
        FeatureToggle::update($value);
    }
});

服务总线（RabbitMQ + PHP）

// 生产者
$connection = new AMQPStreamConnection('rabbitmq', 5672, 'guest', 'guest');
$channel = $connection->channel();
$channel->queue_declare('order_events', false, true, false, false);

$msg = new AMQPMessage(json_encode([
    'event' => 'ORDER_CREATED',
    'data' => ['id' => 123]
]), ['delivery_mode' => 2]);

$channel->basic_publish($msg, '', 'order_events');

// 消费者
$channel->basic_consume('order_events', '', false, false, false, false, 
    function($msg) {
        $event = json_decode($msg->body, true);
        EventDispatcher::dispatch($event);
        $msg->ack();
    }
);

服务降级（ResiliencePHP）

use Resilience\Retry;
use Resilience\CircuitBreaker;

// 熔断器配置
$circuitBreaker = CircuitBreaker::builder()
    ->withFailureRateThreshold(50)
    ->withWaitDuration(10000)
    ->build();

// 带熔断的重试机制
$result = Retry::with(Retry::maxAttempts(3))
    ->decorate($circuitBreaker)
    ->run(function() use ($service) {
        return $service->callApi();
    }, function($e) {
        // 降级处理
        return ['status' => 'degraded', 'data' => cached_data()];
    });

分布式调度（Swoole协程）

use Swoole\Coroutine;

// 并发调用多个服务
Coroutine\run(function() {
    $results = [];
    $wg = new Coroutine\WaitGroup();

    $services = ['inventory', 'payment', 'notification'];

    foreach ($services as $service) {
        $wg->add();
        go(function() use ($service, &$results, $wg) {
            $results[$service] = callService($service);
            $wg->done();
        });
    }

    $wg->wait();

    // 处理聚合结果
    processResults($results);
});

三、完整架构部署方案

graph LR
    A[客户端] --> B[Kong网关]
    B --> C[认证服务]
    B --> D[用户服务]
    B --> E[订单服务]
    B --> F[支付服务]

    subgraph 微服务集群
        C -->|注册| H[Consul]
        D -->|注册| H
        E -->|注册| H
        F -->|注册| H

        C -->|配置| I[Apollo]
        D -->|配置| I
        E -->|配置| I
        F -->|配置| I

        E -->|消息| J[RabbitMQ]
        J --> F
        J --> K[通知服务]
    end

    H --> L[Prometheus监控]
    I --> L
    J --> L
    L --> M[Grafana]

四、关键组件安装与配置

基础设施部署（Docker示例）

# docker-compose.yml
version: '3'

services:
  consul:
    image: consul:latest
    ports:
      - "8500:8500"

  kong:
    image: kong:latest
    depends_on:
      - postgres
    ports:
      - "8000:8000"
      - "8001:8001"

  apollo:
    image: apolloconfig/apollo-portal
    ports:
      - "8070:8070"

  rabbitmq:
    image: rabbitmq:management
    ports:
      - "5672:5672"
      - "15672:15672"

PHP服务Dockerfile

FROM php:8.2-fpm

# 安装必要扩展
RUN apt-get update && apt-get install -y \
    libzip-dev \
    librabbitmq-dev \
    && docker-php-ext-install zip pdo_mysql \
    && pecl install amqp \
    && docker-php-ext-enable amqp

# 安装Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

WORKDIR /var/www
COPY . .
RUN composer install --no-dev --optimize-autoloader

五、生产环境建议

服务注册中心：
- 使用Consul集群（至少3节点）
- 开启ACL安全控制
- 集成Prometheus监控

网关层：
- Kong集群 + Nginx负载均衡
- 启用JWT认证插件
- 配置速率限制（1000rps/服务）
配置管理：
- Apollo多环境配置（DEV/TEST/PROD）
- 敏感配置加密存储
- 配置变更审计日志
服务通信：
- 同步调用：HTTP/2 + Protobuf
- 异步消息：RabbitMQ镜像队列
- 服务网格：Istio（可选）
可观测性：
- 日志：ELK收集Nginx/PHP日志
- 指标：Prometheus收集服务指标
- 追踪：Jaeger实现全链路追踪

六、PHP微服务开发工具包

composer require:
  sensiolabs/consul-php-sdk     # Consul客户端
  guzzlehttp/guzzle             # HTTP客户端
  php-amqplib/php-amqplib       # RabbitMQ
  kwn/php-jaeger-client         # Jaeger追踪
  resilience-php/resilience-php # 熔断降级
  ext-swoole                    # 协程调度

EMM与MDM系统详解

Fri, 27 Jun 2025 10:12:00 +0800

EMM（Enterprise Mobility Management，企业移动化管理）和MDM（Mobile Device Management，移动设备管理）是企业用于安全管理移动设备、应用及数据的核心技术体系。下面从定义、功能、演进和应用场景等方面进行系统说明：

📱 一、核心概念
MDM（移动设备管理）

定义：专注于移动设备（如手机、平板）的全生命周期管理，包括注册、配置、监控、远程控制（如锁定/擦除）及停用146。

适用场景：适用于企业统一配发的设备（如物流手持终端、公司手机），需完全控制硬件和操作系统39。

EMM（企业移动化管理）

定义：MDM的扩展，是一套综合解决方案，除设备管理外，还包含移动应用管理（MAM）、移动内容管理（MCM）、移动身份管理（MIM）等组件，目标是在保障安全的前提下提升移动办公效率189。

核心能力：支持BYOD（自带设备办公），通过“容器化”技术隔离企业数据与个人数据，实现细粒度控制（如仅擦除企业应用数据）59。

⚙️ 二、核心功能组件
EMM通过以下模块协同工作：

MDM：设备注册、策略配置（密码复杂度、加密）、远程擦除16。

MAM（移动应用管理）：

企业应用商店分发、静默安装/更新；

控制应用权限（如禁止截屏/粘贴）19。

MCM（移动内容管理）：

安全分发企业文件（如合同、报表）；

数据加密存储，限制分享至非授权应用18。

MIM（移动身份管理）：

单点登录（SSO）、多因素认证；

基于角色/设备状态动态调整访问权限18。

📊 三、MDM与EMM的区别
维度 MDM EMM
管理对象设备硬件及操作系统设备+应用+数据+身份
控制粒度设备级（全盘控制）应用/数据级（如仅管理企业容器）
适用场景企业统一配发设备（COBO/COPE） BYOD（员工个人设备）为主
隐私兼容性低（需完全控制设备）高（隔离企业数据，保护个人隐私）
演进关系 EMM的基础组件 MDM的扩展与升级
示例：在BYOD场景中，EMM允许员工用个人手机访问企业邮箱，但仅对企业邮箱App内的数据加密并远程擦除，不影响个人照片等隐私内容59。

⏳ 四、技术演进：从MDM到EMM
移动管理技术经历了三个阶段：

设备驱动阶段（2007-2012）：MDM主导，功能限于设备注册、密码策略、远程擦除210。

应用管理阶段（2011-2013）：MAM兴起，引入沙箱/容器隔离企业应用数据，适应BYOD需求25。

内容与身份融合阶段（2013至今）：

EMM整合MCM/MIM，实现基于角色、位置、设备状态的动态策略（如“出差时禁止访问财务系统”）10；

向UEM（统一端点管理）演进，覆盖PC、IoT等更多终端35。

🏢 五、企业应用价值
安全提升：防止数据泄露（如阻断企业文件保存至个人云盘）、抵御越狱/root设备风险16。

效率优化：

自动分发应用（如销售团队统一安装CRM工具）；

远程故障排查，减少现场支持成本9。

合规支持：满足GDPR等法规要求，审计日志记录敏感操作68。

💎 总结
MDM是移动管理的起点，聚焦设备控制；EMM是更成熟的解决方案，通过应用/数据/身份的精细管理，在安全与员工体验间取得平衡。随着远程办公普及，EMM已成为企业移动化转型的核心基础设施，并持续向跨终端、智能化的UEM方向演进358。

php开发捕鱼游戏的构思

Tue, 10 Jun 2025 23:09:00 +0800

使用PHP开发捕鱼游戏涉及前后端协作，以下是核心实现思路和代码示例：

一、系统设计

前端：HTML5 Canvas + JavaScript 绘制游戏场景
后端：PHP 处理游戏逻辑和数据库操作
数据库：MySQL 存储玩家数据
通信：AJAX 实现前后端交互

二、核心功能实现

1. 数据库设计（MySQL）

CREATE TABLE players (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) UNIQUE,
    password VARCHAR(255),
    gold INT DEFAULT 1000,
    score INT DEFAULT 0
);

2. PHP后端逻辑（结合前端交互）

游戏核心文件：game.php

<?php
session_start();
// 连接数据库
$db = new mysqli('localhost', 'username', 'password', 'fishing_game');

class FishingGame {
    private $db;
    
    public function __construct($db) {
        $this->db = $db;
    }
    
    // 捕鱼逻辑
    public function catchFish($playerId, $cannonType, $fishType) {
        $cost = $this->getCannonCost($cannonType);
        $reward = $this->getFishReward($fishType);
        
        // 扣除金币
        $this->db->query("UPDATE players SET gold = gold - $cost WHERE id = $playerId");
        
        // 捕获判定（简化版概率计算）
        $success = (rand(1, 100) > 30); // 70%成功率
        
        if($success) {
            $this->db->query("UPDATE players SET gold = gold + $reward, score = score + $reward WHERE id = $playerId");
            return ['success' => true, 'reward' => $reward];
        }
        return ['success' => false];
    }
    
    private function getCannonCost($type) {
        $costs = [1 => 5, 2 => 10, 3 => 20]; // 炮弹类型对应消耗
        return $costs[$type] ?? 5;
    }
    
    private function getFishReward($type) {
        $rewards = [1 => 10, 2 => 25, 3 => 50]; // 鱼类奖励
        return $rewards[$type] ?? 10;
    }
}

// 实例化游戏
$game = new FishingGame($db);

// 处理AJAX请求
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $playerId = $_SESSION['player_id'];
    $data = json_decode(file_get_contents('php://input'), true);
    
    if(isset($data['action']) && $data['action'] === 'catch') {
        $response = $game->catchFish(
            $playerId,
            $data['cannon'],
            $data['fishType']
        );
        header('Content-Type: application/json');
        echo json_encode($response);
        exit;
    }
}
?>

3. 前端核心实现（JavaScript）

<canvas id="gameCanvas" width="800" height="600"></canvas>
<script>
// 游戏配置
const FISH_TYPES = {
  1: { speed: 2, color: '#FF9900', size: 30 },
  2: { speed: 3, color: '#00CCFF', size: 50 },
  3: { speed: 1, color: '#FF66CC', size: 80 }
};

class FishingGame {
  constructor() {
    this.canvas = document.getElementById('gameCanvas');
    this.ctx = this.canvas.getContext('2d');
    this.fishes = [];
    this.player = { gold: 1000, score: 0 };
    this.init();
  }

  init() {
    this.generateFish();
    this.gameLoop();
    this.canvas.addEventListener('click', this.handleClick.bind(this));
  }

  generateFish() {
    // 随机生成鱼群
    setInterval(() => {
      const type = Math.floor(Math.random() * 3) + 1;
      this.fishes.push({
        type,
        x: -50,
        y: Math.random() * 500 + 50,
        ...FISH_TYPES[type]
      });
    }, 2000);
  }

  handleClick(e) {
    const rect = this.canvas.getBoundingClientRect();
    const clickX = e.clientX - rect.left;
    const clickY = e.clientY - rect.top;
    
    // 检测点击到的鱼
    const cannonType = 1; // 默认炮弹类型
    for(let i = this.fishes.length - 1; i >= 0; i--) {
      const fish = this.fishes[i];
      const distance = Math.sqrt(
        Math.pow(fish.x - clickX, 2) + 
        Math.pow(fish.y - clickY, 2)
      );
      
      if(distance < fish.size) {
        this.sendCatchRequest(fish.type, cannonType);
        this.fishes.splice(i, 1);
        break;
      }
    }
  }

  async sendCatchRequest(fishType, cannonType) {
    const response = await fetch('game.php', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        action: 'catch',
        fishType: fishType,
        cannon: cannonType
      })
    });
    
    const result = await response.json();
    if(result.success) {
      this.player.gold += result.reward;
      this.player.score += result.reward;
      this.showEffect('+'+result.reward);
    }
  }

  gameLoop() {
    this.ctx.clearRect(0, 0, 800, 600);
    
    // 绘制背景
    this.ctx.fillStyle = '#3399FF';
    this.ctx.fillRect(0, 0, 800, 600);
    
    // 更新并绘制鱼
    this.fishes.forEach(fish => {
      fish.x += fish.speed;
      if(fish.x > 850) fish.x = -50;
      
      this.ctx.beginPath();
      this.ctx.fillStyle = fish.color;
      this.ctx.arc(fish.x, fish.y, fish.size/2, 0, Math.PI * 2);
      this.ctx.fill();
    });
    
    // 绘制UI
    this.ctx.fillStyle = '#000';
    this.ctx.font = '20px Arial';
    this.ctx.fillText(`金币: ${this.player.gold}`, 20, 30);
    this.ctx.fillText(`分数: ${this.player.score}`, 20, 60);
    
    requestAnimationFrame(() => this.gameLoop());
  }
}

new FishingGame();
</script>

三、游戏功能扩展建议

高级功能：
- 添加多种武器系统（激光炮、渔网）
- 实现鱼群特殊行为（BOSS鱼、鱼群迁徙）
- 道具系统（金币加倍、冰冻效果）
性能优化：
- WebSocket实现实时通信
- 对象池重用鱼对象
- 精灵图代替纯色绘制
安全增强：
- 炮弹消耗验证
- 频率限制（防作弊）
- 数据加密传输
商业化功能：
- 内购金币系统
- 每日任务奖励
- 玩家排行榜

四、部署注意事项

使用PHP 7.4+ 获取最佳性能
配置OPCache加速PHP执行
前端资源使用CDN加速
定期备份玩家数据

完整实现需包含用户系统（注册/登录）、游戏商城、社交功能等模块。实际开发中建议使用游戏引擎如Phaser.js替代原生Canvas API以提高开发效率。

webman和hyperf对比解析

Mon, 26 May 2025 21:55:00 +0800

好的，我们来深入探讨一下 webman、Hyperf 的底层原理以及 PHP 中注解（Annotations）的实现原理。

1. webman 底层原理

webman 的核心设计理念是 轻量、高性能、易用。它构建在强大的异步事件驱动网络库 Workerman 之上，充分利用了 PHP 的 CLI（命令行接口）模式和事件循环机制，摒弃了传统的 PHP-FPM 模式，从而实现了高性能和高并发。

核心原理剖析

基于 Workerman：
- 事件驱动： Workerman 使用 libevent (默认)、event 或 swoole 扩展提供的事件循环库。它在一个或多个主进程中创建和管理一个或多个事件循环 (event loop)。
- 非阻塞 I/O： 所有网络操作（TCP/UDP/Unix Socket 监听和连接）都是非阻塞的。当一个连接上有数据可读、可写或发生错误时，事件循环会触发注册的回调函数进行处理。这避免了为每个连接创建线程或进程的巨大开销。
- 多进程模型：
  - 主进程 (Master)： 负责解析配置、创建监听套接字、管理子进程（Worker 进程）、监控子进程状态（如崩溃重启）、处理信号（如 reload, stop, status）。
  - Worker 进程 (Worker)： 真正处理业务逻辑的进程。主进程 fork 出多个 Worker 子进程。默认情况下，这些 Worker 进程是常驻内存的。每个 Worker 进程都独立运行着自己的事件循环，处理分配给它的连接请求。
  - 进程间通信 (IPC)： Master 和 Worker 之间通常通过 Unix Socket 管道进行通信（例如发送 reload 信号、状态查询）。
- 协议支持： Workerman 内置了对 HTTP、WebSocket、TCP、UDP 等协议的支持，并能自定义协议。
webman 在 Workerman 上的封装：
- PSR 兼容： 提供了符合 PSR-7 (HTTP 消息接口)、PSR-15 (HTTP 中间件)、PSR-11 (容器) 等标准的实现，使得开发者可以使用熟悉的中间件模式和依赖注入。
- 路由： 提供灵活的路由配置（如文件路由 route.php），将 HTTP 请求映射到对应的控制器方法或闭包。
- 中间件： 实现了洋葱圈模型的中间件机制，方便处理请求前、后的逻辑（如鉴权、日志、跨域）。
- 控制器： 组织业务逻辑代码。
- 视图： 支持简单的模板渲染。
- 数据库/Redis： 提供便捷的封装，但需要注意在默认 Worker 进程模型下，数据库连接不能像 Swoole 协程那样自动释放/重用，需要开发者自行管理连接的生命周期（通常在一个请求处理周期内创建和关闭，或使用连接池）。webman 官方提供了 webman/redis-queue 等插件来帮助管理。
- 文件监控与热更新：
  - php webman start 默认启动时带 -w 参数开启监控。
  - Workerman 利用 Linux 内核的 inotify 机制（或 macOS 的 kqueue）监控项目文件（.php, .env 等）的更改。
  - 当检测到文件修改，主进程会向所有 Worker 进程发送 SIGUSR1 信号。
  - Worker 进程收到信号后，安全地退出当前正在处理的请求（如果有），然后优雅地重启自身（重新加载修改后的代码），而主进程保持运行并重新 fork 新的 Worker 进程。这个过程非常快速，用户几乎感知不到服务中断，实现了“热更新”。
高性能关键点：
- 常驻内存： 最大的优势。框架核心、业务代码、配置等在 Worker 进程启动时加载一次，驻留在内存中。处理后续请求时无需重复初始化框架、加载核心文件、连接数据库（如果连接池管理得当），极大减少了开销。
- 事件驱动 & 非阻塞： 高效处理高并发连接，尤其适合 I/O 密集型场景。
- 轻量级： 框架本身代码量少，抽象层薄，开销小。

总结 webman 原理： 利用 Workerman 的事件驱动、非阻塞 I/O 和多进程模型提供高性能网络基础。webman 在其上构建了一个符合现代 PHP 开发规范（PSR）的轻量级 Web 框架，并通过文件监控实现了便捷的热更新。其核心优势在于常驻内存带来的性能提升和 Workerman 的稳定性。

2. Hyperf 底层原理

Hyperf 是一个 高性能、高灵活性的企业级协程框架。它的核心建立在 Swoole 扩展之上，深度利用了 Swoole 提供的协程能力来实现高性能和高并发，并引入了大量 Java Spring Cloud 等框架的设计理念（如依赖注入、AOP、注解驱动）。

核心原理剖析

基于 Swoole：
- 协程： Swoole 的核心能力。协程是用户态的轻量级线程，由框架或运行时自身调度，切换成本极低（通常只有函数调用的开销）。Hyperf 深度拥抱协程，几乎所有组件（HTTP Server、Database Client、Redis Client、RPC Client/Server、AMQP 等）都设计为协程安全或协程友好。
- 协程调度： Swoole 提供了协程调度器。当一个协程遇到 I/O 操作（如数据库查询、网络请求、文件读写）时，它会自动挂起（yield），将 CPU 让给其他就绪的协程。当 I/O 操作完成，调度器会恢复（resume）该协程继续执行。这使得单进程内可以并发处理成千上万个连接/任务，且代码逻辑依然是顺序编写（异步回调的 callback hell 问题得到极大缓解）。
- 事件驱动： 底层仍然是事件驱动（基于 epoll/kqueue 等），Swoole 的事件循环驱动着协程的调度。
- Server： 提供高性能的 HTTP Server、WebSocket Server、TCP/UDP Server 等。Hyperf 主要使用 HTTP Server。
Hyperf 在 Swoole 上的高级封装与架构：
- 强大的依赖注入容器 (DI Container)：
  - 是整个框架的基石（基于 hyperf/di 组件）。
  - 实现了 PSR-11。
  - 支持自动装配（Autowiring）、接口绑定实现、构造函数注入、属性注入、方法注入。
  - 管理着应用中几乎所有对象的生命周期（单例、原型等）。
  - 是 AOP 和注解驱动实现的基础。
- 注解驱动开发 (Annotation-Driven Development)：
  - Hyperf 重度依赖注解来配置路由、定义中间件、声明 AOP 切面、标记定时任务、配置依赖注入、定义 RPC 服务等。
  - 框架启动时（或在 Worker 进程启动时，取决于注解作用域），会通过反射扫描代码，解析类、方法、属性上的注解，收集元数据，并动态生成代理类或进行相应的配置注册（如将路由信息注册到路由器）。
  - 极大提高了开发效率和代码的可读性、可维护性（配置紧贴代码）。
- 面向切面编程 (AOP)：
  - 基于 DI 容器和动态代理实现。
  - 允许开发者定义“切面”（Aspect）类，其中包含“通知”（Advice - 如 @Before, @After, @Around）和“切入点”（Pointcut - 通过注解或表达式指定哪些类的哪些方法需要被切入）。
  - 框架在运行时，会为匹配 Pointcut 的目标类生成代理类。当调用目标方法时，实际上是调用代理类的方法，代理类会按顺序执行相关的 Advice 逻辑（如日志记录、性能监控、事务管理、缓存处理、权限校验等），然后再调用或环绕调用原始目标方法。
  - 实现了横切关注点（Cross-Cutting Concerns）与核心业务逻辑的解耦。
- 协程上下文管理：
  - 由于协程是轻量级且并发执行的，传统的全局变量、单例模式在协程环境下可能不安全（一个协程修改会影响其他协程）。
  - Hyperf 提供了 hyperf/context 组件，利用 Swoole 的协程 API (Swoole\Coroutine::getContext()) 实现协程级别的上下文隔离。Context 类允许安全地在同一个协程内存储和获取数据。
- 连接池：
  - 为昂贵的资源（如数据库连接、Redis 连接、HTTP 客户端连接）提供池化管理。
  - 当协程需要资源时，从池中获取；使用完毕后，归还到池中。
  - 避免频繁创建和销毁连接的开销，极大提升性能，并且天然适配协程模型（每个协程使用独立的连接，避免并发问题）。
- 组件化与异步非阻塞客户端：
  - Hyperf 提供了大量开箱即用的高性能协程组件：数据库 (hyperf/database - 基于 Eloquent/Doctrine, 带连接池)、Redis (hyperf/redis - 带连接池)、缓存、队列 (hyperf/async-queue)、RPC (hyperf/json-rpc)、服务注册与发现 (hyperf/service-governance)、配置中心 (hyperf/config)、分布式追踪 (hyperf/tracer)、限流熔断 (hyperf/rate-limit, hyperf/circuit-breaker)、GraphQL、gRPC、AMQP、WebSocket 等。
  - 这些客户端底层都使用 Swoole 提供的协程 Client 或自行实现的协程化 Client，确保所有 I/O 操作都是异步非阻塞的，能够被协程调度器挂起和恢复。
- 进程模型：
  - 主进程 (Master)： 管理服务生命周期。
  - Manager 进程： 管理 Worker/TaskWorker 进程（创建、回收）。
  - Worker 进程： 处理网络请求（HTTP, WebSocket, TCP 等）。每个 Worker 进程是一个独立的协程调度单元，内部可以并发运行大量协程处理请求。
  - TaskWorker 进程 (可选)： 专门处理耗时较长的同步阻塞任务（如某些复杂计算、调用不支持协程的库）。Worker 进程通过 task() 投递任务到 TaskWorker。Hyperf 也提供了基于消息队列 (async-queue) 的异步任务处理方案。
- 热更新：
  - 原理类似 webman/Workerman，使用 inotify/kqueue 监控文件变化。
  - 向 Worker 进程发送信号 (SIGUSR1 或 SIGTERM) 通知其优雅重启（完成当前请求后退出，主进程重新拉起新 Worker 加载新代码）。Hyperf 的 DI 容器和代理类生成机制使得热更新相对可靠。

总结 Hyperf 原理： 深度集成 Swoole 协程，构建了一个高性能、企业级的微服务框架。其核心在于强大的依赖注入容器、基于注解的元编程和配置、AOP 解耦横切关注点、完善的协程上下文和连接池管理，以及大量开箱即用的高性能协程组件。它更适合构建复杂的、分布式的高并发系统（如微服务架构）。

3. PHP 注解 (Annotations) 原理

注解（PHP 8 之前常称为 DocBlock Annotations，PHP 8 引入了原生 Attributes）是一种元数据机制。它允许你将结构化的信息（元数据）附加到代码元素（类、方法、属性、函数、参数）上。这些信息本身不会直接影响代码的逻辑执行，但可以被外部工具（如框架、库、IDE、文档生成器）在运行时或编译时读取并利用。

实现原理 (重点在框架如何利用)

PHP 8 之前 (DocBlock Annotations)：
- 存储位置： 元数据以特定格式的注释块（/** ... */）形式写在代码元素的上方。
- 格式： 遵循 PHPDoc 标准，但框架会定义自己的特殊标签（如 @Route, @Inject, @Cacheable）。
- 解析：
  - 反射 (Reflection)： 框架利用 PHP 的反射 API (ReflectionClass, ReflectionMethod, ReflectionProperty) 获取代码元素（类、方法、属性）。
  - 获取 DocComment： 通过反射对象的 getDocComment() 方法获取该元素上的文档注释字符串。
  - 解析字符串： 框架需要编写自己的解析器（或使用库如 doctrine/annotations）来解析这个字符串。解析器：
    - 识别以 @ 开头的标记（Tags）。
    - 解析标记后的参数（可能是简单的字符串、键值对、数组、甚至嵌套结构）。
    - 将解析结果转换为结构化的数据（通常是数组或特定的注解对象）。
- 处理：
  - 启动时扫描： 框架通常在启动阶段（或首次请求时）扫描指定的目录或命名空间下的所有 PHP 文件。
  - 反射与解析： 对扫描到的类、方法、属性使用反射获取 DocComment 并进行解析。
  - 元数据收集： 将解析得到的结构化注解信息收集并存储起来（例如，将 @Route 信息注册到路由表中；将 @Inject 信息用于 DI 容器的自动装配配置）。
  - 运行时利用： 在处理请求或执行特定逻辑时，框架会根据之前收集的注解元数据来指导行为（如根据路由注解匹配控制器方法；根据缓存注解决定是否从缓存读取数据）。
PHP 8 及之后 (原生 Attributes)：
- 语言级支持： PHP 8 将注解作为一级语言特性引入，称为 Attributes。它们不再是注释，而是正式的语法结构。
- 定义： 使用 #[...] 语法定义。Attribute 本身就是一个普通的 PHP 类（通常继承自 \Attribute），可以有自己的构造函数、属性和方法，用于定义和验证元数据的结构。
- 反射获取： 反射 API 新增了 getAttributes() 方法（例如 ReflectionClass::getAttributes()）。这个方法返回一个 ReflectionAttribute 对象数组。
- 实例化： 可以通过 ReflectionAttribute::newInstance() 方法实例化 Attribute 类对象（如果定义了类），传入的参数就是在 Attribute 定义时提供的参数。这样就得到了一个强类型的、结构化的注解对象。
- 优势：
  - 性能： 原生语法，解析速度比解析 DocComment 字符串快得多。
  - 验证： Attribute 类可以定义构造函数参数类型，PHP 引擎会在定义时就进行参数类型检查，避免运行时解析错误。
  - 结构清晰： 强类型对象比解析字符串得到的数组更清晰、更安全。
  - IDE 支持： IDE 能更好地识别、自动补全和检查 Attributes。
- 框架处理流程 (类似 DocBlock，但更高效安全)：
  - 启动扫描目录/命名空间。
  - 使用反射 API 获取类/方法/属性。
  - 调用 getAttributes() 获取附加的 Attribute 列表。
  - newInstance() 实例化需要的 Attribute 对象。
  - 收集这些 Attribute 对象包含的元数据。
  - 根据元数据配置框架（注册路由、配置 DI、定义 AOP 切入点等）。

总结注解原理： 无论是旧的 DocBlock 还是新的原生 Attribute，注解的本质都是附加在代码元素上的元数据。框架通过 反射机制 在启动阶段（或按需） 扫描代码，解析这些元数据，将其转换为结构化信息，并利用这些信息来动态配置框架行为、生成代理代码（AOP）或指导运行时逻辑。原生 Attributes 在性能、类型安全性和开发体验上带来了显著提升。像 Hyperf 这类现代框架已全面转向使用原生 Attributes。

webman vs Hyperf 核心原理对比摘要

特性	webman	Hyperf
核心引擎	Workerman (事件驱动, 多进程)	Swoole (事件驱动 + 协程, 多进程)
编程模型	事件回调 + 传统同步逻辑 (需自行管理阻塞I/O)	协程 (同步写法, 异步非阻塞I/O)
性能关键	常驻内存 (减少初始化开销)	常驻内存 + 协程 (高并发, 低资源消耗)
连接管理	需手动管理或借助插件/连接池	内置协程连接池 (DB, Redis, HTTP Client等)
核心机制	轻量路由、中间件、PSR 封装	强大的DI容器、注解驱动、AOP、丰富组件化
并发能力	高 (多进程)	极高 (多进程 + 单进程内高协程并发)
复杂度	轻量简单，学习曲线平缓	功能强大复杂，学习曲线较陡 (需理解DI, AOP, 协程)
定位	高性能 HTTP API / 简单实时应用	企业级、微服务、分布式系统、复杂高并发应用
热更新	支持 (基于 inotify/kqueue)	支持 (基于 inotify/kqueue)
代表技术	文件监听、Workerman API	Attributes、AOP、依赖注入、连接池、服务治理

python后端管理框架有哪些

Fri, 11 Apr 2025 21:24:00 +0800

Python 后端管理框架主要用于快速构建后台管理系统（如数据管理、用户权限控制等）。以下是常见的 Python 后端管理框架分类及代表工具：

1. 基于 Django 的框架

Django Admin

Django 内置的管理后台，开箱即用。
支持 ORM 自动生成 CRUD 界面，适合快速开发。

缺点：默认界面较简陋（可通过插件美化）。

# 示例：注册模型到 Admin
from django.contrib import admin
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price')

Django Jet
- 现代化的 Django Admin 主题（支持响应式布局）。
Django Grappelli
- 经典的美化扩展，提供更友好的 UI。
Django Suit
- 另一个流行的 Admin 主题（需付费）。

2. 基于 Flask 的框架

Flask-Admin

轻量级、高度可定制，支持多种数据库后端（SQLAlchemy、MongoDB 等）。

特点：灵活性高，适合中大型项目。

# 示例：集成 Flask-Admin
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView

app = Flask(__name__)
db = SQLAlchemy(app)
admin = Admin(app, name='管理后台')

class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80))

admin.add_view(ModelView(Product, db.session))

Flask-AppBuilder
- 快速生成 CRUD 界面，内置 RBAC 权限控制。
- 提供图表、表单生成等高级功能。

3. 独立/通用框架

SQLAlchemy-Admin
- 基于 SQLAlchemy 的独立管理界面，不依赖 Web 框架。
WTForms-Alchemy
- 自动从 SQLAlchemy 模型生成表单（常与 Flask-Admin 配合使用）。

4. 基于 FastAPI 的框架

FastAPI Admin

异步支持，适合高性能场景。

提供模型管理、文件上传等功能。

# 示例：FastAPI-Admin 基础使用
from fastapi import FastAPI
from fastapi_admin.app import app as admin_app
from fastapi_admin.providers.login import UsernamePasswordProvider

app = FastAPI()
admin_app.add_provider(UsernamePasswordProvider())
app.mount("/admin", admin_app)

SQLModel-Admin
- 基于 SQLModel（FastAPI 官方 ORM）的管理界面。

5. 低代码/可视化工具

AppSmith / ToolJet
- 支持连接数据库/API，通过拖拽生成管理界面（非纯 Python，但可集成）。
Django Builder
- 可视化构建 Django 后台的第三方工具。

选择建议

快速原型：用 Django Admin（Django 项目）或 Flask-AppBuilder（Flask 项目）。
高定制化：选 Flask-Admin 或手动扩展 Django Admin。
现代异步架构：选 FastAPI Admin。
低代码需求：AppSmith/ToolJet + Python API。

根据项目需求和技术栈选择合适的工具，能大幅提升后台管理系统的开发效率！

github开源的即时通讯项目

Sat, 22 Mar 2025 10:01:00 +0800

以下是 GitHub 上当前活跃且功能强大的开源即时通讯（IM）项目，涵盖企业级解决方案、轻量级应用和创新型平台，适合不同开发需求：

🔧 一、企业级解决方案（高可用、可扩展）

OpenIM
- 技术栈：Go 语言服务端，支持 Android/iOS/Web/Flutter 等全平台 SDK 。
- 核心特性：
  - 私有化部署，数据完全自控，支持集群扩展至亿级用户。
  - 消息必达（100% 可靠性），支持单聊、群聊（10 万人超大群）、已读回执、消息撤回等。
  - 集成组织架构、工作圈、音视频通话，适合政企办公场景。
- 适用场景：替代商业 IM 云服务（如融云、环信），降低长期成本。
- 项目地址：GitHub - OpenIMSDK | 🌟 Star 9k+ 。

🖥️ 二、轻量级跨平台应用

HuLa
- 技术栈：基于 Tauri（Rust 跨平台框架） + Vue 3 + TypeScript，支持 Windows/macOS/Linux 。
- 核心特性：
  - 轻量高效（资源占用低），支持文字、语音、视频通话及文件传输。
  - 内置主题定制、表情包、群组管理，界面简洁易用。
- 适用场景：个人开发者快速构建桌面端聊天应用。
- 项目地址：GitHub - HuLaSpark。
Tailchat
- 技术栈：React + TypeScript + Node.js，插件化架构（类似 Discord）。
- 核心特性：
  - 高度可扩展的插件系统（30+ 官方插件），支持身份组权限管理、自定义面板。
  - 多端同步（Web/移动/桌面），集成开放平台（机器人、第三方登录）。
- 适用场景：社区协作、游戏社交等需定制化功能的场景。
- 项目地址：GitHub - Tailchat。

🔌 三、垂直场景与集成方案

基于环信 SDK 的社交应用
- 代表项目：高仿微信、图忆（LBS 社交）、美肤 GO（电商客服）。
- 特点：提供完整 UI 和业务逻辑源码，适合快速集成社交功能。
- 项目示例：GitHub - 环信 Demo 合集。
FreeTube（隐私向 IM 扩展）
- 技术栈：JavaScript 桌面应用，专注隐私保护。
- 特色：无广告、无追踪，本地存储用户数据，适合安全敏感场景。
- 项目地址：GitHub - FreeTube | 🌟 Star 15k+。

📊 核心项目对比

项目	技术优势	适用场景	部署复杂度
OpenIM	高并发、企业级功能全	政务/大型企业 IM	中高（需 Docker）
HuLa	轻量跨平台、开发快捷	个人/小团队桌面应用	低
Tailchat	插件化、高度可定制	社区/游戏社交平台	中

💡 四、选型建议

追求企业级稳定性：选择 OpenIM，支持私有化部署和国产化需求。
快速开发桌面端应用：HuLa 的现代前端技术栈（Vue3 + Tauri）可大幅提升效率。
需要高度定制化：Tailchat 的插件机制允许自由扩展功能。

💡 更多项目源码和部署指南可访问对应 GitHub 仓库。若需替代商业 IM 服务（如融云、环信），OpenIM 的私有化方案能显著降低成本并提升数据安全性。

开源桌面共享工具

Thu, 13 Feb 2025 21:35:00 +0800

1. xrdp

功能：xrdp 是一个开源的远程桌面协议 (RDP) 服务器，允许 Linux 系统通过 Windows 的 RDP 客户端远程访问。它与 Microsoft RDP 协议兼容，能够让你从 Windows 客户端连接到 Linux 系统。
安装：通常可以通过 Linux 的包管理器安装，例如在 Ubuntu 上使用命令：
1
sudo apt install xrdp

2. VNC (Virtual Network Computing)

功能：VNC 是一种图形桌面共享系统，支持跨平台远程访问。常见的开源 VNC 实现有：
- TightVNC：轻量级且性能优化。
- TigerVNC：增强了性能和安全性。
- RealVNC：提供商业和开源版本。
安装：可以通过包管理器（如 apt）安装，或通过下载其源代码来安装。

3. NoMachine

功能：NoMachine 是一款开源远程桌面解决方案，支持跨平台远程访问。它具有高性能和较低延迟，支持音视频流和文件传输等功能。
安装：可以直接从官网下载安装包，也可以通过官方的开源版本进行安装。

4. Remmina

功能：Remmina 是一个支持多种远程桌面协议的客户端，支持 RDP、VNC、SSH 等多种协议。它的设计非常适合 Linux 用户，但也支持其他操作系统。
安装：大多数 Linux 发行版都可以通过包管理器安装，例如：
1
sudo apt install remmina

5. FreeRDP

功能：FreeRDP 是一个开源的远程桌面协议实现，可以用作 RDP 客户端和服务器。它支持 Windows 和 Linux 系统之间的远程访问，并且非常轻量级。
安装：可以通过包管理器进行安装，例如：
1
sudo apt install freerdp2-x11

6. WayVNC

功能：WayVNC 是专门为 Wayland 兼容的 Linux 系统设计的 VNC 服务器，适用于那些使用 Wayland 显示服务器的系统。
安装：可以通过源码编译安装，或查找相关的 Linux 包。

7. Guacamole

功能：Guacamole 是一个基于 Web 的远程桌面客户端，支持 RDP、VNC 和 SSH。你可以通过浏览器访问并远程控制计算机，安装较为复杂，通常需要配置 Web 服务器。
安装：需要在服务器端安装 Guacamole，并配置相应的 Web 服务器。它支持各种操作系统。

白马寺

Wed, 05 Feb 2025 13:16:00 +0800

      白马寺

千年风霜斑驳目，新出寰宇客来慕。
佛丘已非今朝时，独得枯木逢春时。

composer内网部署

Sun, 12 Jan 2025 22:01:00 +0800

在内网环境中部署 Composer（PHP的依赖管理工具），通常是为了避免因外网访问限制而导致的依赖下载问题。内网部署 Composer 主要涉及配置一个私有 Composer 仓库，或者使用本地代理镜像来加速和管理依赖。

1. 使用 composer.json 设置依赖

首先，确保你的 composer.json 文件包含所有项目依赖，并正确配置了包的版本和来源。

{
    "name": "vendor/project",
    "require": {
        "monolog/monolog": "^2.0"
    }
}

2. 使用代理镜像

由于内网无法直接访问 Composer 官方的包仓库，常见的做法是使用国内镜像或搭建代理服务器，常见的方案包括使用阿里云 Composer 镜像或私有镜像仓库。

2.1 使用国内镜像源

你可以通过配置 Composer 使用国内镜像源来加速依赖包的下载。在 Composer 中，你可以使用下面的命令设置国内镜像：

1	composer config repo.packagist composer https://mirrors.aliyun.com/composer/

这个命令将 packagist.org 源更换为阿里云的镜像源。

你还可以通过在 composer.json 文件中进行设置，强制使用镜像源：

{
    "repositories": [
        {
            "type": "composer",
            "url": "https://mirrors.aliyun.com/composer/"
        }
    ]
}

这样每次执行 composer install 时，都会从阿里云的镜像源下载依赖。

2.2 配置自建 Composer 镜像代理

如果你想在企业内部完全控制包管理，可以搭建自己的 Composer 镜像代理。常见的选择包括：

Satis：一个官方提供的工具，用来搭建私有的 Composer 仓库。
Private Packagist：一个商业解决方案，专门用于在私有环境中管理 Composer 包。
Sinopia (npm 仓库代理工具)：可以作为私有的 Composer 仓库代理使用。

2.2.1 使用 Satis 搭建私有 Composer 仓库

Satis 是 Composer 官方提供的一个轻量级工具，专门用于创建私有的 Composer 仓库。通过使用 Satis，你可以将内网环境下常用的依赖缓存下来，并提供给项目中使用。

步骤：

安装 Satis：

使用 Composer 安装 Satis：

1	composer require composer/satis

配置 Satis：

在你的服务器上创建一个 satis.json 配置文件，指定你希望托管的包源。

{
    "name": "my-private-repo",
    "homepage": "https://example.com/packages",
    "repositories": [
        {
            "type": "vcs",
            "url": "https://github.com/some/package"
        },
        {
            "type": "composer",
            "url": "https://packagist.org"
        }
    ],
    "output-dir": "/path/to/output"
}

生成静态资源：

运行以下命令生成静态的 Composer 包：

1	php bin/satis build satis.json /path/to/output

提供访问：

你可以通过 Web 服务器（如 Nginx 或 Apache）提供访问静态资源。这样，其他项目就能通过你的内部 Satis 仓库获取依赖了。

2.2.2 配置 Composer 使用私有仓库

在 composer.json 中配置私有仓库（例如，你的公司内部搭建的 Satis 仓库）。

{
    "repositories": [
        {
            "type": "composer",
            "url": "http://your-internal-repository.com"
        }
    ]
}

这样，Composer 会从你配置的私有仓库中拉取依赖。

3. 离线安装 Composer 依赖

如果内网无法访问外部网络，也可以考虑在有外网访问权限的机器上下载依赖包，然后将它们导入到内网机器中进行安装。

3.1 在有外网的机器上下载依赖

在能够访问外网的机器上执行 composer install。
下载完成后，将 vendor 目录及 composer.lock 文件拷贝到内网服务器相同位置。

3.2 使用 —prefer-dist 参数

你还可以使用 composer install —prefer-dist 来下载 .tar.gz 或 .zip 格式的包，这样可以方便地进行离线安装。

3.3 配置 COMPOSER_HOME

如果你希望在内网机器上使用本地缓存的包，可以设置 COMPOSER_HOME 环境变量来指定 Composer 缓存目录。

1	export COMPOSER_HOME=/path/to/composer/cache

然后，将缓存目录复制到内网机器，确保 Composer 能够使用这些缓存。

4. 其他考虑

代理配置：如果内网可以通过 HTTP 代理访问外网，确保 Composer 配置了代理。在 composer.json 中配置代理，或者使用环境变量来指定代理：

1 2	export HTTP_PROXY=http://proxy.example.com:8080 export HTTPS_PROXY=http://proxy.example.com:8080

私有包的权限：如果你使用了私有 Composer 仓库或 GitHub 仓库，记得配置好认证方式（如使用 auth.json 文件存储 GitHub Token）。

农业检测系统设计

Fri, 10 Jan 2025 22:34:00 +0800

农业检测系统设计

根据你的需求，我们将设计一个智能农业系统，通过多种技术手段实现温湿度、光照度监测、设备控制和远程管理。系统的核心功能包括：智能节点监控环境数据、手动和自动控制模式、通过 LoRa 和 4G 通信传输数据、以及通过手机或电脑端进行远程控制。

1. 系统模块概述

该农业检测系统包括以下几个主要模块：

智能节点（传感器与控制单元）：
- 获取温湿度、光照度传感器数据。
- 控制风扇的启停，显示当前风扇状态。
- 支持手动和自动模式切换。
- 显示温湿度、光照度、风扇状态和模式状态。
- 通过 LoRa 发送数据到 4G 节点。
4G 网关节点：
- 接收来自智能节点的传感器数据。
- 将数据通过 4G 网络上传至 MOTT 服务器。
- 在显示屏上显示各项传感器数据。

MOTT 服务器：
- 存储从 4G 节点发送来的数据。
- 提供远程访问接口。
应用软件（电脑端或手机端）：
- 显示温湿度、光照度、风扇状态、手动/自动模式等数据。
- 提供登录、手动控制、自动控制等功能。

2.系统功能设计

2.1 智能节点功能

传感器数据采集：
- 温湿度传感器：实时获取温度和湿度数据。
- 光照度传感器：实时获取光照强度数据。

模式切换：
- 手动模式：允许用户通过按键手动启动或停止风扇。
- 自动模式：当温度和光照度超过设定阈值时，自动启停风扇。
风扇控制：
- 在手动模式下，用户通过按键控制风扇开关，并通过绿色 LED 指示灯显示风扇状态。
- 在自动模式下，系统会根据设定的温度和光照度阈值自动控制风扇，并使用绿灯和红灯进行状态指示。
数据传输：
- 使用 LoRa 无线传输模块将传感器数据和风扇状态上传至 4G 网关节点。
显示屏：
- 显示当前温湿度、光照度、模式状态和风扇状态。

2.2 4G 网关节点功能

数据接收：
- 通过 LoRa 接收智能节点上传的传感器数据（温度、湿度、光照度、风扇状态、手动/自动模式状态）。

4G 网络传输：
- 将智能节点的数据通过 4G 网络上传至 MOTT 服务器。
显示屏显示：
- 在 4G 网关节点的显示屏上展示温湿度、光照度、模式状态和风扇状态。

2.3 MOTT 服务器功能

数据存储：
- 存储来自 4G 网关节点的温湿度、光照度、风扇状态等数据。

远程管理接口：
- 提供 RESTful API 或 WebSocket 接口，供客户端应用访问。

2.4 应用软件功能

用户登录：
- 提供登录界面，用户通过输入用户名和密码登录（用户名：admin，密码：admin123）。

手动控制：
- 登录成功后，用户可通过界面手动启停风扇，操作时触发红灯和蜂鸣器的提示。
自动控制：
- 用户可以设定温度和光照度的阈值，智能节点进入自动模式后，系统根据传感器数据自动控制风扇开关，并通过 LED 指示灯显示状态。
显示功能：
- 实时显示温度、湿度、光照度、风扇状态、手动/自动模式状态。

3. 原型图设计

3.1 智能节点原型图

+-------------------------+
|    温湿度传感器          |
|                         |
|    光照度传感器          |
|                         |
|    按键面板 (5个按键)    |
|                         |
|    显示屏 (LCD)          |
|                         |
|    风扇控制 (LED/蜂鸣器) |
+-------------------------+

显示屏：显示温度、湿度、光照度、当前模式（手动/自动）和风扇状态。
按键面板：5个按键，其中包括：
- 切换模式按键（手动/自动）
- 启动风扇的控制按键
- 停止风扇的控制按键
LED 灯：指示风扇是否正在运行（绿色为运行，红色为停止）。
蜂鸣器：在风扇运行时以 1Hz 的频率发出声音。

3.2 4G 网关节点原型图

+-------------------------+
|    LoRa 接收模块        |
|    (接收数据)           |
|                         |
|    显示屏 (LCD)          |
|                         |
|    4G 网络模块          |
|    (上传数据)           |
+-------------------------+

显示屏：显示温湿度、光照度、模式状态和风扇状态。
LoRa 接收模块：接收智能节点发送的传感器数据。
4G 网络模块：将接收到的数据上传到 MOTT 服务器。

3.3 应用软件原型图（电脑端或手机端）

+-------------------------------------------------------+
| 登录界面                                               |
|   - 用户名输入框                                        |
|   - 密码输入框                                          |
|   - 登录按钮                                            |
+-------------------------------------------------------+
| 主界面                                                 |
|   - 实时显示温湿度、光照度、风扇状态、手动/自动模式   |
|   - 手动控制按钮 (启动/停止风扇)                       |
|   - 自动模式阈值设置 (温度、光照度)                    |
|   - 状态显示：当前模式（手动/自动）、风扇状态（开/关）|
+-------------------------------------------------------+

4. 系统设计步骤

4.1 硬件设计与开发

选择适当的传感器：温湿度传感器（如 DHT22）、光照度传感器、风扇控制模块、LED 指示灯、蜂鸣器。
智能节点电路设计：设计电源管理电路，确保所有传感器和控制组件能正常工作。
LoRa 模块集成：将 LoRa 模块集成到智能节点中，实现数据的无线传输。

4.2 软件开发

智能节点程序：
- 编写代码获取传感器数据。
- 控制风扇及 LED 指示灯。
- 实现手动与自动模式的切换。
- 实现 LoRa 数据发送功能。

4G 网关节点程序：
- 接收 LoRa 数据并通过 4G 网络上传至 MOTT 服务器。
MOTT 服务器开发：
- 提供数据存储和远程管理接口（API）。
应用软件开发：
- 实现用户登录、手动控制、自动控制、数据展示等功能。

4.3 系统集成与测试

硬件集成：将传感器、LoRa 模块、显示屏等硬件连接至智能节点和 4G 网关节点。
功能测试：测试手动模式、自动模式、数据传输功能等。
性能优化：确保系统在实时数据传输和控制中的稳定性。

4.4 部署与维护

部署智能节点和 4G 网关：将系统部署到实际农业环境中，进行现场测试和调试。
维护与更新：定期检查系统，进行必要的功能更新和优化。

php串口开发

Fri, 03 Jan 2025 15:30:00 +0800

使用外置设备，通过串口发送和接收数据。那么，就要在php端有个串口的操作代码。
PHP 的 dio 扩展（Direct I/O）提供了对底层 I/O 操作的访问，包括串口通信。通过 dio 扩展，你可以直接操作串口设备文件（如 /dev/ttyUSB0 或 COM1）来实现串口通信。

1. 安装 dio 扩展

dio 扩展是 PHP 的一个 PECL 扩展。你可以通过以下步骤安装：

在 Linux 上安装：

1
2
3

sudo apt-get install php-dev  # 安装 PHP 开发工具
sudo pecl install dio         # 安装 dio 扩展

安装完成后，在 php.ini 文件中启用扩展：

1 2	extension=dio.so

2. 使用 dio 实现串口通信

以下是一个使用 dio 扩展实现串口通信的示例代码：

<?php
// 串口设备路径
$device = '/dev/pts/4'; // Linux
// $device = 'COM1';      // Windows

// 打开串口设备
$fd = dio_open($device, O_RDWR | O_NOCTTY | O_NONBLOCK);

if (!$fd) {
    die("无法打开串口设备: $device\n");
}

// 配置串口参数
dio_tcsetattr($fd, [
    'baud' => 9600,          // 波特率
    'bits' => 8,             // 数据位
    'stop' => 1,             // 停止位
    'parity' => 0,           // 校验位 (0: none, 1: odd, 2: even)
    'flow_control' => 0,     // 流控制 (0: none, 1: hardware)
]);

// 发送数据到串口
$message = "你好我在https://erik.xyz上出生了！";
dio_write($fd, $message);
echo "已发送: $message";

// 从串口读取数据
$data = dio_read($fd, 1024); // 读取最多 1024 字节
echo "已接收: $data\n";

// 关闭串口
dio_close($fd);
?>

3. 代码说明

dio_open: 打开串口设备文件。O_RDWR 表示以读写模式打开，O_NOCTTY 表示不将设备作为控制终端，O_NONBLOCK 表示非阻塞模式。
dio_tcsetattr: 配置串口参数，包括波特率、数据位、停止位、校验位和流控制。
dio_write: 向串口写入数据。
dio_read: 从串口读取数据。
dio_close: 关闭串口设备。

4. 串口参数配置

dio_tcsetattr 的配置选项：
baud: 波特率（如 9600、19200、38400、57600、115200）。
bits: 数据位（通常为 8）。
stop: 停止位（1 或 2）。
parity: 校验位（0: 无校验，1: 奇校验，2: 偶校验）。
flow_control: 流控制（0: 无流控制，1: 硬件流控制）。

那么这时候需要测试一下代码。那总不能真的找个串口设备吧，然而虚拟串口真香。

5.在Linux中使用 socat 模拟虚拟串口

socat 是一个强大的工具，可以创建虚拟串口对。

安装 socat：
在Debian/Ubuntu系统上：

1 2	sudo apt update sudo apt install socat

创建虚拟串口对：
运行以下命令创建一对虚拟串口：

1	socat -d -d pty,raw,echo=0 pty,raw,echo=0

运行后如图：

这样可以看到出现两个虚拟串口。
把上面的php代码放到文件中运行一下:

同时新开个窗口执行：cat /dev/pts/5来读取串口数据。
如下图：

这里是发送数据，那接收数据怎么看呢。
那就在代码上改造一下加个for：

1
2
3

// 从串口读取数据
$data = dio_read($fd, 1024); // 读取最多 1024 字节
echo "已接收: $data\n";

这里改造主要是测试用，实际上不需要。

//测试接收
for($i=0;$i<20;$i++){
    sleep(3);
// 从串口读取数据
$data = dio_read($fd, 1024); // 读取最多 1024 字节
echo "已接收: $data\n";
}

那么，再次运行php代码,然后在新窗口运行echo "欢迎你出生在https://erik.xyz" > /dev/pts/5来发送信息，你会看到如图的接收：

到这里，发送和接收串口已经好了。

maven内网库

Wed, 18 Dec 2024 20:55:00 +0800

1. 搭建 Maven 私有仓库

首先，需要在内网环境中搭建一个 Maven 仓库，常用的私有 Maven 仓库工具有：

Nexus Repository：Sonatype Nexus 是最流行的私有 Maven 仓库管理工具。
Artifactory：JFrog Artifactory 是另一种流行的构建管理工具，提供了私有仓库的支持。
Apache Archiva：Apache Archiva 也是一个支持 Maven 的仓库管理工具。

以下是搭建 Nexus Repository 的简单步骤：

1.1 安装 Nexus Repository

下载 Nexus：访问 Nexus Repository 下载页面下载 Nexus OSS 版本。
解压并启动：解压下载的压缩包并启动 Nexus。

1
2
3


cd /opt/nexus/bin
./nexus start

访问 Nexus UI：打开浏览器，访问 Nexus 的默认地址：

1	http://localhost:8081

默认用户名为 admin，密码为 admin123，可以在首次登录后修改密码。

1.2 配置 Maven 仓库

在 Nexus UI 中，你可以创建一个新的 Maven 仓库。创建仓库后，你可以上传公司的内部依赖、插件和构建工件。

2. 配置 Maven 使用内网仓库

配置 Maven 使用内网仓库需要修改 settings.xml 文件。

2.1 修改 settings.xml

在 Maven 的 settings.xml 文件中，配置私有仓库的地址和认证信息。settings.xml 文件通常位于 ~/.m2/ 目录下（用户级别配置）或者 ${MAVEN_HOME}/conf/ 目录下（全局配置）。

以下是配置内网 Maven 仓库的示例：

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

    <mirrors>
        <!-- 配置私有仓库镜像 -->
        <mirror>
            <id>nexus</id>
            <mirrorOf>external:http://central</mirrorOf>
            <url>http://your-nexus-server:8081/repository/maven-public/</url>
            <blocked>false</blocked>
        </mirror>
    </mirrors>

    <repositories>
        <repository>
            <id>internal-repo</id>
            <url>http://your-nexus-server:8081/repository/maven-releases/</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>internal-plugins</id>
            <url>http://your-nexus-server:8081/repository/maven-plugins/</url>
        </pluginRepository>
    </pluginRepositories>

    <servers>
        <!-- 配置 Maven 仓库认证 -->
        <server>
            <id>nexus</id>
            <username>your-nexus-username</username>
            <password>your-nexus-password</password>
        </server>
    </servers>
</settings>

2.2 配置镜像和仓库

镜像（Mirror）：在标签中配置私有仓库的 URL，将 Maven 的中央仓库或其他公共仓库的请求代理到私有仓库中。通过 mirrorOf 配置来选择代理哪些仓库（external:http://central 表示代理所有外部仓库）。
仓库（Repository）：在和标签中配置你的内网仓库的 URL。
认证（Server Authentication）：在标签中配置内网仓库的认证信息（如果仓库需要认证）。

3. 配置项目使用内网仓库

在项目的 pom.xml 文件中，通常不需要额外配置仓库，因为 Maven 会使用 settings.xml 中配置的内网仓库。但是如果需要强制指定某个仓库，可以在 pom.xml 中配置标签：

<repositories>
    <repository>
        <id>nexus-repo</id>
        <url>http://your-nexus-server:8081/repository/maven-releases/</url>
    </repository>
</repositories>

4. 上传和下载依赖

4.1 上传依赖到内网仓库
你可以通过 Maven 命令将本地构建的 JAR 文件上传到内网仓库。例如，将某个 JAR 上传到 Nexus：

mvn deploy:deploy-file \
    -DgroupId=com.example \
    -DartifactId=my-artifact \
    -Dversion=1.0.0 \
    -Dpackaging=jar \
    -Dfile=path/to/your-artifact.jar \
    -DrepositoryId=nexus \
    -Durl=http://your-nexus-server:8081/repository/maven-releases/

4.2 从内网仓库下载依赖

配置好内网仓库后，Maven 会自动从内网仓库下载依赖。如果仓库中没有该依赖，Maven 会尝试从其他配置的仓库下载。

5. 使用私有仓库中的依赖

一旦仓库配置好，Maven 将会从配置的内网仓库下载依赖。你可以在项目的 pom.xml 中正常引用依赖，Maven 会自动从私有仓库中拉取。

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>my-artifact</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

6. 配置镜像以提高构建速度（可选）

为了提高构建速度，你可以配置 settings.xml 来使用私有仓库作为 Maven 的默认镜像，确保所有的构建依赖都从私有仓库中拉取，避免每次访问外部仓库，降低构建时间。

spring boot内网部署

Thu, 12 Dec 2024 18:22:18 +0800

1. 准备环境

确保内网中的服务器或机器具备运行 Spring Boot 应用的基本环境：

JDK：确保服务器安装了合适版本的 JDK（通常建议使用 Java 8 及以上版本）。
Maven/Gradle：根据项目使用的构建工具安装 Maven 或 Gradle。
数据库：如果应用需要连接数据库，确保数据库在内网中可访问，且连接配置正确。

2. 编译 Spring Boot 应用

首先，你需要编译你的 Spring Boot 应用，生成可执行的 JAR 文件。可以通过以下命令在项目目录下执行：

Maven 构建命令：

1 2	mvn clean package

Gradle 构建命令：

1	./gradlew build

这会在 target/ 或 build/libs/ 目录下生成一个可执行的 JAR 文件，通常名为 your-application-name.jar。

3. 传输 JAR 到内网服务器

将生成的 JAR 文件上传到内网的目标服务器。可以使用各种文件传输工具，比如：

SCP（如果服务器支持 SSH）：

1	scp your-application-name.jar user@server-ip:/path/to/deploy/

FTP 或 SFTP（如果有配置 FTP 服务）。

4. 配置 Spring Boot 应用

在内网部署时，你可能需要根据环境修改配置文件，比如 application.properties 或 application.yml。常见的配置项包括：

数据库连接信息（spring.datasource.url、spring.datasource.username 等）。
日志配置。
服务端口（server.port）。
安全设置（如禁用外部访问，或者设置访问白名单等）。

例如，修改 application.properties 中的数据库配置：

1
2
3

spring.datasource.url=jdbc:mysql://localhost:3306/your_db
spring.datasource.username=db_user
spring.datasource.password=db_password

5. 启动 Spring Boot 应用

在内网服务器上，使用以下命令启动 Spring Boot 应用：

1	java -jar your-application-name.jar

如果你希望应用在后台运行，可以使用 nohup 或者类似的工具：

1	nohup java -jar your-application-name.jar > output.log 2>&1 &

这会将输出重定向到 output.log 文件，并让应用在后台运行。

6. 配置防火墙和网络

确保服务器的防火墙允许访问应用所绑定的端口（默认是 8080）。如果使用其他端口，可以在防火墙中配置允许访问该端口。
如果 Spring Boot 应用需要通过内网的特定 IP 地址或域名访问，确保 DNS 或 hosts 配置正确。

7. 监控和日志

日志：Spring Boot 应用会将日志输出到控制台，你可以将日志配置为输出到文件中进行持久化存储。常见做法是在 application.properties 或 application.yml 中设置日志路径：

1	logging.file.name=/path/to/logs/application.log

监控：可以使用 Spring Boot 的 Actuator 或其他监控工具（如 Prometheus 和 Grafana）来监控应用的运行状态。

8. 设置开机启动（可选）

如果希望应用在服务器重启时自动启动，可以使用 systemd（Linux 系统）或配置为 Windows 服务。

Linux 系统 (Systemd)

创建一个 systemd 服务文件，如 /etc/systemd/system/yourapp.service：

[Unit]
Description=Spring Boot Application
After=network.target

[Service]
User=your_user
ExecStart=/usr/bin/java -jar /path/to/your-application-name.jar
SuccessExitStatus=143
Restart=always

[Install]
WantedBy=multi-user.target

然后启用并启动服务：

1 2	sudo systemctl enable yourapp sudo systemctl start yourapp

艾瑞可erik • Posts by "undefined" categories

『uni-app、小程序』蓝牙连接、读写数据全过程

思路

大致思路

初始化阶段

搜寻附近设备

连接目标设备

监听

第一步，获取蓝牙服务

第二步，获取指定服务的特征值

第三、四步，开启消息监听 并 接收消息监听传来的数据

发送指令

开发语言应用场景与学习方向解析

📊 一、语言对比概览表

🔍 二、分语言详解

1. PHP

2. Go

3. Rust

4. C

5. C++

6. Java

7. C#

8. Qt（C++框架）

💎 三、总结建议

Spark、Hive、Hadoop选择与组合使用指南

核心定位与区别

如何选择？

典型的组合使用模式

总结与关键建议

virtualbox与hyper-v的冲突

PLC基础概念与应用场景详解

一、自学必备基础准备

📚 二、分阶段学习路线（附资源）

▶ 阶段1：PLC核心概念筑基（1-2周）

▶ 阶段2：编程语言实战（重点！3-6周）

▶ 阶段3：硬件实操（核心环节！）

▶ 阶段4：工业通信与高级应用（2-3个月）

🔧 三、避坑指南（血泪经验！）

🌐 四、持续进阶资源

🚀 五、就业能力转化建议

php架构方面的设计与思考（三）

完整架构调用流程示例

php 架构方面的设计与思考（二）

一、服务注册中心增强实现（Consul + PHP）

二、API 网关深度集成（Kong + OpenResty）

三、配置中心完整方案（Apollo + PHP）

四、服务总线可靠消息方案（RabbitMQ）

五、服务降级完整策略

六、部署架构优化方案

php架构方面的设计与思考（一）

一、架构核心模块与实现技术选型

二、各模块具体实现方案

三、完整架构部署方案

四、关键组件安装与配置

五、生产环境建议

六、PHP微服务开发工具包

EMM与MDM系统详解

php开发捕鱼游戏的构思

一、系统设计

二、核心功能实现

1. 数据库设计（MySQL）

2. PHP后端逻辑（结合前端交互）

3. 前端核心实现（JavaScript）

三、游戏功能扩展建议

四、部署注意事项

webman和hyperf对比解析

1. webman 底层原理

核心原理剖析

2. Hyperf 底层原理

核心原理剖析

3. PHP 注解 (Annotations) 原理

实现原理 (重点在框架如何利用)

webman vs Hyperf 核心原理对比摘要

python后端管理框架有哪些

1. 基于 Django 的框架

2. 基于 Flask 的框架

3. 独立/通用框架

4. 基于 FastAPI 的框架

5. 低代码/可视化工具

选择建议

第三、四步，开启消息监听并接收消息监听传来的数据