前言

2024-2025年，AI辅助编程工具迎来爆发式增长。本文对比三款主流工具：Cursor、Claude（计划任务模式）和Kiro，帮助开发者选择适合自己的工具。

工具概览

Cursor

简介

Cursor是基于VS Code的AI增强IDE，集成了GPT-4等大模型，提供智能代码补全和对话式编程。

核心功能

1. Tab补全

1
2
3
4
5
6

# 输入函数签名，Tab自动补全实现
def calculate_fibonacci(n):
    # Cursor自动补全↓
    if n <= 1:
        return n
    return calculate_fibonacci(n-1) + calculate_fibonacci(n-2)

2. Cmd+K 内联编辑
选中代码，按Cmd+K描述修改需求，AI直接修改代码。

3. Chat对话
在侧边栏与AI对话，可以引用文件、代码片段进行讨论。

优势

• 无缝集成VS Code生态
• 代码补全速度快
• 支持多种模型切换

局限

• 对复杂任务缺乏规划能力
• 上下文管理需要手动控制

Claude 计划任务模式

简介

Claude的计划任务模式（Artifacts + Projects）支持结构化的任务分解和执行。

工作流程

1
2
3
4
5
6
7
8
9
10
11

1. 任务分析
   └── Claude分析需求，生成任务计划

2. 计划确认
   └── 用户审核并调整计划

3. 逐步执行
   └── 按计划逐个完成任务

4. 结果整合
   └── 汇总所有产出物

使用示例

提示词模板：

1
2
3
4
5
6
7

我需要开发一个用户认证模块，请帮我：
1. 分析需求并列出功能点
2. 设计技术方案
3. 分步骤实现代码
4. 编写测试用例

请先给出计划，等我确认后再开始执行。

Claude响应：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

## 任务计划

### 阶段1：需求分析
- 用户注册功能
- 用户登录功能
- Token管理
- 密码重置

### 阶段2：技术设计
- JWT认证方案
- 数据库设计
- API接口设计

### 阶段3：代码实现
- [ ] 用户模型
- [ ] 认证服务
- [ ] API路由
- [ ] 中间件

### 阶段4：测试
- [ ] 单元测试
- [ ] 集成测试

请确认计划，我将开始执行。

优势

• 任务分解清晰
• 支持复杂项目
• 可以中途调整计划

局限

• 需要手动管理文件
• 无法直接操作本地代码

Kiro

简介

Kiro是AWS推出的AI IDE，核心特色是Spec驱动开发（Spec-Driven Development），通过规范化的需求→设计→任务流程来开发功能。

核心概念：Spec

Spec是Kiro的核心工作流，包含三个文档：

1
2
3
4

.kiro/specs/{feature-name}/
├── requirements.md    # 需求文档
├── design.md         # 设计文档
└── tasks.md          # 任务清单

工作流程

1. 需求阶段 (requirements.md)

使用EARS模式编写需求：

1
2
3
4
5
6
7

### Requirement 1
**User Story:** As a user, I want to login, so that I can access my account.

#### Acceptance Criteria
1. WHEN user enters valid credentials THEN the system SHALL authenticate and redirect to dashboard
2. WHEN user enters invalid credentials THEN the system SHALL display error message
3. IF user fails login 5 times THEN the system SHALL lock the account for 30 minutes

2. 设计阶段 (design.md)

包含架构、组件、数据模型和正确性属性：

1
2
3
4
5
6
7
8

## Architecture
- JWT-based authentication
- Redis session storage

## Correctness Properties
Property 1: Login round-trip
*For any* valid user credentials, login then verify token should return the same user
**Validates: Requirements 1.1**

3. 任务阶段 (tasks.md)

可执行的任务清单：

1
2
3
4
5
6
7

- [ ] 1. Setup authentication module
  - [ ] 1.1 Create User model
  - [ ] 1.2 Implement JWT service
  - [ ]* 1.3 Write property tests for JWT
- [ ] 2. Implement login API
  - [ ] 2.1 Create login endpoint
  - [ ] 2.2 Add rate limiting

Kiro特色功能

Steering（引导规则）

1
2
3
4

<!-- .kiro/steering/coding-standards.md -->
- Use TypeScript strict mode
- Follow REST API naming conventions
- All functions must have JSDoc comments

Hooks（自动化钩子）

• 保存文件时自动运行测试
• 提交代码时检查规范

优势

• 结构化开发流程
• 需求可追溯
• 支持属性测试
• 任务可逐个执行

局限

• 学习曲线较陡
• 小任务可能过于繁琐

三款工具对比

使用建议

选择Cursor当：

• 日常编码，需要快速补全
• 小型修改和重构
• 熟悉VS Code生态

选择Claude当：

• 需要讨论和分析问题
• 学习新技术
• 生成独立代码片段

选择Kiro当：

• 开发完整功能模块
• 需要需求追溯
• 团队协作开发
• 重视代码质量和测试

组合使用策略

1
2
3
4
5

日常开发流程：
1. Kiro: 创建Spec，规划功能
2. Kiro: 执行任务，生成代码框架
3. Cursor: 快速补全细节代码
4. Claude: 讨论复杂问题，优化方案

未来展望

AI辅助编程正在从”代码补全”向”智能协作”演进：

• 更强的上下文理解：理解整个项目
• 更好的任务规划：自动分解复杂任务
• 更深的集成：与CI/CD、测试框架深度集成
• 团队协作：多人协作的AI辅助

总结

三款工具各有特色：

• Cursor：最佳代码补全体验
• Claude：最佳对话和分析能力
• Kiro：最佳结构化开发流程

建议根据任务类型灵活选择，甚至组合使用，发挥各自优势。

参考资料

• Cursor官网
• Claude官网
• Kiro官网
• Spec-Driven Development介绍

评论和共享

前言

RuoYi-Cloud是基于Spring Cloud的微服务权限管理系统，采用前后端分离架构。本文介绍如何使用Nacos进行微服务管理，以及单机调试与微服务模式部署的方法。

技术栈

项目结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ruoyi-cloud/
├── ruoyi-api/                    # API模块
│   ├── ruoyi-api-system/        # 系统API
│   └── ruoyi-api-file/          # 文件API
├── ruoyi-auth/                   # 认证中心
├── ruoyi-common/                 # 通用模块
│   ├── ruoyi-common-core/       # 核心模块
│   ├── ruoyi-common-redis/      # Redis模块
│   ├── ruoyi-common-security/   # 安全模块
│   └── ruoyi-common-swagger/    # Swagger模块
├── ruoyi-gateway/                # 网关服务
├── ruoyi-modules/                # 业务模块
│   ├── ruoyi-system/            # 系统模块
│   ├── ruoyi-gen/               # 代码生成
│   ├── ruoyi-job/               # 定时任务
│   └── ruoyi-file/              # 文件服务
├── ruoyi-visual/                 # 可视化模块
│   └── ruoyi-monitor/           # 监控中心
└── ruoyi-ui/                     # 前端项目

自定义模块结构

按照你提供的结构，创建自定义业务模块：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

${artifactId}/
├─ pom.xml                           # 根pom（带profiles）
├─ ${artifactId}-api/                # API聚合模块
│   ├─ ${artifactId}-local-api/      # 单机启动模块
│   │   ├─ pom.xml
│   │   └─ src/main/java/...
│   ├─ ${artifactId}-cloud-api/      # 微服务启动模块
│   │   ├─ pom.xml
│   │   └─ src/main/java/...
│   └─ pom.xml
├─ ${artifactId}-biz/                # 业务逻辑模块
│   ├─ pom.xml
│   └─ src/main/java/...
└─ ${artifactId}-start/              # 启动模块
    ├─ pom.xml
    └─ src/main/java/...

Nacos配置

1. 安装Nacos

1
2
3
4
5
6
7
8
9
10

# 下载Nacos
wget https://github.com/alibaba/nacos/releases/download/2.2.0/nacos-server-2.2.0.tar.gz
tar -xvf nacos-server-2.2.0.tar.gz
cd nacos/bin

# 单机模式启动
./startup.sh -m standalone

# Windows
startup.cmd -m standalone

访问 http://localhost:8848/nacos，默认账号密码：nacos/nacos

2. 服务注册配置

1
2
3
4
5
6
7
8
9
10
11
12
13

# application.yml
spring:
  application:
    name: ruoyi-system
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev
      config:
        server-addr: 127.0.0.1:8848
        namespace: dev
        file-extension: yml

3. 配置中心使用

在Nacos控制台创建配置：

• Data ID: ruoyi-system-dev.yml
• Group: DEFAULT_GROUP

1
2
3
4
5
6
7
8
9
10

# Nacos配置内容
server:
  port: 9201

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ry-cloud?useUnicode=true
    username: root
    password: password

单机调试模式

Profile配置

根pom.xml配置profiles：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<profiles>
    <!-- 单机模式 -->
    <profile>
        <id>local</id>
        <properties>
            <profile.active>local</profile.active>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <!-- 微服务模式 -->
    <profile>
        <id>cloud</id>
        <properties>
            <profile.active>cloud</profile.active>
        </properties>
    </profile>
</profiles>

单机启动配置

application-local.yml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

spring:
  profiles:
    active: local
  cloud:
    nacos:
      discovery:
        enabled: false  # 禁用服务注册
      config:
        enabled: false  # 禁用配置中心

# 直接配置数据源
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ry-cloud
    username: root
    password: password

单机启动命令

1
2
3
4

# 使用local profile启动
mvn spring-boot:run -Plocal

# 或者IDEA中设置Active Profiles为local

微服务模式部署

1. 启动顺序

1
2
3
4
5
6

1. Nacos (服务注册与配置中心)
2. MySQL + Redis
3. ruoyi-gateway (网关)
4. ruoyi-auth (认证中心)
5. ruoyi-system (系统服务)
6. 其他业务服务

2. Docker Compose部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

version: '3'
services:
  nacos:
    image: nacos/nacos-server:v2.2.0
    environment:
      - MODE=standalone
    ports:
      - "8848:8848"
    
  mysql:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=root
    ports:
      - "3306:3306"
    
  redis:
    image: redis:6.0
    ports:
      - "6379:6379"
    
  ruoyi-gateway:
    build: ./ruoyi-gateway
    ports:
      - "8080:8080"
    depends_on:
      - nacos
      
  ruoyi-auth:
    build: ./ruoyi-auth
    depends_on:
      - nacos
      - redis
      
  ruoyi-system:
    build: ./ruoyi-modules/ruoyi-system
    depends_on:
      - nacos
      - mysql

3. 微服务启动命令

1
2
3
4
5
6
7
8

# 使用cloud profile启动
mvn spring-boot:run -Pcloud

# 打包
mvn clean package -Pcloud

# 运行jar
java -jar ruoyi-gateway.jar --spring.profiles.active=cloud

服务调用

Feign客户端定义

1
2
3
4
5
6
7
8
9

// ruoyi-api-system模块
@FeignClient(contextId = "remoteUserService", 
             value = "ruoyi-system",
             fallbackFactory = RemoteUserFallbackFactory.class)
public interface RemoteUserService {
    
    @GetMapping("/user/info/{username}")
    R<LoginUser> getUserInfo(@PathVariable("username") String username);
}

服务调用

1
2
3
4
5
6
7
8
9
10
11

@Service
public class SysLoginService {
    
    @Autowired
    private RemoteUserService remoteUserService;
    
    public LoginUser login(String username) {
        R<LoginUser> result = remoteUserService.getUserInfo(username);
        return result.getData();
    }
}

常见问题

1. Nacos连接失败

检查Nacos是否启动，namespace是否正确配置

2. 服务注册不上

检查spring.application.name是否配置，网络是否通畅

3. 配置不生效

确认Data ID格式：${spring.application.name}-${profile}.${file-extension}

总结

RuoYi-Cloud通过Nacos实现了服务注册与配置管理，支持单机和微服务两种部署模式。开发时使用单机模式方便调试，生产环境使用微服务模式实现高可用。

参考资料

• RuoYi-Cloud官方文档
• Nacos官方文档
• Spring Cloud Alibaba

评论和共享

什么是OKR

OKR（Objectives and Key Results）即目标与关键结果法，是一套明确和跟踪目标及其完成情况的管理工具和方法。由Intel发明，后被Google、Facebook等公司广泛采用。

OKR的组成

• O (Objective)：目标，你想要达成什么
• KR (Key Results)：关键结果，如何衡量目标的达成

OKR vs KPI

OKR制定原则

1. Objective 目标原则

• 鼓舞人心：目标应该能激励团队
• 可达成但有挑战：不是轻易能完成的
• 定性描述：用文字描述，不是数字
• 时间限定：通常为一个季度

2. Key Results 关键结果原则

• 可量化：必须是可衡量的数字
• 有挑战性：完成60-70%算成功
• 3-5个为宜：每个O对应3-5个KR
• 结果导向：关注结果而非过程

OKR实践案例

案例一：技术团队OKR

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

【Q3 技术团队OKR】

O1: 提升系统稳定性，打造高可用服务
├── KR1: 系统可用性从99.5%提升到99.9%
├── KR2: P0故障数量从每月3次降低到0次
├── KR3: 平均故障恢复时间从30分钟降低到10分钟
└── KR4: 完成核心服务的容灾演练，覆盖率100%

O2: 提升研发效率，加速产品迭代
├── KR1: 需求平均交付周期从14天缩短到7天
├── KR2: 代码review覆盖率从60%提升到100%
├── KR3: 自动化测试覆盖率从40%提升到80%
└── KR4: 部署频率从每周1次提升到每天1次

O3: 建设技术影响力，打造学习型团队
├── KR1: 团队成员人均输出技术文章2篇
├── KR2: 组织内部技术分享会8次
└── KR3: 完成新人培训体系搭建，新人上手时间缩短50%

案例二：产品经理OKR

1
2
3
4
5
6
7
8
9
10
11
12

【Q3 产品经理OKR】

O1: 提升用户体验，打造极致产品
├── KR1: 用户满意度NPS从30提升到50
├── KR2: 核心功能用户留存率从40%提升到60%
├── KR3: 用户反馈处理率达到100%，平均响应时间<24小时
└── KR4: 完成3次用户调研，产出调研报告

O2: 驱动业务增长，实现商业价值
├── KR1: 付费转化率从2%提升到5%
├── KR2: 用户ARPU值从50元提升到80元
└── KR3: 新功能上线后DAU增长20%

案例三：个人OKR

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

【Q3 个人OKR - 后端开发工程师】

O1: 成为团队核心骨干，独当一面
├── KR1: 独立负责完成2个核心模块的设计与开发
├── KR2: 代码质量评分从B提升到A（bug率<1%）
└── KR3: 主导完成1次技术方案评审

O2: 提升技术深度，建立技术壁垒
├── KR1: 深入学习分布式系统，完成《DDIA》读书笔记
├── KR2: 输出2篇高质量技术博客
└── KR3: 获得1项云计算相关认证

O3: 提升软技能，增强团队协作
├── KR1: 主动帮助2名新同事完成onboarding
├── KR2: 参与跨团队项目协作，获得合作方好评
└── KR3: 完成1次团队内部技术分享

OKR实施流程

1. 制定阶段（季度初）

1
2
3
4
5
6
7
8
9

第1周：
├── 公司层面确定年度/季度战略目标
├── 各部门负责人制定部门OKR
└── 团队成员制定个人OKR

第2周：
├── OKR对齐会议，确保上下一致
├── 横向对齐，确保跨部门协作
└── 最终确认并公示所有OKR

2. 执行阶段（季度中）

1
2
3
4
5
6
7
8
9

每周：
├── 周会回顾OKR进展
├── 更新KR完成进度
└── 识别风险和阻碍

每月：
├── 月度OKR复盘会议
├── 调整策略和行动计划
└── 必要时调整KR（O一般不变）

3. 复盘阶段（季度末）

1
2
3
4
5

季度末：
├── 自评OKR完成情况（打分0-1）
├── 团队OKR复盘会议
├── 总结经验教训
└── 为下季度OKR制定做准备

OKR评分标准

注意：OKR评分不应直接与绩效考核挂钩，否则会导致目标设定保守。

常见问题与解决方案

问题1：OKR变成了任务清单

解决：KR应该是结果而非任务，问自己”完成这个能证明目标达成吗？”

问题2：目标设定过于保守

解决：鼓励挑战性目标，强调60-70%完成率是正常的

问题3：OKR与日常工作脱节

解决：每周回顾OKR，将日常工作与OKR关联

问题4：跨部门OKR不对齐

解决：建立OKR对齐机制，定期进行横向沟通

推荐工具

• 飞书OKR：字节跳动出品，功能完善
• Worktile：国产项目管理工具，支持OKR
• Notion：灵活的文档工具，可自定义OKR模板
• Weekdone：专业OKR管理工具

总结

OKR的核心价值：

1. 聚焦：让团队专注于最重要的事
2. 对齐：确保上下左右目标一致
3. 透明：全员可见，促进协作
4. 挑战：鼓励设定有野心的目标

成功实施OKR的关键：

• 领导层的支持和参与
• 持续的沟通和反馈
• 与绩效考核适度分离
• 建立学习和迭代的文化

参考资料

• 《这就是OKR》- 约翰·杜尔
• 《OKR工作法》- 克里斯蒂娜·沃特克
• Google re:Work OKR指南

评论和共享

前言

ET框架是一个基于C#的双端（客户端+服务端）游戏开发框架，由熊猫大佬开发维护。它的最大特点是客户端和服务端共用一套代码，大大提高了开发效率。本文将介绍ET框架的核心概念和简单入门。

ET框架特点

1. 双端共用代码

• 客户端使用Unity引擎
• 服务端使用.NET Core
• 网络协议、实体组件等代码可以共用

2. ECS架构

ET采用Entity-Component-System架构：

• Entity（实体）：游戏中的对象，如玩家、怪物
• Component（组件）：实体的数据和行为
• System（系统）：处理组件的逻辑

3. Actor模型

服务端采用Actor模型进行消息处理，每个Actor独立处理自己的消息队列，避免多线程竞争。

项目结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ET/
├── Unity/                    # Unity客户端项目
│   ├── Assets/
│   │   ├── Scripts/
│   │   │   ├── Core/        # 核心框架代码
│   │   │   ├── Model/       # 数据模型
│   │   │   ├── Hotfix/      # 热更新代码
│   │   │   └── ThirdParty/  # 第三方库
│   │   └── Bundles/         # 资源包
├── Server/                   # 服务端项目
│   ├── Model/               # 服务端数据模型
│   ├── Hotfix/              # 服务端热更新
│   └── App/                 # 启动入口
└── Share/                    # 共享代码
    ├── Proto/               # 协议定义
    └── Config/              # 配置文件

核心概念

Entity 实体

1
2
3
4
5
6
7
8
9
10
11

// 定义一个玩家实体
public class Player : Entity
{
    public string Name { get; set; }
    public int Level { get; set; }
}

// 创建实体
Player player = ComponentFactory.Create<Player>();
player.Name = "TestPlayer";
player.Level = 1;

Component 组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 定义移动组件
public class MoveComponent : Component
{
    public Vector3 Position { get; set; }
    public float Speed { get; set; }
    
    public void MoveTo(Vector3 target)
    {
        // 移动逻辑
    }
}

// 给实体添加组件
player.AddComponent<MoveComponent>();

消息处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 定义消息
[Message(OuterOpcode.C2G_Login)]
public partial class C2G_LoginRequest : IRequest
{
    public string Account { get; set; }
    public string Password { get; set; }
}

// 消息处理器
[MessageHandler]
public class C2G_LoginHandler : AMRpcHandler<C2G_LoginRequest, G2C_LoginResponse>
{
    protected override async ETTask Run(Session session, C2G_LoginRequest request, 
        G2C_LoginResponse response, Action reply)
    {
        // 处理登录逻辑
        response.PlayerId = 10001;
        reply();
    }
}

快速入门

1. 环境准备

1
2
3
4
5

# 安装 .NET Core SDK 3.1+
# 安装 Unity 2019.4 LTS

# 克隆项目
git clone https://github.com/egametang/ET.git

2. 启动服务端

1
2

cd ET/Server/App
dotnet run

3. 启动客户端

1. 用Unity打开 ET/Unity 项目
2. 打开场景 Assets/Scenes/Init.unity
3. 点击Play运行

4. 创建第一个功能

以创建一个简单的聊天功能为例：

定义协议 (Share/Proto/OuterMessage.proto)

1
2
3
4
5
6
7
8
9
10
11

message C2G_Chat // IRequest
{
    string Content = 1;
}

message G2C_Chat // IResponse
{
    int32 RpcId = 90;
    int32 Error = 91;
    string Message = 92;
}

服务端处理器

1
2
3
4
5
6
7
8
9
10
11

[MessageHandler]
public class C2G_ChatHandler : AMRpcHandler<C2G_Chat, G2C_Chat>
{
    protected override async ETTask Run(Session session, C2G_Chat request, 
        G2C_Chat response, Action reply)
    {
        Log.Info($"收到聊天消息: {request.Content}");
        response.Message = $"服务器收到: {request.Content}";
        reply();
    }
}

客户端调用

1
2
3
4
5
6

public static async ETTask SendChat(string content)
{
    G2C_Chat response = await SessionComponent.Instance.Session
        .Call(new C2G_Chat { Content = content }) as G2C_Chat;
    Log.Info(response.Message);
}

服务端架构

ET服务端采用分布式架构，主要包含以下进程：

热更新机制

ET支持代码热更新：

• Model层：不可热更新的基础代码
• Hotfix层：可热更新的业务逻辑

1
2

// Hotfix层代码可以在运行时重新加载
// 修改Hotfix代码后，服务端可以不停服更新

总结

ET框架的优势：

1. 开发效率高：双端共用代码
2. 架构清晰：ECS + Actor模型
3. 支持热更新：业务逻辑可热更
4. 社区活跃：持续更新维护

适用场景：

• 中小型网络游戏
• 需要快速迭代的项目
• 熟悉C#的团队

参考资料

• ET框架GitHub
• ET框架文档
• ET框架QQ群

评论和共享

容器简介

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。

CentOS 7 安装docker

安装必要的一些系统工具

1

$ yum update

1

$ yum install -y yum-utils device-mapper-persistent-data lvm2

添加软件源信息

1

$ yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

更新并安装 Docker

1
2
3
4
5
6
7

$ yum makecache fast
$ yum -y install docker-ce


$ echo 开启容器服务
$ systemctl enable docker
$ systemctl start docker

注意：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ 官方软件源默认启用了最新的软件，您可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，你可以通过以下方式开启。同理可以开启各种测试版本等。
$ vim /etc/yum.repos.d/docker-ce.repo
$   将 [docker-ce-test] 下方的 enabled=0 修改为 enabled=1
$ 
$ 安装指定版本的Docker-CE:
$ Step 1: 查找Docker-CE的版本:
$ yum list docker-ce.x86_64 --showduplicates | sort -r
$   Loading mirror speeds from cached hostfile
$   Loaded plugins: branch, fastestmirror, langpacks
$   docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable
$   docker-ce.x86_64            17.03.1.ce-1.el7.centos            @docker-ce-stable
$   docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable
$   Available Packages
$ Step2 : 安装指定版本的Docker-CE: (VERSION 例如上面的 17.03.0.ce.1-1.el7.centos)
$ yum -y install docker-ce-[VERSION]

注册一个阿里的账号,
进入加速器页面https://cr.console.aliyun.com/#/accelerator

1

$ vim /etc/docker/daemon.json

内容如下

1
2
3

{
"registry-mirrors": ["https://你的阿里云加速地址.mirror.aliyuncs.com"]
}

重启docker

1
2

$ systemctl daemon-reload
$ systemctl restart docker

常用docker命令

查看运行容器

1

$ docker ps

查看所有容器

1

$ docker ps -a

进入容器
其中字符串为容器ID:

1

$ docker exec -it d27bd3008ad9 /bin/bash

1.停用全部运行中的容器:

1

$ docker stop $(docker ps -q)

2.删除全部容器：

1

$ docker rm $(docker ps -aq)

3.一条命令实现停用并删除容器：

1

$ docker stop $(docker ps -q) && docker rm $(docker ps -aq)

安装mariadb

centOS上比yum安装mysql要方便.

###安装mysql-client，用于访问mysql容器数据库

1

$ yum -y install mariadb

单独MySQL模式

1
2
3
4
5
6
7

docker run -d \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-master:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e REPLICATION_PASSWORD=admin \
-p 3306:3306 \
mariadb

MariaDB MASTER

进入容器需要修改镜像
将下面内容添加进/etc/mysql/conf.d/*.cnf
从机server-id=2

1
2
3
4
5

[mysqld]
server-id=1
log-bin=mysql-bin
binlog_format=MIXED
default-time_zone = '+8:00'

提交

1
2

docker commit -m "set log bin on" -a "lional" d27bd3008ad9 mariadb-master:1.0
docker commit -m "set log bin on" -a "lional" d27bd3008ad9 mariadb-slave:1.0

运行master, 这里LOG_BIN参数没有用,所以在上面修改了镜像

1
2
3
4
5
6
7
8
9
10
11

docker run -d \
--restart=always \
--name mysql-master \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-master:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e LOG_BIN=mysql-bin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-p 3306:3306 \
mariadb-master:1.0

查询容器的ip地址

1

$ docker inspect --format='{{.NetworkSettings.IPAddress}}' $(docker ps -a -q)

1

172.17.0.2

链接容器mysql

1

mysql -uroot -padmin -h 172.17.0.2

查看master是否启用了log_bin

1
2
3
4
5
6
7
8
9
10
11
12

MariaDB [(none)]> show variables like '%log_bin%';
+---------------------------------+--------------------------------+
| Variable_name                   | Value                          |
+---------------------------------+--------------------------------+
| log_bin                         | ON                             |
| log_bin_basename                | /var/lib/mysql/mysql-bin       |
| log_bin_compress                | OFF                            |
| log_bin_compress_min_len        | 256                            |
| log_bin_index                   | /var/lib/mysql/mysql-bin.index |
| log_bin_trust_function_creators | OFF                            |
| sql_log_bin                     | ON                             |
+---------------------------------+--------------------------------+

查看主机状态,注意启动从机的时候bin和pos的参数

1
2
3
4
5
6

MariaDB [(none)]> show master status;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000003 |      342 |              |                  |
+------------------+----------+--------------+------------------+

添加slave账户

1
2

GRANT REPLICATION SLAVE ON *.* to 'slave'@'%' identified by 'reader';
FLUSH PRIVILEGES;

MariaDB SLAVE

没有sql导入的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

docker run -d \
--restart=always \
--name mysql-slave2 \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-slave:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e LOG_BIN=mysql-bin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-e MASTER_LOG_FILE=mysql-bin.000003 \
-e MASTER_LOG_POS=342 \
-e MASTER_PORT=3306 \
-e MASTER_HOST=172.17.0.2 \
-p 3310:3306 \
mariadb-slave2:1.0

先用sql文件导入再同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

docker run -d \
--restart=always \
--name mysql-master \
-e TIMEZONE=Asia/Shanghai \
-v /data/mariadb-slave:/data/mariadb \
-e MYSQL_ROOT_PASSWORD=admin \
-e BINLOG_FORMAT=MIXED \
-e REPLICATION_PASSWORD=admin \
-e DATABASE_FILE=database.sql \
-e MASTER_LOG_FILE=mysql-bin.000003 \
-e MASTER_LOG_POS=342 \
-e MASTER_PORT=3306 \
-e MASTER_HOST=172.17.0.2 \
-p 3308:3306 \
mariadb-slave:1.0

需要把database.sql文件存提前存放在/data/mariadb-slave目录

进入slaver的mariadb

1

mysql -uroot -padmin -h 172.17.0.3

设置主库链接

1

change master to master_host='172.17.0.2',master_user='slave',master_password='reader',master_log_file='mysql-bin.000003',master_log_pos=342,master_port=3306;

启动从库同步

1

start slave;

查看状态

1

show slave status\G;

当看到

1
2

Slave_IO_Running: Yes
Slave_SQL_Running: Yes

则启动成功

##docker redis 集群（cluster）搭建

顺带完成redis集群,安装依赖

1

$ docker pull redis

1

$ docker pull ruby

创建redis容器

1、创建redis配置文件（redis-cluster.tmpl）

我在路径/root下创建一个文件夹redis-cluster,在路径/root/redis-cluster下创建一个文件redis-cluster.tmpl，并把以下内容复制过去。

10.0.2.15 //自己的服务器ip

1
2
3
4
5
6
7
8

port ${PORT}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 10.0.2.15
cluster-announce-port ${PORT}
cluster-announce-bus-port 1${PORT}
appendonly yes

创建自定义network

1

$ docker network create redis-net

在/root/redis-cluster下生成conf和data目标，并生成配置信息

1
2
3
4
5

for port in `seq 6379 6384`; do \
  mkdir -p ./${port}/conf \
  && PORT=${port} envsubst < ./redis-cluster.tmpl > ./${port}/conf/redis.conf \
  && mkdir -p ./${port}/data; \
done

创建6个redis容器

1
2
3
4
5
6
7

for port in `seq 6379 6384`; do \
  docker run -d -ti -p ${port}:${port} -p 1${port}:1${port} \
  -v /root/redis-cluster/${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  -v /root/redis-cluster/${port}/data:/data \
  --restart always --name redis-${port} --net redis-net \
  --sysctl net.core.somaxconn=1024 redis redis-server /usr/local/etc/redis/redis.conf; \
done

通过启动ruby来实现集群

1
2
3
4
5
6
7

echo yes | docker run -i --rm --net redis-net ruby sh -c ' \
gem install redis \
&& wget http://download.redis.io/redis-stable/src/redis-trib.rb \
&& ruby redis-trib.rb create --replicas 1 \
'"$(for port in `seq 6379 6384`; do \
echo -n "$(docker inspect --format '{{ (index .NetworkSettings.Networks "redis-net").IPAddress }}' "redis-${port}")":${port} ' ' ; \
done)"

评论和共享

前言

写这篇文章之前,我在想这是属于策划案还是开发框架,最终定位到策划案,希望有更多的游戏设计者能先策划出新的玩法,再来定开发框架.
本文所述并未实现过任何代码,也并未用于任何上线产品,纯属概念模型.之所以有这种想法,可能是基于昨晚的一次灵感,以及即将设计的游戏有关.

第一章 去中心化概念

其实最简单的去中心化游戏就是单机游戏和局域网游戏,但是本文要讲诉的是mmo网络游戏的去中心化,为什么既然网络化了又要去中心化,这不是矛盾吗.
网络游戏有个通病,就是网速影响游戏体验过,这是客户端所直接反映的问题,服务端反应的你不能直接感受到的问题,很难做到全球同服,什么意思呢,就是所有玩家不全是在一台服务器上
因为服务器是有瓶颈的,本身计算量很大的情况下,socket能承载同时单服1W人在线就很不错了,像coc这种全球一个服的游戏很少,这种服务器的架构就很复杂,绝大部分网游就是分区,另一个好处就是分区重新开始游戏,可以解决通货膨胀问题.coc玩到满级满王满墙也就没有玩下去的动力了.另一方面,单机游戏比起网游,不具备强交互能力,可玩性,游戏性大打折扣.如果做到既能联网交互,又可以不靠网络来获得体验,由客户端去演算游戏逻辑,极大降低服务端成本,这就是本文想探讨的去中心化的游戏.像王者荣耀这样的moba游戏已经很接近本文所说的功能了,但是还是有所区别.至于什么区别读完本文可能有个大致了解.本文要探讨的不是moba,也不是rpg,亦或是slg这些类型,而是总的游戏设计方法.去中心化,没有中心服务器,可以是弱联网,亦或是强联网,核心是有各自客户端或是区域链来演算游戏的逻辑,然而还是有一处中心化得服务器为大家来解决统一数据问题,例如物品交易,这点类似于比特币

第二章 比特币模型

我大概简单的描述一下比特币,这也是去中心化的基石.比特币是一种符合某种算法结果的数字货币,什么意思呢,比如在某一个坐标区域,坐标值代入md5公式,能得到一个符合”x01”字符串的值,那么就认为你找到一枚数字货币,而且这个货币还能定义下一个坐标区域,也就是说,当前区域总的货币数量是一定的,没有挖掘完之前,也无法开采下一个坐标区域.比特币的函数要比我所述的复杂,但基本上是这个意思,算法是公开的,能得到的货币是有限的,一旦挖掘到货币就与中心服确认,并且获得所有权.那如果把这个模型改造一下.游戏币是从boss掉落的,或者生产制作的.或者任务获得的,假设boss,制作工具,任务都有一个gid,全局唯一ID,而且产生的作者也有个唯一uid,再加上创造出来的时间戳time,那我们可以拿着这些数据,到服务器去鉴别真伪,中心服务器会保存一个私钥,给gid+uid+time+key签名,这个货币就有一个串值,如果同一个uid复制多个货币,因为签名一样,也会被认为是一个货币而删掉其他,如果发生交易,那么这个货币还要一个交易序列,给gid+uid+time+trade+key签名会成为新的串值,而中心服会保存所有货币的最新值,也就是说两个玩家拥有了同样的货币,看他们串值是否是最新的,那么鉴别为旧版货币的就是假币.如果都修改成同一串值,那么看交易序列的最后拥有者是谁,谁就是真币.这是我想到的数字货币模型,但是如果作为游戏币,每一个货币都要保存很多值,所以我更倾向于付费可交易货币做这种去中心化的真伪模型,比如银票.而不能交易的游戏币还是只是简单的数字.

第三章 装备模型

上述所说比特币模型,数字货币模型,如果直接引用到装备模型,完全可以像数字货币一样,做到去中心化的真伪模型,玩家获得一件装备,属于未鉴定状态,需要向中心服鉴别真伪,如果为伪,那装备没有加成的属性.我们还需要处理的一件事情是防止玩家直接对真实装备改值,这需要第一,配置表的时候就生产一个验证,是否是改过配置表,第二,生成装备的时候要要把属性加入到串码算法中.玩家战斗时检测装备正确性,因为是客户端自己验算,所以也不会对服务端产生压力,目前客户端性能越来越强大,对于简单的演算还是可以接受的.

第四章 函数逻辑模型

所有的演算,逻辑都在客户端,或者说区域链服,可以把区域链服理解为几个人组局域网后其中一个人为主机的概念,那么客户端也可能对函数进行作弊,这种无法从任何算法上解决,但去中心化还有种思路是,可以认同50%以上的逻辑为正确的逻辑,也就是说假如我5个人联网,有3个人结果一致,就按这3个人的逻辑,如果5个人结果都不一致,那么此次验证失败,那么只要大部分的人保持正确心态,可以容忍少部分人作弊,也只能是自己单机演算作弊,假如多数人作弊的情况下,大环境下也可以认可是公平的.只是作为运营的我们收入大大折扣了,所以要防止这种事情发生.另外,如果防止单机作弊,我的想法是每次函数堆栈(重要的战斗算法)要保存起来参数,返回值,这些,传给服务器做一个校正,是否真伪,如果作弊可以纳入非诚信玩家,并给与一定惩罚

第五章 其他中心化包含的内容

有些内容是无法去中心化的,比如全局装备鉴别,货币鉴别,装备交易,玩家排行榜,世界聊天,世界地图等这些本身就是要做中心化的交互,所以这里不予讨论,这里只是把战斗,组队,装备掉落这些耗时的主要逻辑在客户端来演算,来增加体验和性能.

后记

说了这么多,其实还并没有实现一个基于这个想法的游戏.如果把RPG设计成去中心化,要解决大地图的问题,如果大地图还是中心服那就没有意义,还是需要处理很多逻辑,所以这个适合跑大地图,进副本战斗和回合制战斗的RPG游戏.如果把MOBA设计成去中心化,那其实就是当年的魔兽,星际,只是主机不是一台,而是多台,以大多数人的演算为准,个人感觉,意义也不大,直接做局域网的游戏就可以了,只是加个中心交互,如果用来做SLG,感觉还是不错的,试想一下三国志并不是你一个人在攻城略地,有没有很刺激.如果做其他的小地图副本游戏也是可以的.当然这个设计也是有弊端的,你需要容忍数据不能像ARGP那样及时同步,因为你无法保证组队的5个人每个人的网络都很好,万一有个别人卡住,要么踢掉他,要么等他回来的验算结果.其他的弊端暂未想到,欢迎一起来讨论

评论和共享

Foreword

I have been looking for such a blog, strong self-confidence like WordPress.
And Spending dollars to buy the domain name and server space is prerequisite.
I never thought that a free and almost unlimited freedom blog exist.
Hexo just like this. A fast, simple & powerful blog. I did not hesitate to try it.
So far so amazing.

Quick Start

First

Let’s introduce how to set up hexo.
Please Download nodejs from http://nodejs.org.
I get node-v4.2.2-x64.msi.
then double click to install nodejs.
Keep the default configuration to direct the installation.

1

$ npm install -g hexo-cli

Setup your blog.

make a name in the computer called “YOU NAME” folder (for example, I make dir in D:\workspace\OSGDreamWorks\ibunnyteam.github.io).
then open this folder, run the following command.

1
2
3
4

$ hexo init
[info] Copying data
[info] You are almost done! Don't forget to run `npm install` before you start b
logging with Hexo!

Hexo will automatically create a file in the target folder that website require.
Then follow the prompts to run npm install (in “YOU NAME” folder).

1

$ npm install

then you can get the node_modules.
All work will be done automatically by nodejs.

Start the server

Run the following command (in “YOU NAME” folder).

1
2

$ hexo server
[info] Hexo is running at http://localhost:4000/. Press Ctrl+C to stop.

Then you can open the local blog. easy, all right!

Create a new post

Open a new command-line window, execute the following command

1
2

$ hexo new "My New Post"
[info] File created at d:\Hexo\source\_posts\My-New-Post.md

Refresh http://localhost:4000/，you can see the “My New Post”。

Generate static files

执行下面的命令，将markdown文件生成静态网页。

1

$ hexo generate

After this command is executed, it will be generating a series of html, css and other documents in public directory.

Upload the blog

Now you only have established a local blog.
How others see your blog.
You need github. Also amazing project.
your can know every thing in github.comhttps://github.com/

continue

Deployed to the former Github need to configure _config.yml file, first locate the following content.

1
2
3
4

# Deployment
## Docs: http://hexo.io/docs/deployment.html
deploy:
  type:

Changed to:

1
2
3
4
5
6

# Deployment
## Docs: http://hexo.io/docs/deployment.html
deploy:
  type: git
  repository: git@github.com:ibunnyteam/ibunnyteam.github.io.git
  branch: master

NOTE1:

Repository: SSH form must be url (git@github.com: ibunnyteam / ibunnyteam.github.io.git), but can not be HTTPS form url (https://github.com/ibunnyteam/ibunnyteam.github.io. git), otherwise an error:
You need named the repository YOU_GITHUB_ACCOUNT.github.io then you can open the github static web.

1
2

$ hexo deploy
[info] Start deploying: github

Use SSH url, if the computer is not an open SSH port will cause the deployment to fail.

1
2
3
4
5

[error] https://github.com/ibunnyteam/ibunnyteam.github.io is not a valid repositor URL!
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

NOTE2：

If you are making a project website, then you need to branch to gh-pages.

Last

you can make a domain name with the github static web.

The short command for hexo:

new blog

1

$ hexo n

generate

1

$ hexo g

upload

1

$ hexo d

Have fun

评论和共享