Cyeam Go学习优化沉淀架构设计分享

LLM不能做什么？解析大模型的能力边界与适用场景

2026-04-09T00:00:00+00:00

大模型虽然能力强大，但并非万能，LLM访问次数就是其关键瓶颈之一。本质上，AI并不适合处理高频率、大批量的重复性任务。

批量数据处理就是大模型的典型盲区。当你需要处理几千条数据记录时，不管采用MCP（模型上下文协议）还是让AI生成代码执行，都很难完整、可靠地完成任务。大模型的设计初衷是进行推理和生成，而非充当高速数据处理引擎。面对海量条目，API调用频率会迅速触及上限，响应延迟累积，最终导致任务超时或中断。

以我实际经验来看，通过LLM和MCP批量上传图片场景，这种场景下LLM可以尝试主动提醒或者往控制调用次数的方向来执行：

trae MCP上传了几张后就开始一本正经胡说八道，返回地址都是错误的。
claude+黄大善人模型上传没问题但一晚上只完成30%，几百张图片，因为要拼参数，模型调用次数是非常大的。
后面我还考虑过批量生成上传命令，但都不行，因为根本问题没解决——模型调用次数不会减少。后来索性让AI给我实现一个批量上传脚本解决掉了。

总结而言，单次调用、逻辑复杂、需要推理的任务适合大模型；而高频重复、数据量大、纯机械操作的任务则应交给传统脚本或专用工具。理解这一边界，才能避免把 Ferrari 当拖拉机用。

Harness Engineering深度解析：AI时代的系统控制新范式

2026-04-06T00:00:00+00:00

AI工程化三阶段
Code Harness Engineering架构
更多阅读

AI工程化三阶段

维度	Prompt Engineering（提示词工程）	Context Engineering（上下文工程）	Harness Engineering（驾驭 / 控束工程）
核心定位	指令优化	信息供给	系统控制
通俗比喻	写台词	搭布景 / 查资料	造赛车 / 拉缰绳
解决问题	模型听不懂、答非所问	模型记不住、知识匮乏	模型不靠谱、不可控、不安全
操作对象	纯文本字符串（Prompt）	会话历史 + 外部知识库（RAG）	整个 Agent 生命周期 + 外部工具
技术手段	角色设定、Few-shot、CoT、模板	会话管理、向量检索、窗口截断	状态机、函数调用、护栏、自愈闭环
代码复杂度	低（字符串拼接）	中（数据库 / 向量库交互）	高（循环逻辑、异常处理）
交互层级	单次交互（点）	多轮记忆（面）	自主执行（体）
代表产物	各种提示词模板、咒语	RAG 系统、聊天记录管理器	OpenClaw、AutoGPT、Claude Code

Code Harness Engineering架构

Code Harness = 模型层 + 智能体循环 + 运行时支撑

模型层：LLM / Reasoning LLM（引擎）
智能体循环：Observe → Inspect → Choose → Act（决策闭环）
运行时支撑：上下文、工具、权限、缓存、记忆、子代理（脚手架）

第一阶段：系统启动与加载（构建底座）

1. 实时代码仓库上下文 (Live Repo Context)

flowchart TD
    %% 样式定义：红色高亮核心节点，其他节点保持默认清晰样式
    classDef highlight fill:#ff4d4f,stroke:#cf1322,stroke-width:2.5px,font-weight:bold,color:#fff

    %% 流程节点
    A["Inspect current repo"]:::normal -->|1| B["Git context<br/>Branch, status, commits"]:::normal
    A -->|1| C["Project docs<br/>AGENTS.md, README.md, etc."]:::normal
    B -->|2| D["Workspace<br/>Summary"]:::highlight
    C --> D
    D -->|3| E["Stable prompt prefix<br/>Rules, tools, workspace summary"]:::normal
    E -->|4| F["Combined prompt<br/>Prefix + request"]:::normal
    G["User request<br/>'Write unit test for function xyz'"]:::normal -->|5| F
    F -->|6| H[LLM]:::normal
    H -->|7| I["Model response<br/>Tool call or final answer"]:::normal

2. 提示词形态与缓存复用 (Prompt Shape And Cache Reuse)

flowchart LR
    classDef highlight fill:#ff4d4f,stroke:#cf1322,stroke-width:2.5px,font-weight:bold,color:#fff

    A["Workspace<br/>Summary"] --> B["Stable prompt prefix<br/>Rules, tools, workspace summary"]:::highlight
    B --> C["Prompt assembly<br/>Prefix + memory + transcript + request"]
    D["Compact Transcript<br/>Recent history"]:::highlight -->|1| C
    E["Latest user request<br/>'Improve xyz'"] -->|3| C
    F["Working memory<br/>Task, files, notes"] -->|4| C
    C -->|5| G[LLM]
    G -->|6| H["Model response<br/>Tool call or final answer"]
    H -->|7| F

纯聊天式的 LLM 使用中，每一轮对话都会把所有内容（规则、工具、仓库信息、历史对话）重建成一个完整的大 Prompt。

结构化拆分 Prompt，分离「稳定前缀」与「动态内容」
标准化 Prompt Shape（形态），保证推理稳定性
对稳定前缀做缓存复用，降本提效
联动全链路模块，为 Agent 循环打基础

Stable Prompt Prefix（稳定提示词前缀）——CLAUDE.md

CLAUDE.md 文件：你编写的指令，为 Claude 提供持久上下文。CLAUDE.md不会被压缩，每个文件目标在 200 行以下。

your-project/
├── .claude/
│   ├── CLAUDE.md           # 主项目指令
│   └── rules/
│       ├── code-style.md   # 代码样式指南
│       ├── testing.md      # 测试约定
│       └── security.md     # 安全要求

Rules

CLAUDE.md 是「主项目说明」，rules 是「模块化补充规则」，二者共同构成项目级稳定提示词前缀，且 rules 优先级更高。

类型	位置	核心定位	内容特点
CLAUDE.md	./CLAUDE.md 或 ./.claude/CLAUDE.md	主项目说明	项目整体架构、全局约定、常用命令、团队共享的核心规则
rules	./.claude/rules/*.md	模块化专项规则	特定语言指南、测试约定、API 标准、安全要求等细分主题

第二阶段：对话运行与组装（核心循环）

5. 结构化的会话记忆 (Structured Session Memory)

flowchart TD
    classDef highlight fill:#ff4d4f,stroke:#cf1322,stroke-width:2.5px,font-weight:bold,color:#fff

    subgraph UsedInNextPrompt_Main
        A["New events<br/>User turns, tool results, LLM responses"] --> B["Session file on disk"]
        B --> C["Full transcript<br/>User requests, tools results, LLM responses"]:::highlight
        B --> D["Working memory<br/>Task, files, notes"]:::highlight
    end
    subgraph UsedInNextPrompt
        C --> E["Compact Transcript<br/>Recent, compacted history"]:::highlight
        F["Workspace<br/>Summary"] --> G["Stable prompt prefix<br/>Rules, tools, workspace summary"]
        G --> H["Prompt assembly<br/>Prefix + memory + transcript + request"]
        E --> H
        D --> H
        I["Latest user request<br/>'Improve xyz'"] --> H
        H --> J[LLM]
    end

记忆系统Memory:

自动记忆：Claude 根据你的更正和偏好自己编写的笔记
使用Sonnet模型，扫描 memory 目录下所有 .md，排除 MEMORY.md，只读每个文件前 30 行 frontmatter，按 mtime 倒序排序，最多保留 200 个候选

CLAUDE.md 文件	自动记忆
你	Claude
指令和规则	学习和模式
项目、用户或组织	每个工作树
每个会话	每个会话（前 200 行或 25KB）
编码标准、工作流、项目架构	构建命令、调试见解、Claude 发现的偏好

打开方式：

{
  "autoMemoryEnabled": false
  "autoMemoryDirectory": "~/my-custom-memory-dir"
}

存储方式：

~/.claude/projects/<project>/memory/
├── MEMORY.md          # 简洁索引，加载到每个会话
├── debugging.md       # 关于调试模式的详细笔记
├── api-conventions.md # API 设计决策
└── ...                # Claude 创建的任何其他主题文件

会话Transcript：

层级	项目	保存位置	存储内容	生命周期
请求级 / 进程级缓存	readFileState	进程内 LRU 内存缓存	已读取文件的内容快照，以及 mtime、offset、limit、isPartialView 等读取状态	仅当前进程有效；LRU 淘汰；进程退出即丢失
请求级 / 进程级缓存	fileReadCache	进程内 Map	某些文件读取结果及其 mtime	仅当前进程有效；依赖 mtime 失效；进程退出即丢失
请求级 / 进程级缓存	FileIndex	进程内索引对象	文件路径和目录路径的模糊检索索引，不包含文件正文	仅当前进程有效；可重建；进程退出即丢失
请求级 / 进程级缓存	ignore 过滤缓存	进程内缓存	.ignore、.gitgnore 解析后的过滤规则	仅当前进程有效；进程退出即丢失
请求级 / 进程级缓存	GitFileWatcher cache	进程内 watcher/cache	当前 branch、HEAD、default branch、remote URL 等 git 元信息	仅当前进程有效；.git 变化时失效；进程退出即丢失
项目级持久化	exampleFiles	项目配置	由 git log 推导出的高频修改文件列表及时间戳	跨进程、跨会话保留；按项目保存；过期后重算
会话级持久化	session transcript	~/.claude/projects/…/.jsonl	会话消息、工具结果摘要、快照事件、替换记录、折叠记录等 JSONL 事件流	跟随 session 长期存在；用于 resume/continue
会话级持久化	attribution snapshot	~/.claude/projects/…/.jsonl	Claude / 人工改动归因状态	跟随 session transcript 存在；恢复会话时加载
会话级持久化	file-history snapshot	~/.claude/projects/…/.jsonl	文件版本快照的索引信息，如文件路径、版本号、关联备份名	跟随 session transcript 存在；用于恢复文件历史状态
会话级持久化	content-replacement	~/.claude/projects/…/.jsonl	上下文压缩 / 替换后的映射关系	跟随 session transcript 存在；服务长会话恢复
会话级持久化	context-collapse / related snapshot	~/.claude/projects/…/.jsonl	上下文折叠后的提交点、摘要快照及相关恢复信息	跟随 session transcript 存在；服务 resume/continue
会话级文件实体	file-history 备份文件	~/.claude/file-history//@vN	文件某个版本的真实内容副本	跟随该 session 的文件历史存在；可在 resume 时复制 / 复用

进程级：都是性能缓存，退出即丢。
项目级：只有 exampleFiles 这类轻量衍生缓存。
会话级：核心都写进 ~/.claude/projects/…/*.jsonl。
文件实体级：真正的旧文件内容只在 ~/.claude/file-history//...。

第三阶段：工具执行与安全管控（驾驭核心）

3. 工具的接入与调用 (Tool Access and Use)

领域	实现方式	关键配置项
命令 / 工具执行权限	先匹配通用工具规则，再进入工具自己的 checkPermissions ()，最后叠加 mode、bypass、dangerous rule 处理	permissions.allow、permissions.deny、permissions.ask、permissions.defaultMode、permissions.disableBypassPermissionsMode、permissions.disableAutoMode
文件系统权限	基于路径规则、工作目录边界、敏感路径 / 危险路径检查做 allow/deny/ask；编辑类工具会单独接入文件权限检查	permissions.additionalDirectories、permissions.allow/deny/ask
外部访问权限	WebFetch 做 host/path 级规则；MCP 先做 server 级启用 / 批准 / 企业策略，再到具体 MCP tool 权限	allowedMcpServers、deniedMcpServers、enableAllProjectMcpServers、enabledMcpjsonServers、disabledMcpjsonServers、allowManagedMcpServersOnly、allowManagedPermissionRulesOnly、skipWebFetchPreflight

相关配置：Claude Code 完整使用指南

低幻觉

生成 → 执行 → 验证 → 诊断 → 自愈 → 再执行
闭环 = 零幻觉、高可靠的根本原因

强力提示词

src/services/compact/prompt.ts:19：明确要求 Your entire response must be plain text: an block followed by a <summary> block.这是最直接的“先分析再给总结”。
src/services/compact/prompt.ts:31：Before providing your final summary, wrap your analysis in tags...，属于硬性两阶段输出。
src/commands/security-review.ts:92：有 ANALYSIS METHODOLOGY，后面分 Phase 1/2/3做仓库研究、对比分析、漏洞评估，明显是先论证再结论。
src/commands/security-review.ts:130：要求 FALSE POSITIVE FILTERING 和 confidence score，不是简单找问题，而是要求证据和置信度。
src/memdir/memoryTypes.ts:201：Before answering the user … verify that the memory is still correct and up-to-date，这是“先验证再回答”。
src/coordinator/coordinatorMode.ts:328：Prove the code works, don’t just confirm it exists，要求给可验证依据，不接受口头确认。

第四阶段：上下文瘦身（防爆炸与优化）

4. 给上下文瘦身，防止撑爆 (Minimizing Context Bloat)

在长会话（比如写代码、改项目）中，AI 会产生大量冗余信息，如果全部塞给 LLM，会：

超 Token 限制（报错）
算力成本飙升
AI 注意力分散（记不住重点）所以，必须做上下文压缩（Context Compression）。

Clip（裁剪）把过长的搜索结果、Shell 日志，截断到合适长度。
Deduplicate（去重），删掉旧的、重复的文件读取记录，避免重复信息干扰。
Asymmetric detail（非对称细节）。最近的对话保留详细信息，久远的对话只保留摘要。AI 对最近的事记得最清，对很久以前的事只需要大概印象。
Compact transcript（精简转录）。经过上面 3 步处理后，得到一个短小、干净、无冗余的历史记录。
Prompt assembly（组装）。把精简后的历史，和其他信息（规则、任务、记忆）拼成最终 Prompt，发给 LLM。

压缩时机

手动执行：/compact。/compact 能明显压缩当前会话上下文，让后续对话继续跑下去；但它不会把磁盘上的 transcript JSONL 文件变小。
自动执行：系统在上下文快满时自动做的 autoCompact

压缩方式

压缩内容：session transcript 在这条链上插入 compact boundary 和 compact summary

之后模型只取 boundary 后面的消息继续工作
所以被“压缩”的是 transcript 里的会话历史视图

flowchart LR
    classDef highlight fill:#ff4d4f,stroke:#cf1322,stroke-width:2.5px,font-weight:bold,color:#fff

    A["Search results<br/>Often larger than needed"] -->|1| B["Clip<br/>Reduce raw output size"]:::highlight
    C["Shell logs<br/>Also often larger than needed"] -->|2| B
    Skill["Skills"] -->|3|B
    D["Repeated reads<br/>Same file, many turns"] -->|3| E["Deduplicate<br/>Older read_file events"]:::highlight
    F["Full transcript<br/>User requests, tools results, LLM responses"] -->|4| G["Asymmetric detail<br/>Recent rich, older short"]:::highlight
    E -->|5| H["Compact transcript<br/>Recent, compacted history"]
    G --> H
    B --> H
    H -->|6| I["Prompt<br/>The assembled prompt<br/>(last section)"]
    I -->|7| J[LLM]

第五阶段：任务委派与复杂场景

6. 任务委派与受限子智能体 (Delegation With (Bounded) Subagents)

官方文档：创建自定义 subagents

配置方式

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  },
  "debugger": {
    "description": "Debugging specialist for errors and test failures.",
    "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."
  }
}'

调用方式

自动委托：Claude 根据您请求中的任务描述、subagent 配置中的 description 字段和当前上下文自动委托任务。要鼓励主动委托，在您的 subagent 的 description 字段中包含”use proactively”之类的短语。
显示调用
- 自然语言：在提示中命名 subagent；Claude 决定是否委托
- @-mention：保证 subagent 为一个任务运行
- 会话范围：整个会话使用该 subagent 的系统提示、工具限制和模型，通过 –agent 标志或 agent 设置

完整架构图

graph TD
    %% 样式定义
    classDef context fill:#e1f5fe,stroke:#01579b,stroke-width:2px;
    classDef memory fill:#fff9c4,stroke:#fbc02d,stroke-width:2px;
    classDef compression fill:#e0f2f1,stroke:#00695c,stroke-width:2px;
    classDef prompt fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px;
    classDef llm fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px;
    classDef tools fill:#fff3e0,stroke:#f57c00,stroke-width:2px;
    classDef agents fill:#ffebee,stroke:#c62828,stroke-width:2px;

    subgraph Context_Layer [1. 实时代码仓库上下文]
        A1[Git 上下文<br/>分支/状态/提交]:::context
        A2[工作区摘要<br/>文件结构/内容]:::context
        A3[项目文档<br/>AGENTS.md / README.md]:::context
    end

    subgraph Memory_Layer [5. 结构化的会话记忆]
        B1[会话文件<br/>完整转录]:::memory
        B2[工作记忆<br/>当前任务/笔记]:::memory
    end

    subgraph Compression_Layer [4. 上下文瘦身]
        C1[裁剪<br/>减少原始输出]:::compression
        C2[去重<br/>合并重复读取]:::compression
        C3[非对称细节<br/>近期丰富 / 远期简略]:::compression
    end

    subgraph Prompt_Layer [2. 提示词形态与缓存复用]
        D1[稳定前缀<br/>规则/工具/摘要]:::prompt
        D2[提示词组装<br/>前缀+记忆+转录+请求]:::prompt
    end

    subgraph Execution_Layer [核心执行引擎]
        E1[LLM 大语言模型]:::llm
    end

    subgraph Tool_Layer [3. 工具的接入与调用]
        F1[工具定义<br/>搜索/Shell/文件]:::tools
        F2[沙箱执行<br/>环境隔离]:::tools
        F3[结果处理<br/>格式化/截断]:::tools
    end

    subgraph Agent_Layer [6. 任务委派与受限子智能体]
        G1[规划与分解<br/>拆解复杂任务]:::agents
        G2[子智能体执行<br/>独立上下文]:::agents
        G3[结果聚合<br/>返回主会话]:::agents
    end

    %% 数据流向
    UserRequest --> Memory_Layer
    UserRequest --> Context_Layer
    
    Memory_Layer --> Compression_Layer
    Context_Layer --> Compression_Layer
    
    Compression_Layer --> Prompt_Layer
    Prompt_Layer --> Execution_Layer
    
    Execution_Layer -- 工具调用 --> Tool_Layer
    Tool_Layer -- 观察结果 --> Memory_Layer
    
    Execution_Layer -- 复杂任务委派 --> Agent_Layer
    Agent_Layer -- 子智能体结果 --> Memory_Layer
    
    Execution_Layer -- 最终响应 --> User

Claude Code安装与使用完全指南：从OpenRouter到黄大善人模型

2026-04-05T00:00:00+00:00

准备
安装使用OpenRouter模型
- 配置环境变量
- 启动
使用黄大善人模型
接入LangSmith
- 安装插件
- 配置Token
模型选择
增加提示音
Shortcuts
配置文件

准备

curl -fsSL https://claude.ai/install.sh | bash

这里需要魔法，绕过Claude登录限制。

安装使用OpenRouter模型

官方文档：Claude Code

配置环境变量

注意ANTHROPIC_API_KEY要留空，保存后执行source。

export OPENROUTER_API_KEY="<your-openrouter-api-key>"
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="$OPENROUTER_API_KEY"
export ANTHROPIC_API_KEY=""

source ~/.zshrc # 记得要让模型生效

启动

如果前面的配置都正确，不会要求登录并且执行/init命令后会初始化项目，创建CLAUDE.md文件。

cd /path/to/your/project
claude
/status
/init

使用黄大善人模型

claude-code-router支持在本地路由模型、做协议转换。在这里我们用它代理黄大善人的模型。

注册。移步：黄大善人官网。
1. 注册好后创建API Key。
2. 也可以点击右上角的View Code，能看到完整Url和API Key。
安装代理npm install -g @musistudio/claude-code-router
配置ccr ui。强烈建议用这个，比直接改配置省事。
启动Claude。ccr code。

接入LangSmith

安装插件

/plugin marketplace add langchain-ai/langsmith-claude-code-plugins
/plugin install langsmith-tracing@langsmith-claude-code-plugins
/reload-plugins

配置Token

路径：.claude/settings.local.json。

{
  "env": {
    "TRACE_TO_LANGSMITH": "true",
    "CC_LANGSMITH_API_KEY": "<LangSmith API key>",
    "CC_LANGSMITH_PROJECT": "my-project"
  }
}

Trace Claude Code applications

模型选择

模型名称	别名	核心定位	适用场景	核心优势
Claude 3.5/4.5 Sonnet（执行力 / 日常首选）	十四行诗	开发主力	日常代码编写、复杂需求理解、功能落地实现、代码重构优化	在模型智力与响应速度间达成完美平衡，是绝大多数编码任务的最高性价比选择
Claude 3.5/4.5 Opus（逻辑王 / 高阶规划）	宏大乐章	复杂任务攻坚	系统架构设计、高复杂度算法开发、大型项目重构、超长上下文深度理解	思考逻辑缜密、具备全局统筹能力，是 Claude 系列中推理能力最强的型号
Claude 3.5/4.5 Haiku（闪电速 / 轻量级）	俳句	简单辅助、高频轻量任务处理	简单样板代码生成、文档内容总结、代码格式化、轻量自动化脚本编写	响应速度最快，调用成本极低，适合高频次、低复杂度的辅助需求

增加提示音

这个很重要，由于CC能力很强需要后台做很多事情，所以需要提示音来提醒我们任务进度。你可以参考这篇文档调整自己喜欢的提示音配置任务提示音。

Notification 需要操作确认时播放Glass.aiff
Stop 任务完成时播放Ping.aiff

vi ~/.claude/settings.json

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Glass.aiff"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Ping.aiff"
          }
        ]
      }
    ]
  }
}

Shortcuts

Shortcut	Action
Ctrl+C	Cancel current generation or input
Ctrl+D	Exit Claude Code
Ctrl+L	Clear terminal screen
Ctrl+R	Reverse search command history
Esc + Esc	Rewind to previous checkpoint (undo)
Shift+Tab	Cycle permission modes (default/plan/yolo)
Ctrl+G	Open input in external editor (vim, etc.)
Ctrl+O	Toggle verbose output
Ctrl+T	Toggle task list
Ctrl+F	Kill all background agents (press twice)

Claude Code Cheat Sheet – Commands, Shortcuts, Tips

配置文件

Claude Code 设置。

大语言模型选型指南：从架构到场景的全方位对比分析

2026-04-04T00:00:00+00:00

发展史
模型指标
模型选择参考

发展史

史前时代（2017年前）：基于规则和统计的小模型，只能完成简单任务，长文本处理能力弱。
奠基时代（2017-2019）：Transformer架构诞生，自注意力机制实现并行训练，GPT和BERT开启预训练+微调范式。
爆发时代（2020-2022）：GPT-3证明规模即能力，ChatGPT通过RLHF技术实现对话能力，LLM进入大众视野。
多模态与智能体时代（2023至今）：GPT-4实现图文多模态，开源模型百花齐放，RAG、Agent等技术推动应用落地。

模型指标

Attribute	Nemotron Nano 12B 2 VL (free)	说明
Author	nvidia
Model Size / Parameters	7B	模型体量 / 参数量。
Context Length	128K	上下文越大，长文本 / 长对话 / 复杂任务理解能力越强
Hallucination		幻觉率
Architecture	hybrid Transformer-Mamba architecture	大模型架构
Reasoning	Yes	推理能力
Latency (p50)	2.09s	延迟越低，响应越快
Throughput (p50)	40.0 tok/s	吞吐量越高，生成速度越快
Input Pricing	$0 / M tokens
Output Pricing	$0 / M tokens
Input Modalities	image, text, video	输入模态，此处均为多模态
Output Modalities	text	输出模态
Quantization	unknown	量化精度
Stream cancellation	Yes	流式取消
Supports Tools	Yes	工具调用
No Prompt Training	No	无提示词训练
Caching	No	缓存

模型体量 Parameters

它决定了模型的知识存储容量、复杂推理能力、泛化能力的理论上限。
但「上限高」≠「实际表现好」，就像一个天赋高的学生，不努力（训练差）也考不过努力的普通学生

架构 Architecture

普通大模型（Dense）：一个超级大脑。
专家模型（MoE）：一群分工明确的小专家（但对外表现为一个整体）。

英文术语	中文	简单直白解释	优点	缺点	典型模型
Transformer	标准 Transformer 架构	目前主流大模型通用架构，靠注意力机制理解上下文	逻辑强、推理稳、对话自然	越长文本越慢、算力开销大	Llama、Qwen、GPT 系列
Mamba (SSM)	状态空间模型	新一代架构，靠 “状态传递” 处理长文本	极快、超长上下文稳定、显存友好	逻辑 / 数学略弱于 Transformer	Mamba 系列、Jamba
Hybrid Transformer-Mamba	混合 Transformer+Mamba	一部分层用 Transformer，一部分用 Mamba	兼顾推理能力 + 长文本速度	结构复杂、训练难度高	Nemotron Nano、一些新 VL 模型
Dense	稠密模型	每次生成都会激活全部参数	输出稳定、质量均匀、不忽强忽弱	更吃显存、速度一般	大部分 7B/13B/12B 模型
MoE (Mixture of Experts)	混合专家模型	只激活部分参数做推理	速度快、可做大参数量模型	可能不稳定、质量波动	Gemma 4、Qwen MoE、Mixtral
Base Model	基座模型	只预训练过，不会对话	泛化强、适合二次训练	不能直接聊天	原始 Llama、原始 Qwen
Chat / Instruct Tuned	对话 / 指令微调	专门优化过，会听话、会聊天	好用、对齐人类意图	能力受微调数据限制	几乎所有 API 模型

Embedding 模型

LLM：负责说话、思考、回答
Embedding：负责把内容变成可计算的数字，方便查找和匹配

维度区间	典型代表模型	核心适用场景
128-384 维	bge-small、m3e-small、text-embedding-3-small	轻量场景、移动端部署、海量短文本（评论 / 标题）、对延迟要求极高、成本敏感的业务
512-1024 维	bge-base、m3e-base、通用多模态 embedding	通用 RAG 场景、企业知识库、文档问答、百万级数据量，平衡精度与性能的首选区间
1024-3072 维	bge-large、text-embedding-3-large、gte-large	专业领域（法律 / 医疗 / 科研）、复杂长文本、千万级大规模数据、对召回精度有极高要求的场景
3072 维以上	仅特定科研 / 多模态细分场景	通用 RAG 几乎不推荐使用，仅极端细分的高精度语义匹配场景有极少量应用

蒸馏&RAG

知识蒸馏（Knowledge Distillation, KD）
- 本质是模型压缩与知识内迁技术，核心是将参数量大、性能强的「教师模型」的知识、推理逻辑与输出分布，通过特定训练机制迁移到轻量的「学生模型」的参数中，把知识固化到模型内部，最终在牺牲少量性能的前提下，实现模型轻量化、推理降本增效。
- 蒸馏后的小模型，推理速度快、成本低，但能力有天花板：它的能力上限无法超过教师模型，甚至会有 10%-15% 的性能损失，尤其在复杂推理、长文本生成等任务上，和大模型的差距会更明显。但优势是推理延迟极低，无需依赖复杂的外部组件，甚至可以离线运行。
检索增强生成（Retrieval-Augmented Generation, RAG）
- 本质是外部知识实时增强技术，核心是不修改模型本身的参数，在生成回答前，先基于用户查询从外部知识库（向量数据库、文档库等）召回相关信息，再将检索结果作为上下文注入 Prompt，让模型基于最新、最精准的外部知识完成生成，核心解决大模型知识过时、生成幻觉、专业知识不足的痛点。
- RAG 增强后的模型，能力边界可无限拓展，但推理开销更高：它可以通过对接不同的知识库，无限拓展知识覆盖范围，同时不损失模型本身的推理、生成能力，甚至能通过多源信息整合完成更复杂的专业任务。但缺点是每次推理都要执行检索步骤，会增加响应延迟，且长上下文输入会提升推理成本。

模型选择参考

场景名称	核心优先级	架构选型推荐	上下文窗口	模型体量（参数量）	推理能力要求	模态要求	避坑指南
个人本地部署 / 边缘设备运行	体量 > 架构 > 上下文	优先Dense 稠密模型，可选混合 Transformer-Mamba，量化友好的纯 Transformer	32K 以内（满足日常需求即可）	1B-7B，最高不超过 14B	基础 - 中等	纯文本为主，无需多模态	不要盲目选 20B + 大模型，消费级显卡带不动，体验极差；优先选支持 int4/int8 量化的模型
日常通用对话 / 轻量问答	体验 > 成本 > 体量	纯 Transformer、混合架构均可，Dense/MoE 无强制要求	8K-32K	3B-14B	中等	纯文本即可	不要为了日常对话选 70B + 超大模型，纯纯性能浪费，延迟高还贵
超长文档处理 / 长对话 / RAG 检索	上下文窗口 > 架构 > 体量	优先混合 Transformer-Mamba，次选优化过长文本的纯 Transformer，Dense/MoE 均可	最低 128K，优先 256K+，极致场景选 1M+	7B-32B（平衡成本与能力）	中等 - 强	纯文本为主，多模态文档可选图文模态	不要选 32K 以下短上下文模型，长文档会断章取义；纯 Mamba 模型长文本虽快，但会丢失关键逻辑
代码开发 / 工程化任务	推理能力 > 架构 > 工具调用	优先纯 Transformer Dense 稠密模型，代码专项优化的架构	32K-128K（长代码文件需要）	13B-34B，极致场景选 70B+	强 - 顶级	纯文本为主，可选支持截图读图的多模态	不要选纯 Mamba 小模型，代码逻辑、debug 能力远弱于 Transformer 架构；必须验证工具调用（Git、API、终端）兼容性
多模态图文 / 视频理解	模态能力 > 上下文 > 架构	优先混合 Transformer-Mamba 多模态架构，次选带视觉编码器的纯 Transformer	64K-128K（长视频 / 多图需要）	7B-14B，专业场景选 34B+	中等 - 强	必须支持图文 + 视频，优先原生多模态	不要选文本模型后加视觉插件的 “伪多模态”，读图精度差、幻觉率极高
复杂推理 / 科研 / 数学逻辑任务	推理能力 > 架构 > 体量	优先纯 Transformer Dense 稠密模型，推理专项优化的架构	32K-128K（复杂逻辑需要长上下文推导）	34B-70B+，同架构下越大越好	顶级	纯文本即可	不要选纯 Mamba、MoE 小模型，逻辑严谨性、数学推导能力远弱于大参数量 Dense Transformer 模型
垂直领域专用任务（翻译 / 医疗 / 法律）	垂直能力 > 架构 > 体量	优先垂直场景专项微调的 Dense 模型，通用架构为辅	32K-128K（匹配垂直文档长度）	7B-14B，专业场景选 34B+	中等 - 强（匹配垂直领域逻辑）	按需选择	不要用通用大模型硬做垂直场景，专业度、准确率远低于专项微调模型，幻觉率极高
免费测试 / 个人原型开发	成本 > 可用性 > 能力	无强制要求，优先官方免费开放的成熟架构	越高越好	无强制要求	中等 - 强	按需选择	不要选免费但有严格调用限额、限速的模型，影响原型开发效率；优先验证免费版是否阉割核心能力

AGENTS.md与SKILL.md：为AI智能体赋能的标准格式详解

2026-04-02T00:00:00+00:00

AGENTS.md
SKILL.md

AGENTS.md

用于指导编码Agent的简单、开放格式。将 AGENTS.md 视为代理商的README：一个专门、可预测的场所，提供背景和指示，帮助AI编码Agent为您的项目工作。

跟README.md的区别

README.md 是写给人看的：包含快速上手、项目说明与贡献指南。 AGENTS.md 则作为补充，存放编码智能体所需的额外信息（有时是详细上下文）：构建步骤、测试流程与开发规范 —— 这些内容若放进 README 会显得冗余，或对人工贡献者无关紧要。我们特意将二者分开，目的是：

为智能体提供一个清晰、固定的指令存放位置
让 README 保持简洁，聚焦于人工贡献者
提供精准、面向智能体的指引，作为现有 README 与文档的补充我们没有新增一种专属文件格式，而是选用了对所有人都通用的命名与格式。如果你在开发或使用编码智能体时觉得这份文件有用，欢迎直接沿用。

兼容性

目前支持超过24种Agent和工具，而且CLAUDE.md在我看来也是一回事，另外Trae也兼容这个格式。

如何使用

放在项目根目录里，或者用/init初始化。

例子

详细内容可移步官方文档：AGENTS.md规范

Project overview：项目概述
Build and test commands：构建与测试命令
Code style guidelines：代码风格规范
Testing instructions：测试说明
Security considerations：安全注意事项

# AGENTS.md

## Project Overview
项目的整体目标与架构简介

## Build & Commands
用于开发、测试与部署的常用命令

## Code Style
格式化规则、命名规范与最佳实践

## Testing
测试框架、约定及执行指南

## Security
安全注意事项与数据保护策略

## Configuration
环境配置方式与配置管理说明

SKILL.md

一种简洁、开放的格式，用于为智能体赋予新能力与专业知识。智能体技能是由说明文档、脚本和资源组成的文件夹，智能体可以发现并使用它们，从而更准确、更高效地完成任务。

智能体的能力日益增强，但往往缺少可靠完成实际工作所需的上下文信息。技能体系很好地解决了这一问题：它让智能体能够获取流程化知识，以及企业、团队和用户专属的上下文，并可按需加载。具备技能库的智能体，能够根据当前执行的任务灵活扩展自身能力。面向技能开发者：一次构建能力，即可在多款智能体产品中复用部署。面向兼容的智能体：支持技能体系，可让终端用户开箱即用地为智能体赋予新能力。面向团队与企业：将组织知识沉淀为可移植、可版本控制的标准化包。

智能体技能可以实现哪些能力？

领域专业知识：将专业知识打包为可复用的指令，涵盖法律审查流程、数据分析流程等各类专业场景。
全新能力：为智能体赋予新技能（例如制作演示文稿、搭建 MCP 服务器、分析数据集）。
可复用工作流：将多步骤任务转化为统一、可审计的工作流程。
互通兼容性：在不同兼容技能的智能体产品中，复用同一套技能。

Skill的结构

从本质上讲，一项技能就是一个包含 SKILL.md 文件的文件夹。该文件包含元数据（至少包含名称和描述）以及指导智能体如何执行特定任务的说明。技能还可以打包脚本、模板和参考资料。

my-skill/
├── SKILL.md          # Required: instructions + metadata
├── scripts/          # Optional: executable code
├── references/       # Optional: documentation
└── assets/           # Optional: templates, resources

位置	路径	适用于
个人	~/.claude/skills//SKILL.md	你的所有项目
项目	.claude/skills//SKILL.md	仅此项目
插件	/skills//SKILL.md	启用插件的位置

如何工作

发现阶段：启动时，智能体仅加载每项可用技能的名称与描述，只需足够判断该技能是否相关即可。
激活阶段：当任务与某项技能的描述匹配时，智能体才会将完整的 SKILL.md 指令加载到上下文。
执行阶段：智能体按照指令执行任务，并可根据需要按需加载引用文件或执行捆绑的代码。

例子

详细内容可移步官方文档：SKILL.md规范
更多例子：UI UX Pro Max
使用 skills 扩展 Claude - Claude Code Docs

---
name: 技能名称
description: 简要描述这个技能的功能和使用场景

---

# 技能名称

## 描述
描述这个技能的作用。

## 使用场景
描述触发这个技能的条件。

## 指令
清晰的分步说明，告诉智能体具体怎么做。

## 示例 (可选)
输入/输出示例，展示预期效果。

渐进式拉取skill

sequenceDiagram
    actor User
    participant Agent as Claude Code Agent
    participant Skill as Skill 知识库 (.md)
    participant LLM as Claude LLM

    %% 交互流程
    User->>Agent: 提出需求（如：生成SVG动画）
    
    Agent->>Skill: 根据需求检索匹配技能
    Skill-->>Agent: 返回对应技能手册内容
    
    Agent->>LLM: 注入技能上下文 + 用户需求
    LLM-->>Agent: 要求查询Skill完整信息
    
    Agent->>LLM: 注入完整 Skill 上下文
    LLM-->>Agent: 要求执行Skill命令（如：sed）
    Agent->>LLM: 提供执行结果

    LLM-->>Agent: 生成最终结果
    Agent-->>User: 输出最终答案

OpenClaw深度解析：模型选择、Skill系统与Heartbeat机制

2026-03-31T00:00:00+00:00

准备工作
全链路数据流转总流程
- 源码目录
- 四层调用链
模型选择规则
- 实际案例
- 选择规则&优先级
SKILL
HEARTBEAT
Approval

准备工作

对话日志目录：/data/.openclaw/agents/<agent_id>/sessions/<run_id>.jsonl；
OpenRouter并不支持查看完整上下文，这里建议接入LangSmith库来解决。

全链路数据流转总流程

用户消息 → 对应Channel适配器（协议转换）→ Gateway 接收校验 → 会话锁获取与上下文加载
→ Agent Core 核心推理（Prompt 组装→模型选择→LLM 调用→工具/Skill 调用决策）
→ Skill/Plugin 执行 → 结果回灌 LLM → 多轮推理循环（按需）→ 最终回复生成
→ Gateway 消息封装 → 对应 Channel 适配器 → 用户端接收

源码目录

openclaw/
├── src/
│   ├── agents/                 # Agent 核心执行逻辑（对话处理核心）
│   │   └── pi-embedded-runner/ # 嵌入式 Agent 运行时（核心推理入口）
│   ├── channels/               # 渠道接入层（微信/飞书/API 等适配器）
│   ├── gateway/                # 调度网关层（Cron/Heartbeat/会话管理）
│   ├── core/                   # 核心基础能力（Skill/Plugin/事件/存储）
│   │   ├── skills/             # Skill 技能系统核心
│   │   ├── plugins/            # Plugin 插件管理核心
│   │   └── storage/            # 持久化存储实现
│   ├── extensions/             # 扩展模块（模型路由/钩子等）
│   └── utils/                  # 通用工具函数
├── docs/                       # 官方文档
└── examples/                   # 官方示例代码[[2]]

关键函数/模块	文件路径	职责说明
Channel Adapter	src/channels/	消息适配器：每个聊天平台对应一个适配器，负责接收特定平台的消息，并将其转换为 OpenClaw 内部的标准化事件格式。这是连接外部世界与 OpenClaw 内部系统的桥梁。
Gateway	src/gateway/server.impl.ts	网关服务：作为系统的神经中枢，Gateway 是一个 WebSocket 服务器，负责管理所有渠道的连接、会话状态以及消息路由。它接收来自 Channel 的标准事件。
Command Queue	src/auto-reply/reply/queue.ts	指令队列：收到的消息不会立即执行，而是进入一个基于会话（Session）的队列。该队列有三种模式（collect/steer/followup），决定了新消息是排队等待、中断当前任务还是作为后续指令，确保了任务处理的并发与有序。
agent/agent.wait	src/auto-reply/reply/agent-runner.ts	执行触发器：队列中的任务最终通过调用 agent() 或 agent.wait() RPC 方法，唤醒 Agent Runtime，正式开始一个完整的 ReAct 执行回合。agent.wait() 会等待任务执行完毕并返回结果。

四层调用链

层级	关键函数	文件路径	职责说明
L1	runReplyAgent	src/auto-reply/reply/agent-runner.ts	最高层封装：处理队列策略、任务“掌舵”（Steer）检查、最终结果的后处理和使用量上报。它确保一个入站消息能被完整地响应。
L2	runAgentTurnWithFallback	src/auto-reply/reply/agent-runner-execution.ts	失败回退层：核心职责是“容错”。它包裹了模型调用，当遇到可恢复的错误（如上下文超长、瞬时网络问题、API 限流）时，会自动执行重试、上下文压缩或切换到备用模型等回退策略。
L3	runEmbeddedPiAgent	src/agents/pi-embedded-runner/run.ts	并发控制与资源准备层：管理执行“车道”（Lane），确保每个会话的任务串行执行。此层还负责解析模型、迭代认证配置（Auth Profile）。
L4	runEmbeddedAttempt	src/agents/pi-embedded-runner/run/attempt.ts	单次尝试执行层：这是最核心的执行单元。它负责准备工作区（Workspace）、创建工具集、初始化会话，并最终调用 subscribeEmbeddedPiSession 发起对大语言模型（LLM）的单次请求。

模型选择规则

实际案例

"agents": {
    "defaults": {
        "model": {
            "primary": "openrouter/nvidia/nemotron-3-super-120b-a12b:free",
            "fallbacks": ["openrouter/nvidia/llama-nemotron-embed-vl-1b-v2:free"]
        },
        "models": {
            "openrouter/nvidia/nemotron-3-super-120b-a12b:free": {},
            "openrouter/nvidia/llama-nemotron-embed-vl-1b-v2:free": {}
        }
    }
},
"models": {
    "providers": {
        "openrouter": {
            "baseUrl": "https://openrouter.ai/api/v1",
            "apiKey": "${OPENROUTER_API_KEY}",
            "models": [
                {
                    "id": "nvidia/nemotron-3-super-120b-a12b:free",
                    "name": "Nemotron-3 Super 120B",
                    "input": ["text"]
                },
                {
                    "id": "nvidia/nemotron-nano-12b-v2-vl:free",
                    "name": "LLama-Nemotron EmbedEmbedding",
                    "input": ["text", "image"]
                }
            ]
        }
    }
}

选择规则&优先级

当前请求的模型（动态传入的 provider/model）；
单个智能体的 model.fallbacks；
全局 agents.defaults.model.fallbacks；
全局 agents.defaults.model.primary （最后的保障）；
全局允许列表：agents.defaults.models 作为模型白名单，仅列表内的模型可被调用；
提供者内部回退：同一模型提供商内的接口 / 认证失败，会先在提供商内部重试，再切换到下一个模型。

SKILL

SKILL名称是url链接里的，有很多事重复的，以这个为准，例如https://clawhub.ai/pskoett/self-improving-agent名称是self-improving-agent。
可以直接对话里安装SKILL。

执行过程

sequenceDiagram
    autonumber
    title OpenClaw 消息处理时序图
    participant User
    participant Channel
    participant Gateway
    participant CommandQueue as Command Queue
    participant AgentRuntime as Agent Runtime (L1-L4)
    participant Model as Model (LLM)
    participant ToolExecutor as Tool Executor
    participant EventSubscriber as Event Subscriber
    participant Persistence as Persistence (JSONL)

    User->>Channel: 发送消息
    Channel->>Gateway: 转发消息
    Gateway->>CommandQueue: 消息入队 (collect/steer/followup)
    CommandQueue->>AgentRuntime: agent.wait() 触发执行
    Note over AgentRuntime: L1: runReplyAgent\nL2: runAgentTurnWithFallback\nL3: runEmbeddedPlAgent\nL4: runEmbeddedAttempt
    AgentRuntime->>Model: 构建 Prompt (上下文+技能)
    Model->>AgentRuntime: 返回决策 (文本/工具调用)

    alt 直接回复
        AgentRuntime->>EventSubscriber: 流式事件 (assistant)
        Note over AgentRuntime: buildReplyPayloads()
        EventSubscriber->>User: 返回最终回复
    else 工具调用
        AgentRuntime->>ToolExecutor: 执行工具
        ToolExecutor->>AgentRuntime: 返回工具结果
        AgentRuntime->>Model: 注入结果, 再次推理
        Model->>AgentRuntime: 返回最终文本
        AgentRuntime->>EventSubscriber: 流式事件 (assistant)
        Note over AgentRuntime: buildReplyPayloads()
        EventSubscriber->>User: 返回最终回复
    end

    AgentRuntime->>Persistence: 会话持久化 (.JSONL)
    Persistence->>AgentRuntime: 持久化完成

OpenClaw也是用Reasoning and Acting（推理与行动）模式。

计算执行方式activeRunQueueAction

判断条件	activeRunQueueAction
当前无活跃运行？	run-now	typingSignals打字信号
心跳消息	drop
应该后续执行 OR messages.queue “steer”	enqueue-followup	messages.queue默认是collect
默认	run-now

LLM交互案例

INPUT

SYSTEM

SYSTEM 系统角色 / System Prompt，AI 的 “身份说明书” 和 “行为准则”，由开发者设定，是整个对话的「总纲领」。定义 AI 的角色、任务、回答风格、约束条件（比如 “你是一个专业的天气助手，只回答北京的天气问题，用口语化表达”）。

给模型设定上下文背景、规则、格式要求，全程约束模型的输出。
只在对话开头出现一次（或少数几次），不会由用户输入。

You are a personal assistant running inside OpenClaw.
## Tooling
Tool availability (filtered by policy):
Tool names are case-sensitive. Call tools exactly as listed.
- read: Read file contents
- write: Create or overwrite files
- edit: Make precise edits to files
- exec: Run shell commands (pty available for TTY-required CLIs)
- web_search: Search the web
- web_fetch: Fetch and extract readable content from a URL

HUMAN&AI

HUMAN。human（用户角色 / Human Message），真实用户的提问 / 输入，代表用户的需求、问题、补充信息，是模型需要响应的核心输入。
```
ou_aaaaaa: 明天北京需要带伞吗？
```
AI。AI 角色 / Assistant MessageAI 模型自己的历史回复，也就是上一轮对话的 Output。
- 保存对话历史，让模型理解上下文，实现多轮对话的连贯性。
- 比如用户追问 “那后天呢？”，模型需要通过 ai 角色的历史回复，知道上一轮已经回答了明天的天气，才能承接上下文。
```
read{"path":"/data/.openclaw/workspace/skills/weather/SKILL.md"}
```

HUMAN

---
name: weather
description: Get current weather and forecasts (no API key required).
homepage: https://wttr.in/:help
metadata: {"clawdbot":{"emoji":"🌤️","requires":{"bins":["curl"]}}}
---
# Weather
Two free services, no API keys needed.
## wttr.in (primary)
Quick one-liner:
curl -s "wttr.in/London?format=3"
# Output: London: ⛅️ +8°C

exec{"command":"curl -s \"https://api.open-meteo.com/v1/forecast?latitude=39.9042&longitude=116.4074&daily=precipitation_sum&timezone=Asia%2FShanghai\""}

HUMAN

{"latitude":39.875,"longitude":116.375,"generationtime_ms":0.042319297790527344,"utc_offset_seconds":28800,"timezone":"Asia/Shanghai","timezone_abbreviation":"GMT+8","elevation":47.0,"daily_units":{"time":"iso8601","precipitation_sum":"mm"},"daily":{"time":["2026-03-31","2026-04-01","2026-04-02","2026-04-03","2026-04-04","2026-04-05","2026-04-06"],"precipitation_sum":[1.00,0.00,0.00,0.30,1.50,0.00,0.00]}}

OUTPUT（输出）

明天北京不需要带伞☀️  
降水量：0.0 mm（干燥）  
可放心出门！ 🌤️

定义：这是 AI 模型返回的最终响应结果。这一轮它最后吐出的那一条 AI 回复；
内容：就是模型给用户的自然语言回答或结构化数据。

HEARTBEAT

CLI

openclaw system event --text "手动触发心跳" --mode now # 手动执行
openclaw system heartbeat last # 查询上一次执行结果
{
    "ts": 1774963724609,
    "status": "ok-token",
    "reason": "interval",
    "durationMs": 157974,
    "channel": "feishu",
    "silent": true,
    "indicatorType": "ok"
}

重点关注status、reason字段。

开启心跳

"heartbeat": {
    "every": "120m",
    "model": "openrouter/minimax/minimax-m2.5:free",
    "ackMaxChars": 0,
    "target": "feishu",
    "to": "${FEISHU_CHAT_ID}"
}
// 完整配置
{
    "agents": {
        "defaults": {
            "heartbeat": {
                "every": "30m",              // 触发间隔
                "target": "feishu",          // 发送通道
                "to": "chat:oc_xxx",         // 发送目标 ID
                "prompt": "自定义提示词",     // 可选：自定义提示词
                "model": "特定模型",          // 可选：专用模型
                "accountId": "账号ID",        // 可选：指定账号
                "isolatedSession": true,      // 可选：独立会话
                "lightContext": true,         // 可选：轻量上下文
                "includeReasoning": true,     // 可选：包含思考
                "ackMaxChars": 300,           // 可选：确认字符限制
                "directPolicy": "block"       // 可选：私聊策略
            }
        }
    }
}

飞书场景配置

场景	配置格式示例	ID 前缀	对应的 receive_id_type
群聊（推荐）	chat:oc_abc123、group:oc_abc123、channel:oc_abc123、oc_abc123	oc_	chat_id
用户私聊（open_id）	user:ou_abc123、dm:ou_abc123、open_id:ou_abc123、ou_abc123	ou_	open_id
用户私聊（user_id）	user:abc123、dm:abc123、abc123	无前缀	user_id
邮箱	email:user@example.com、user@example.com	邮箱格式	email

流程图


graph TB
    subgraph "一、触发时机"
        A1[定时触发<br/>heartbeat.every: 30m]
        A2[手动触发<br/>requestHeartbeatNow]
        A3[事件触发<br/>exec-event/cron-event/wake]
        A1 --> A4[requestHeartbeatNow]
        A2 --> A4
        A3 --> A4
        A4 --> A5[queuePendingWakeReason]
        A5 --> A6[schedule定时器]
    end

    subgraph "二、执行主流程"
        B1[入口: runHeartbeatOnce]
        B2[前置检查<br/>- 全局启用<br/>- 代理启用<br/>- 间隔配置<br/>- 活跃时间<br/>- 队列空闲]
        B3[预飞行检查<br/>resolveHeartbeatPreflight]
        B4[解析发送目标<br/>resolveHeartbeatDeliveryTarget]
        B5[解析提示词<br/>resolveHeartbeatRunPrompt]
        B6[调用LLM<br/>getReplyFromConfig]
        B7[处理LLM回复]
        B8[发送结果]
        B9[清理和收尾]

        B1 --> B2
        B2 --> B3
        B3 --> B4
        B4 --> B5
        B5 --> B6
        B6 --> B7
        B7 --> B8
        B8 --> B9
    end

    subgraph "三、HEARTBEAT.md处理"
        C1[文件位置<br/>workspaceDir/HEARTBEAT.md]
        C2[预飞行读取<br/>检查是否有效为空]
        C3{有效为空?}
        C4[是: skipReason=empty-heartbeat-file]
        C5[否: 继续执行]
        C6[提示词引用<br/>Read HEARTBEAT.md]
        C7[LLM读取并处理]
        
        C1 --> C2
        C2 --> C3
        C3 -->|是| C4
        C3 -->|否| C5
        C5 --> C6
        C6 --> C7
    end

    subgraph "B3 预飞行检查详情"
        D1[解析会话信息]
        D2[检查系统事件队列]
        D3[读取HEARTBEAT.md]
        D4[判断触发原因类型]
        
        D1 --> D2
        D2 --> D3
        D3 --> D4
    end

    subgraph "B6 调用LLM详情"
        E1[构建请求上下文]
        E2[Body: 提示词+时间线]
        E3[OriginatingChannel/To]
        E4[Provider: heartbeat]
        E5[执行智能体调用]
        E6[获取回复结果]
        
        E1 --> E2
        E1 --> E3
        E1 --> E4
        E2 --> E5
        E3 --> E5
        E4 --> E5
        E5 --> E6
    end

    subgraph "B7 处理LLM回复详情"
        F1[解析回复负载]
        F2[标准化回复<br/>移除HEARTBEAT_TOKEN]
        F3{需要跳过?}
        F4[仅HEARTBEAT_OK → 跳过]
        F5[内容为空且无媒体 → 跳过]
        F6[24小时重复 → 跳过]
        F7[继续发送]
        
        F1 --> F2
        F2 --> F3
        F3 -->|是| F4
        F3 -->|是| F5
        F3 -->|是| F6
        F3 -->|否| F7
    end

    %% 连接关系
    A6 --> B1
    B3 --> D1
    D3 --> C1
    B6 --> E1
    B7 --> F1
    C5 --> B5

发送结果

status	reason	result
skipped	disabled	心跳功能已禁用
skipped	quiet-hours	当前处于非活跃时间段
skipped	requests-in-flight	请求队列忙碌，跳过本次心跳
skipped	empty-heartbeat-file	HEARTBEAT.md 文件内容为空
skipped	no-target	未配置心跳发送目标
skipped	unknown-account	目标账号不存在
skipped	dm-blocked	私聊被对方阻止
skipped	alerts-disabled	警报功能已禁用
skipped	duplicate	心跳内容重复，跳过发送
skipped	not-due	未到下一次心跳执行时间
ok-empty	-	执行成功，但无回复内容
ok-token	-	执行成功，返回 HEARTBEAT_OK 标识
sent	-	心跳消息发送成功
failed	-	心跳消息发送失败

Reason	触发方式	说明
interval	定时触发	配置 heartbeat.every: 30m 的定时触发
wake	外部唤醒	CLI –mode now、服务重启、Push 通知等
hook	Webhook	HTTP webhook 触发（hook:wake）
cron	Cron 任务	Cron 定时任务触发（cron:*）
exec-event	执行事件	Shell 命令执行完成后触发
manual	手动	其他手动触发方式
retry	重试	心跳失败重试
other	其他	未识别的触发方式

交互案例

与SKILL区别不大，提示词如下：

Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.
When reading HEARTBEAT.md, use workspace file /data/.openclaw/workspace/HEARTBEAT.md (exact case). Do not read docs/heartbeat.md.
Current time: Tuesday, March 31st, 2026 — 04:15 (UTC) / 2026-03-31 04:15 UTC

Approval

security - 安全模式

值	代码作用	说明
“deny”	默认拒绝所有	最严格，默认拒绝所有命令执行
“allowlist”	只允许 allowlist 中的命令	平衡安全和灵活，需要手动配置 allowlist
“full”	允许所有命令	最宽松，完全关闭安全检查

ask - 审批询问策略

值	代码作用	说明
“off”	从不询问审批	完全跳过审批流程，直接根据安全模式决定
“on-miss”	不在 allowlist 中时询问	只有当命令不在 allowlist 中时才弹出审批询问
“always”	总是询问审批	无论命令是否在 allowlist 中，都会弹出审批询问

askFallback - 审批超时后的行为

值	代码作用	说明
“deny”	超时后拒绝执行	最安全，超时后默认拒绝命令
“allowlist”	超时后检查 allowlist	超时后，如果命令在 allowlist 中就允许
“full”	超时后直接允许	最宽松，超时后无条件允许命令

OpenClaw部署实战：在fly.io上快速搭建AI智能助手

2026-03-30T00:00:00+00:00

Quick Start
部署流程
运行效果
常用命令

Quick Start

下载OpenClaw脚手架cyeamclaw。
申请fly应用和外挂存储，参考官方文档fly.io.
在fly.io或.env中部署密钥，使用fly deploy命令部署。

部署流程

flowchart TD
    subgraph "运行([processes]start-services.sh)"
        feishu --> gateway
        gateway --> openclaw_json[(openc claw\n.json)]
        gateway --> Runtime
        Runtime --> models[models\nsecrets]
        Runtime --> skills[skills\nSKILL.md, CONF]
        Runtime --> cron
    end

    subgraph "部署([env][mounts])"
        env_vars[环境变量\n配置路径路径、启动参数]
        secrets[秘钥\n.env、fly Secrets]
        mounts[挂载磁盘\n/data]
    end

    subgraph "环境"
        openclaw_dir[OPENCLAW 目录=/data/.openclaw]
        cli_path[可执行cli /usr/bin/ /usr/local/bin]
    end

    subgraph "打包([build]Dockerfile)"
        compile_env[编译环境变量]
        set_cn[设置中文]
        sync_json[同步openclaw.json]
        add_perm[增加执行权限]
        install_openclaw[安装openclaw]
        install_skill_deps[安装skill依赖]
    end

在fly.io部署最核心的是fly.toml文件，它定义了应用的编译信息[build]、环境变量[env]、硬盘挂载[mounts]、启动配置[processes]等。

[build]用Dockerfile文件实现，构建包含 OpenClaw 全量运行依赖的 Docker 镜像，本阶段最终产出：可直接部署的 OpenClaw 标准化 Docker 镜像。：
1. 配置编译环境变量：在 Dockerfile 中预设构建所需的基础环境参数，比如 Node.js 运行时版本、软件源、系统架构适配参数等，确保跨环境构建的一致性。
2. 设置系统中文环境：安装中文字体、配置zh_CN.UTF-8系统编码，解决 OpenClaw 运行时的中文乱码、 emoji 显示异常问题。
3. 同步 openclaw.json 主配置文件：将提前编写好的 OpenClaw 核心配置文件打包到镜像内，或预设配置模板，确保服务启动时可直接加载核心规则。
4. 增加执行权限：给启动脚本start-services.sh、技能执行脚本等核心文件授予可执行权限，避免容器启动时因权限不足报错。
5. 安装 OpenClaw 主程序：通过 npm 全局安装 OpenClaw CLI，将可执行文件部署到/usr/bin/、/usr/local/bin/系统路径（对应图表「环境」模块的可执行 CLI 路径），确保全局可调用。
6. 安装 Skill 技能依赖：提前安装自定义技能所需的系统依赖、语言运行时依赖，避免运行时技能加载失败。
[env]定义环境变量，磁盘挂载。OpenClaw运行时信息，包括记忆、日志不能放在容器中，否则会在每次部署时被覆盖，需要放在挂载硬盘/data上。
1. 持久化工作目录准备：确定 OpenClaw 核心工作目录为/data/.openclaw，该目录用于存储会话数据、技能文件、运行日志、模型密钥等核心数据，需提前准备对应的持久化存储资源。
2. 执行需要的cli放在/usr/bin，/usr/local/bin，确保全局可调用。
3. 环境变量注入：通过容器环境变量，配置 OpenClaw 的核心运行参数，主要是OpenClaw和Skill的配置文件路径、模型并发限制等。
```
OPENCLAW_HOME = "/data"
OPENCLAW_STATE_DIR = "/data/.openclaw"
OPENCLAW_CONFIG_PATH = "/data/.openclaw/openclaw.json"
```
4. 敏感密钥安全管理：通过.env文件、fly Secrets 等安全方式，注入模型 API 密钥、飞书渠道凭证、第三方服务 Token 等敏感信息，避免硬编码到镜像中造成泄露。
[processes]从start-services.sh作为入口启动服务，核心是openclaw.json配置文件。
1. 默认日志在/tmp/openclaw.log。
2. openclaw工作目录功能如下，workspace里的文件调教方式可参考《搞懂这7个配置文件让你的OpenClaw变智能助手》：

环境变量	作用	优先级	默认值	示例
OPENCLAW_HOME	用户主目录，用于解析 ~ 路径	低	$HOME	/data
OPENCLAW_STATE_DIR	状态/配置目录，存储所有文件	高	$OPENCLAW_HOME/.openclaw	/data/.openclaw

/data/.openclaw/
├── openclaw.json                 # 主配置文件（JSON/JSON5）
├── exec-approvals.json           # 执行审批配置文件（JSON/JSON5）
├── workspace/                    # 你的 AI “灵魂”文件夹（推荐 git 版本控制）
│   ├── SOUL.md                   # 人格设定（语气、风格）
│   ├── USER.md                   # 你的个人信息（让 AI 更懂你）
│   ├── MEMORY.md                 # 长期记忆（手动可编辑）
│   ├── IDENTITY.md               # Agent 名称、形象
│   ├── AGENTS.md                 # 多 Agent 路由规则
│   ├── BOOT.md                   # 启动提示词
│   ├── HEARTBEAT.md              # 每日检查清单
│   └── skills/                   # 已安装技能（每个技能一个子文件夹）
├── agents/<cid>/                 # 每个 Agent 的独立状态
├── memory/<cid>.sqlite           # 向量记忆库
├── credentials/                  # API Key、OAuth（旧版）
├── skills/                       # 全局技能包
└── secrets.json                  # 加密凭证（可选）
└── devices/                      # 设备
│   ├── paired.json               # 已配对设备列表

运行效果

cron执行效果如下，每天定时推送热门新闻。

openclaw cron add \
  --name "每日热榜推送" \
  --cron "0 0 * * *" \
  --tz "Asia/Shanghai" \
  --session isolated \
  --message "使用 daily-hot-push 技能获取今日热榜TOP10并推送" \
  --announce \
  --channel feishu \
  --to "ou_aaaaa"

常用命令

fly.io命令

flyctl secrets list -a cyeamclaw
fly machine start 2865110a372e48
fly logs -i 2865110a372e48
fly deploy -a cyeamclaw && sleep 5 && fly machine start 2865110a372e48 && fly logs -i 2865110a372e48

OpenClaw命令

openclaw --version
openclaw logs -follow
openclaw pairing list
openclaw pairing list feishu
openclaw gateway restart
openclaw channels list
openclaw cron list --all
openclaw config set agents.sandbox.mode all
openclaw config set tools.deny '["group:web","browser"]'
openclaw approvals get

斜杠命令

官方文档斜杠命令

/model
/model list
/model openrouter/nvidia/nemotron-nano-12b-v2-vl:free
/verbose full

最近切换域名服务器，为了查问题用了很多方法，这里记录下

2026-03-21T00:00:00+00:00

Chrome浏览器报错如下，中间走了很多网路，TLS配置、QUIC、服务器限流等等，确实有知识盲区，领取Chrome报错也太不清楚了。。。

检查网络连接
检查代理服务器和防火墙
ERR_CONNECTION_CLOSED 访问网页有问题

确定是不是真有问题
1. https://downforeveryoneorjustme.com/;
2. Ping;
查询域名服务器，选择NS类型
1. ITDog
2. while true; do dig cyeam.com NS +short; sleep 20; done
查询解析结果，AA、AAAA
1. ITDog
2. while true; do dig cyeam.com AAAA +short; sleep 20; done
用IP138检测解析出来的结果是否正确，拿着IP查询所在地，是Cloudflare还是其他服务器；
检查浏览器DNS解析结果
1. chrome://net-internals/#dns 输入域名cyeam.com查询

因为是偶发问题很难复现，最后问题就是出现在第5步，当出问题时查了下域名记录，结果如下，其中多了ech_config_list，这就是问题所在，该记录携带了 Cloudflare 的 ECH 加密配置和 Cloudflare 边缘节点 IP，Chrome 优先用这个 Cloudflare 节点发起连接；但我们无法正常使用ECH，收到请求后直接关闭了 TCP 连接。其他人也需要了类似问题，Cloudflare无法在页面关闭，需要用命令行。

Resolved IP addresses of "note.cyeam.com": ["1.1.1.1"].
Alternative endpoint: {"alpns":["h2","http/1.1"],"ech_config_list":"fdsafafdafadsfadsfdsa","ip_endpoints":["1.1.1.1"]}

用Playwright扫描渲染问题

2026-03-17T00:00:00+00:00

按照依赖包：

npm install playwright --save
npx playwright install

保存下面的脚本，用命令node scan.js运行即可。

const { chromium, devices } = require('playwright');
const https = require('https');
const fs = require('fs');
const path = require('path');

// --- 配置区域 ---
const CONFIG = {
  urls: [
// 'https://www.cyeam.com/tool/ddl2gostruct',
// 'https://www.cyeam.com/tool/json2ddl',
 
    'https://www.cyeam.com/sitemap.xml',
   ],
  outputDir: './scan-results',
  timeout: 10000,
  headless: true,
  devicesToTest: [
    { name: 'Mobile-iPhone-15', preset: 'iPhone 15' },
    { name: 'Desktop-MacBook-Pro-16', preset: 'MacBook Pro 16' },
  ],
  maxSitemapUrls: 300,
  retryTimes: 3 // 重试次数
};

// --- 辅助函数：带重试的page.goto ---
const gotoWithRetry = async (page, url, options, maxRetries) => {
  let lastError;
  for (let retry = 1; retry <= maxRetries; retry++) {
    try {
      if (retry > 1) {
        console.log(`   🔄 重试(${retry}/${maxRetries})访问: ${url}`);
      }
      await page.goto(url, options);
      return; // 成功则直接返回
    } catch (error) {
      lastError = error;
      if (error.message.includes('Timeout') || error.message.includes('timeout')) {
        if (retry === maxRetries) {
          throw new Error(`[Retry Failed] 超过${maxRetries}次重试仍无法访问: ${url}，错误：${error.message}`);
        }
        await new Promise(resolve => setTimeout(resolve, 1000));
      } else {
        throw error;
      }
    }
  }
  throw lastError;
};

// --- 辅助函数：原生解析Sitemap ---
const fetchSitemapUrls = (sitemapUrl) => {
  return new Promise((resolve, reject) => {
    https.get(sitemapUrl, (res) => {
      let xml = '';
      // 1. 处理编码问题（避免chunk拼接乱码）
      res.setEncoding('utf8');
      
      res.on('data', (chunk) => xml += chunk);
      res.on('end', () => {
        try {
          // 2. 替换正则匹配方式：用matchAll（ES2020+），避免lastIndex陷阱
          const urlRegex = /<loc>(.*?)<\/loc>/g;
          // 兼容写法：如果环境不支持matchAll，用while循环+重置lastIndex
          const urls = [];
          let match;
          // 重置正则lastIndex，确保从头匹配
          urlRegex.lastIndex = 0;
          while ((match = urlRegex.exec(xml)) !== null) {
            if (match[1]) {
              urls.push(match[1].trim()); // 去除首尾空格，避免无效URL
            }
          }

          // 3. 优化域名过滤逻辑：匹配主域名（而非完整hostname）
          const baseUrlObj = new URL(sitemapUrl);
          // 提取主域名（如从www.cyeam.com提取cyeam.com）
          const baseDomain = baseUrlObj.hostname.split('.').slice(-2).join('.');
          
          const filteredUrls = urls.filter(url => {
            try {
              const urlObj = new URL(url);
              // 匹配主域名（支持所有子域名：www/blog/note/game.cyeam.com）
              const urlDomain = urlObj.hostname.split('.').slice(-2).join('.');
              return urlDomain === baseDomain;
            } catch (e) {
              console.warn('无效URL:', url, e.message);
              return false;
            }
          });

          // 4. 最终结果：按CONFIG截断（但先确保CONFIG值足够大）
          const result = filteredUrls.slice(0, CONFIG.maxSitemapUrls);
          console.log(`提取结果：总匹配${urls.length}个 → 过滤后${filteredUrls.length}个 → 最终${result.length}个`);
          resolve(result);
        } catch (e) {
          reject(new Error(`解析XML失败：${e.message}`));
        }
      });
    })
    // 处理请求错误（如超时、连接失败）
    .on('error', (err) => reject(new Error(`请求Sitemap失败：${err.message}`)))
    // 处理超时
    .setTimeout(10000, () => reject(new Error('请求Sitemap超时')));
  });
};

// --- 辅助函数：初始化目录 ---
const initDirs = (deviceName) => {
  const dir = path.join(CONFIG.outputDir, deviceName);
  const shotDir = path.join(dir, 'screenshots');
  if (!fs.existsSync(shotDir)) fs.mkdirSync(shotDir, { recursive: true });
  return { dir, shotDir };
};

// --- 核心逻辑 ---
(async () => {
  try {
    let urls = [];
    let isSitemapMode = false;

    if (CONFIG.urls.length === 1 && CONFIG.urls[0].toLowerCase().includes('sitemap.xml')) {
      isSitemapMode = true;
      const sitemapUrl = CONFIG.urls[0];
      console.log(`🔍 检测到sitemap模式，正在解析: ${sitemapUrl}`);
      urls = await fetchSitemapUrls(sitemapUrl);
      console.log(`✅ 从sitemap解析出 ${urls.length} 个URL\n`);
    } else {
      urls = CONFIG.urls;
      console.log(`📋 使用手动配置的URL列表，共 ${urls.length} 个URL\n`);
    }

    if (urls.length === 0) {
      console.log('❌ 未找到可检测的URL，请检查配置！');
      return;
    }

    for (const deviceConfig of CONFIG.devicesToTest) {
      console.log(`\n========== 正在测试设备: ${deviceConfig.name} ==========`);
      const { dir, shotDir } = initDirs(deviceConfig.name);
      const results = [];

      const browser = await chromium.launch({ headless: CONFIG.headless });
      
      let context;
      if (deviceConfig.preset) {
        const device = devices[deviceConfig.preset];
        context = await browser.newContext({ ...device });
      } else {
        context = await browser.newContext({ viewport: deviceConfig.viewport });
      }

      const page = await context.newPage();

      for (const url of urls) {
        // 1. 初始化结果对象，新增timeCost字段
        const pageResult = { url, errors: [], screenshot: null, timeCost: 0 };
        const safeFilename = url.replace(/[^a-zA-Z0-9]/g, '_');
        
        // 2. 记录访问开始时间（毫秒级）
        const startTime = Date.now();

        try {
          page.on('pageerror', err => pageResult.errors.push(`[JS] ${err.message}`));
          
          // 访问页面（包含重试逻辑）
          await gotoWithRetry(page, url, { waitUntil: 'load', timeout: CONFIG.timeout }, CONFIG.retryTimes);

          // 检查横向滚动条
          const hasHorizontalScroll = await page.evaluate(() => {
            return document.documentElement.scrollWidth > document.documentElement.clientWidth;
          });
          if (hasHorizontalScroll) {
            pageResult.errors.push('[Layout] 检测到横向滚动条，内容溢出屏幕');
          }

          // 检查裂图
          const brokenImages = await page.evaluate(() => {
            const imgs = Array.from(document.images);
            return imgs
              .filter(img => !img.alt.includes('大图预览'))
              .filter(img => img.naturalWidth === 0)
              .map(img => {
                const getXPath = (element) => {
                  if (element.id !== '') return `//*[@id="${element.id}"]`;
                  if (element === document.body) return '/html/body';
                  
                  let ix = 0;
                  const siblings = element.parentNode.childNodes;
                  for (let i = 0; i < siblings.length; i++) {
                    const sibling = siblings[i];
                    if (sibling === element) return `${getXPath(element.parentNode)}/${element.tagName.toLowerCase()}[${ix + 1}]`;
                    if (sibling.nodeType === 1 && sibling.tagName === element.tagName) ix++;
                  }
                  return getXPath(element.parentNode);
                };

                return {
                  src: img.src,
                  alt: img.alt,
                  html: img.outerHTML,
                  xpath: getXPath(img)
                };
              });
          });

          if (brokenImages.length > 0) {
            for (const brokenImg of brokenImages) {
              const errMsg = `[Layout] 裂图详情：
                - 链接: ${brokenImg.src}
                - Alt文本: ${brokenImg.alt || '无'}
                - HTML代码: ${brokenImg.html}
                - XPath路径: ${brokenImg.xpath}`;
              pageResult.errors.push(errMsg);
            }
          }

          // 截图保存
          const screenshotPath = path.join(deviceConfig.name, 'screenshots', `${safeFilename}.png`);
          await page.screenshot({ path: path.join(CONFIG.outputDir, screenshotPath), fullPage: true });
          pageResult.screenshot = screenshotPath;

        } catch (e) {
          pageResult.errors.push(`[Critical] ${e.message}`);
        } finally {
          // 3. 计算总耗时（无论成功/失败，都会执行）
          pageResult.timeCost = Date.now() - startTime;
        }

        results.push(pageResult);
        
        // 4. 控制台输出时展示耗时
        if (pageResult.errors.length > 0) {
          console.log(`❌ ${url} (耗时: ${pageResult.timeCost}ms)`);
          pageResult.errors.forEach(err => console.log(`   - ${err}`));
        } else {
          console.log(`✅ ${url} (耗时: ${pageResult.timeCost}ms)`);
        }
      }

      // 保存检测报告（包含耗时字段）
      fs.writeFileSync(path.join(dir, 'report.json'), JSON.stringify(results, null, 2));
      await browser.close();
    }

    console.log(`\n🎉 扫描完成！结果已保存至: ${path.resolve(CONFIG.outputDir)}`);
  } catch (error) {
    console.error('💥 运行出错:', error);
  }
})();

手机端页面横向滚动条排查方法

2026-03-16T00:00:00+00:00

复现
定位

AI教我学习前端系列。

移动端因为页面较窄，很容易由于内部元素配置有问题导致出现横向滚动条。但手机端排查难度又比较大，还是需要在PC端排查。

复现

在桌面Chrome打开调试页面，切换成移动端模式。
我的情况要复杂些，桌面调试一开始无法复现问题，是分辨率对不上的问题，遂又搭建了设备信息检测工具。如下图所示：
在浏览器中填入问题设备的像素，问题复现。

定位

如果是简单的页面，通过Elements工具就能发现问题了，可以把鼠标放到每个Element上面看，Chrome自然会提示宽度。如果宽度超出了第一步获取到的数值，那么恭喜你，你找到问题元素了。但如果页面比较复杂，元素嵌套比较深，通过Elements工具就比较麻烦了。这时可以考虑通过Chrome的Console工具来排查。在Console中输入以下代码，回车执行：

// 查找所有溢出视口的元素（带定位+高亮）
(function() {
  const allElements = document.querySelectorAll('*');
  const overflowElements = [];
  
  // 先清除之前的高亮（避免干扰）
  document.querySelectorAll('[data-overflow-highlight]').forEach(el => {
    el.style.removeProperty('border');
    el.removeAttribute('data-overflow-highlight');
  });

  allElements.forEach(el => {
    const rect = el.getBoundingClientRect();
    // 检查元素是否超出视口宽度（排除不可见元素，减少干扰）
    if ((rect.right > window.innerWidth || rect.left < 0) && rect.width > 0) {
      // 1. 给溢出元素加红色边框（可视化高亮）
      el.style.border = '2px solid red !important';
      el.style.boxShadow = '0 0 10px red !important';
      el.setAttribute('data-overflow-highlight', 'true');

      // 2. 构造定位信息（方便查找）
      let selector = '';
      if (el.id) {
        selector = `#${el.id}`; // 有id直接用#id
      } else if (el.className) {
        // 处理多class，转为.类名1.类名2
        selector = `.${el.className.trim().replace(/\s+/g, '.')}`;
      } else {
        selector = el.tagName.toLowerCase(); // 无class/id用标签名
      }

      // 3. 收集信息（包含元素本身，关键！）
      overflowElements.push({
        元素引用: el, // 核心：Console点击可跳转到Elements面板
        标签名: el.tagName,
        类名: el.className,
        ID: el.id || '无',
        选择器: selector,
        元素宽度: `${rect.width.toFixed(2)}px`,
        元素右边界: `${rect.right.toFixed(2)}px`,
        视口宽度: `${window.innerWidth}px`,
        溢出宽度: `${(rect.right - window.innerWidth).toFixed(2)}px` // 超出多少
      });
    }
  });

  // 输出表格（可点击「元素引用」列跳转到Elements）
  console.table(overflowElements);
  
  // 提示信息
  console.log('%c✅ 溢出元素已标红边框，Console表格中点击「元素引用」可直接定位到Elements面板', 'color: green; font-weight: bold');
  console.log('%c⚠️ 刷新页面可清除红色边框', 'color: orange; font-weight: bold');
})();

如果有问题，所显示一个Array，点击展开它，点击「元素引用」会跳到Elements面板，这就是有问题的元素，右击这个元素选择「Scroll into View」，鼠标放上去看宽度即可诊断。

药不能停

2026-03-14T00:00:00+00:00

说明
使用指南
ChangeLog
- v1.0.1 (2026-04-02)
  - Build
  - Feat
  - Fix
- v1.0.0 (2026-03-14)

立即下载-药不能停

说明

本应用用于帮助用户快速掌握药品管理、每日提醒、历史记录、数据备份等全部功能。所有数据均保存在手机本地，不联网、不上传。

功能模块	说明	产品截图
药品管理	添加 / 删除药品名称、剂量、每日提醒时间
每日定时提醒	按设定时间准时提醒，每天自动重复
服药历史记录	查看所有已提醒、已确认服药的记录

使用指南

添加药品

点击主界面右下角 + 按钮
填写：
- 药品名称（必填）
- 服药剂量（可选）
点击选择时间，设置每日提醒时刻
点击保存
系统自动设置每日重复闹钟

删除药品

在药品列表找到对应药品
点击删除按钮
系统自动取消该药品的所有提醒

查看服药历史

点击主界面右上角菜单（三个点）
选择服药历史
可查看：
- 药品名称
- 提醒时间
- 服药状态（已服药）

常见问题 FAQ

Q1：提醒只响一次，之后不提醒？ A：通常是被系统杀后台。请开启：自启动 + 后台运行 + 关闭电池优化。
Q2：收不到通知？ A：检查： APP 通知权限是否开启手机是否开启静音 / 勿扰模式
Q3：APP 升级后数据不见了？ A：正常覆盖升级不会丢数据。如丢失，点击恢复数据即可从备份找回。
Q4：手机重启后提醒失效？ A：不会。 APP 已支持开机自动恢复所有闹钟。

注意事项

卸载 APP 会清空本地数据，卸载前请务必备份。
提醒依赖系统闹钟，请勿使用 “清理内存” 类工具强制关闭 APP。
所有数据仅存在本地，隐私安全。
最低支持 Android 8.0（API 26）。

ChangeLog

v1.0.1 (2026-04-02)

Build

更新应用版本号为v1.0.1

Feat

analytics: 集成百度移动统计SDK
i18n: 添加多语言支持并国际化UI字符串
ui: 添加未来提醒功能并优化界面

Fix

MedicineAdapter: 使用资源字符串显示剂量标签

v1.0.0 (2026-03-14)

Added
- 支持本地保存药品和服药记录
- 支持查询服药历史
- 支持推送功能

Geek新闻每日AI热点新闻

2026-03-12T00:00:00+00:00

需求
方案
MCP 实现
- 传输方式对比
- MCP 切换官方Go SDK

立即体验-GeekNews

需求

新增微信公众号RSS，微信防爬虫力度非常强，需要做适配。只展示标题、链接即可；
其他RSS支持标题、链接、内容简介（基于AI总结）;
基于MCP搭建，每天定时更新AI最新动态。

方案

flowchart TB
    %% Web端
    subgraph Web端
        A[拉取JSON数据] --> B[页面渲染]
    end

    %% 应用层
    subgraph 应用层
        GenNews[定时拉取新闻数据] --> D[保存新闻JSON]
        D --> E[刷新缓存]
    end
    
    %% MCP服务核心层
    subgraph MCP服务
        TechNews[并发获取新闻] --> H[时间排序&截取模块]
        H --> J[LLM总结精简内容]
        
        
    end
    
    %% 数据源
    subgraph 数据存储
        DS1[新闻数据RSS]
        DS2[当天新闻JSON文件]
    end

    LLM[LLM]
   

    %% 链路连接
    A --> DS2
    GenNews -->|title/img/desc|TechNews
    TechNews --> DS1
    D --> DS2
    J --> LLM
    
    A ~~~ GenNews
    E ~~~ DS2
    E ~~~ TechNews

MCP 实现

传输方式对比

对比维度	stdio（标准输入输出）	Streamable HTTP（新版官方推荐）	HTTP with SSE（旧版已弃用）
核心通信机制	客户端启动服务器子进程，通过 stdin/stdout 双向传输换行分隔的 JSON-RPC 消息，stderr 用于日志Model Context Protocol	单一 HTTP 端点同时支持 POST/GET；客户端 POST 发请求，支持同步 JSON 响应或 SSE 流式推送，内置会话管理与断点续传	双端点架构：SSE GET 端点建立长连接收服务端消息，HTTP POST 端点发客户端消息，服务端通过 SSE 单向推送结果
部署模式	本地父子进程，仅限同一台机器	独立服务进程，支持本地 / 局域网 / 云端跨网络跨机器部署	独立服务进程，支持跨网络跨机器部署
生命周期	与客户端进程强绑定，客户端退出则服务器子进程终止	服务端独立运行，与客户端完全解耦，支持会话生命周期管理	服务端独立运行，与客户端解耦
多客户端能力	不支持，1 个客户端对应 1 个独立服务器进程	原生支持多客户端并发连接，可负载均衡	支持多客户端连接
连接恢复能力	进程退出即连接终止，无恢复能力	原生支持 SSE 流断点续传，通过 Last-Event-ID 重放丢失消息Model Context Protocol	断连后需重建 SSE 连接，无官方续传机制
性能表现	本地进程间通信，延迟极低（通常 < 1ms），无网络栈开销，资源占用最小	受网络带宽 / 延迟影响，长连接模式下延迟可控，支持流式传输优化	受网络影响，长连接占用固定资源，断连开销大
安全性	天然安全，不暴露网络端口，无远程攻击面，依赖操作系统进程隔离	需自行配置 HTTPS 加密、Origin 校验、身份认证、防火墙策略，有网络暴露风险Model Context Protocol	同左，需额外的安全加固

MCP 切换官方Go SDK

// 服务端
server1 := mcp.NewServer(&mcp.Implementation{Name: "greeter1"}, nil)
mcp.AddTool(server1, &mcp.Tool{Name: "greet1", Description: "say hi"}, SayHi)
handler := mcp.NewStreamableHTTPHandler(func(request *http.Request) *mcp.Server {
    return server1
}, nil)
app.Handle("/mcp", http.HandlerFunc(handler.ServeHTTP))
l, err := net.Listen("tcp", ":1031")
if err != nil {
    logger.Errorf("Listen: %v", err)
    return
}
app.Serve(l)

// 客户端
client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
ctx := context.Background()
transport := &mcp.StreamableClientTransport{Endpoint: "http://localhost:1031/mcp"}
session, err := client.Connect(ctx, transport, nil)
if err != nil {
    log.Fatal(err)
}
defer session.Close()

params := &mcp.CallToolParams{
    Name:      "greet1",
    Arguments: map[string]any{"name": "you"},
}
res, err := session.CallTool(ctx, params)
if err != nil {
    log.Fatalf("CallTool failed: %v", err)
}
for _, a := range res.Content {
    buf, _ := a.MarshalJSON()
    fmt.Println(string(buf))
}

Mermaid语法整理

2026-03-10T00:00:00+00:00

一、流程图（Flowchart）
二、时序图（Sequence Diagram）
三、甘特图（Gantt Chart）
四、饼图（Pie Chart）
- 1. 基础规则
- 2. 完整示例
五、类图（Class Diagram）
六、状态图（State Diagram）
- 1. 基础规则
- 2. 完整示例
七、Mermaid 通用使用技巧

Mermaid 是一款基于 JavaScript 的图表绘制工具，通过简单的文本描述即可生成流程图、时序图、甘特图等多种图表。以下整理了最常用的几种图表的核心语法。

一、流程图（Flowchart）

最常用的图表类型，用于描述业务流程、执行逻辑，支持多方向布局和复杂子图/分支。

1. 基础规则

图表开头用flowchart（旧版graph也兼容），后跟布局方向，无方向默认从上到下；
节点用唯一标识定义，标识与显示文本用[]/()/{}/(())分隔，对应不同节点样式；
连线用箭头/符号表示，可添加连线说明文本；
子图用subgraph定义，用于分组逻辑，子图可独立指定方向。

2. 核心元素

（1）布局方向

语法	含义
TD/TB	从上到下（Top Down/Top Bottom，最常用）
LR	从左到右（Left Right）
BT	从下到上（Bottom Top）
RL	从右到左（Right Left）

（2）节点样式

语法	节点类型	示例
id[文本]	矩形（普通流程节点，最常用）	start[开始]
id(文本)	圆角矩形（开始/结束节点）	end(结束)
id{文本}	菱形（判断/分支节点）	judge{是否符合条件？}
id((文本))	圆形（起止/重要节点）	core((核心步骤))
id>文本	右向旗帜形	flag>备注

（3）连线类型

语法	连线样式	示例（带说明）
->	实线箭头（最常用）	A->B
–>	虚线箭头	A–>B
-.-	点线箭头	A-.-B
==>	粗线箭头	A==>B
->\|文本\|	实线箭头+说明	A->\| 执行操作 \| B
~~~	隐藏线，用于控制布局，不展示实际连线	A~~~B

3. 完整示例

flowchart LR
A[Hard] -->|Text| B(Round)
B --> C{Decision}
C -->|One| D[Result 1]
C -->|Two| E[Result 2]

二、时序图（Sequence Diagram）

用于描述不同参与者之间的交互过程，按时间顺序展示消息传递，适合接口调用、系统交互等场景。

1. 基础规则

图表开头用sequenceDiagram，无需指定方向，默认从左到右、从上到下按时间流；
先定义参与者（Actor/Participant），参与者可自定义别名；
消息连线按交互关系选择，可添加消息文本，支持循环、条件、并行等逻辑块。

2. 核心元素

（1）参与者定义

sequenceDiagram
    actor U as 用户  # 角色参与者（人形图标）
    participant S as 服务端  # 普通参与者（矩形图标）
    participant D as 数据库

actor：带人形图标的参与者（如用户、管理员）；
participant：普通矩形参与者（如系统、服务、数据库）；
as：为参与者设置别名，简化后续语法。

（2）消息连线（核心）

语法	连线含义	适用场景
A->B: 文本	实线无箭头，单向消息	普通通知 / 调用
A-»B: 文本	实线有箭头，单向同步调用	核心交互（最常用）
A–»B: 文本	虚线有箭头，单向异步调用	异步接口 / 消息队列
A–x B: 文本	虚线叉号，调用失败	异常反馈
A->B\B->A: 文本	双向箭头，互相交互	双向通信

（3）逻辑块

语法	逻辑块类型	示例（带说明）
loop	循环块	loop 重复执行 { 操作 }
alt/else	条件分支（二选一）	alt 条件1 { 操作1 } else { 操作2 }
alt	条件块	alt 条件1 { 操作1 } alt 条件2 { 操作2 }
par	并行块	par 并行操作1 { 操作1 } and 并行操作2 { 操作2 }

3. 完整示例

sequenceDiagram
    actor U as 前端用户
    participant S as 后端服务
    participant D as 数据库
    U->>S: 提交登录请求(账号/密码)
    S->>S: 密码加密处理
    alt 密码加密成功
        S->>D: 查询用户信息
        D-->>S: 返回用户数据
        S->>S: 验证账号密码是否匹配
        opt 匹配成功
            S->>S: 生成Token
            S-->>U: 登录成功(返回Token)
        end
        opt 匹配失败
            S--x U: 登录失败(提示账号密码错误)
        end
    else 密码加密失败
        S--x U: 登录失败(提示系统异常)
    end

三、甘特图（Gantt Chart）

用于项目进度管理，按时间维度展示任务的开始 / 结束时间、持续时长、任务归属和完成状态，适合项目排期、里程碑规划。

1. 基础规则

图表开头用gantt，无需指定方向，默认从左到右、从上到下按时间流；
先定义任务（Task），任务可自定义名称、开始时间、持续时长、任务归属和完成状态；
必选日期格式（dateFormat）和标题（title）；
用section划分任务模块（如需求、开发、测试）；
任务连线按任务依赖关系选择，可添加任务描述，支持循环、条件、并行等逻辑块。

2. 核心元素

（1）日期格式（常用）

语法	格式说明	示例
YYYY-MM-DD	年 - 月 - 日（最常用）	2025-01-01
MM-DD	月 - 日（默认当年）	01-01
HH:mm	时：分（默认当天）	09:00

（2）任务定义格式

任务名 : 标识, 开始时间, 结束时间
# 或（按持续时长）
任务名 : 标识, 开始时间, +持续时间（d=天，h=小时，m=分钟）

标识：可选，用于任务关联，可省略；
特殊标记：done（已完成任务）、crit（关键任务）。

3. 完整示例

gantt
    section Section
    Completed :done,    des1, 2014-01-06,2014-01-08
    Active        :active,  des2, 2014-01-07, 3d
    Parallel 1   :         des3, after des1, 1d
    Parallel 2   :         des4, after des1, 1d
    Parallel 3   :         des5, after des3, 1d
    Parallel 4   :         des6, after des4, 1d

四、饼图（Pie Chart）

用于展示数据占比，语法极简，适合快速呈现分类数据的比例关系。

1. 基础规则

图表开头用pie；
必选标题（title）；
数据行格式：”分类名” : 数值（数值支持整数 / 浮点数，会自动计算占比）。

2. 完整示例

pie
    title 网站流量来源占比
    "搜索引擎" : 65
    "社交媒体" : 20
    "直接访问" : 10
    "外部链接" : 5

五、类图（Class Diagram）

用于面向对象设计，描述类、接口、对象之间的关系（继承、关联、聚合等），适合架构设计、代码建模。

1. 基础规则

图表开头用classDiagram；
类的定义：class 类名 { 属性; 方法 }，支持访问修饰符（公有 / 私有 / 受保护）；
用符号表示类之间的关系，箭头指向被关联 / 继承的类。

2. 核心元素

（1）访问修饰符

语法	含义
+	公有（public，最常用）
-	私有（private）
#	受保护（protected）

（2）类间关系（核心）

语法	关系含义	适用场景	示例
—>	继承（泛化）	子类 –> 父类
–>	关联	类之间的普通依赖	学生 –> 课程
*–	聚合	整体包含部分，部分可独立存在	班级 *– 学生
o–	组合	整体包含部分，部分不可独立存在	人 o– 心脏
..>	实现	类实现接口	实现类..> 接口

3. 完整示例

classDiagram
Class01 <|-- AveryLongClass : Cool
<<Interface>> Class01
Class09 --> C2 : Where am I?
Class09 --* C3
Class09 --|> Class07
Class07 : equals()
Class07 : Object[] elementData
Class01 : size()
Class01 : int chimp
Class01 : int gorilla
class Class10 {
  <<service>>
  int id
  size()
}

六、状态图（State Diagram）

用于描述对象的状态变化过程，展示状态之间的转换条件和触发事件，适合生命周期、状态机设计（如订单状态、设备状态）。

1. 基础规则

图表开头用stateDiagram（或stateDiagram-v2，新版更友好）；
用[*]表示初始状态 / 结束状态；
状态之间用–> 连接，可添加触发条件 / 事件。

2. 完整示例

stateDiagram-v2
    [*] --> 待支付
    待支付 --> 待发货 : 支付成功
    待支付 --> 已取消 : 用户取消/超时未支付
    待发货 --> 待收货 : 商家发货
    待收货 --> 已完成 : 用户确认收货
    待收货 --> 售后中 : 用户申请退款/换货
    售后中 --> 已完成 : 售后处理结束
    已取消 --> [*]
    已完成 --> [*]

七、Mermaid 通用使用技巧

代码块包裹：所有语法必须写在mermaid和 ``` 之间，平台才会渲染；
注释：用%%添加注释，注释内容不会渲染；
空格 / 换行：语法对空格、换行不敏感，可合理换行让代码更易读；
别名 / 唯一标识：节点、参与者的标识必须唯一，建议用简单英文 / 拼音，避免中文；
布局控制：流程图中子图可通过subgraph 子图名 [方向]指定独立方向；调整子图位置可通过「定义顺序 + 隐形连接（-.->/—）」引导排版；

这一年AI编程总结

2026-03-06T00:00:00+00:00

总结
AI使用流程
药不能停

总结

近一年我在很多场景都使用AI辅助开发，我最明显的想法是确实能够通过AI高效的解决了。先后用过这些：

TRAE：基于vscode开发，所以没啥上手成本，对于整个项目理解能力一般，编码调整较大很难基于Diff判断代码修改是否符合预期。我一般当做编辑器使用，顺便使用自动提示功能。另外代码提交时自动生成commit message这个好评。
豆包：知识面较广知道的东西比较多，但编码水平稍逊色于DeepSeek；
DeepSeek：编码质量最好的一款，不知道为啥没有PC端，而且TRAE也支持开源的DeepSeek，说明差异主要在于调度大模型的流程上

AI编码近一年发展速度还是比较明显的，从之前代码都跑不通到今天能提供比较完整的样例。尤其是前端领域，我这种小白已经在AI的辅助下搭建了非常多工具，如果你之前也留意过我的网站，这一年已经实现了游戏、记事本这种复杂的工具了，整个站点的复杂度、精致程度向前迈了一大步。几点经验：

AI目前对于大型项目、上下文理解还不足，但是做单体页面、函数开发能力非常强，使用的时候也可以注意下；
人和AI是经理和指挥者的关系，整个开发过程中的思路、逻辑输出、问题排查更多得依赖人来分析以及给出思路；
AI的优势是知识面广，经常能给一些意想不到的解法，这方面是远胜于搜索引擎的。比如前端样式方面，它会给我讲解BootStrap响应式断点，以及匹配优先级；
CR的效果特别好，未使用变量、疑似Panic、逻辑错误都能指出来。

这就是AI教我BootStrap响应式断点知识🐶：

断点前缀	对应屏幕宽度	说明
sm-	≥576px	小屏（平板/手机横屏）
md-	≥768px	中屏（平板/小屏 PC）
lg-	≥992px	大屏（常规 PC）
xl-	≥1200px	超大屏

AI使用流程

先聊一些具体且关键的问题
1. 当AI能准确回答问题，执行下一步
2. 当AI不能准确回答问题，指出错误纠正它
3. 如果纠正还不行，换一个Agent试试。。。
前一步成功意味着基础的上下文和任务说清楚了，继续迭代提出新要求
1. 在这个过程中我需要验证每次返回的结果，指出问题

药不能停

基于豆包的专家模式开发了提醒吃药工具，代码比较简单，发布在GitHub。因为我也不会开发安卓，属于一步一步问的，比如这段代码应该放在哪个目录哪个文件，回答的都很靠谱。

发布到了蒲公英，大家可以尝试使用。

资损常见治理思路

2025-10-13T00:00:00+00:00

治理思路
评估完整性

维度	一致性	卡单	幂等（重复执行无副作用）	合理性
核心定义	多数据源 / 存储节点间的数据 “最终一致” 或 “强一致”，重点关注状态字段不一致问题	业务流程在关键节点停滞（未按预期向下流转），表现为 “状态卡住”	同一请求（或重复请求）多次执行，产生的业务结果与 “仅执行一次” 完全一致，避免重复扣钱、重复发货等副作用	业务逻辑符合业务规则、赔付原则、财务合规
典型场景	稳定性问题：1. 强一致性：分布式事务；2. 最终一致性：MQ、重试；3. 跨数据源数据不一致；4. 跨服务数据同步	业务类问题：1. 任务下发失败；2. 回调丢失；3. 资源锁死（如分布式锁未释放导致流程阻塞）；	技术问题：1. 重复支付（用户多次点击支付按钮导致重复扣款）；2. MQ 消息重复消费（如重试机制导致消息重复投递）；3. 接口重试（如前端超时重试、网关重试导致重复执行业务逻辑）；	业务、技术问题：1. 边界值违规（如零空负）；2. 财务合规违规（极大、极小）；3. 逻辑冲突（如 “已取消订单” 仍能发起退款）；4. 规则不合理，增值服务开通了错误的的国家
核心工作内容	1. 一致性方案设计；2. 不一致监控；3. 不一致数据修复（修复接口可重试）	1. SLA 计算；2. 流程链路追踪（埋点监控关键节点状态流转）；3. 阻塞原因洞察、归因；4. 异常单据修复	1. 幂等标识设计；2. 悲观锁；3. DB 幂等校验；4. 不幂等数据处理，迁移新库	1. 规则线上化；2. 边界值测试（覆盖极端场景，如 0 金额、超大数据量）；3. 灰度；4. 仿真；
影响面	涉及单量大，修复方式简单	影响用户体验	一旦下游无法兜底拦截会产生直接资损，优化成本高	大部分为 Bug，需要对业务有深刻理解，修数难度大

治理思路

推荐按照一致性、幂等、卡单、合理性的顺序进行治理。优先保证系统质量，再拔高监控解决细分场景的问题。

评估完整性

一致性：重点关注系统间数据一致性，监控系统间数据传输质量。需要列举核心系统调用来评估；
幂等：评估系统是否对重复请求有正确的处理机制，避免重复执行导致的副作用。需要列举核心单据来评估；
卡单：评估系统是否对关键节点的状态流转有监控和修复机制，避免业务流程停滞。需要通过单据核心状态&动作来评估；
合理性：评估系统是否符合业务规则、赔付原则、财务合规等要求，下钻到细分场景监控，监控代码 Bug。需要梳理下游使用的重点字段来评估，如订单金额、支付状态、退款金额等。

用AI搭建一个数独游戏

2025-06-22T00:00:00+00:00

惊艳的开始——基本框架
优化调整难度大——样式、唯一解
交互优化无法指望——提示、关联框标记
最后总结

说来惭愧，大学学习都就是游戏开发，但是自己也没做过什么游戏，最后还是需要AI来帮助。

惊艳的开始——基本框架

帮我生成一个数独网页游戏，支持简单、困难、专家三种模式，能够按照模式随机生成新游戏，支持通过cookie记录游戏进度，支持提醒执行过程

一开始的试用非常惊艳，一句话就直接实现了，成品效果非常成熟。

优化调整难度大——样式、唯一解

游戏我也试玩了几把，可以跑起来。但是我发现一些问题：比如样式有点问题，格子之间间隔太大；比如题目有问题，解不唯一。这个时候直接写提示词让AI调整代码，难度就很大。我先后试了豆包、Trae都太行，而且会越改越乱。

最后没有办法，自己读代码理解逻辑，分析如何调整。这个时候你会发现，你分析到一个优化点，就新开一个回话，告诉他要解唯一，他就会生成一个新的代码，新老代码需要自己来融合。我这里用了DeepSeek的逻辑，豆包的思路也差不多，都是回溯法，但是跑出来运行结果不对。

交互优化无法指望——提示、关联框标记

除了基本功能，后面还想升级页面UI：

选中一个数字后，高亮潜在冲突的表格；
自动填充可能的候选值；
某个数字用完后，置灰；

这些功能就没有用AI了，实现出来的基本就不可用，要么是我找的现成的例子，要么是自己实现的（当让我也不会写前端，请教了AI）。

最后总结

AI的优势在于知识面广，啥也知道，但是不一定对，自己要能够识别；
AI 不擅长改写，擅长从头搭建一个简单实现，所以Trae我自己用起来效果也一般，因为本身Trae都是要修改现有逻辑；问题识别到了，要修改的内容也就知道，修改剔除逻辑和验证逻辑；
我也在怀疑是不是我不会写提示词，或者用法有问题，这方面谁可以指导下？

LangSmith介绍以及Golang的介绍方法

2025-05-29T00:00:00+00:00

LangSmith
- 效果
- Python 接入
Golang 接入
- 初始化
- 写入请求和响应

LangSmith

LangSmith是一个用于管理和监控机器学习模型生命周期的平台，它可以帮助开发者更好地监控和优化他们的模型。

可观察性。可以支持分析、追踪，并且可以基于这些数据配置看板和报警；
评估。评估您的应用在生产流量中的表现。
Prompt 工程。通过版本控制迭代升级你的提示词。

特性也可以看下面这个图，完整资料移步官网：

效果

看到这个效果基本就知道LangSmith的强大了，它能完整记录跟LLM交互的过程以及相应内容。

Python 接入

Python 默认就可以打开，不需要额外的代码，你可以直接设定好环境变量或者通过如下代码配置。

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGSMITH_ENDPOINT"]="https://api.smith.langchain.com"
os.environ["LANGSMITH_API_KEY"]="你申请到的Key"
os.environ["LANGSMITH_PROJECT"]="你创建的项目名称"

Golang 接入

Golang 本身langchaingo包不支持，我看ISSUE里作者也提到他没想到如何像Python一样自动记录，我目前找到一个十来个Star的包github.com/devalexandre/langsmithgo。

初始化

var smith *langsmithgo.Client
os.Setenv("LANGSMITH_API_KEY", "你申请到的Key")
os.Setenv("LANGSMITH_PROJECT_NAME", "你创建的项目名称")

smith, err = langsmithgo.NewClient()
if err != nil {
  return fmt.Errorf("langsmithgo.NewClient: %v", err)
}

写入请求和响应

import (
	"context"
	"fmt"

	"github.com/devalexandre/langsmithgo"
	"github.com/google/uuid"
	"github.com/mnhkahn/gogogo/logger"
	"github.com/tmc/langchaingo/llms"
)
func SmithStart(ctx context.Context, prompt string) string {
	runId := uuid.New().String()
	err := smith.Run(&langsmithgo.RunPayload{
		RunID:   runId,
		Name:    "langsmithgo-chain",
		RunType: langsmithgo.Chain,
		Inputs: map[string]interface{}{
			"prompt": prompt,
		},
	})
	if err != nil {
		logger.Errorf("smith.Run: %v", err)
	}
	return runId
}

func SmithEnd(ctx context.Context, runId, output string) {
	err := smith.PatchRun(runId, &langsmithgo.RunPayload{
		Outputs: map[string]interface{}{
			"output": output,
		},
	})

	if err != nil {
		logger.Errorf("smith.PatchRun: %v", err)
	}
}

通过OpenAI对接LLM——搭建Geek头条

2025-05-21T00:00:00+00:00

AI Agent 与 LLM 关系
- 一般架构
- MCP 中 Tools、Prompts、Resources的区别
流程
Geek 头条实现
- OpenAI 对接 LLM
最后

AI Agent 与 LLM 关系

LLM 扮演了 Agent 的 “大脑”，在 Agent 这个系统中提供推理、规划等能力。——《LLM、Prompt、AI Agent、RAG… 一网打尽大模型热门概念》

一般架构

AI Agent 中 LLM 是最核心的部分，实际工程应用中，还需要建设好周边工具，提供「作业」、「记忆」等能力，结合 LLM 一套建设完整的智能体。

MCP 中 Tools、Prompts、Resources的区别

Primitive	Control	Description	Example
Prompts	User-controlledPrompts 像是提前配置好的，需要指定后执行，不需要每次填写	Interactive templates invoked by user choice	Slash commands, menu options /prompts /prompt generate_search_prompt topic=history num_papers=2
Resources	Application-controlled应用选择怎么用，如果需要LLM使用还是需要提供Tools	Contextual data attached and managed by the client	File contents, git history
Tools	Model-controlled	Functions exposed to the LLM to take actions	API POST requests, file writing

流程

Geek 头条实现

Geek 头条的流程：

调用tech_news工具，获取最新科技新闻；
调用tech_news_prompt工具生成提示词；
调用LLM，生成总结。

OpenAI 对接 LLM

OpenAI除了做模型，也提供了标准API，我们可以直接调用API来调用LLM。

模型申请

我申请的是siliconflow的模型，它支持免费使用 Qwen/Qwen2-7B-Instruct 和 deepseek-ai/DeepSeek-R1-Distill-Qwen-7B 等多种模型。

需要用到的包：

go get github.com/openai/openai-go

初始化 OpenAI

aiClient = openai.NewClient(
  option.WithBaseURL("https://api.siliconflow.cn/v1"),
  option.WithAPIKey("ApiKey"), // defaults to os.LookupEnv("OPENAI_API_KEY")
)

获取新闻

callToolReq := mcp.CallToolRequest{}
callToolReq.Params.Name = "tech_news"
callResp, err := mcpClient.CallTool(ctx, callToolReq)

获取提示词

getPromptReq := mcp.GetPromptRequest{}
getPromptReq.Params.Name = "tech_news_prompt"
getPromptReq.Params.Arguments = map[string]string{
  "news": strings.Join(newsLink, ","),
}

https://github.com/ThinkInAIXYZ/deepchat/releases/tag/v0.1.1,https://tonybai.com/2025/05/20/post-quantum-cryptography-in-go/,https://tonybai.com/2025/05/19/shardedvalue-per-cpu-proposal/ [I] 2025/05/21 21:20:35 new_agent.go:67: https://github.com/ThinkInAIXYZ/deepchat/releases/tag/v0.1.1,https://tonybai.com/2025/05/20/post-quantum-cryptography-in-go/,https://tonybai.com/2025/05/19/shardedvalue-per-cpu-proposal/
分别总结这些网页，使用网页标题，不需要做对比，并为每个标题附带上文档链接。

调用LLM

params := openai.ChatCompletionNewParams{
  Messages: []openai.ChatCompletionMessageParamUnion{
    openai.UserMessage(promptMsg), // 提示词，UserMessage代表说用户说的话
  },
  Model: "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", // 选择的模型
  Tools: ts,
  Seed: openai.Int(0),
}
chatCompletion, err := aiClient.Chat.Completions.New(ctx, params)

User（用户）：代表与 AI 进行对话的人类。是对话的发起者和推动者，通过提出问题、表达需求或提供指令来引导对话的方向。
Assistant（助手）：代表 AI 本身，是对用户进行回应的角色。根据系统设定和用户输入生成相应的回复，为用户提供信息、回答问题、完成任务或提供建议等。

finish_reason

chatCompletion.Choices[0].FinishReason字段保存了 LLM 停止&返回客户的的原因。

原因标识	含义解释
stop	模型到达自然停止点或遇到提供的停止序列
length	达到请求中指定的最大 token 数量
content_filter	内容因内容过滤器标记被省略
tool_calls	模型调用了工具
function_call（deprecated）	模型调用了函数（已弃用）

渲染

因为生成的内容是markdown格式，这里用到了github.com/gomarkdown/markdown包来将markdown渲染成html，

func MDToHTML(md []byte) []byte {
	// create markdown parser with extensions
	extensions := parser.CommonExtensions | parser.AutoHeadingIDs | parser.NoEmptyLineBeforeBlock
	p := parser.NewWithExtensions(extensions)
	doc := p.Parse(md)

	// create HTML renderer with extensions
	htmlFlags := html.CommonFlags | html.HrefTargetBlank
	opts := html.RendererOptions{Flags: htmlFlags}
	renderer := html.NewRenderer(opts)

	return markdown.Render(doc, renderer)
}

默认html只能按照文本展示，需要用template.HTML用作安全渲染。
```go
res["news"] = template.HTML(string(views))

最后

效果查询：Geek 头条。

为什么是用markdown而不是更结构化的比如json呢？尝试了很多提示词，并不能严格按照期望的格式生成json，经常会有自由发挥的字段，总结的内容也很离谱，还不如用简单的提示词效果好。另外猜测模型本身也是基于markdown训练的，所以对json支持并不友好。
关于流程，目前我了解到的是也有流程框架LangChainGo，它和MCP之间也有Adaptar来做适配对接，接下来详细学学看。

Git Comments 提交规范

2025-05-14T00:00:00+00:00

1. 提交信息格式
2. 常用提交类型
3. 提交信息示例

Git 代码提交规范对于团队协作和项目维护至关重要，它能够确保提交历史清晰、可追溯，便于后续的代码审查、问题追踪以及版本发布。以下是一些常见的 Git 代码提交规范和最佳实践：

1. 提交信息格式

一个完整的提交信息通常包含三个部分：标题（Header）、正文（Body） 和 页脚（Footer），各部分之间用空行分隔。

<类型>(<范围>): <简短描述>
// 空行
[可选] 详细描述
// 空行
[可选] 关联的 Issue 或 Breaking Change

标题（Header）：
- 类型（Type）：必须，描述提交的类型（如 feat、fix、docs 等）。
- 范围（Scope）：可选，说明修改的具体模块或功能（如 user、api、ui 等）。
- 简短描述（Description）：必须，用简洁的语言概括变更内容（不超过 50 个字符，首字母小写，结尾不加标点）。
正文（Body）：
- 可选，详细说明修改的动机、背景和实现细节，每行不超过 72 个字符。
页脚（Footer）：
- 可选，用于关联 Issue（如 Fixes #123）或声明重大变更（如 BREAKING CHANGE: ...）。

2. 常用提交类型

以下是常见的提交类型及其含义：

类型	描述
`feat`	新增功能
`fix`	修复 bug
`docs`	文档更新（如 README、注释等）
`style`	代码格式调整（不影响功能，如空格、缩进）
`refactor`	代码重构（既不修复 bug 也不添加功能）
`test`	添加或修改测试用例
`chore`	构建流程或辅助工具的变动（如配置文件）
`perf`	性能优化
`ci`	CI/CD 配置或脚本更新
`revert`	回滚之前的提交

3. 提交信息示例

示例 1：新增功能

feat(user): 添加用户注册验证码功能

新增了验证码生成、发送和验证逻辑，
使用 Redis 存储验证码，有效期 5 分钟。

Fixes #456

示例 2：修复 bug

fix(api): 修复用户登录时密码加密错误

由于密码加密算法使用错误，导致部分用户无法登录。
现已更正为使用 bcrypt 进行加密。

Fixes #789

示例 3：文档更新

docs: 更新 API 文档中的用户接口说明

补充了用户注册、登录和获取信息接口的参数说明，
添加了错误码对照表。

遵循这些规范可以让你的 Git 提交历史更加清晰、专业，提高团队协作效率。根据项目需求，你可以在此基础上调整或扩展规范。

MCP Resource学习，用Go搭建一个Demo

2025-05-05T00:00:00+00:00

概述
协议消息
数据流
资源类型
Go 实现
测试工具

概述

MCP 协议提供了标准协议来让服务端向客户端暴露资源内容，例如文件、数据库，每个资源使用唯一标识URI来区分。

本文介绍最新版本2025-03-26。

协议消息

Listing Resources

客户端发送resources/list请求查询可用的资源，该操作支持分页。

Reading Resources

发送resources/read请求检索资源内容。

Resource Templates

resources/templates/list允许向客户端暴露参数化资源。

List Changed Notification

当资源发生变更时，服务器会发送notifications/resources/list_changed通知。

Subscriptions

协议支持订阅资源变更，可以支持订阅指定资源当发生变更时会收到通知。

数据流

资源类型

资源定义

uri: 资源的唯一标识符
name: 资源的名称
description: 【可选】资源描述
mimeType: 【可选】资源的MIME类型，常见的有：text/plain、text/html、image/jpeg、image/png、application/json、application/pdf、application/octet-stream等
size: 【可选】资源大小，单位为字节

URI Scheme

https://
file://
git://

错误码

资源不存在: -32002
内部错误：-32603

Go 实现

func registerAllGoResources(mcpServer *server.Server) {
	for _, item := range items {
		mcpServer.RegisterResource(&protocol.Resource{
			URI:      item.Link,
			Name:     item.Title,
			MimeType: "text/html",
		}, resourceHandler)
	}
}

func resourceHandler(ctx context.Context, r *protocol.ReadResourceRequest) (*protocol.ReadResourceResult, error) {
	for _, item := range items {
		if item.Link == r.URI {
			res := protocol.NewReadResourceResult([]protocol.ResourceContents{
				protocol.TextResourceContents{
					URI:      item.Link,
					Text:     item.Description,
					MimeType: "text/html",
				},
			})
			return res, nil
		}
	}
	return nil, fmt.Errorf("resource not found")
}

测试工具

MCP官方提供的Inspector，支持本地部署调试，启动命令：

npx @modelcontextprotocol/inspector https://www.cyeam.com/sse

用Go基于stdio通信搭建本地MCP工具

2025-04-29T00:00:00+00:00

概述
实现
- 解析Env
- 返回处理
部署

概述

本文将基于Go语言开发的MCP（Multi - Cloud Processing）服务器，主要功能是将文件上传到Cloudinary云存储服务。服务器通过MCP协议接收文件路径请求，并将对应文件上传到Cloudinary，最后返回文件的安全访问链接。

实现

本身SSE和Stdio的实现方式区别不大，只需要将transport改成NewStdioServerTransport。上传逻辑使用包github.com/cloudinary/cloudinary-go/v2。详细使用方式参考官方文档。

解析Env

由于是命令行调用，参数需要通过环境变量解析获取。

for _, env := range os.Environ() {
    ks := strings.Split(env, "=")
    if len(ks) == 2 {
        k, v := ks[0], ks[1]
        if k == "cloud" {
            cloud = v
        } else if k == "key" {
            key = v
        } else if k == "secret" {
            secret = v
        }
    }
}

返回处理

本次场景使用文本格式返回，还支持图片、音频等。

return &protocol.CallToolResult{
    Content: []protocol.Content{
        protocol.TextContent{
            Type: "text",
            Text: res,
        },
    },
}, nil

部署

环境变量

运行项目前，需要设置以下环境变量：

cloud: Cloudinary的云名称。
key: Cloudinary的API密钥。
secret: Cloudinary的API密钥密码。

密钥从这里获取。

运行步骤

确保Go环境已正确安装（版本1.23.1及以上）。
设置所需的环境变量。
在项目根目录下执行以下命令运行项目：

go install gitee.com/cyeam/cloudinary_mcp@latest
{
  "mcpServers": {
    "image_upload": {
      "type": "stdio",
      "command": "cloudinary",
      "args": [],
      "env": {
        "cloud": "cyeam",
        "key": "key",
        "secret": "password"
      }
    }
  }
}

测试代码

package main

import (
	"context"
	"github.com/ThinkInAIXYZ/go-mcp/pkg"
	"log"

	"github.com/ThinkInAIXYZ/go-mcp/client"
	"github.com/ThinkInAIXYZ/go-mcp/protocol"
	"github.com/ThinkInAIXYZ/go-mcp/transport"
)

func main() {
	transportClient, err := transport.NewStdioClientTransport("cloudinary", nil,
		transport.WithStdioClientOptionLogger(pkg.DebugLogger),
		transport.WithStdioClientOptionEnv("cloud=cyeam", "key=key1", "secret=password"))
	if err != nil {
		log.Fatalf("Failed to create transport client: %v", err)
	}
	// Initialize MCP client
	mcpClient, err := client.NewClient(transportClient)
	if err != nil {
		log.Fatalf("Failed to create MCP client: %v", err)
	}
	defer mcpClient.Close()

	// Get available tools
	ctx := context.Background()
	tools, err := mcpClient.ListTools(ctx)
	if err != nil {
		log.Fatalf("Failed to list tools: %v", err)
	}
	for _, tool := range tools.Tools {
		log.Printf("Tool Name: %+v, Description: %s, Required: %+v", tool.Name, tool.Description, tool.InputSchema.Required)
		if tool.Name == "cloudinary" {
			req := &protocol.CallToolRequest{
				Name: tool.Name,
				Arguments: map[string]interface{}{
					"file_path": "/Users/cyeam/Downloads/abc.jpg",
				},
			}
			resp, err := mcpClient.CallTool(context.Background(), req)
			if err != nil {
				log.Fatalf("Failed to call tool: %v", err)
			} else {
				log.Printf("Tool Response: %+v", resp)
			}
		}
	}
}

如何用自己的http server搭建一个线上MCP服务？

2025-04-28T00:00:00+00:00

MCP Server 初始化
超时设置
代码调用
用 Trae 调试

前文讲解了MCP协议并使用Go搭建了一个简单的Demo，本文将介绍如何将其部署到线上。

MCP Server 初始化

和前面的Demo一样，需要初始化MCP Server，因为要集成到现有 HTTP 服务中，不能直接启动 Server 而是要把Handler注册到 app 中。

app.Handle("/sse", newSseHandler.HandleSSE())
app.Handle("/sse/message", newSseHandler.HandleMessage())

app 包是我自研的框架，完整内容可以移步这里。

完整代码：

func InitMCPServer() error {
	// Create SSE transport server
	transportServer, newSseHandler, err := transport.NewSSEServerTransportAndHandler("/sse/message", transport.WithSSEServerTransportAndHandlerOptionLogger(pkg.DebugLogger))
	if err != nil {
		return err
	}

	// Initialize MCP server
	mcpServer, err := server.NewServer(transportServer)
	if err != nil {
		return err
	}

	// Register time query tool
	tool, err := protocol.NewTool("current_time", "Get current time for specified timezone", TimeRequest{})
	if err != nil {
		log.Fatalf("Failed to create tool: %v", err)
		return err
	}
	mcpServer.RegisterTool(tool, handleTimeRequest)

	app.Handle("/sse", newSseHandler.HandleSSE())
	app.Handle("/sse/message", newSseHandler.HandleMessage())

	return nil
}

超时设置

由于是 SSE 协议，需要放开超时时间，否则会报错：context deadline exceeded。

需要使用没有超时时间的方式启动：app.ServeDefault(l)。不能设置ReadTimeout和WriteTimeout。

代码调用

实际测试的时候AI不一定靠谱，问多了就不真正请求了，所以用代码请求调试靠谱些。

package main

import (
    "context"
    "log"

    "github.com/ThinkInAIXYZ/go-mcp/client"
    "github.com/ThinkInAIXYZ/go-mcp/protocol"
    "github.com/ThinkInAIXYZ/go-mcp/transport"
)

func main() {
    // Create SSE transport client
    transportClient, err := transport.NewSSEClientTransport("https://www.cyeam.com/sse")
    if err != nil {
        log.Fatalf("Failed to create transport client: %v", err)
    }

    // Initialize MCP client
    mcpClient, err := client.NewClient(transportClient)
    if err != nil {
        log.Fatalf("Failed to create MCP client: %v", err)
    }
    defer mcpClient.Close()

    // Get available tools
    ctx := context.Background()
    tools, err := mcpClient.ListTools(ctx)
    if err != nil {
        log.Fatalf("Failed to list tools: %v", err)
    }
    for _, tool := range tools.Tools {
        log.Printf("Tool Name: %+v, Description: %s, Required: %+v", tool.Name, tool.Description, tool.InputSchema.Required)
        if tool.Name == "current_time" {
            req := &protocol.CallToolRequest{
                Name: tool.Name,
                Arguments: map[string]interface{}{
                    "timezone": "Asia/Shanghai",
                },
            }
            resp, err := mcpClient.CallTool(context.Background(), req)
            if err != nil {
                log.Fatalf("Failed to call tool: %v", err)
            } else {
                log.Printf("Tool Response: %+v", resp)
            }
        }
    }
}

用 Trae 调试

配置：

{
  "mcpServers": {
    "current_time": {
      "url": "https://www.cyeam.com/sse"
    }
  }
}

命令：使用mcp服务告诉我北京时间。

结果：

validator 包使用方法

2025-04-25T00:00:00+00:00

package valiader

import (
	"github.com/go-playground/validator/v10"
	"github.com/stretchr/testify/assert"
	"os"
	"testing"
)

var v = validator.New()
var rules = map[string]string{
	"NotNull":        "required",
	"LargerThanZero": "gt=0",
	"Enum":           "required,oneof=1 2 3",
}

func TestMain(m *testing.M) {
	v.RegisterStructValidationMapRules(rules, Struct{})
	os.Exit(m.Run())
}

type Struct struct {
	NotNull        string
	LargerThanZero int
	Enum           int
}

// https://pkg.go.dev/github.com/go-playground/validator/v10#section-readme
func TestValidate(t *testing.T) {
	// 正常值放过
	var x Struct
	x.NotNull = "not null string"
	x.LargerThanZero = 1
	x.Enum = 1
	assert.NoError(t, v.Struct(x))

	// 异常值报错
	x.NotNull = ""
	x.LargerThanZero = -1
	x.Enum = 9
	err := v.Struct(x)
	assert.Error(t, err)
	t.Log(err)
}

MCP 模型上下文协议初探，用Go快速构建一个 MCP Server

2025-04-17T00:00:00+00:00

整体架构
通信方式
编码方式
Go语言实现
- Server
- 客户端
最后
扩展阅读

Model Context Protocol (MCP)是一个开源协议，正如 USB-C 为将你的设备连接到各种外围设备和配件提供了一种标准化的方式一样，MCP 也为将人工智能模型连接到不同的数据源和工具提供了一种标准化的方式。大语言模型常常需要与数据和工具集成，而 MCP 能够提供：

一份不断扩充的预构建集成列表，你的大语言模型可直接接入这些集成；
在不同大语言模型提供商和供应商之间切换的灵活性；
在你的基础设施内保障数据安全。

整体架构

MCP Hosts：诸如 Claude 桌面应用程序、集成开发环境（IDE）或希望通过 MCP 访问数据的人工智能工具等程序。本文使用的是VSCode里面的插件Cline。
MCP Clients: 与服务器保持一对一连接的协议客户端。
MCP Servers：通过MCP协议提供的轻量级服务。
Local Data Sources：你的计算机上 MCP 服务器能够安全访问的文件、数据库和服务。
Remote Services：MCP 服务器可以连接的通过互联网可用的外部系统（例如，通过应用程序编程接口（API））。

通信方式

MCP协议支持两种数据通信方式：

本地通信
- 对于本地进程，使用stdio传输方式，就是常见的进程输入输出；
- 对于同一机器上的通信而言效率较高；
- 进程管理简单
远程通信
- 对于需要 HTTP 兼容性的场景，使用服务器发送事件（SSE）技术；
- 需考虑包括身份验证和授权等方面的安全问题；

编码方式

为了灵活支持复杂命令，MCP协议使用JSON-RPC数据格式。

Request

{
  jsonrpc: "2.0";
  id: string | number;
  method: string;
  params?: {
    [key: string]: unknown;
  };
}

请求必须包含一个字符串或整数类型的标识符（ID）。
与基础的 JSON-RPC 不同，该标识符不能为 null。
在同一会话中，请求者此前一定不能使用过该请求标识符。

Response

{
  jsonrpc: "2.0";
  id: string | number;
  result?: {
    [key: string]: unknown;
  }
  error?: {
    code: number;
    message: string;
    data?: unknown;
  }
}

响应必须包含与所对应请求相同的标识符（ID）。
响应进一步细分为成功结果或错误两类。必须设置结果或错误其中之一，响应绝不能同时设置两者。
结果可以遵循任何 JSON 对象结构，而错误至少必须包含一个错误代码和一条错误消息。
错误代码必须是整数。

Notifications

{
  jsonrpc: "2.0";
  method: string;
  params?: {
    [key: string]: unknown;
  };
}

通知是从客户端发送到服务器，或者从服务器发送到客户端的一种单向消息。接收方不能发送响应。

Go语言实现

Server

代码类似于 HTTP 服务，也需要写Handler。例子里是在本地启动，日志等级为Debug方便观察响应流程。

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/ThinkInAIXYZ/go-mcp/pkg"
	"github.com/ThinkInAIXYZ/go-mcp/protocol"
	"github.com/ThinkInAIXYZ/go-mcp/server"
	"github.com/ThinkInAIXYZ/go-mcp/transport"
)

type TimeRequest struct {
	Timezone string `json:"timezone" description:"timezone" required:"true"` // Use field tag to describe input schema
}

func main() {
	// Create SSE transport server
	transportServer, err := transport.NewSSEServerTransport("127.0.0.1:8080", transport.WithSSEServerTransportOptionLogger(pkg.DebugLogger))
	if err != nil {
		log.Fatalf("Failed to create transport server: %v", err)
	}

	// Initialize MCP server
	mcpServer, err := server.NewServer(transportServer)
	if err != nil {
		log.Fatalf("Failed to create MCP server: %v", err)
	}

	// Register time query tool
	tool, err := protocol.NewTool("current_time", "Get current time for specified timezone", TimeRequest{})
	if err != nil {
		log.Fatalf("Failed to create tool: %v", err)
		return
	}
	mcpServer.RegisterTool(tool, handleTimeRequest)

	// Start server
	if err = mcpServer.Run(); err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}

func handleTimeRequest(req *protocol.CallToolRequest) (*protocol.CallToolResult, error) {
	var timeReq TimeRequest
	if err := protocol.VerifyAndUnmarshal(req.RawArguments, &timeReq); err != nil {
		return nil, err
	}

	loc, err := time.LoadLocation(timeReq.Timezone)
	if err != nil {
		return nil, fmt.Errorf("invalid timezone: %v", err)
	}

	return &protocol.CallToolResult{
		Content: []protocol.Content{
			protocol.TextContent{
				Type: "text",
				Text: time.Now().In(loc).String(),
			},
		},
	}, nil
}

客户端

VSCode安装插件Cline，登录，配置MCP服务器。Trae也支持了，在AI对话框的设置添加下面的配置即可。

{
  "mcpServers": {
    "current_time": {
      "timeout": 60,
      "url": "http://127.0.0.1:8080/sse",
      "transportType": "sse",
      "disabled": false
    }
  }
}

输入问题：「告诉我北京时间」，等待即可。

最后

MCP协议最大的应用场景在于AI编程，本地文件、数据库资源都可以作为Local Data Sources引入进来支持高效开发，Trae要赶紧跟上了。

扩展阅读

OTP原理分析

2025-04-15T00:00:00+00:00

生成方式
原理
Go语言实现
- 生成二维码
- 验证OTP

OTP 是一次性密码（One-Time Password）的缩写，它是一种用于身份验证的安全机制，下次登录或进行身份验证时需要生成新的密码，从而大大提高了安全性。

生成方式

基于时间同步 TOTP（Time - based One - Time Password）：服务器和用户的设备（如手机令牌）都有精确的时钟，它们通过网络进行时间同步。服务器根据当前时间以及用户的密钥，按照特定的算法生成一个一次性密码。用户的设备也使用相同的算法和密钥，基于本地时间生成相同的密码。由于双方时间同步，生成的 OTP 在特定时间内是一致的。例如，每隔 30 秒或 60 秒，OTP 就会更新一次。
基于事件同步：这种方式是基于特定的事件来生成 OTP，而不是时间。例如，用户每次按下令牌上的按钮，或者进行特定的操作（如在手机应用中进行特定手势操作），令牌会根据一个密钥和当前的事件计数生成一个新的 OTP。服务器端也会记录用户的事件计数，并使用相同的算法和密钥生成相应的密码，以验证用户身份。

常用的是基于时间同步的方式，可以安装 Google 提供的 App Authenticator 来生成 OTP。

原理

graph TD
    A["初始化：生成唯一密钥"] -->|1. 生成160位随机数（十六进制）| B["密钥存储"]
    B --> B1["服务器端存储密钥"]
    B --> B2["用户设备（手机令牌）存储密钥"]

    C["OTP生成阶段"] --> C1["计算当前时间戳（秒级，从1970-01-01 00:00:00起）"]
    C1 --> C2["时间戳处理：时间戳 // 固定时间间隔（如30秒），得到整数"]
    C2 --> C3["生成哈希值：以【处理后的时间戳+密钥】为输入，通过SHA-1计算，得到20字节二进制哈希值"]
    C3 --> C4["生成6位OTP"]
    C4 --> C41["取哈希值最后1字节的低4位作为偏移量"]
    C41 --> C42["从偏移量开始取4个字节，转换为32位整数"]
    C42 --> C43["整数对1000000取模，得到6位OTP"]

    D["OTP验证阶段"] --> D1["用户设备生成OTP并提交至服务器"]
    D1 --> D2["服务器端按相同算法（同C1-C4）生成OTP"]
    D2 --> D3["对比服务器端OTP与用户提交的OTP"]
    D3 -->|一致| D4["身份验证通过"]
    D3 -->|不一致| D5["身份验证失败"]

    B1 --> C
    B2 --> D1
    C --> D

生成密钥：首先，需要为用户生成一个唯一的密钥（Key），这个密钥通常是一个长度为 160 位的随机数，以十六进制表示。例如：3132333435363738393031323334353637383930。这个密钥会同时存储在服务器端和用户的设备（如手机令牌）中。
计算时间戳：计算当前的时间戳，通常以秒为单位。例如，当前时间是 2024 年 1 月 1 日 12:00:00，对应的时间戳（从 1970 年 1 月 1 日 00:00:00 到当前时间的秒数）可能是1704115200。
时间戳处理：将时间戳除以一个固定的时间间隔（T），得到一个整数。这个时间间隔通常是 30 秒或 60 秒，这里假设时间间隔为 30 秒。则1704115200 // 30 = 56803840。
生成哈希值：将处理后的时间戳和密钥作为输入，使用哈希函数（如 SHA - 1）进行计算，得到一个哈希值。计算得到的哈希值是一个 20 字节的二进制数据，例如：
```
\x03\xcd>\xa9\x84\x9c\x94\x13\x1b\x80\xcd\x0c\xe6\x18\x1d\x0b\x87\x05\x9b\x93
```
生成 OTP：从哈希值中提取特定的字节，根据这些字节计算出一个数字，再将这个数字转换为指定长度的 OTP。通常是取哈希值的最后一个字节的低 4 位作为偏移量，从哈希值中偏移量开始的 4 个字节作为一个 32 位的整数，然后对这个整数取模1000000（得到 6 位数字的 OTP）。例如，哈希值的最后一个字节是\x93，低 4 位是0011，对应的十进制数是 3。从哈希值的第 3 个字节开始取 4 个字节\xcd>\xa9\x84，转换为 32 位整数是3405691780，对1000000取模得到569178，这就是最终生成的 OTP。
验证 OTP：当用户进行身份验证时，服务器和用户的设备都会按照相同的算法和密钥计算出一个 OTP。服务器和用户的设备会比较这两个 OTP 是否一致，如果一致，则表示身份验证通过。如果不一致，则表示身份验证失败。
配置信息一般是通过二维码同步到App上，二维码的内容如下：

otpauth://totp/cyeam.com:test@cyeam.com?algorithm=SHA1&digits=6&issuer=cyeam.com&period=30&secret=AAAW7EIEWF3U7S5EX4LRU4TVKZSCTOJNNR62UXBGIEJOUDG54W7Q

Go语言实现

生成二维码

package main

import (
	"bytes"
	"fmt"
	"image/png"
	"os"

	"github.com/pquerna/otp"
	"github.com/pquerna/otp/totp"
)

var optKey *otp.Key

func InitOtp() {
	var err error
	optKey, err = totp.Generate(totp.GenerateOpts{
		Issuer:      "cyeam.com",
		AccountName: "test@cyeam.com",
		SecretSize:  32,
	})
	if err != nil {
		panic(err)
	}
	optLog()
}

func optLog() {
	var buf bytes.Buffer
	img, err := optKey.Image(200, 200)
	if err != nil {
		panic(err)
	}
	png.Encode(&buf, img)

	// display the QR code to the user.
	fmt.Printf("Issuer:       %s\n", optKey.Issuer())
	fmt.Printf("Key:          %s\n", optKey.String())
	fmt.Printf("Account Name: %s\n", optKey.AccountName())
	fmt.Printf("Secret:       %s\n", optKey.Secret())
	fmt.Println("Writing PNG to qr-code.png....")
	os.WriteFile("qr-code.png", buf.Bytes(), 0644)
	fmt.Println("Please add your TOTP to your OTP Application now!")
}

验证OTP

func OptValidate(passcode string, k *otp.Key) bool {
	valid := totp.Validate(passcode, k.Secret())
	return valid
}

2024年的总结

2025-01-06T00:00:00+00:00

调岗
超出预期
我理解的架构师

调岗

去年有一个比较大的身份转变：我调岗了。调整的原因一个是我自己想动动了，干得太久了，一个是新岗位也需要人，借机就过来了。新岗位和之前有所不同，需要去横向支持架构工作。对这个事情我一开始还有点犯怵，之前虽然也搞架构，但都是给自己做，给几百人的团队做架构师，之前没有这种类型的经验，这里面还牵扯到公信力和专业性的问题。

超出预期

到今天为止，我自己觉得是超出预期的，超出我自己预期。

架构项目A：确保架构顺利升级，完善了全流程监控，最近集中召回了多起线上问题。架构升级项目，尤其是ToB的项目，技术成果很难拿，目前来看拿到了；
探索项目B：业务那边和老板那边的事情，都有交代，自己也进去帮助业务梳理了一些事情和思路，并推进业务按照我的思路执行。能让业务按照技术思路做，很难得。

我理解的架构师

架构师岗位设立的初衷，是为了帮助部门负责人解决技术层面看到的问题，这里面有技术设计问题，也有需求问题引起的架构问题，总之，是要技术驱动主动往前推。

方案问题，这个好办，方案拿出来review下，该调整链路就调整，该调整模型就调整，对我来说难度不大；
需求问题，这个会复杂很多，因为它还会好办业务需求、产品需求两层。
- 要推进这个事情，首要是梳理清楚业务流程、生产关系。我的经验是一开始找一些case去接触，如果case没找好，大不了被喷一顿，但是人是要认识下的，流程也是要了解下的，从点到线再到面，一步步把业务情况摸清楚，这样技术才不会被动。
- 如果要解决需求问题，对于沟通、信息拉齐上也有一些要求，能基于了解到的分工，把大家串联起来，相当于自己来做业务在某个场景的POC，要置身其中，用业务语言也大家交流。目前大家遇到问题咨询我的时候，我会冲淡路由的角色，把对应的负责人拉进来；
边界问题，我帮大家解决了一些架构问题后，后续类似的问题或者大家觉得关联的问题都会拉我进来一起聊。如果双方有分歧，架构师得做到中立，确保自己输出的架构理念跟老板的一致，这样也能树立好自己的威信。如果吃不准，需要找老板确认。我前前后后也支持了几次架构仲裁，目前看我的判断OK，这点也超出我的预期，说实话没有团队这个包袱设计方案要轻松和清晰很多。
人的问题，架构治理完后，怎么保证后续不劣化？我目前的做法是整理好流程说明，比如报警后怎么处理，该找谁，去哪个群反馈。目前看负责的同学执行得很好。架构治理得做到这一步；
汇报问题，这个其实很重要，甚至我认为是最重要的。前面提到，架构师是帮助老板解决问题的，那么我们遇到问题是需要及时反馈的，包括我们的想法，每个子团队的想法，都需要同步到位，哪怕挨喷。今年能拿到这个结果，我觉得跟老板给空间、时间都有关系。另外，我定期找他同步进展沟通想法也帮助很大，我目前推进事情、交流想法越来越遛，跟老板的背书和支持都离不开关系，需要多去争取。

线上问题处理SOP

2024-11-26T00:00:00+00:00

问题处理原则
一般处理流程
报警

开发是个苦逼的差使，除了保证日常需求如期上线，还需要维护服务运行、保证稳定性，一旦出点问题都是麻烦事。而体现技术价值的也在这里，这是少有的可以技术主导推进的事情。

问题处理原则

5分钟内响应，半小时止损，当天修复完成，3天内复盘。

考核故障的指标不是单看问题大小，最核心指标其实是影响时长，5min内处理完和1个小时处理完完全不是一个量级。举个当年在京东的例子，有一次早上刚上班，空调页面panic了，接到报警开始处理，前后有了差不多3min吧，最后啥事没有，也不需要发故障通报，就是因为有预案、处理快。

一般处理流程

问题发现&初步排查 -> 问题同步 -> 线上止损 -> Bug解决 -> 总结复盘

问题发现&初步排查

发现问题后需要初步定位问题，确定影响面。确定是已知问题还是新增问题：

定位问题原因、故障模块
确定问题开始时间，是否有对应上线操作
确定影响数据量

这步非常关键，和故障的等级强关联，如果有提前准备预案辅助定位分析缩小范围，那么处理就会快很多；当然，处理的人也很关键，需要冷静+果断，尤其是预案不足的情况，不管用什么方案要尽快产出止损方案。

拉群同步

如果影响面较大、问题难定位、或者需要拉人决策，需要拉群、拉会同步信息（业务相关RD、PM、TL、QA）。

不同的角色要有分工：

技术专注在故障止损上，QA提前准备上线流程、回归case；
业务根据影响面评估进线方案、话术、法务风险；
产品需要配合安抚，一方面帮助业务整理故障话术，一方面帮技术隔离无效沟通，让技术专注解决问题；

线上止损

如果确定了止损方案就立刻实施。一般都是上线引入的，回滚上线操作、配置操作、数据库操作。

如果一下子无法完美止损，先尝试部分止损，例如MysQL打满时 kill 慢 SQL，先处理一部分；比如服务端负载被打满，先加限流保证负载降下来，一部分流程能成功。

Bug解决

技术来主导，但是QA把控好质量，建好工单跟进不能不了了之。

确认是否需要二次数据修复；
默认需要当天修复上线，如果问题较小或者确保不会再发生，可以周知后排期修复；

总结复盘

时间线梳理；
问题定位工具和方案；
如果第一时间是通过Oncall渠道等非技术报警反馈的问题，说明报警设计待优化，需要复盘业务报警，需要确保业务报警及时性；

报警

报警等级要怎么划分？按照报警分业务报警和技术报警来看。

业务报警

业务报警的含义是业务受影响要高优报警 Critical，例如下单失败率过高，下单单量环比下降50%。制定规则：前期需要根据业务场景制定好规则，所有业务报警都需要高优响应和处理。

技术报警

技术视角的报警，例如网关限流、CPU负载高，它算是业务报警的下钻报警，处理业务报警时要参考技术报警来分析定位。如果只有技术报警而未影响实际业务，我们也就不需要太着急了。制定规则：按照业务报警拆解，优先对核心接口监控，其次考虑横向展开。

报警 & 监控

报警、监控一般是一起做，不过真有问题看监控肯定来不及，优先要把下钻辅助分析的制作为报警。

响应率

如果只报警不响应，那么报警毫无意义，需要定期Review响应率，业务报警需要100% 5min内响应，技术报警需要95%响应。

需要制定好值班计划，并宣导及时响应的要求，如果没有及时响应需要预警backup；
也需要关注噪音，核心报警可以按照核心系统数量来估算，系统动线上的关键节点有多少，就对应做多少业务报警，切记不要太多。

Github Actions 初探，代码发布成功后发送微信推送

2024-10-30T00:00:00+00:00

代码自动部署（以fly.io为例）
微信通知
飞书通知

先看图感受下，当部署完成后可以在微信里收到推送。Github Actions支持自动触发，执行命令。本文不会讲解具体语法，可以参考阮一峰的博客《GitHub Actions 入门教程》。

代码自动部署（以fly.io为例）

在代码仓库里执行fly launch --no-deploy创建部署文件fly.toml；
执行命令fly tokens create deploy -x 999999h创建部署密钥；
访问Github网址，点击自己的项目->Settings->Secrets and variables->Actions->Repository secrets->New repository secret，填写部署密钥。Name为FLY_API_TOKEN，Secret为第二步生成的内容；
在代码仓库里，在这个目录里创建问题：.github/workflows/fly.yml，把下面的内容粘贴进去；

name: Fly Deploy
on:
  push:
    branches:
      - master    # change to main if needed
jobs:
  deploy:
    name: Deploy app
    runs-on: ubuntu-latest
    concurrency: deploy-group    # optional: ensure only one action runs at a time
    steps:
      - uses: actions/checkout@v4
      - uses: superfly/flyctl-actions/setup-flyctl@master
      - run: flyctl deploy --remote-only
        env:
          FLY_API_TOKEN: $

简单介绍下语法：
- on/push，当master分支代码提交后触发执行；
- jobs/deploy，触发后执行的内容。runs-on指运行环境，steps指运行指令，env加载之前第三部设置的环境变量，uses指引入了三方的工具包，这个例子是使用fly官方的部署包；

完整例子移步Continuous Deployment with Fly.io and GitHub Actions。

微信通知

重复上面第三步，新建一个Name为WECHAT_WORK_BOT_WEBHOOK的密钥，值为微信通知的Webhook地址，用企业微信创建一个即可（拉个微信群添加机器人后会展示出来）；
在目录github/workflows里新建文件notify.yml，粘贴下面的内容：

name: Watch Workflow Status
on:
  workflow_run:
    workflows: [ "Fly Deploy" ]
    types: [ completed ]
env:
  WECHAT_WORK_BOT_WEBHOOK: $

jobs:
  notify:
    runs-on: ubuntu-latest
    steps:
      - id: prep
        uses: hocgin/action-env@main
      - name: WeChat Work Notification
        uses: chf007/action-wechat-work@master
        env:
          WECHAT_WORK_BOT_WEBHOOK: $
        with:
          msgtype: markdown
          content: "**【[$]($)】** \n
          📌 $ \n
          🏃 [@$]($)\n
          🕐 <font color=\"comment\">$</font> \n
          🔧 <font color=\"warning\">$ -> $</font> \n
          🏆 <font color=\"comment\">$ / $</font> \n
          📝 提交信息: $ \n
          \n
          [查看更多]($)
          "

on/workflow_run 指在部署完成后执行这个脚本，workflows里的Fly Deploy是前面第一步的工作流名称，如果你用的不是fly，按照自己情况修改；
jobs 复用了chf007/action-wechat-work@master包的能力，发送markdown格式的消息，能使用的变量可以参考这个文件。

飞书通知

name: Watch Workflow Status
on:
  workflow_run:
    workflows: [ "Fly Deploy" ]
    types: [ completed ]
env:
  # 飞书机器人 Webhook 地址（需在 Secrets 中配置 LARK_BOT_WEBHOOK）
  LARK_BOT_WEBHOOK: $

jobs:
  notify:
    runs-on: ubuntu-latest
    steps:
      - id: prep
        uses: hocgin/action-env@main

      - name: Send Lark notification
        env:
          LARK_WEBHOOK: $
        run: |
          # 使用 jq 构建飞书 post 消息
          jq -n \
            --arg repo_full_name "$" \
            --arg repo_html_url "$" \
            --arg conclusion "$" \
            --arg sender "$" \
            --arg sender_html_url "$" \
            --arg action_trigger_at "$" \
            --arg source_branch "$" \
            --arg target_branch "$" \
            --arg env "$" \
            --arg version "$" \
            --arg commit_body "$" \
            --arg repo_homepage "$" \
            '{
              msg_type: "post",
              content: {
                post: {
                  zh_cn: {
                    title: "Cyeam站点部署通知（Fly Deploy）",
                    content: [
                      [ { tag: "a", text: "【\($repo_full_name)】", href: $repo_html_url } ],
                      [ { tag: "text", text: (if $conclusion == "success" then "☀️☀️☀️☀️☀️" else "🌧️🌧️🌧️🌧️🌧️" end) } ],
                      [ { tag: "a", text: "@\($sender)", href: $sender_html_url } ],
                      [ { tag: "text", text: "🕐 \($action_trigger_at)" } ],
                      [ { tag: "text", text: "🔧 \($source_branch // "∅") -> \($target_branch // "∅")" } ],
                      [ { tag: "text", text: "🏆 \($env // "未知版本") / \($version // "未知版本")" } ],
                      [ { tag: "text", text: "📝 提交信息: \($commit_body // "")" } ],
                      [ { tag: "a", text: "查看更多", href: ($repo_homepage // $repo_html_url) } ]
                    ]
                  }
                }
              }
            }' | curl -X POST -H "Content-Type: application/json" -d @- $LARK_WEBHOOK

代码隔离大法

2024-04-02T00:00:00+00:00

现在系统架构大多采用分层的形式web->handler->service->dao->model 每次调用都是从前到后发起，每一层沉淀必要的代码能力，当有新需求迭代某个模块即可，无需重新大规模开发。但经常也会有一些问题发生，一单这些代码不够solid，出现了一些劣化问题，就会使得整个项目迭代难度、稳定性保障难度变大。尤其是每层表现均不够稳定、分层不够清晰的时候，改造难度会更大。这次我面临的就是底层模型的调整，这样上面几层多少也会受影响，改造工作量非常大。解决这个问题，有两个思路：

每一层收敛新老模型兼容逻辑
从web到model重新开发，做代码隔离

前者看起来技术含量高，后者反而显得很low，但是我推荐隔离的方式。 大的系统改造，一定要确保上线后遇到任何问题都有兜底的处理办法。一但上线后系统有异常，会有非常多的数据清洗、系统止损工作，而方式1每一层的梳理兼容工作，会把整个项目的难度提升多个数量级，一但有一个点没梳理到，将会面临不可预期的问题，另外，回归的挑战也非常大。而方式2，恰恰可以做到对主干流程侵入降到最低，甚至可以做降级、灰度开关，一点一点放量控制影响面。

团队间互卷怎么解决？

2024-03-16T00:00:00+00:00

这些年没少经历踩脚的事情，要么人家来卷我，要么我领了任务去卷别人。

为啥会踩脚？说白了就是两个团队核心目标一致，都想拿同一个结果。上面两边老板没能拉齐，只能安排下去抢。说白了，层层下放。而且卷地盘这种事情确实一线好操作，需求那么多，很容易通过一些case收一些东西。但是两边团队实力本身也不会差特别多，所以结果大多是两边互相收一些东西，整体架构乱得一批。

我们要如何应对？大家如果在团队里，本身也有屁股问题，要说客观视角也都是相对的，所以谁遇到也会头疼。说说我的想法：

一般开卷，都是通过一些方案来聊起的。往往一开始大家也不知道对面想做啥，底线是什么，通过一次次方案、交互、流程的交锋来试探双方的真实想法，讲究的就是一个反应速度。
探到想法，两边想法没冲突还好，有冲突就得解，不解项目都得卡死。
怎么解冲突？如果不是触及自己底线，可以适当让步，当然我们自己也要给自己争取些资源。
如果还解决不了，上升，让两边负责人去聊。
当然，还有一些骚操作，找合作伙伴去聊，比如产品、业务。上游同学说话非常有效果。

按照康威定律，组织架构决定系统架构。如果系统有overlap，那一定是组织分工有问题。说实话高层不一定很快想清楚这种问题的，也依赖一线反馈，所以我们遇到这种问题也积极些，卷确实让人恶心，但问题还是要推动解决。而且针对这些问题，多完整得梳理下全局情况，让大家都有机会，自己也能成长。但也防不住对方藏材料恶心你。。。

所以说要根治，离不开整个团队负责人的管理方法和手段，确保大家分工明确，都有发展空间。如果大家发现自己团队搞不定，趁早撤。

如何做平台？

2024-03-15T00:00:00+00:00

平台的初衷是为了沉淀一些常见能力，当新业务启动时可以快速复用。

理想是好的，但实际落地难度非常大。新业务很多是在尝试和探索，可能做了半年就停了，平台还没成型。此时又开始一个新业务，但要平台能力不同又需要重新做。如此往复，到最后往往乱七八糟，平台不像平台，开发效率低，强行复用问题也多。

这个时候大家又会觉得平台是个累赘，还不如小而美快速支持业务。但是这种情况下容易偏case推进，也不能在发展受阻的时候把之前优质的经验分享给业务。

从上面的描述也能看出来存在两条路，每条路都有优劣，要在合适的契机选择好路线。选很关键，一般发展早期糙快猛支持业务，成熟期需要精细化运营的时候做平台。千万不要既这又那，不是说选了行业先行就不做平台，选了平台就可以慢点做业务，而且说要有侧重，选了哪个哪个优先。四不像系统就是既这又那的过程中做烂的。

要选好，并且排除阻力，就需要高层支持，如果说我们负责的系统和路线不匹配，千万别纠结，四不像系统是最可怕的。

最后，平台路线到底要咋做？

平台切记不是为了做平台而做，他是孵化出来的。所以平台团队也是要去做业务的，尤其是复杂的业务场景，在支持业务的工程中逐步沉淀，而不是上下分层，搞成行业和平台。一开始我们是看不清楚平台核心目标的，而且业务一旦放缓，之前定的架构全部作废。理想的做法是收拢多行业垂直业务，逐步沉淀平台系统。

一些管理方面的思考

2023-09-28T00:00:00+00:00

如何适应新的位置？
- 冒充者综合症
- 需要做好三件事
看清全局
- 做过才能写规划么？
  - 怎么规划？
- 为什么有人会觉得你的产出不足，事情简单？
需要哪些人？
这些人要如何运转？
最后

如何适应新的位置？

随着自己能力的提升，工作的积累，会安排越来越多的相关工作，我们就需要承担更多的任务。这是一个循序渐进的过程，和传统企业的「任命」不同。不过，随着我们承担工作越来越多，量变也会引起质变，突然有一天，你会发现我们需要带实习生、分配工作、写规划、甚至要去吵架聊分工。越到后面你会发现自己承担的责任越大，压力也越大。而且由于并不是官方任命，缺少了专门的培训流程。这里其实体感会很差，突然要承担一个之前没太接触或者培训过的事情。

冒充者综合症

冒名顶替症候群（英语：Impostor syndrome），亦称为冒名顶替现象（英语：impostor phenomenon）、骗子症候群（英语：fraud syndrome）。这个名称是在1978年由临床心理学家克兰斯博士（英语：Pauline R. Clance）与因墨斯（英语：Suzanne A. Imes）所提出，用以指称出现在成功人士身上的一种现象。患有冒名顶替症候群的人无法将自己的成功归因于自己的能力，并总是担心有朝一日会被他人识破自己其实是骗子这件事。他们坚信自己的成功并非源于自己的努力或能力，而是凭借著运气、良好的时机，或别人误以为他们能力很强、很聪明，才导致他们的成功。即使现实环境中的证据指明，他们确实具备优秀才能，他们还是认为自己只是骗子，不值得获得成功。

这里推荐阅读《硬核晋升》，作者一步一步讲了自己晋升或者提升scope后的思考和解法。

需要做好三件事

前面也提到，互联网的提升往往是被动且缺少培训的，那我们也就不绕弯子了，带团队或者小方向，都算管理的职责了，可以分为三件事：

初衷：团队想要实现的成果，或者也可以称为「为什么」，就是我们常说的规划。为什么要做这件事，为什么要这个月做这件事？我们需要保证团队知道成功是什么，都认可这个目标，都认为可以实现。
人员：需要谁来完成初衷，团队人力是否满足？技能是否满足？不满足接下来要怎么办？
流程：团队要如何一起工作，要协调好成员。能够控制好自己的团队，培养健康、高效的团队文化。

看清全局

大部分人认为的规划，是要指出来一条路，这里就需要我们已经是这个领域的专家了。XX业务应该这样做：1. XXX；2. XXX；3. XXX。

做过才能写规划么？

我们要开始着手规划的时候，往往接手的业务，或者一些细节，我们是不了解的。前面提到的冒充者综合征，自己虚的点往往是这个。

压根没做过。团队新开了个方向，直接安排去支持；
之前虽然做过类似业务，但是这次很难照搬。所以，不管做没做过，实际上都需要我们从头开始了解业务情况作出适当的规划。恰恰照搬是最不可取的，参考云仓。

怎么规划？

自己的定位更像是做顾问，我们接手了一个新的项目，需要需求方说清楚自己的目标和要求，我们自己有一套方法论，可以快速了解全局情况并给出解法，最后需要有一个逻辑自洽的PPT来做汇报。关键的几件事：

收集业务目标需求生产的顺序是业务运营->产品->开发。整个运营其实是一个完整运转的「企业」。业务的流转本身是闭环的，但有时需要自研系统来提升关键环节的效率和收益。常见的一个误区是教业务做事，这是因为业务和产品的分工看起来没有那么「干净」，出现了混合汇报的情况。

前面也提到，业务本身是闭环的，所以我们不可能去教业务做事情；但是可以去教产品做事，本身产研是不分家的。所以对于业务的一些规划和思考，没有必要等产品转达，我们作为实现方可以直接沟通获取一手消息，也避免信息差过大影响规划方向。今年前半年我重点做的就是这个方面。

看清业务全貌业务团队的研发一定要懂业务，要明白我们到底做出来的东西是怎么支持业务运转的，这个非常重要。而且我们能够用自己的语言来描述我们的业务架构（当然了，如果你对口的业务非常猛，直接白嫖即可，但也要提醒下，业务的首要任务是GMV，并不是架构）。这块也需要多少了解下友商的情况，不用太细，可以帮助我们判断后续的走势；架构的话基于金字塔模型来梳理，用MECE原则搞一张大图，一般是以业务动线、业务模块等套路来表达。我们能从准确表达业务发展的思路：为什么去年重点是做A？A做得怎么样？有了A能力得沉淀，接下来要做什么？为什么做这个？业务全貌不是单纯说自己负责的部分。因为产研和业务不是1:1，所以要看清楚全貌要看业务团队负责的内容。
提炼技术目标能回答好前面的问题后，基于此来推导技术规划。大家一开始着手规划的时候往往是从3开始考虑，很容易没想法最后写不下去，1、2做得越好，3越明确和清晰。

这里推荐阅读《麦肯锡结构化战略思维》。

为什么有人会觉得你的产出不足，事情简单？

业务复杂，规划复杂比较理想的情况，一般是业务增长比较好的时候，我们能跟着业务蹭一波。最好有技术沉淀，比如把脉、调度引擎、对账框架、主数据。
业务简单，规划复杂这种情况说明能力更强，去年云仓就有这种趋势，从一开始没有目标但又非常忙到后来收了无忧目标清晰游刃有余。
业务复杂，规划看起来简单这种情况其实最常见，电商本身还是在增长的，大家都很忙，沉浸在倒排期中，最后没有时间思考没啥沉淀。
业务简单，规划看起来简单同3。我不认为有简单的业务，业务团队的规模摆在那里，我们看到的东西少，可能是同步给我们的少；也可能是东西多但没我们想要的。思考和深度就非常重要了。

需要哪些人？

有了目标、事项、里程碑，就需要有人来干。

如果现有人能力能够满足，我们需要给每个人明确事情和目标。总体策略：扬长避短，让大家做擅长的事情并提高一定的要求来提升一些方面的能力；
如果现有人力&能力不足，需要做好招聘，招聘候选人的画像要很明确；
除了考虑单个人，人多了之后，还需要考虑组织建设。我们要分几个方向（一般建议和规划里的目标对齐）？每个方向的负责人是谁？负责人需要做什么？负责人需要提升哪些？

这部分推荐阅读《硬核晋升》。

这些人要如何运转？

关键目标就是提效，需要1+1>2，而不是人越多越乱。内部：解决一线问题，提升需求流转效率。

定容会，做好需求安排人力安排，不能单纯压力下放；
周会是非常重要的手段，定期同步进展解决需求推进卡点；
问题Review会，培养团队质量意识，沉淀处理办法、规范。

外部：做好协同

业务间：定期走一线；
产研间，周会；
研发间：规划&总结会，同步好业务价值；

另外，为了能拿关键结果，专事专办：

大型项目技术O管理；
专项成立FT，例如稳定性小组、专项小组；

这部分推荐阅读《卓有成效的管理者》、《增长黑客》。

最后

关于方法论

方法论不可能完整，关键还是要思考沉淀，不断优化、丰富自己的方法。这也没有那么高端，把自己做事情的方法看作提高流程，不断优化丰富工具。另外，也不能光想，也要去了解世面上其它人的思考方式。

除了前面提到的还有啥要做的？

后续我能看到的方法，要去考虑团队增长。按传统企业发展来看，做好一个业务只需要维护即可，要预留人力甚至招聘都是建立在业务增长的前提下。在业务规划已经支持比较好的情况下，一旦发现业务苗头不对，基于高层的远景和规划做好前瞻性布局。

为什么要总结规划，对自己的收益？

面对一系列复杂问题理清楚思路，给出思路，解决阶段性问题，让自己和团队更「躺」。

【Go实现】熔断机制

2020-03-01T00:00:00+00:00

什么是熔断？

熔断是指在下游发生错误时上游主动关闭或限制对下游的请求。

原理

通常熔断器分为三个时期: CLOSED，OPEN，HALFOPEN
RPC 正常时，为 CLOSED；
当 RPC 错误增多时，熔断器会被触发, 进入 OPEN；
OPEN 后经过一定的冷却时间，熔断器变为 HALFOPEN；
HALFOPEN 时会对下游进行一些有策略的访问, 然后根据结果决定是变为 CLOSED，还是 OPEN；

总得来说三个状态的转换大致如下图：

Go 实现

https://github.com/rubyist/circuitbreaker

IsAllowed 是否允许请求，根据当前状态判断

CLOSE 允许

OPEN

在 CoolingTimeout 冷却时间内，不允许
过了冷却时间，状态变为 HALFOPEN，允许访问

HALFOPEN

在 DetectTimeout 检测时间内，允许访问
否则不允许

atomic.StoreInt32((*int32)(&b.state), int32(HALFOPEN))

trip 判断是否达到熔断限额（可以自定义）

type TripFunc func(Metricser) bool

ThresholdTripFunc 错误阈值
ConsecutiveTripFunc 连续错误超过阈值
RateTripFunc 根据最少访问数和错误率判断

Metricser 访问统计，包括成功数、失败数、超时数、错误率、采样数、连续错误数

type Metricser interface {
   Fail()    // records a failure
   Succeed() // records a success
   Timeout() // records a timeout

   Failures() int64    // return the number of failures
   Successes() int64   // return the number of successes
   Timeouts() int64    // return the number of timeouts
   ConseErrors() int64 // return the consecutive errors recently
   ErrorRate() float64 // rate = (timeouts + failures) / (timeouts + failures + successes)
   Samples() int64     // (timeouts + failures + successes)
   Counts() (successes, failures, timeouts int64)

   Reset()
}

window 实现类

type window struct {
   sync.RWMutex
   oldest  int32     // oldest bucket index
   latest  int32     // latest bucket index
   buckets []bucket // buckets this window holds

   bucketTime time.Duration // time each bucket holds
   bucketNums int32         // the numbe of buckets
   inWindow   int32         // the number of buckets in the window

   allSuccess int64
   allFailure int64
   allTimeout int64

   conseErr int64
}

type bucket struct {
   failure int64
   success int64
   timeout int64
}

用环形队列实现动态统计。把一个连续的时间切成多个小份，每一个 bucket 保存 BucketTime 的统计数据，BucketTime * BucketNums 是统计的时间区间。

每 BucketTime，会有一个 bucket 过期

if w.inWindow == w.bucketNums {
   // the lastest covered the oldest(latest == oldest)
   oldBucket := &w.buckets[w.oldest]
   atomic.AddInt64(&w.allSuccess, -oldBucket.Successes())
   atomic.AddInt64(&w.allFailure, -oldBucket.Failures())
   atomic.AddInt64(&w.allTimeout, -oldBucket.Timeouts())
   w.oldest++
   if w.oldest >= w.bucketNums {
      w.oldest = 0
   }
} else {
   w.inWindow++
}

w.latest++
if w.latest >= w.bucketNums {
   w.latest = 0
}
(&w.buckets[w.latest]).Reset()

Panel Metricser 的容器

PanelStateChangeHandler 熔断事件

type PanelStateChangeHandler func(key string, oldState, newState State, m Metricser)

缺陷

所有 breaker 公用同一个 BucketTime，统计周期不支持更新
冷却时间不支持动态更新

使用 Golang 生成 PDF

2019-06-26T00:00:00+00:00

gofpdf
wkhtmltopdf

这是一个例子，可以先感受下：口算大通关。

gofpdf

仓库：https://github.com/jung-kurt/gofpdf

一开始就发现了这个包，纯 Go 实现，用起来很友好。

举几个简单的样例：

加载字体

pdf.AddUTF8Font("NotoSansSC", "", "./resource/font/NotoSansSC-Regular.ttf")

绘制矩形并填充颜色

pdf.SetFillColor(0, 0, 0)
pdf.Rect(30, 0, 26.5, 14, "FD")

写字

pdf.Text(32, 9, "字字字")
// 多行文字，根据宽度自动换行
func TextMultiLine(pdf *gofpdf.Fpdf, text string, x, y, width, heightPerLine float64) {
	texts := pdf.SplitText(text, width)

	i := 0
	for _, text := range texts {
		_y := y + (heightPerLine * float64(i))
		pdf.Text(x, _y, text)
		i++
	}
}

增加图片

pdf.Image("./resource/image/logo.jpeg", 2, 1.5, 26, 10, false, "", 0, "")

简单的svg

sig, err = gofpdf.SVGBasicParse(templateStr)
if err == nil {
	scale := 100 / sig.Wd
	scaleY := 113 / sig.Ht
	if scale > scaleY {
		scale = scaleY
	}
	pdf.SetLineWidth(0.25)
	pdf.SetDrawColor(0, 0, 0)
	pdf.SetXY(0, 0)
	pdf.SVGBasicWrite(&sig, scale)
} else {
	pdf.SetError(err)
}

条形码、二维码

key = barcode.RegisterCode128(pdf, "barcode")
width = 55
height = 6.7
barcode.BarcodeUnscalable(pdf, key, 39, 110.5, &width, &height, false)

简单的 HTML

htmlStr := `You can now easily print text mixing different styles: <b>bold</b>, ` +
	`<i>italic</i>, <u>underlined</u>, or <b><i><u>all at once</u></i></b>!<br><br>` +
	`<center>You can also center text.</center>` +
	`<right>Or align it to the right.</right>` +
	`You can also insert links on text, such as ` +
	`<a href="http://www.fpdf.org">www.fpdf.org</a>, or on an image: click on the logo.`
html := pdf.HTMLBasicNew()
html.Write(lineHt, htmlStr)

居中

pdf.SetXY(40, 117.8)
pdf.CellFormat(60, 2, "center", "", 0,
	"CM", false, 0, "")

优势：

纯 Go 实现，使用方便；
性能好 BenchmarkSvg-4 100 15806543 ns/op；
支持格式多，除了上面的例子，还支持根据简单 HTML 绘制 PDF；
非常完善的样例，fpdf_test.go里面有所有接口的生成样例，可以直接看效果；

缺陷：

svg 支持的比较简单。只支持最外层是path，path内只支持d，其他的比如坐标转换都不支持。其实大部分svg都是包含坐标转换的，这个不太友好。可以通过Method-Draw将svg简化压缩一下。
html 支持的比较简单。上面的例子写得比较明白了，支持居中、加粗、超链接这种。

wkhtmltopdf

网上经常能找到在线html转pdf的在线小工具，其实都是基于c语言的实现wkhtmltopdf做的。这个工具功能很强大，甚至可以解析<script>引入的jQuery外网包。Go 语言是通过cgo bind实现的包，https://github.com/adrg/go-wkhtmltopdf，功能非常强大，缺点是生成得太慢。

Docker(Linux) 环境下如何配置 host

2019-03-18T00:00:00+00:00

Linux 系统如何配置 host？
Docker 里配置没起作用
/etc/nsswitch.conf

Linux 系统如何配置 host？

如果你有管理员权限

sudo vi /etc/hosts

增加你想配置的 host，保持并退出

127.0.0.1 cyeam.com

可以通过ping命令来检测一下

ping cyeam.com

大部分情况到这里就结束了。

Docker 里配置没起作用

测试俊哥在自己的 Docker 里搭起了我的服务，但是发现发 http 请求没有按照预想的用配置好的 host 发。但是我在自己的 Mac 上面配 host 是可以的。下面讲一下原因，特别感谢俊哥的研究。

/etc/nsswitch.conf

Linux 系统解析域名，支持本地文件配置，也支持通过域名服务器查询。本地文件配置的方式就是第一步提到的 /etc/hosts。而域名解析服务器的配置则在 /etc/resolv.conf 中。此外，还有一个重要的文件 /etc/nsswitch.conf，它可以用来配置域名解析的优先级。

hosts:          files dns

我的开发机上面是这样，意思是先读取文件，如果文件里没有从 dns 服务器查询。

而我们的情况是 docker 里面没有这个文件，当系统没有这个文件时，Go 的表现是：

// If /etc/nsswitch.conf doesn't exist or doesn't specify any
// sources for "hosts", assume Go's DNS will work fine.
if os.IsNotExist(nss.err) || (nss.err == nil && len(srcs) == 0) {
	if c.goos == "solaris" {
		// illumos defaults to "nis [NOTFOUND=return] files"
		return fallbackOrder
	}
	if c.goos == "linux" {
		// glibc says the default is "dns [!UNAVAIL=return] files"
		// https://www.gnu.org/software/libc/manual/html_node/Notes-on-NSS-Configuration-File.html.
		return hostLookupDNSFiles
	}
	return hostLookupFilesDNS
}

它会按照dns [!UNAVAIL=return] files的默认值来查询。也就是先查询 dns，如果 dns 服务器不可用，再查询本地 hosts 文件。

The system takes the action associated with the STATUS (return) if the DNS method does not return UNAVAIL (!UNAVAIL)—that is, if DNS returns SUCCESS, NOTFOUND, or TRYAGAIN. As a consequence, the following method (files) is used only when the DNS server is unavailable: If the DNS server is not unavailable (read the two negatives as “is available”), the search returns the domain name or reports that the domain name was not found. The search uses the files method (check the local /etc/hosts file) only if the server is not available.

一个想当然的问题最后引出了这么多不了解的新知识，真好。

Go http 如何发送 multipart/form-data (发送文件)？

2019-03-15T00:00:00+00:00

通过multipart/form-data提交数据
通过 CreateFormFile 发送文件

通过`multipart/form-data`提交数据

bodyBuf := &bytes.Buffer{}
bodyWriter := multipart.NewWriter(bodyBuf)
_ = bodyWriter.WriteField("param", string(param))
defer bodyWriter.Close()

req, err := http.NewRequest("POST", callbackUrl, bodyBuf)
if err != nil {
	return nil, err
}
req.Header.Set("Content-Type", bodyWriter.FormDataContentType())
req.WithContext(ctx)

resp, err := http.DefaultClient.Do(req)
if err != nil {
	return nil, err
}
defer resp.Body.Close()

Content-Type头很重要，丢了的话服务端无法正常解析。

通过 CreateFormFile 发送文件

multipart.Writer支持CreateFormFile，写入文件名就能实现上传文件了。

http 的 POST 方法可以通过 body 发送数据，而数据的编码格式是通过Content-Type来定义，常见的类型是What are all the possible values for HTTP “Content-Type” header?。

Go module 如何发布 v2 及以上版本？

2019-03-12T00:00:00+00:00

Go module 版本号
Go 项目如何升级 v2？
incompatible
v0.0.0-20190312205133-abcdefghijklm
tag 删除了重建为什么没效果？

用上 go mod 之后，依赖包都是通过版本打 tag 的形式确定版本号。比如 ` github.com/mnhkahn/gogogo v1.0.9`。每次都改动都是在累加低位的版本号，一直这么用也挺安逸的。突然有一天，我的一个底层包需要大改，导致和之前的版本彻底不兼容，这种情况下如何设置版本号，如何能让调用方成功接入？

Go module 版本号

先讲一下 Go 在用的版本号协议semver (Semantic Versioning)。它定义的版本号格式是：

vMAJOR.MINOR.PATCH

MAJOR 主版本号，如果有大的版本更新，导致 API 和之前版本不兼容。我们遇到的就是这个问题。
MINOR 次版本号，当你做了向下兼容的新 feature。
PATCH 修订版本号，当你做了向下兼容的修复 bug fix。
v 所有版本号都是 v 开头。

比如我们用的 Go 语言，目前是 1.12.0。它还是 Go 1，每次升级都保证是兼容的，12的版本号是新 feature，而最末尾的版本号是修复。说明当前的版本上了之后还没有修复过问题。

我这次也是搞了一个不兼容的更新，所以需要升级到 v2.0.0。

Go 项目如何升级 v2？

假设你的项目已经支持 go module 了。

修改 go.mod 第一行，在module那行最后加上/v2。module github.com/mnhkahn/aaa/v2。
对于不兼容的改动（除了 v0 和 v1），都必须显示得修改 import 的路径。所以我们的引用需要改成 import "github.com/mnhkahn/aaa/v2/config"。在所有的地方都需要修改，包括自己的包内和调用方包。
底层包的更新有个小工具可以帮助快速实现mod。GO111MODULE=on go get github.com/marwan-at-work/mod/cmd/mod mod upgrade。
代码提交之后需要打新 tag，v2.0.0。
调用方修改引用代码，需要加v2，和第二步提到的一样。
go get github.com/mnhkahn/aaa/v2。

incompatible

有时候你能在 go.mod 文件中发现不兼容的标记，v3.2.1+incompatible，这是因为这个依赖包没有使用 go module，并且它通过 git 打了 tag。

v0.0.0-20190312205133-abcdefghijklm

对于没有打 tag 的仓库，go.mod 就会很丑陋，它的格式是pseudo-version。它的含义是v0.0.0-yyyymmddhhmmss-abcdefabcdef。

tag 删除了重建为什么没效果？

困扰了我很久的一个问题。有一个 tag v2.0.0 的代码有问题，我删除了这个 tag，新建了一个好的版本，但是go get依然报错，困扰了很久，一直以为是 v2 的版本号写错了。后来才发现是 go 有本地缓存，缓存在 $GOPATH/pkg/mod/cache 下面，把里面的内容清掉，重新获取即可。

更多阅读：Go 1.11 Modules。

Mac 环境下 git 如何自动补全

2018-11-12T00:00:00+00:00

安装 bash-completion
安装 git-completion.bash

安装 bash-completion

brew install bash-completion

将下面代码添加到~/.bash_profile（如果没有该文件，新建一个）。

# git auto completition
if [ -f ~/.git-completion.bash ]; then
  . ~/.git-completion.bash
fi

安装 git-completion.bash

这个文件不能随便安装，网上的教程都是用git参数的master分支，这是不对的，这个版本需要和当前系统安装的git版本对应。

git version

看看自己的版本是什么，我的是2.17.1，就需要用这个版本的脚本。将脚本报存到~/.git-completion.bash里面，然后执行：

source ~/.git-completion.bash
source ~/.bash_profile

这样就可以咯，按下Tab键就可以提示啦。

$ git che
checkout      cherry        cherry-pick

在这个大促的日子聊一聊我的大促经历

2018-11-11T00:00:00+00:00

之前在某东待了 3 年半，经历了 4 个 618，3 个双十一。之前所在的团队是京东 PC 端三级列表页，关于我们项目的架构介绍，可以参考这篇文章。每年两次大促，每年也需要为这两次大促进行长达一个月的准备。

压测

压测不光是要大促的时候压，平时每个月都会压。每个月压单机，压的链接是线上抓取的真实访问链接，我们线下找一台机器。压测单机会根据不同的并发进行压，一般从 5 并发开始，逐渐增加，直到 TP99 下降到不可接受为止。每次压测都会和之前的进行对比，如果发现性能下降，需要定位原因和优化。

大促压测每年集中在 5 月和 10 月，会在夜里进行。整个项目组的所有机器（或者一个机房的所有机器）进行压测，从入口开始压。大促前的压测标准是之前大促峰值的流量，能够能扛得住之前峰值的倍数，能达标就行，不能的话需要优化或者加机器（主要还是加机器）。

全链路加测。这个是最近开始搞的，全公司的同一个夜里一起加班压。这个会模拟当时的实时流量，并不会像单独压测的时候那么狠。

性能

对于性能最重要的指标还是 TP99，公司对性能其实有不成文的规定，TP99 要小于 200ms。如果大于这个值，用户会明显觉得卡顿。

禁止读库、禁止跨机房调用

线上只读服务，比如我们列表服务，禁止直连数据库。用户的任何操作都不能发生数据库操作。平时我们经常会写这种接口：取缓存读数据，没有的话去读库，然后把数据设置到缓存里。这种方案只适用于小流量的情况，一旦数据库来个慢查询或者数据量变大，所有接口都会挂，所有哦。这也算是雪崩的一种吧。

跨机房调用一个是慢，一个是这样的话就失去了双活的意义了。不过我们的降级方案里有跨机房方案，不过常规方案里要禁止。

监控

监控非常重要。程序接口和关键模块都需要加监控，包括性能和流量监控，报警阈值也需要调整成一个合理的值。发送异常问题需要能立刻报警。

除了接口监控，还需要有实例监控，防止机器或者服务挂了自己没有感知影响到了用户。一般我会选择监听端口获取发起一个 HTTP 请求来检测存活。之前就遇到一个问题，重启 nginx 失败了，没有设置报警，导致刷新页面会偶尔跳错误页，害得我会滚代码第二天才重新上。

还有一种监控是针对页面的，定时调用指定页面，并渲染页面，渲染完成后通过抓取页面上的 HTML 信息检测业务是否正确。回归测试中非常有用。

服务降级

依赖的模块有时候会发生异常，比如 Redis，每过几个月就会来一次，一般原因是某个分片过大，分片过大性能会下降。还有一些情况，比如硬件维修，这个时候需要摘机器等。

方案有很多，比如双机房，双集群，多组 Redis 等。当时我们设计了十几套降级方案，尽量把所有的降级操作都压缩到最小。

兜底

上面说了，nginx 出错会跳错误页，而不是 nginx 的默认错误页。而我们的要求是三级列表页能根据每个类目跳兜底页面。也就是说，兜底的时候用户有可能并不会发现我们兜底了。这样可以保证在后端服务发生任何异常的时候都能给用户一个友好的页面。

对于一个电商而且是上市技术公司来说，兜底是非常重要的，它会影响到公司的股价。如果发生时间很长的故障，而且又引发一些舆论效应的话，损失的就不是那些订单了，而是市值。分享一个真实的事情：有一次我的接口出了问题，没有返回正常的数据，前端接口没有兼容，在用户端看到了 nginx 的 404 页面，当时要求第一个要修复的是兜底方案。

事故

写到这里，线上紧急问题的处理方法已经有了，自动的有兜底，手动的是报警+降级操作。可以这么说，这几个部分是影响绩效的最重要因素。线上问题不管多么严重，衡量级别的最重要因素是影响时间，处理得快，比如十五分钟内，问题不算大；如果超过半个小时，事故级别就会往上走了。

处理事故最重要的，还是要快。自己操作时需要权衡，如何快速恢复。处理问题最差的方案是改代码。如果实在找不到问题，可以考虑强制更改数据库或者缓存来解决。紧急问题处理的快慢主要还是看平时项目预留了多少调试的方案和快速定位问题的辅助工具。真发生紧急问题一般会比较着急，没办法集中注意力，所以前面提到的调试工具或者降级方案就显得很重要了。

值班

进入 6 月份和 11 月份就要封版了，那个时候也没啥需求了，主要就是值班。一般 1 号是秒杀日，那天凌晨需要值班。移动端的流量很大，移动是未来啊。有时候每个夜里都得留人值班，不是每次都这样，这个主要是领导决定。17 和 10 号夜里一定得留在公司值班，夜里也不能回家，2 点流量下来后需要到公司附近的酒店休息，早上 8 点前回来，因为早上 8 点有秒杀。

连夜值班我还是比较喜欢的，可以换调休，第二天还可以休息一天。一个组的会经常大促一起开房，大家的基情是其它公司比不了的。

每次值班领导都会给买吃的，各种吃的，还有饮料，我最喜欢的还是那个豚骨汤泡面，在每个值班的夜里，泡一碗，周围都是这个味，最后大家都开始吃这个了。

一般 17 号或 10 的时候就需要进值班室了，值班室挺挤的，大家在那里呆一宿，全是味。在那边有基础服务的人，出了问题方便解决。0 点的量真的很大，那个时候大家都很紧张。

讲一个真实的值班情况：那天我像往常一样在值班，那是我第一次负责我们组所有的大促服务稳定和降级策略，所有准备工作都像往常一样过完了，能想到的意外情况也都做了准备，但还是发生了意外。10 号晚上 23:20，流量突然可以激增，是平时流量的几倍，触发了报警。看到流量还在上涨，就得找上涨的源头。我们的服务除了给自己的列表用，其它部门也会调用，我们把请求量大的都做了单独的监控，但是这次的流量上涨却没找到源头。这个平时量太小，被我忽略了。没办法，只能上 nginx 去看 access log，找出流量来源。发生这种情况，都很意外，不过我们服务性能很好（曾经有一度可以单台抗所有量），我定位起来也就没有很紧张了。后来找到了调用方，他们在大促前更新了缓存服务，这个服务并不是那么可靠，导致 10 号晚上缓存被击穿，流量回源，全到我了这里。平时 QPS 应该是个零点几的样子，那天晚上那么短的时间 QPS 有几十万，还好我们服务扛得住，否则的话只能把这个来源降级了。

很多情况下问题就是这么来的，你觉得可以没什么，优化了一把，跑得也正常，大促极端情况下就会被击穿了，下游服务都扛住了，如果下游依赖的很多服务因为流量突然上涨没有扛住，问题就很严重了。

最后

今年双 11 是第一次没有亲自参与的大促，我自己也没买什么，感觉大促气氛不像以前那么浓烈了，大家是什么感觉呢？

通过两个例子介绍一下 Golang For Range 循环原理

2018-10-30T00:00:00+00:00

下面的代码是死循环么？
语法糖
下面的代码有什么问题么？
切片For Range原理
其它语法糖
- map
- channel
- 数组
- 字符串

下面的代码是死循环么？

func main() {
	v := []int{1, 2, 3}
	for i := range v {
		v = append(v, i)
	}
}

上面的代码先初始化了一个内容为1、2、3的slice，然后遍历这个slice，然后给这个切片追加元素。随着遍历的进行，数组v也在逐渐增大，那么这个for循环是一个死循环么？

答案是否。只会遍历三次，v的结果是[0, 1, 2]。并不是死循环，原因就在于for range实现的时候用到了语法糖。

语法糖

语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·蘭丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。

对于切片的for range，它的底层代码就是：

//   for_temp := range
//   len_temp := len(for_temp)
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//           value_temp = for_temp[index_temp]
//           index = index_temp
//           value = value_temp
//           original body
//   }

可以看到，在遍历之前就获取的切片的长度len_temp := len(for_temp)，遍历的次数不会随着切片的变化而变化，上面的代码自然不会是死循环了。

下面的代码有什么问题么？

slice := []int{0, 1, 2, 3}
myMap := make(map[int]*int)

for index, value := range slice {
	myMap[index] = &value
}
fmt.Println("=====new map=====")
for k, v := range myMap {
	fmt.Printf("%d => %d\n", k, *v)
}

这也是实际编码中有可能会遇到的问题，循环切片，把切片值的地址保存到myMap中，这样的操作结果是：

=====new map=====
=> 3
=> 3
=> 3
=> 3

结果完全一样，都是最后一次遍历的值。通过上面的底层代码看下，遍历后的值赋给了value，而在我们的例子中，会把value的地址保存到myMap的值中。这里的value是个「全局变量」，所以赋完值之后myMap里面所有的值都是value，所以结构都是一样的而且是最后一个值。

注意，这里必须是保存指针才会有问题，如果直接保存的是value，因为 Golang 是值拷贝，所以值会重新复制再保存，这种情况下结果就会是正确的了。

切片For Range原理

总结一下，通过For Range遍历切片，首先，计算遍历次数（切片长度）；每次遍历，都会把当前遍历到的值存放到一个全局变量index中。

其它语法糖

另外，For Range 不光支持切片。其它的语法糖底层代码。

map

// Lower a for range over a map.
// The loop we generate:
//   var hiter map_iteration_struct
//   for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
//           index_temp = *hiter.key
//           value_temp = *hiter.val
//           index = index_temp
//           value = value_temp
//           original body
//   }

channel

// Lower a for range over a channel.
// The loop we generate:
//   for {
//           index_temp, ok_temp = <-range
//           if !ok_temp {
//                   break
//           }
//           index = index_temp
//           original body
//   }

数组

// Lower a for range over an array.
// The loop we generate:
//   len_temp := len(range)
//   range_temp := range
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//           value_temp = range_temp[index_temp]
//           index = index_temp
//           value = value_temp
//           original body
//   }

字符串

// Lower a for range over a string.
// The loop we generate:
//   len_temp := len(range)
//   var next_index_temp int
//   for index_temp = 0; index_temp < len_temp; index_temp = next_index_temp {
//           value_temp = rune(range[index_temp])
//           if value_temp < utf8.RuneSelf {
//                   next_index_temp = index_temp + 1
//           } else {
//                   value_temp, next_index_temp = decoderune(range, index_temp)
//           }
//           index = index_temp
//           value = value_temp
//           // original body
//   }

完整底层代码。

如何在Mac上快速切换Host

2018-10-26T00:00:00+00:00

切换 Host
Which Host
断开现有链接
一键断开链接

切换 Host

我们会经常遇到需要切换 Host 的场景，最原始的方法是直接修改/etc/hosts。不过这个方法太原始了，一般我们都会分测试场景分不同的 Host 组。这个时候就需要一个工具来保存多个分组的 Host，我用的是Gas Mask。这种工具很多，功能也都差不多，大家可以选择自己习惯的。

Which Host

大部分人也就到上一步就结束了，其实很多时候也会有问题，我们会经常发现 Host 没有生效。

我们这个时候需要做的就是明确到底 Host 指到哪里了，切换 Host 到底成功了没有。

借助 Chrome 的调试工具也可以看到具体这次访问的 Host 到底是什么，如上图。不过这个方法多少有些繁琐，推荐大家一个插件：Which host，一个京东前端大神开发的。具体效果就和封面图的一样。

断开现有链接

那么配了 Host 为啥有时候不是立刻生效呢？原因在于 Chrome 和之前的 Host 还保持着链接，切换 Host 并不会释放这个链接，这种情况下访问的有可能还是之前的 Host。

Chrome 本身提供了清空链接的功能，把当前保持的链接清空了就能解决这个问题。在浏览器输入：chrome://net-internals/#sockets。

在打开的页面依次点击 Close idle sockets 和 Fulsh socket pools 就能释放链接了。你可以把这个地址保持到书签栏来提高速度。

一键断开链接

不过这个还是很慢，我们需要打开一个标签页，点击这个书签，再点击两个情况按钮，再回到之前的测试页面，需要点5次呢。

后来我又找到一个插件：Flush DNS & close sockets。它可以帮助我们一键解决这个问题。不过用这个插件还是会有个问题，那就是需要增加 Chrome 的启动参数--enable-net-benchmarking。

在Mac上通过下面几行命令就可以解决：

mv "Google Chrome" Google.real
touch "Google Chrome"
printf '#!/bin/bash\ncd "/Applications/Google Chrome.app/Contents/MacOS"\n"/Applications/Google Chrome.app/Contents/MacOS/Google.real" --enable-net-benchmarking "$@"\n' > "Google Chrome"
chmod 755 "Google Chrome"

大功告成。

为 Go module 搭建私服

2018-09-27T00:00:00+00:00

私服安装
启动
打包脚本
GOPROXY
Athens 的实现

之前介绍了如何在线上环境打包，这样能解决问题，但是由于是借助代理下载依赖包，打包的过程偏慢，我自己的感觉打一个项目需要2分钟所有。而且还有一个严重问题，那就是一旦下载失败，打包就失败了，还得重试。这个体验很不好。关于 Go module 打包，我感觉未来的发展方向还是和 Java 的一样，得自己整私服，这样打包会很快，而且也安全。我们打包从私服下载，私服如果缓存了当前版本的包，直接返回；否则私服去下载对应版本的代码。

私服安装

首先你需要安装 Go1.11。

我用的是Athens，雅典娜。

首先下载代码：

git clone https://github.com/gomods/athens
cd athens

即使用私服还是得设置代理：

export HTTP_PROXY=10.244.255.3:7766
export HTTPS_PROXY=10.244.255.3:7766

编译安装二进制文件：

cd cmd/proxy
go install

启动

因为是通过go install安装，所以会被安到$GOBIN里，它会是全局的可以直接调用。

./proxy

但是这样太简陋了，我用 Supervisor 来做进程守护，配置文件如下：

[program:proxy]
command=/path/to/proxy -config_file=/path/to/github.com/gomods/athens/config.dev.toml
environment=HTTP_PROXY="10.244.255.3:7766",HTTPS_PROXY="10.244.255.3:7766"
stdout_logfile=/tmp/proxy.log
stderr_logfile=/tmp/proxy.log
autostart=true
autorestart=true
startsecs=5
priority=1
stopasgroup=true
illasgroup=true

打包脚本

之前是四行脚本，这次变了两行：

export GO111MODULE=on
export GOPROXY=http://127.0.0.1:3000

打包开始后，私服的日志能看到类似于这样的日志：

handler: GET /github.com/spf13/afero/@v/v1.1.1.zip [200]

而打包日志是这样：

go: downloading github.com/spf13/pflag v1.0.2

如果是第一次下载，会有可能超时：

go: gopkg.in/tomb.v1@v1.0.0-20141024135613-dd632973f1e7: unexpected status (http://10.244.255.3:7766/gopkg.in/tomb.v1/@v/v1.0.0-20141024135613-dd632973f1e7.info): 500 Internal Server Error

这样没事，稍等一会就会好，可以把上面的链接放到浏览器里面刷一下，能刷出来结果那说明下载好了。

{
	"Version": "v1.0.0-20141024135613-dd632973f1e7",
	"Time": "2014-10-24T13:56:13Z"
}

GOPROXY

其实最核心的是上面的GOPROXY，这个是 Go 官方的代理设置，和HTTP_PROXY不一样哦。

可以使用命令go help goproxy查看详细介绍，也可以看这里。

Go module 支持通过代理的方式下载，如果环境变量GOPROXY设置了，所有的包都会从这个代理下载。

代理基于 HTTP 协议的 GET 方法，请求的时候没有参数，所以只要是符合固定的规则，任何服务器都可以做代理服务器。比如一个静态文件服务器。

规则是：

GET $GOPROXY//@v/list 返回所有已知的当前 module 的版本号，每行一条

GET /github.com/mnhkahn/gogogo/@v/list
v1.0.0
v1.0.1
v1.0.2
v1.0.3
v1.0.4
v1.0.5

GET $GOPROXY//@v/.info 返回 JSON 格式的版本元数据

GET /github.com/mnhkahn/gogogo/@v/v1.0.5.info
{
	"Version": "v1.0.5",
	"Time": "2018-09-26T02:47:43Z"
}

元数据的 Go 结构体定义：

type Info struct {
    Version string    // version string
    Time    time.Time // commit time
}

GET $GOPROXY//@v/.mod 返回这个 module 版本的 go.mod 文件

GET /github.com/mnhkahn/gogogo/@v/v1.0.5.mod
module github.com/mnhkahn/gogogo

require (
	github.com/BurntSushi/toml v0.3.0 // indirect
	github.com/ChimeraCoder/gojson v1.0.0
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/magiconair/properties v1.8.0
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/sasbury/mini v0.0.0-20161224193750-64bd399395db
	github.com/stretchr/testify v1.2.2
	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d
	gopkg.in/natefinch/lumberjack.v2 v2.0.0-20170531160350-a96e63847dc3
	gopkg.in/yaml.v2 v2.2.1 // indirect
)

GET $GOPROXY//@v/.zip 返回这个 module 对应版本的 zip 压缩包。

GET /github.com/mnhkahn/gogogo/@v/v1.0.5.mod
v1.0.5.zip

所有的包名会被编码成小写。如果有大写字母，前面加感叹号。

github.com/Azure => github.com/!azure

Athens 的实现

下载的时候会读取这些环境变量：

func PrepareEnv(gopath string) []string {
	pathEnv := fmt.Sprintf("PATH=%s", os.Getenv("PATH"))
	httpProxy := fmt.Sprintf("HTTP_PROXY=%s", os.Getenv("HTTP_PROXY"))
	httpsProxy := fmt.Sprintf("HTTPS_PROXY=%s", os.Getenv("HTTPS_PROXY"))
	noProxy := fmt.Sprintf("NO_PROXY=%s", os.Getenv("NO_PROXY"))
	gopathEnv := fmt.Sprintf("GOPATH=%s", gopath)
	cacheEnv := fmt.Sprintf("GOCACHE=%s", filepath.Join(gopath, "cache"))
	disableCgo := "CGO_ENABLED=0"
	enableGoModules := "GO111MODULE=on"
	...
}

HTTP_PROXY和HTTPS_PROXY是私服下载包的时候会用到的代理设置，而NO_PROXY可以加不走代理的白名单：

export NO_PROXY=gopkg.in,$NO_PROXY

这些环境变量会被作为临时环境变量用于代码的下载。而下载依赖包的逻辑：

cmd := exec.Command(goBinaryName, "mod", "download", fullURI)
cmd.Env = PrepareEnv(gopath)
cmd.Dir = repoRoot
o, err := cmd.CombinedOutput()

实际执行时就是：

HTTP_PROXY=10.244.255.3:7766 HTTPS_PROXY=10.244.255.3:7766 GOPATH=/tmp/athens167327692 GOCACHE=/tmp/athens167327692/cache go mod download golang.org/x/text@v0.3.0

增加4 行代码，实现使用 Go module 在线上环境打包

2018-09-18T00:00:00+00:00

初始化
下载外网代码
下载内网私有代码
详细说说 insteadOf
总结

初始化

go mod init

把生成好的 go.mod 和 go.sum 提交到代码仓库。

如果要开启 module，需要设置环境变量：

export GO111MODULE="on"

下载外网代码

执行打包脚本，发现报了一堆报错：

go: golang.org/x/sys@v0.0.0-20180909124046-d0be0721c37e: unrecognized import path "golang.org/x/sys" (https fetch: Get https://golang.org/x/sys?go-get=1: dial tcp 216.239.37.1:443: connect: connection timed out)

下载超时，这也是能够预料到的。不过可以使用replace来解决，比如上面的 Go 扩展包，它没法下载，而它正好在 GitHub 上面有代码镜像，通过replace就可以到 GitHub 上面下载了。详细用法可以参考When should I use the replace directive?。不过我并没有用这个方法，这里就不展开说了。

我的方法是使用代理。

export http_proxy=10.244.255.3:7766
export https_proxy=10.244.255.3:7766

下载内网私有代码

再次执行打包脚本，因为有了代理，刚才的报错没有了，不过又有了新的报错：

cd .; git clone https://github.com/examplesite/myprivaterepo /Users/tom/go/src/github.com/examplesite/myprivaterepo
Cloning into '/Users/tom/go/src/github.com/examplesite/myprivaterepo'...
fatal: could not read Username for 'https://github.com': terminal prompts disabled
package github.com/examplesite/myprivaterepo: exit status 128

这个报错也不难看懂，下载内网包的时候没有授权，需要输入密码，而 Go 会屏蔽输入密码的操作，导致下载失败。

打开密码输入也很简单：

env GIT_TERMINAL_PROMPT=1 go get xxxx

不过这个并不是我想要的方法。一个原因是通过打包脚本输密码不方便，还有一个原因是把开发者个人密码写到打包脚本里也并不合适。

Git 支持两种授权方式，一种是 HTTPS，一种是 SSH。刚才的问题就是通过 HTTPS 下载代码的时候引起的，而通过 SSH 校验权限的话并不需要密码。那么问题来了，为什么go get是通过 HTTPS 下载代码而不是 SSH 呢？

Go 官方也给出了解释：Why does “go get” use HTTPS when cloning a repository? 。

公司一般喜欢只暴露80端口（HTTP）和433端口（HTTPS），其它端口会被屏蔽，包括9418（git）和22（SSH）。当使用 HTTPS 而不是 HTTP 协议时，git 会强制执行证书验证，预防中间人、窃听和篡改攻击。所以go get使用 HTTPS 协议来保证安全。

其实还有一个原因，Github 本身也推荐使用 HTTPS，大家去克隆代码的时候默认的连接都是 HTTPS 的。

如果是通过 HTTPS 下载私有代码，可以在$HOME/.netrc文件中配置密码用于授权。如果是 GitHub 用户，密码可以是access token。

machine github.com login USERNAME password APIKEY

当然，go get也是可以通过 SSH 协议实现授权的。git 也支持替换的功能，可以把 HTTPS 替换成 SSH。比如要访问 Github 的私有仓库，可以把下面的代码放到~/.gitconfig里面：

[url "ssh://git@github.com/"]
	insteadOf = https://github.com/

也可以通过一条命令实现：

git config --global url."git@git.cyeam.com:".insteadOf "https://code.cyeam.com/"

SSH 授权需要用到私钥，这里就不展开讲了。默认情况下是在$HOME/.ssh/id_rsa的文件。

详细说说 insteadOf

如果你都没有填错的话，代码就可以正常下载并编译了。

但是我实际操作的时候真是费了特别大的劲，网上的搜索结果都是上面的一条替换命令，再也没有多说了，但是有一个符号错了就会有问题。

insteadOf其实就是字符串替换。

比方说我的仓库，HTTPS 连接：

https://github.com/mnhkahn/gogogo.git

SSH 连接：

git@github.com:mnhkahn/gogogo.git

这两个协议区别就是一个是 https 开头，而一个是 git（注意：是git，不是你的用户名）。中间是域名，自己的私有仓库就换成仓库的域名。后面的仓库地址，这部分是完全一样的。而域名和仓库地址中间的符号，这里也有区别，一个是斜线，一个是冒号。

总结

在编译脚本里加下面的4行代码，就能通过 Go1.11 实现自动下载依赖包了，代理自己搭哦。推荐这个。

export GO111MODULE="on"
export http_proxy=10.244.255.3:7766
export https_proxy=10.244.255.3:7766

# 内网似有包需要通过ssh下载
git config --global url."git@git.cyeam.com:".insteadOf "https://code.cyeam.com/"

fmt 源码分析——fmt 如何进行格式化？

2018-09-10T00:00:00+00:00

format
常见类型的格式化方法
完整流程
总结

format

fmt包虽然不建议用来打印日志，但是格式化字符串确实是必不可少的，比如打印日志的时候。先详细介绍一下格式化的格式format。

format由百分号%开始，后面的部分可以分为四部分：

`verb` 占位符。

完整的格式可以参考Go 文档，下面我大概列几个：

%v  通过默认格式打印
%t  用于布尔类型，打印true或者false
%d  以10进制格式打印数字
%c  将数据转换成 Unicode 里面的字符打印
%x  以16进制格式打印数字
%e  科学计数法表示
%f  以10进制表示浮点数
%s  字符串
%p  指针，以0x开头的16进制地址

还有Go语言自己定义的类型：

%#v

宽度

比如%3c，c是占位符，表示把整数转成 Unicode 字符展示，而前面的3就是宽度了。

源码如下，看到num = num*10 + int(s[newi]-'0')很熟悉有没有，就是一个把字符转成整形的方法。那么%3c返回的num就是3了。

func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
	if start >= end {
		return 0, false, end
	}
	for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
		if tooLarge(num) {
			return 0, false, end // Overflow; crazy long number most likely.
		}
		num = num*10 + int(s[newi]-'0')
		isnum = true
	}
	return
}

打印下面的语句：

fmt.Printf("%3c\n", 'a')

控制输出3位，a输出占用一位，前面需要补两个0。在源码中，是通过pad实现：

func (f *fmt) pad(b []byte) {
	...
	width := f.wid - utf8.RuneCount(b)
	if !f.minus {
		// left padding
		f.writePadding(width)
		f.buf.Write(b)
	} else {
		// right padding
		f.buf.Write(b)
		f.writePadding(width)
	}
}

上面的代码width就是2，调用writePadding会打印对应宽度的空格。

如果打印的内容很长，比如有10位，而宽度只设置了3位，会展示完整的数字还是只显示3位呢？

答案是完整展示，当n小于等于0，直接返回，而打印内容方面，不受影响：

func (f *fmt) writePadding(n int) {
	if n <= 0 { // No padding bytes needed.
		return
	}
	...

精度

比如%3.2f，f是占位符，表示浮点数展示。3表示宽度，而小数点后面的2则是精度。精度在浮点数的格式化中会用到。精度的控制是通过strconv包的字符串转换函数来实现的：

num := strconv.AppendFloat(f.intbuf[:1], v, byte(verb), prec, size)

标记

除了宽度和精度，还有标记可以用来控制输出。

+      总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。 
-      在右侧而非左侧填充空格（左对齐该区域）
#      备用格式：为八进制添加前导 0（%#o）      Printf("%#U", '中')      U+4E2D
       为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；
       如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；
       如果是可打印字符，%U（%#U）会写出该字符的
       Unicode 编码形式（如字符 x 会被打印成 U+0078 'x'）。
' '    (空格)为数值中省略的正负号留出空白（% d）；
       以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0      填充前导的0而非空格；对于数字，这会将填充移到正负号之后

fmt.State 和 fmt.Formatter

上面提到的占位符、宽度、精度和标记，除了占位符，剩下的3个在解析后被保存到了接口fmt.State里面。这个接口还增加了一个函数Write用于写入数据。

type State interface {
	// Write is the function to call to emit formatted output to be printed.
	Write(b []byte) (n int, err error)
	// Width returns the value of the width option and whether it has been set.
	Width() (wid int, ok bool)
	// Precision returns the value of the precision option and whether it has been set.
	Precision() (prec int, ok bool)

	// Flag reports whether the flag c, a character, has been set.
	Flag(c int) bool
}

它会在Formatter接口中被用到。参数c就是占位符，这些终于都凑齐了。这个接口用来自定义格式化方法，你可以在自己的结构体中实现Format函数来实现自动调用解析。

type Formatter interface {
	Format(f State, c rune)
}

常见类型的格式化方法

func (p *pp) printArg(arg interface{}, verb rune)是底层真正进行转换的函数。

指针 %p，类型 %T

func (p *pp) printArg(arg interface{}, verb rune) {
	...
	// Special processing considerations.
	// %T (the value's type) and %p (its address) are special; we always do them first.
	switch verb {
	case 'T':
		p.fmt.fmtS(reflect.TypeOf(arg).String())
		return
	case 'p':
		p.fmtPointer(reflect.ValueOf(arg), 'p')
		return
	}
	...

对于类型和指针的转换，有现成的方法调用，而这两个转换都是通过反射实现。

这里并没有判断是否调用用户自定义的 Format 函数，说明所有类型打印内存地址和类型都只能通过上面的代码实现，不能自定义。

数字

数字支持多种进制，16进制、8进制、4进制、2进制、10进制。在fmtInteger中通过求余法实现。

switch base {
	case 10:
		for u >= 10 {
			i--
			next := u / 10
			buf[i] = byte('0' + u - next*10)
			u = next
		}
	...

万能通用格式，%v

万能格式其实也有映射关系：

int, int8 etc.:          %d
uint, uint8 etc.:        %d, %#x if printed with %#v
float32, complex64, etc: %g
string:                  %s
chan:                    %p
pointer:                 %p

一般结构体会用到这种打印方式。如果是结构体：

if p.fmt.sharpV {
	p.buf.WriteString(f.Type().String())
}
p.buf.WriteByte('{')
for i := 0; i < f.NumField(); i++ {
	if i > 0 {
		if p.fmt.sharpV {
			p.buf.WriteString(commaSpaceString)
		} else {
			p.buf.WriteByte(' ')
		}
	}
	if p.fmt.plusV || p.fmt.sharpV {
		if name := f.Type().Field(i).Name; name != "" {
			p.buf.WriteString(name)
			p.buf.WriteByte(':')
		}
	}
	p.printValue(getField(f, i), verb, depth+1)
}
p.buf.WriteByte('}')

通过反射拿到字段 Field 和内容，如果格式是%+v，也就是p.fmt.plusV是true，这样会打印字段名称。

异常

转换的时候还会有异常捕获，这个在 Go 源码中不多见：

defer p.catchPanic(p.arg, verb)
p.fmtString(v.String(), verb)

如果在转换的时候发生异常panic，并不会发生异常，转换后的结果会是这个样子：

type data struct {
	A string
	B int
}

func (d *data) String() string {
	panic("implement me")
}

func main() {
	d := &data{"1", 2}
	fmt.Printf("%s\n", d) // prints: %!s(PANIC=implement me)
}

结果是%!s(PANIC=implement me)，会有 PANIC 的字样。还有一个地方很有趣，String()方法并没有按要求返回字符串，只有一个panic，这样可以编译过。

fmt.Stringer

顺道介绍一下Stringer接口，上面的data对象就实现了这个方法。如果是通过%s打印，或者直接调用的Println，这时候会判断这个对象是否实现了Stringer接口，如果实现了，就调用对象的String方法，上一节的data就是这个例子。

type Stringer interface {
	String() string
}

一个 fmt.Formatter 例子

还是针对上面的data类型，我实现了Formatter接口：

func (d *data) Format(f fmt.State, c rune) {
	switch c {
	case 'v': // &{1 2}
		buf, err := json.Marshal(d)
		if err != nil {
			panic(err)
		}
		f.Write(buf)
	case 's':
		f.Write([]byte(d.String()))
	case 'x', 'X':
		//case 'p':
		v := reflect.ValueOf(d)
		f.Write([]byte{'('})
		f.Write([]byte(v.Type().String()))
		f.Write([]byte{')', '('})
		u := v.Pointer()
		f.Write([]byte(strconv.FormatUint(uint64(u), 16)))
		f.Write([]byte{')'})
	default:
		f.Write([]byte("http://cyeam.com"))
	}
}

d := &data{"1", 2}
fmt.Printf("v %v\n", d)
fmt.Printf("s %s\n", d)
fmt.Printf("p %p\n", d)
fmt.Printf("T %T\n", d)
fmt.Printf("b %b\n", d)
fmt.Printf("o %o\n", d)
fmt.Printf("x %x\n", d)
fmt.Printf("d %d\n", d)

结果如下：

v {“A”:”1”,”B”:2} s {“A”:”1”,”B”:2} p 0xc00006c020 T main.data b http://cyeam.com o http://cyeam.com x (main.data)(c00006c020) d http://cyeam.com

b、o、d我没有实现，所以返回的是一个默认值；
v是返回的json编码；
p和T在前面也介绍了，它并不会调用Format，所以虽然我并没有实现这两个占位符，但是结果是对的；
x手写一个基于反射的实现，能返回变量名称和地址。

完整流程

格式解析，把`fmt.State`接口要用到的数据解析完成

func (p *pp) doPrintf(format string, a []interface{}) {
	...
	// Do we have flags?
	// 解析格式串中的标记
	for ; i < end; i++ {
		c := format[i]
		switch c {
		case '#':
			p.fmt.sharp = true
		case '0':
			p.fmt.zero = !p.fmt.minus // Only allow zero padding to the left.
		case '+':
			p.fmt.plus = true
		case '-':
			p.fmt.minus = true
			p.fmt.zero = false // Do not pad with zeros to the right.
		case ' ':
			p.fmt.space = true
		default:
	}
	...
	// Do we have width?
	if i < end && format[i] == '*' {
	...
	} else {
		// 解析了格式串中的宽度内容
		p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
		if afterIndex && p.fmt.widPresent { // "%[3]2d"
			p.goodArgNum = false			
		}
	}
	...
	// Do we have precision?
	if i+1 < end && format[i] == '.' {
		...
		// 解析了格式串中的精度内容
		p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i, end)
		...
}

在`func (p *pp) printArg(arg interface{}, verb rune)`中进行格式化转换编码；

如果对象值是空，直接打印

if arg == nil {
	switch verb {
	case 'T', 'v':
		p.fmt.padString(nilAngleString)
	default:
		p.badVerb(verb)
	}
	return
}

如果是指针或者类型格式化，调用反射实现

switch verb {
case 'T':
	p.fmt.fmtS(reflect.TypeOf(arg).String())
	return
case 'p':
	p.fmtPointer(reflect.ValueOf(arg), 'p')
	return
}

格式化数据

switch f := arg.(type) {
	case bool:
		p.fmtBool(f, verb)
	case float32:
		p.fmtFloat(float64(f), 32, verb)
	case float64:
	...
	default:
		if !p.handleMethods(verb) {
			// Need to use reflection, since the type had no
			// interface methods that could be used for formatting.
			p.printValue(reflect.ValueOf(f), verb, 0)
		}
}

每种内置类型都有自己的格式化实现，这样就避免了反射；
如果不是内置类型，判断是否实现了Formatter接口，如果实现了调用此接口；
如果需要转成字符串，而对象实现了Stringer接口，调用其String方法转换；
上面两个逻辑在函数func (p *pp) handleMethods(verb rune) (handled bool)中，如果能通过接口实现转换，返回true并格式化数据，否则返回false；(其实还有一些细节的逻辑，例如GoStringer，我就不展开细说了)
如果通过上面的转换失败，则需要使用默认转换策略。

默认转换策略 p.printValue(reflect.ValueOf(f), verb, 0)

默认转换就是通过反射实现，以结构体为例，如果反射出来是结构体，那就遍历所有字段打印，逻辑和上面提到的万能转换里提到的差不多。

总结

从格式化的完整流程中可以发现，底层格式化算法是有对性能优化的，那就是通过对每种内置对象单独编写格式化实现来规避反射来提高性能。

实际工作中经常需要对系统内复杂结构进行格式化，那么为这些对象实现Formatter接口也算是一种提升性能的有效方式。

本文涉及的完整代码请看这里。

godoc 介绍以及 Golang 注释规范

2018-09-03T00:00:00+00:00

命令
代码中注释生成文档
doc.go
- 标题和段落：
- 代码
example_PackageName_test.go
最后

命令

golang 官方有有文档自动生成网站，地址是 godoc.org，比如：logger 的文档，godoc也可以在本地启动：

godoc -http=:6060

启动之后浏览器访问 localhost:6060，就能看到文档首页了。如果想看自己代码的文档，后面输入包的路径即可，比如：

http://localhost:6060/pkg/github.com/mnhkahn/gogogo/

代码或者注释文档的修改可以实时更新，不需要重启服务。

代码中注释生成文档

godoc支持package、const、var和func这些代码生成文档，而且只会对public变量(首字母大写)自动生成，而private变量则不会。

Package

在自动生成的时候，比如说对于包，对包介绍的内容用的就是包名上面的注释（变量和函数同理）。如果是多个包，就会把多个包的注释放在一起，按照文件名字母顺序排序。

如果多个注释中间有一个空行，那么只会算挨着变量位置的注释，其它的会被丢弃。

包生成的内容会放到文档的「Overview」里面。举个例子：

// package gogogo

/*
A web framework includes app server, logger, panicer, util and so on.
 */

变量和函数

和包类似，常量会放到「Constants」里，变量会放到「Variables」里，后面跟的是函数。

BUG

如果代码中有 bug，可以使用注释：

BUG(who): xxx

它会被识别为一个 bug，可以在文档中的「Bugs」中看到。

Deprecated

顺便提一句，弃用注释：

// Deprecated: xxx

这个注释不会体现在godoc中，但是还是挺有用的，Goland可以识别它并作出提示。

链接 URL 自动转成 HTML 的 a 标签

// SetFlag sets log flags. For more information, see the sdk https://golang.org/pkg/log/#pkg-constants.

注释自动生成

有一个自动生成注释的工具gocmt。安装和使用：

go get -u github.com/Gnouc/gocmt
gocmt -i $FilePath$

这个命令可以结合 Goland 的「External Tools」使用，检测文件是否改动，实时生成注释。

doc.go

如果包注释超过3行，可以把注释都迁移到doc.go文件中。

多行注释自然需要支持一些复杂的格式，而godoc支持的并不是Markdown这种熟悉的格式，下面详细说明一下。

标题和段落：

先看看效果：

如果首字母是大写，并且结尾没有标点符号，是标题。结尾有标点的自然是段落了。

代码

注释中的代码也可以转成代码块。如果是通过//来注释，因为默认注释和正文中间是一个空格，那么多整一个空格（最少多一个）就会被识别为代码了。而段注释也同理，比常规注释多一个空格就行，不过我喜欢用 tab。

example_PackageName_test.go

例子非常重要，基本上项目就是通过每个包的例子搭起来的。

例子文件需要创建一个新文件，格式是example_PackageName_test.go。不加 example 的前缀也可以，不过我觉得还是加上好一些，不加感觉和单元测试文件一样。包名也有要求，是PackageName_test。在这个文件中加函数，函数名的格式是ExampleFuncName。不加函数名的话是包级别示例。加函数名的话是函数级别的示例。

包级别的例子：

func Example() {
	logger.Info("hello, world.")
}

包级别的示例放在文档的开头处，而函数级别的示例放在函数后面，函数名得保持一致哦。

func ExampleNewLogger() {
    w := os.Stdout
    flag := log.Llongfile
    l := logger.NewWriterLogger(w, flag, 3)
    l.Info("hello, world")
}

最后

我们写代码都不太爱写注释，每当使用golint这些工具检测代码的时候，就会有一堆的错误提示。看了今天的文章，是不是愿意写注释了呢？

第二部分也是一个 Go 语言写注释的规范说明，大家可以参考这个。

本文涉及的代码可以从这里下载。赶紧 star 起来啊。

更多阅读：

Go 语言实现的一个简单的重试方法

2018-08-27T00:00:00+00:00

代码
重试的逻辑
示例
GitHub

代码

简单的东西就不废话了，直接上代码。

func Retry(attempts int, sleep time.Duration, fn func() error) error {
	if err := fn(); err != nil {
		if s, ok := err.(stop); ok {
			return s.error
		}

		if attempts--; attempts > 0 {
			logger.Warnf("retry func error: %s. attemps #%d after %s.", err.Error(), attempts, sleep)
			time.Sleep(sleep)
			return Retry(attempts, 2*sleep, fn)
		}
		return err
	}
	return nil
}

type stop struct {
	error
}

func NoRetryError(err error) stop {
	return stop{err}
}

接收三个参数：

attempts：最多重试次数；
sleep：调用失败后的等待时间；
fn：重试的函数。函数的类型是func() error，如果你的重试函数定义并不是这样，可以通过闭包包一下。

重试的逻辑

最多重试attempts次，如果调用fn返回错误，等待sleep的时间，而下次错误重试就需要等待两倍的时间了。还有一点是错误的类型，常规错误会重试，而stop类型的错误会中断重试，这也提供了一种中断机制。

示例

cnt := 0
err := fmt.Errorf("test error every time")
a := func() error {
	if cnt == 0 {
		cnt++
		return err
	} else {
		cnt++
		return nil
	}
}
errFn := util.Retry(3, 1*time.Millisecond, a)

GitHub

完整的代码放到了 GitHub 上面，地址。欢迎大家 Star。

完整文档：godoc。

更多阅读：Simple Golang Retry Function

介绍一下Json的Number(二)

2018-08-22T00:00:00+00:00

如何将JSON中的数字和字符串都解析为数字？
原理
UseNumber

如何将JSON中的数字和字符串都解析为数字？

接着《介绍一下Json的Number》继续写，可以两篇文章一起读。

有一些情况下，JSON 解码需要适配多种类型，比如一串数字会被存成整数或者字符串两种格式，类型是不确定的，这个时候如何解析？

通用一点的方法我们可以自定义类型，自己实现MarshalJSON方法来实现负责逻辑的解析，具体方法可以参考《Golang——json数据处理》，但是对于数字，就不用这么复杂了，Go 已经提供了一Number来帮助我们。

var raw = []byte(`{"a":1}`)
var raw_string = []byte(`{"a":"2"}`)

定义了两个 JSON 串，一个是整形，一个是字符串。如何将这两个数据解析到同一种类型中呢？

type S3 struct {
	A json.Number `json:"a"`
}

s3 := new(S3)
err = json.Unmarshal(raw, s3)
log.Println(err, s3.A)

s31 := new(S3)
err = json.Unmarshal(raw_string, s31)
log.Println(err, s31.A)

将对象a的类型定义成json.Number就可以实现对两种数据类型的解析。

原理

我们知道，解析 JSON 的时候其实是对 JSON 串的遍历，其实所有遍历出来的值都是[]byte类型，然后根据识别目标解析对象字段类型，或者识别[]byte数据的内容转换格式。比如，如果数据被解析到int上，把[]byte转换为int；如果被解析到interface{}上，就只能通过[]byte的类型来转换了，数字会被统一处理能float64，这个有个问题，就是会丢精度。而通过Number解析时，值会被直接保存为字符串类型。

// A Number represents a JSON number literal.
type Number string

// String returns the literal text of the number.
func (n Number) String() string { return string(n) }

// Float64 returns the number as a float64.
func (n Number) Float64() (float64, error) {
	return strconv.ParseFloat(string(n), 64)
}

// Int64 returns the number as an int64.
func (n Number) Int64() (int64, error) {
	return strconv.ParseInt(string(n), 10, 64)
}

使用Int64还是float64就可以通过用户自己的情况选择了。

本文涉及的代码可以从这里下载。

UseNumber

有时候我们想偷懒，并不想自己定义结构体，还是想使用map[string]interface{}来解析 JSON，可以使用UseNumber方法：

decoder := json.NewDecoder(bytes.NewBufferString(`{"10000000000":10000000000,"111":1}`))
decoder.UseNumber()
var obj map[string]interface{}
decoder1.Decode(&obj)

strings.Builder 源码分析

2018-08-16T00:00:00+00:00

strings.Builder 和 bytes.Buffer 接口设计上基本一致
底层实现
String() 方法有门道
不允许复制
线程不安全
- 参考文献

众所周知，Go 里面的字符串是常量，对字符串的修改会重新申请内存地址。为了优化这个，我之前都是用 bytes.Buffer 代替字符串的拼接等操作。这种方案避免了字符串修改过程中的内存申请，但是最后从[]byte转成字符串时会重新内存申请，这个无法避免。从 Go 1.10 开始，提供了更友好性能更好的方法 strings.Builder。

strings.Builder 和 bytes.Buffer 接口设计上基本一致

支持的方法是 bytes.Buffer 的子集，仔细看了一下，它实现了io.Writer接口，而 bytes.Buffer 实现了io.Reader和io.Writer两个接口。

type Builder func (b *Builder) Grow(n int) func (b *Builder) Len() int func (b *Builder) Reset() func (b *Builder) String() string func (b *Builder) Write(p []byte) (int, error) func (b *Builder) WriteByte(c byte) error func (b *Builder) WriteRune(r rune) (int, error) func (b *Builder) WriteString(s string) (int, error)

type Writer interface {
        Write(p []byte) (n int, err error)
}

底层实现

type Builder struct {
	addr *Builder // of receiver, to detect copies by value
	buf  []byte
}

它底层还是用[]byte保存数据的，这和 bytes.Buffer 是一致的。

如果写入数据，就是在[]byte后面追加内容：

func (b *Builder) Write(p []byte) (int, error) {
	b.copyCheck()
	b.buf = append(b.buf, p...)
	return len(p), nil
}

追加内容也有讲究，因为底层是 slice，追加数据时有可能引起 slice 扩容。一般的优化方案是为 slice 初始化合理的空间，避免多次扩容复制。Builder 也提供了预分配内存的方法：

func (b *Builder) grow(n int) {
	buf := make([]byte, len(b.buf), 2*cap(b.buf)+n)
	copy(buf, b.buf)
	b.buf = buf
}

func (b *Builder) Grow(n int) {
	b.copyCheck()
	if n < 0 {
		panic("strings.Builder.Grow: negative count")
	}
	if cap(b.buf)-len(b.buf) < n {
		b.grow(n)
	}
}

注意扩容的容量和 slice 直接扩容两倍的方式略有不同，它是2*cap(b.buf)+n，之前容量的两倍加n。

如果容量是10，长度是5，调用Grow(3)结果是什么？当前容量足够使用，没有任何操作；
如果容量是10，长度是5，调用Grow(7)结果是什么？剩余空间是5，不满足7个扩容空间，底层需要扩容。扩容的时候按照之前容量的两倍再加n的新容量扩容，结果是2*10+7=27。

String() 方法有门道

func (b *Builder) String() string {
	return *(*string)(unsafe.Pointer(&b.buf))
}

返回当前数据的字符串，先获取[]byte地址，然后转成字符串指针，然后再取地址。

从 ptype 输出的结构来看，string 可看做 [2]uintptr，而 [ ]byte 则是 [3]uintptr，这便于我们编写代码，无需额外定义结构类型。如此，str2bytes 只需构建 [3]uintptr{ptr, len, len}，而 bytes2str 更简单，直接转换指针类型，忽略掉 cap 即可。

详细可以参考雨痕的【Go性能优化技巧 1/10】。

不允许复制

还是再看一下 Builder 的底层数据，它还有个字段addr，是一个指向 Builder 的指针。

type Builder struct {
	addr *Builder // of receiver, to detect copies by value
	buf  []byte
}

默认情况是它会指向自己：

b.addr = (*Builder)(noescape(unsafe.Pointer(b)))

而如果addr和当前指针所指地址不同，会引发panic异常。

func (b *Builder) copyCheck() {
	if b.addr == nil {
		// This hack works around a failing of Go's escape analysis
		// that was causing b to escape and be heap allocated.
		// See issue 23382.
		// TODO: once issue 7921 is fixed, this should be reverted to
		// just "b.addr = b".
		b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
	} else if b.addr != b {
		panic("strings: illegal use of non-zero Builder copied by value")
	}
}

copyCheck用来保证复制后不允许修改的逻辑。仔细看下源码，如果addr是空，也就是没有数据的时候是可以被复制后修改的，一旦那边有数据了，就不能这么搞了。在Grow、Write、WriteByte、WriteString、WriteRune这五个函数里都有这个检查逻辑。

线程不安全

这个包并不是线程安全的，整个例子看看：

package main

import (
	"fmt"
	"strings"
	"sync"
	"sync/atomic"
)

func main() {
	var b strings.Builder
	var n int32
	var wait sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wait.Add(1)
		go func() {
			atomic.AddInt32(&n, 1)
			b.WriteString("1")
			wait.Done()
		}()
	}
	wait.Wait()
	fmt.Println(len(b.String()), n)
}

结果是902 1000，并不都是1000。如果想保证线程安全，需要在WriteString的时候加锁。

package main

import (
	"fmt"
	"strings"
	"sync"
	"sync/atomic"
)

func main() {
	var b strings.Builder
	var n int32
	var wait sync.WaitGroup
	var lock sync.Mutex
	for i := 0; i < 1000; i++ {
		wait.Add(1)

		go func() {
			atomic.AddInt32(&n, 1)

			lock.Lock()
			b.WriteString("1")
			lock.Unlock()
			wait.Done()
		}()
	}
	wait.Wait()

	fmt.Println(len(b.String()), n)
}

参考文献

【1】7 notes about strings.builder in Golang

【译】在 Go 语言中使用猴子补丁

2018-08-07T00:00:00+00:00

Go 语言中函数值如何工作
运行时替换函数
封装到库中
结论

很多人认为猴子补丁（A monkey patch is a way for a program to extend or modify supporting system software locally (affecting only the running instance of the program). 指可以在运行时动态修改或扩展程序的一种方法）是那些语言，比如 Ruby 和 Python 才有的东西。这并不对，计算机只是愚蠢的机器而我们总能让他们按照我们的想法工作！让我们来看看 Go 的函数如何工作，再看看我们如何在运行时修改它们。这篇文章将会使用 Intel 的汇编语法，所以我假设你了解过它或者在阅读的过程中参考官方文档。

如果你对猴子补丁的原理没有兴趣，只想使用猴子补丁，可以直接移步到代码仓库。

看看下面的代码反编译之后的结果：

package main

func a() int { return 1 }

func main() {
  print(a())
}

编译完成后通过Hopper查看，上面的代码将会展示下面的汇编代码：

我将参考屏幕左侧显示的各种指令的地址。

我们的代码从过程main.main开始，指令 0x2010 到 0x2026 初始化了栈。你可以参考这些扩展阅读，下面的文章将会忽略那些代码。

0x202a 行调用了函数main.a，0x2000 行简单得把 0x1 压入栈返回。0x202f 到 0x2037 行把值传给了runtime.printint。

够简单了！现在咱们一起看看 Go 里面的函数值是如何实现的。

Go 语言中函数值如何工作

看下面的代码：

package main

import (
  "fmt"
  "unsafe"
)

func a() int { return 1 }

func main() {
  f := a
  fmt.Printf("0x%x\n", *(*uintptr)(unsafe.Pointer(&f)))
}

在第11行把a赋值给了f，这就意味着调用f()将会调用a。接下来用unsafe包读取出存在f里面的值。如果你是有 C 语言背景的程序员你可能会认为简单得把指向函数a的指针打印出来将会得到 0x2000（就是上面汇编里面看到的地址）。当我运行上面的代码得到了 0x102c38，这个地址相差了十万八千里！反编译后，这是第11行的代码：

这里引用了main.a.f，我们看看那个位置，可以发现：

啊哈！main.a.f在 0x102c38 并且包含值 0x2000，它正好是main.a的地址。看起来f并不是指向函数的指针，而是指向函数的指针的指针。让我们修改代码证实：

package main
 
import (
  "fmt"
  "unsafe"
)
 
func a() int { return 1 }
 
func main() {
  f := a
  fmt.Printf("0x%x\n", **(**uintptr)(unsafe.Pointer(&f)))
}

和我们期望的一样，将会打印 0x2000。在这里我们也能找到一些线索。Go 语言的函数值包含了额外的信息，这是闭包和绑定实例实现的方式。

type funcval struct {
	fn uintptr
	// variable-size, fn-specific data here
}

接下来看看调用函数值的实现。把代码改成下面这样，给f赋值之后调用它。

package main

func a() int { return 1 }

func main() {
	f := a
	f()
}

反编译后可以得到下面的结果：

main.a.f加载到寄存器rdx里，然后把rdx寄存器指向的地址存入rbx里，最后调用。函数的地址值总是会加载到rdx寄存器里面，当代码调用的时候可以用来加载一些可能会用到的额外信息。这里的额外信息是指向绑定的实例和匿名函数闭包的指针。如果你想了解更多我建议你深入研究一下反编译代码！

让我们用新的知识实现 Go 语言里面的猴子补丁。

运行时替换函数

我们是想实现的是让下面的代码打印出来2:

package main

func a() int { return 1 }
func b() int { return 2 }

func main() {
	replace(a, b)
	print(a())
}

如何实现replace?我们需要修改函数a，让它跳转到b的代码，跳过执行它自己的代码。实际上，我们需要通过这种方法来实现替换，加载函数b到寄存器rdx，然后执行时跳转到rdx上面。

mov rdx, main.b.f ; 48 C7 C2 ?? ?? ?? ??
jmp [rdx] ; FF 22

我在汇编代码旁边附上了相应的机器码（你可以用这种在线汇编工具来模拟测试）。编写一个生成上面汇编代码的函数就很简单了，类似于下面这样：

func assembleJump(f func() int) []byte {
  funcVal := *(*uintptr)(unsafe.Pointer(&f))
  return []byte{
    0x48, 0xC7, 0xC2,
    byte(funcval >> 0),
    byte(funcval >> 8),
    byte(funcval >> 16),
    byte(funcval >> 24), // MOV rdx, funcVal
    0xFF, 0x22,          // JMP [rdx]
  }
}

这样就能把a的函数体指向b了！下面的代码尝试复制机器代码到函数题上。

package main

import (
	"syscall"
	"unsafe"
)

func a() int { return 1 }
func b() int { return 2 }

func rawMemoryAccess(b uintptr) []byte {
	return (*(*[0xFF]byte)(unsafe.Pointer(b)))[:]
}

func assembleJump(f func() int) []byte {
	funcVal := *(*uintptr)(unsafe.Pointer(&f))
	return []byte{
		0x48, 0xC7, 0xC2,
		byte(funcVal >> 0),
		byte(funcVal >> 8),
		byte(funcVal >> 16),
		byte(funcVal >> 24), // MOV rdx, funcVal
		0xFF, 0x22,          // JMP [rdx]
	}
}

func replace(orig, replacement func() int) {
	bytes := assembleJump(replacement)
	functionLocation := **(**uintptr)(unsafe.Pointer(&orig))
	window := rawMemoryAccess(functionLocation)
	
	copy(window, bytes)
}

func main() {
	replace(a, b)
	print(a())
}

运行上面的代码并不会工作，结果会是 segementation fault 段错误。这是因为加载后的二进制文件默认不允许修改。我们可以使用系统调用mprotect来关掉这个保护，这个最终版的代码终于可以像期望的那样，通过调用替换后的函数来打印出来 2。

package main

import (
	"syscall"
	"unsafe"
)

func a() int { return 1 }
func b() int { return 2 }

func getPage(p uintptr) []byte {
	return (*(*[0xFFFFFF]byte)(unsafe.Pointer(p & ^uintptr(syscall.Getpagesize()-1))))[:syscall.Getpagesize()]
}

func rawMemoryAccess(b uintptr) []byte {
	return (*(*[0xFF]byte)(unsafe.Pointer(b)))[:]
}

func assembleJump(f func() int) []byte {
	funcVal := *(*uintptr)(unsafe.Pointer(&f))
	return []byte{
		0x48, 0xC7, 0xC2,
		byte(funcVal >> 0),
		byte(funcVal >> 8),
		byte(funcVal >> 16),
		byte(funcVal >> 24), // MOV rdx, funcVal
		0xFF, 0x22,          // JMP rdx
	}
}

func replace(orig, replacement func() int) {
	bytes := assembleJump(replacement)
	functionLocation := **(**uintptr)(unsafe.Pointer(&orig))
	window := rawMemoryAccess(functionLocation)
	
	page := getPage(functionLocation)
	syscall.Mprotect(page, syscall.PROT_READ|syscall.PROT_WRITE|syscall.PROT_EXEC)
	
	copy(window, bytes)
}

func main() {
	replace(a, b)
	print(a())
}

封装到库中

我把上面的代码封装到了一个易用的库中。它支持32位，关闭补丁，对实例打方法补丁。我在 README 中写了一些例子。

结论

有志者事竟成！我们可以在运行时修改程序了，它能让我们做一些很酷的事情，例如猴子补丁。

我希望你读了本文之后能有所收获，我玩得很开心！

Hacker News

原文地址。

Golang 中整数转字符串

2018-06-20T00:00:00+00:00

fmt.Sprintf
strconv.Itoa
strconv.FormatInt
Format 的实现
Sprintf 的实现
性能对比
- 参考文献

整形转字符串经常会用到，本文讨论一下 Golang 提供的这几种方法。基于 go1.10.1

fmt.Sprintf

fmt 包应该是最常见的了，从刚开始学习 Golang 就接触到了，写 ‘hello, world’ 就得用它。它还支持格式化变量转为字符串。

func Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

fmt.Sprintf("%d", a)

%d代表十进制整数。

strconv.Itoa

func Itoa(i int) string

Itoa is shorthand for FormatInt(int64(i), 10).

strconv.Itoa(a)

strconv.FormatInt

func FormatInt(i int64, base int) string

FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters ‘a’ to ‘z’ for digit values >= 10.

参数i是要被转换的整数，base是进制，例如2进制，支持2到36进制。

strconv.Format(int64(a), 10)

Format 的实现

[0, 99)的两位整数

对于小的（小于等于100）十进制正整数有加速优化算法：

if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
	return small(int(i))
}

加速的原理是提前算好100以内非负整数转换后的字符串。

const smallsString = "00010203040506070809" +
    "10111213141516171819" +
    "20212223242526272829" +
    "30313233343536373839" +
    "40414243444546474849" +
    "50515253545556575859" +
    "60616263646566676869" +
    "70717273747576777879" +
    "80818283848586878889" +
    "90919293949596979899"

可以看出来，转换后的结果是从1到99都有，而且每个结果只占两位。当然个人数的情况还得特殊处理，个位数结果只有一位。

func small(i int) string {
    off := 0
    if i < 10 {
        off = 1
    }
    return smallsString[i*2+off : i*2+2]
}

如果被转换的数字是个位数，那么偏移量变成了1，默认情况是0。

只支持2到36进制的转换。36进制是10个数字加26个小写字母，超过这个范围无法计算。

var a [64 + 1]byte

整形最大64位，加一位是因为有个符号。转换计算时，要分10进制和非10进制的情况。

10进制转换

10进制里，两位两位转换，为什么这么干？两位数字时100以内非负整数转换可以用上面的特殊情况加速。很有意思。

us := uint(u)
for us >= 100 {
	is := us % 100 * 2
	us /= 100
	i -= 2
	a[i+1] = smallsString[is+1]
	a[i+0] = smallsString[is+0]
}

2、4、8、16、32进制的转换。

const digits = "0123456789abcdefghijklmnopqrstuvwxyz"

var shifts = [len(digits) + 1]uint{
    1 << 1: 1,
    1 << 2: 2,
    1 << 3: 3,
    1 << 4: 4,
    1 << 5: 5,
}

if s := shifts[base]; s > 0 {
	// base is power of 2: use shifts and masks instead of / and %
	b := uint64(base)
	m := uint(base) - 1 // == 1<<s - 1
	for u >= b {
		i--
		a[i] = digits[uint(u)&m]
		u >>= s
	}
	// u < base
	i--
	a[i] = digits[uint(u)]
} 

通过循环求余实现。进制的转换也是这种方式。

for u >= b {
    i--
    a[i] = uint(u)&m
    u >>= s
}

上面的代码实现了进制的转换。而digits[uint(u)&m]实现了转换后的结果再转成字符。

常规情况

b := uint64(base)
for u >= b {
	i--
	q := u / b
	a[i] = digits[uint(u-q*b)]
	u = q
}
// u < base
i--
a[i] = digits[uint(u)]

依然是循环求余来实现。这段代码更像是给人看的。和上面2的倍数的进制转换的区别在于，上面的代码把除法/换成了右移（>>）s位，把求余%换成了逻辑与&操作。

Sprintf 的实现

switch f := arg.(type) {
    case bool:
        p.fmtBool(f, verb)
    case float32:
        p.fmtFloat(float64(f), 32, verb)
    case float64:
        p.fmtFloat(f, 64, verb)
    case complex64:
        p.fmtComplex(complex128(f), 64, verb)
    case complex128:
        p.fmtComplex(f, 128, verb)
    case int:
        p.fmtInteger(uint64(f), signed, verb)
    ...
}

判断类型，如果是整数int类型，不需要反射，直接计算。支持的都是基础类型，其它类型只能通过反射实现。

Sprintf支持的进制只有10%d、16x、8o、2b这四种，其它的会包fmt: unknown base; can’t happen异常。

switch base {
case 10:
	for u >= 10 {
		i--
		next := u / 10
		buf[i] = byte('0' + u - next*10)
		u = next
	}
case 16:
	for u >= 16 {
		i--
		buf[i] = digits[u&0xF]
		u >>= 4
	}
case 8:
	for u >= 8 {
		i--
		buf[i] = byte('0' + u&7)
		u >>= 3
	}
case 2:
	for u >= 2 {
		i--
		buf[i] = byte('0' + u&1)
		u >>= 1
	}
default:
	panic("fmt: unknown base; can't happen")
}

2、8、16进制和之前FormatInt差不多，而10进制的性能差一些，每次只能处理一位数字，而不像FormatInt一次处理两位。

性能对比

var smallInt = 35
var bigInt = 999999999999999

func BenchmarkItoa(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := strconv.Itoa(smallInt)
        _ = val
    }
}

func BenchmarkItoaFormatInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := strconv.FormatInt(int64(smallInt), 10)
        _ = val
    }
}

func BenchmarkItoaSprintf(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := fmt.Sprintf("%d", smallInt)
        _ = val
    }
}

func BenchmarkItoaBase2Sprintf(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := fmt.Sprintf("%b", smallInt)
        _ = val
    }
}

func BenchmarkItoaBase2FormatInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := strconv.FormatInt(int64(smallInt), 2)
        _ = val
    }
}

func BenchmarkItoaBig(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := strconv.Itoa(bigInt)
        _ = val
    }
}

func BenchmarkItoaFormatIntBig(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := strconv.FormatInt(int64(bigInt), 10)
        _ = val
    }
}

func BenchmarkItoaSprintfBig(b *testing.B) {
    for i := 0; i < b.N; i++ {
        val := fmt.Sprintf("%d", bigInt)
        _ = val
    }
}

压测有三组对比，小于100的情况，大数字的情况，还有二进制的情况。

BenchmarkItoa-8                 	300000000	         4.58 ns/op	       0 B/op	       0 allocs/op
BenchmarkItoaFormatInt-8        	500000000	         3.07 ns/op	       0 B/op	       0 allocs/op
BenchmarkItoaBase2Sprintf-8     	20000000	        86.4 ns/op	      16 B/op	       2 allocs/op
BenchmarkItoaBase2FormatInt-8   	50000000	        30.2 ns/op	       8 B/op	       1 allocs/op
BenchmarkItoaSprintf-8          	20000000	        83.5 ns/op	      16 B/op	       2 allocs/op
BenchmarkItoaBig-8              	30000000	        44.6 ns/op	      16 B/op	       1 allocs/op
BenchmarkItoaFormatIntBig-8     	30000000	        43.9 ns/op	      16 B/op	       1 allocs/op
BenchmarkItoaSprintfBig-8       	20000000	       108 ns/op	      24 B/op	       2 allocs/op

Sprintf在所有情况中都是最差的，还是别用这个包了。
小于100的情况会有加速，不光是性能上的加速，因为结果是提前算好的，也不需要申请内存。
FormatInt10进制性能最好，其它的情况差一个数量级。
Itoa虽然只是封装了FormatInt，对于性能还是有一些影响的。

本文涉及的代码可以从这里下载。

参考文献

11.4 类型判断：type-switch - Go 入门指南

Go 项目下载依赖

2018-06-19T00:00:00+00:00

如何自动下载所有依赖包？
代码无法下载怎么办？

如何自动下载所有依赖包？

大部分情况下大家下载 Go 项目都是使用go get命令，它除了会下载指定的项目代码，还会去下载这个项目所依赖的所有项目。

但是有的时候我们的项目由于各种原因并不是通过go get下载的，是通过git clone下载的，这样代码下下来就没有依赖包了，没办法编译通过的。这样的话怎么办呢？

go get -d -v ./...

-d标志只下载代码包，不执行安装命令；
-v打印详细日志和调试日志。这里加上这个标志会把每个下载的包都打印出来；
./...这个表示路径，代表当前目录下所有的文件。

代码无法下载怎么办？

我们会经常用到扩展包，很巧的是扩展包国内无法访问。

可以从Golang 中国下载，它提供了这个服务，好人一生平安。

此外，扩展包还被放在了 GitHub 上面，比如tools，直接下载下来，放到$GOPATH/src/golang.org/x/下面即可。

Slice 小技巧

2018-06-18T00:00:00+00:00

本文翻译自SliceTricks。我会追加一些我的理解。官方给出的例子代码很漂亮，建议大家多看看，尤其是利用多个切片共享底层数组的功能就地操作很有意思。

AppendVector
Copy
Cut
Delete
Delete without preserving order 不保留顺序的删除
Expand
Extend
Insert
InsertVector
Pop/Shift
Pop Back
Push
Push Front/Unshift
Additional Tricks 附加技巧

container/vector包在 Go 1中被删除了，因为引入了内置函数append，它再加上内置函数copy基本上可以代替这个包的功能。

AppendVector

a = append(a, b...)

append支持两个参数，第一个是被追加的 slice，第二个参数是追加到后面的数据。第二个参数是变长参数，可以传多值。

Copy

b = make([]T, len(a))
copy(b, a)
// or
b = append([]T(nil), a...)

copy函数把数据 a 复制到 b 中。它有个坑，复制数据的长度取决于 b 的当前长度，如果 b 没有初始化，那么并不会发生复制操作。所以复制的第一行需要初始化长度。

复制还有一种替代方案，利用append的多值情况来追加。但是这样会有一个问题，追加的时候是追加到[]T(nil)里面，默认初始长度是0，每追加一个元素需要检测当前长度是否满足，如果不满足就要扩容，每次扩容扩当前容量的一倍（详细原理可以查看 slice 的内部实现）。这么操作的话如果 a 长度是3，第一种方法复制出来长度和容量都是3，而第二种方法长度是3，容量却是4。如果只是单纯复制我推荐第一种。

Cut

a = append(a[:i], a[j:]...)

把 [i, j)中间的元素剪切掉。slice 的切片都是前开后闭原则。

Delete

a = append(a[:i], a[i+1:]...)
// or
a = a[:i+copy(a[i:], a[i+1:])]

删除位置 i 的元素。第一种，利用剪切的方式删除。因为只是在删除，这个append操作并不会引起底层数据的扩容。只不过 i 之后的数据发生了更新。此时长度减小1，容量不变。

第二种方式，利用copy方法实现。将 i 后面所有的数据迁移，然后删除最后一位数据。将 i+1 到 len(a) 的数据复制到 i 到 len(a)-1的位置上。copy方法的返回值是复制的元素长度，所以这里又被直接用来截断，将 a 的最后一位没有被删除的数据删除。

这两种操作的底层结果一致。被删除元素的后面元素都需要被复制。

Delete without preserving order 不保留顺序的删除

a[i] = a[len(a)-1] 
a = a[:len(a)-1]

删除第 i 位的元素，把最后一位放到第 i 位上，然后把最后一位元素删除。这种方式底层并没有发生复制操作。

注意如果 slice 的类型是指向结构体的指针，或者是结构体 slice 里面包含指针，这些数据在被删除后需要进行垃圾回收来释放内存。然而上面的Cut和Delete方法有可能引起内存泄漏：被删除的数据依然被 a 所引用（底层数据中引用）导致无法进行垃圾回收。可以用下面的代码解决这个问题：

Cut
copy(a[i:], a[j:])
for k, n := len(a)-j+i, len(a); k < n; k++ {
	a[k] = nil // or the zero value of T
}
a = a[:len(a)-j+i]
相比于之前多了一步操作，将被删除的位置置为 nil。这样指针就没有被引用的地方了，可以被垃圾回收。

Delete

copy(a[i:], a[i+1:])
a[len(a)-1] = nil // or the zero value of T
a = a[:len(a)-1]

Delete without preserving order

a[i] = a[len(a)-1]
a[len(a)-1] = nil
a = a[:len(a)-1]

Expand

a = append(a[:i], append(make([]T, j), a[i:]...)...)

在中间位置 i 扩展长度为 j 的 slice。

Extend

a = append(a, make([]T, j)...)

在最后延伸长度是 j 的 slice。

Insert

a = append(a[:i], append([]T{x}, a[i:]...)...)

在位置 i 插入元素 x。

注意通过第二个append把 a[i:] 追加到 x 后面（这个操作会引起[]T{x}发生多次扩容），然后通过第一个append把这个新的 slice 追加到 a[:i]后面（这个操作会引起 a 发生一次扩容）。这两个操作创建了一个新的 slice（这样相当于创建了内存垃圾），第二个复制也可以被避免：

Insert
s = append(s, 0)
copy(s[i+1:], s[i:])
s[i] = x
首先通过append将 slice 扩容，然后把 i 后面的元素后移，最后复制。整个操作一次扩容。

InsertVector

a = append(a[:i], append(b, a[i:]...)...)

在位置 i 插入 slice b。

Pop/Shift

x, a = a[0], a[1:]

一行实现 pop 出队列头。

Pop Back

x, a = a[len(a)-1], a[:len(a)-1]

一行实现 pop 出队列尾。

Push

a = append(a, x)

push x 到队列尾。

Push Front/Unshift

a = append([]T{x}, a...)

push x 到队列头。

Additional Tricks 附加技巧

Filtering without allocating 不申请内存过滤数据

多个切片引用的底层数组是有可能是同一个，利用这个原理可以实现复用底层数组实现数据过滤。当然，过滤之后底层数组内容会被修改。

b := a[:0]
for _, x := range a {
	if f(x) {
		b = append(b, x)
	}
}

就地过滤。首先申明切片 b，和 a 共享底层数组。遍历 a 进行过滤，过滤后到加入 b 中。这样 a 和 b 同时被修改了。b 是过滤后正确的 slice，而 a 的数据会错乱。

Reversing 反转

将 slice 的数据顺序反转：

for i := len(a)/2-1; i >= 0; i-- {
	opp := len(a)-1-i
	a[i], a[opp] = a[opp], a[i]
}

代码再简化一下，还可以将反转用到的索引省略：

for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
	a[left], a[right] = a[right], a[left]
}

Shuffling 随机

Fisher–Yates 算法:

需要Go 1.10 以上 math/rand.Shuffle

for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}

每个数据随机一个新位置出来。

用 Go 给 Redis 写组件

2018-05-30T00:00:00+00:00

写在前面
一个 C 语言的例子
- Redis 的组件
用 Go 实现一个 Redis 组件
总结

写在前面

Redis 从4.0开始支持组件开发，用户编译生成一个动态链接库，启动时加载就可以启用。Redis 时 C语言开发的，写插件还得用 C 语言。还好 Go 语言也能开发组件，我也能尝试一把开发一个插件了。

一个 C 语言的例子

可以参考这个例子Writing Redis Modules来大概了解下开发流程。

文章里描述了一下如何自己写一个HGETSET命令，他组合了HGET和HSET这两个原生的命令。

从这里可以下载到源代码RedisModulesSDK。需要编译出来一个动态链接库文件。例子提供的很完善，编译脚本都写在了 Makefile 里面。会生成module.so文件。

git clone https://github.com/RedisLabs/RedisModulesSDK.git
cd RedisModulesSDK/
cd example/
make all

我们需要用到最新版的 Redis，并且编译。

wget http://download.redis.io/releases/redis-4.0.9.tar.gz
tar -zxvf redis-4.0.9.tar.gz
cd redis-4.0.9
make

启动 Redis，通过loadmodule参数指出动态链接库的地址。port参数指定启动端口，loglevel设置日志打印级别。

./redis-server --loadmodule ~/code/ccode/RedisModulesSDK/example/module.so --loglevel debug --port 6340

最后启动 Redis 客户端，试着输入下面的命令，很有成就感有没有。

redis-cli -p 6340

127.0.0.1:6340> EXAMPLE.HGETSET foo bar baz
(nil)
127.0.0.1:6340> EXAMPLE.HGETSET foo bar vaz
"baz"
127.0.0.1:6340> EXAMPLE.PARSE SUM 5 2
(integer) 7
127.0.0.1:6340> EXAMPLE.PARSE PROD 5 2
(integer) 10
127.0.0.1:6340> EXAMPLE.TEST
PASS

Redis 的组件

Redis 的热门组件都放在这里。有人用他做了搜索引擎，还有支持 SQL，还有一些扩展了数据结构，比如 JSON 类型、布隆过滤器、bitmap 等等。

完整的开发文档。

大概说下流程：

程序入口是int RedisModule_OnLoad(RedisModuleCtx *ctx)，里面完成相关初始化操作；
初始化组件RedisModule_Init；
如果扩展了数据类型，也需要注册。moduleType *RedisModule_CreateDataType(RedisModuleCtx *ctx, const char *name, int encver, void *typemethods_ptr);。
- name：这是一个 9 字符的字符串，必须是9个字符。可以使用 A-Z、a-z、0-9、-、_这些字符。一般命名规则是类型-vendor；
- encver：编码版本号，用于备份到磁盘时用；
- typemethods_ptr，这个结构体保存了数据类型相关的操作函数，比如rdb格式的加载和备份等等。
创建命令，int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModuleCmdFunc cmdfunc, const char *strflags, int firstkey, int lastkey, int keystep);
- name是命令名字，这是实际调用命令时要输入的名字；
- cmdfunc是注册的函数，函数的定义格式是int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);;
获取一个 key 的句柄，void *RedisModule_OpenKey(RedisModuleCtx *ctx, robj *keyname, int mode);，有了这个句柄，可以查看当前 key 的类型，并且操作这个 key，写入值、写入过期时间、删除等操作；
从 Redis 获取值。void *RedisModule_ModuleTypeGetValue(RedisModuleKey *key);
把值写入 Redis，int RedisModule_ModuleTypeSetValue(RedisModuleKey *key, moduleType *mt, void *value);；
命令的返回需要注意，返回值只能是成功REDISMODULE_OK和失败REDISMODULE_ERR，但是只返回这个是不行的，还需要返回内容。
- RedisModule_ReplyWithError，返回错误；
- RedisModule_ReplyWithSimpleString，返回字符串；
- RedisModule_ReplyWithNull，返回空，一般查询的 key 没有对应值的时候用。

用 Go 实现一个 Redis 组件

不太会用 C，自己想写个组件不是很好搞，还好有一个 Go 版本的库来辅助用 Go 开发。go-rm，看头像是个国人，很不错。README 里有用 Go 实现了最开始举的HGETSET的例子，可以跑起来看看。

这个 Go 语言的包函数命名和 C 的差不太多，上手不是很费劲。

开发一个 JSON 格式的组件

我准备着手开发支持 JSON 格式的组件，它支持保存 JSON，根据用户输入的参数返回 JSON 内符合条件的数据。命令大概是这个样子：

127.0.0.1:6340> json.set doc '{"foo":"bar","baz":43}'
"{\"foo\":\"bar\",\"baz\":43}"

127.0.0.1:6340> json.get doc baz a
{"baz":43}

echo 命令

先写一个简单的练练手。初始化当前组件：

func init() {
    rm.Mod = CreateMyMod()
}

func CreateMyMod() *rm.Module {
    mod := rm.NewMod()
    mod.Name = "json"
    mod.Version = 1
    mod.Commands = []rm.Command{CreateCommand_ECHO()}
    return mod
}

func main() {
    // In case someone try to run this
    rm.Run()
}

编写 echo 的命令实现。里面有参数校验，调用Reply很重要，否则客户的会卡死。

func CreateCommand_ECHO() rm.Command {
    return rm.Command{
        Usage:    "print message",
        Desc:     `like echo.`,
        Name:     "print",
        Flags:    "",
        FirstKey: 1, LastKey: 1, KeyStep: 1,
        Action: func(cmd rm.CmdContext) int {
            ctx, args := cmd.Ctx, cmd.Args
            if len(args) != 2 {
                return ctx.WrongArity()
            }
            ctx.ReplyWithString(args[1])
            return rm.OK
        },
    }
}

写入 Redis

把数据解析到一个map[string]interface{}里面保存。

func CreateCommand_JSONSET() rm.Command {
    return rm.Command{
        Usage:    `json.set a {"foo":"bar","baz":42}`,
        Desc:     `store a json object.`,
        Name:     "json.set",
        Flags:    "",
        FirstKey: 1, LastKey: 1, KeyStep: 1,
        Action: func(cmd rm.CmdContext) int {
            ctx, args := cmd.Ctx, cmd.Args
            if len(args) != 3 {
                return ctx.WrongArity()
            }

            ctx.AutoMemory()
            key, ok := openHashKey(ctx, args[1])
            if !ok {
                return rm.ERR
            }

            // var val *JsonData
            raw := args[2].String()
            rm.LogDebug("raw: %s", raw)

            val := new(JsonData)
            val.Name = args[1]
            val.data = make(map[string]interface{}, 1)
            err := json.Unmarshal([]byte(raw), &val.data)
            if err != nil {
                ctx.ReplyWithError(fmt.Sprintf("ERR %v", err))
                return rm.ERR
            }

            if key.IsEmpty() {
                if key.ModuleTypeSetValue(ModuleType, unsafe.Pointer(val)) == rm.ERR {
                    ctx.ReplyWithError("ERR Failed to set module type value")
                    return rm.ERR
                }
            } else {
                valOld := (*JsonData)(key.ModuleTypeGetValue())
                valOld.data = val.data
            }

            ctx.ReplyWithString(args[2])
            return rm.OK
        },
    }
}

读取 JSON

如果没有找到 key，需要返回空。

func CreateCommand_JSONGET() rm.Command {
    return rm.Command{
        Usage:    `json.get a foo`,
        Desc:     `get a json object.`,
        Name:     "json.get",
        Flags:    "",
        FirstKey: 1, LastKey: 1, KeyStep: 1,
        Action: func(cmd rm.CmdContext) int {
            ctx, args := cmd.Ctx, cmd.Args
            if len(args) < 2 {
                return ctx.WrongArity()
            }

            key, ok := openHashKey(ctx, args[1])
            if !ok {
                return rm.ERR
            }
            val := (*JsonData)(key.ModuleTypeGetValue())
            rm.LogDebug("raw: %v", val)

            if val == nil || val.data == nil {
                ctx.ReplyWithNull()
                return rm.OK
            }

            resLen := len(args[2:])

            var resMap map[string]interface{}
            if resLen == 0 {
                resMap = make(map[string]interface{}, len(val.data))
                for k, v := range val.data {
                    resMap[k] = v
                }
            } else {
                resMap = make(map[string]interface{}, resLen)
                for _, arg := range args[2:] {
                    a := arg.String()
                    rm.LogDebug(a)
                    if v, exists := val.data[a]; exists {
                        resMap[a] = v
                    }
                }
            }

            res, err := json.Marshal(resMap)
            if err != nil {
                ctx.ReplyWithError(err.Error())
                return rm.ERR
            }

            ctx.ReplyWithSimpleString(string(res))
            return rm.OK
        },
    }
}

总结

Redis 这个组件功能真的是很厉害，用Redis的分布式、主从同步、自动备份到磁盘这些特性，分分钟搭起一个高可用分布式应用。

关于数据备份和恢复的部分我还没有研究，等下次搞明白了再说吧。完整的代码放在GitHub上面，有需要可以去看。

常见的哈希算法和用途

2018-05-28T00:00:00+00:00

写在前面
DJB
- DJB 在 Redis中的应用
Java 字符串哈希
FNV
Thomas Wang’s 32 bit Mix Function
Murmur
CRC32
memhash
性能比较
- 参考文献

写在前面

哈希算法经常会被用到，比如我们Go里面的map，Java的HashMap，目前最流行的缓存Redis都大量用到了哈希算法。它们支持把很多类型的数据进行哈希计算，我们实际使用的时候并不用考虑哈希算法的实现。而其实不同的数据类型，所使用到的哈希算法并不一样。

DJB

下面是C语言实现。初始值是5381，遍历整个串，按照hash * 33 +c的算法计算。得到的结果就是哈希值。

unsigned long
    hash(unsigned char *str)
    {
        unsigned long hash = 5381;
        int c;

        while (c = *str++)
            hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

        return hash;
    }

里面涉及到两个神奇的数字，5381和33。为什么是这两个数？我还特意去查了查，说是经过大量实验，这两个的结果碰撞小，哈希结果分散。

还有一个事情很有意思，乘以33是用左移和加法实现的。底层库对性能要求高啊。

DJB 在 Redis中的应用

在Redis中，它被用来计算大小写不敏感的字符串哈希。

static uint32_t dict_hash_function_seed = 5381;
/* And a case insensitive hash function (based on djb hash) */
unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) {
    unsigned int hash = (unsigned int)dict_hash_function_seed;

    while (len--)
        hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */
    return hash;
}

算法和之前的一样，只是多了一个tolower函数把字符转成小写。

Java 字符串哈希

看了上面的再看Java内置字符串哈希就很有意思了。Java对象有个内置对象hash，它缓存了哈希结果，如果当前对象有缓存，直接返回。如果没有缓存，遍历整个字符串，按照hash * 31 + c的算法计算。

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

和DJB相比，初始值从5381变成了0，乘的系数从33变成了31。

FNV

这个算法之前写过《字符串查找算法（二）》，字符串每一位都看成是一个数字，32位的话看成是16777169进制的数字，计算当前串的哈希值就是在把当前串转成10进制。

const primeRK = 16777619

// hashstr returns the hash and the appropriate multiplicative
// factor for use in Rabin-Karp algorithm.
func hashstr(sep string) (uint32, uint32) {
    hash := uint32(0)
    for i := 0; i < len(sep); i++ {
        hash = hash*primeRK + uint32(sep[i])
    }
    var pow, sq uint32 = 1, primeRK
    for i := len(sep); i > 0; i >>= 1 {
        if i&1 != 0 {
            pow *= sq
        }
        // 只有32位，超出范围的会被丢掉
        sq *= sq
    }
    return hash, pow
}

这个算法的厉害之处在于他可以保存状态。比如有个字符串ab，它的哈希值是a*E+b=HashAB，如果计算bc的哈希值，可以利用第一次计算的结果(HashAB-a*E)*E+c=HashBC。这么一个转换例子里是两个字符效果不明显，如果当前串是100个字符，后移一位的哈希算法性能就会快很多。

在Golang里面字符串匹配算法查找用到了这个。

Thomas Wang’s 32 bit Mix Function

前面说的都是字符串的哈希算法，这次说整数的。

public
int hash32shift(int key)
{
    key = ~key + (key << 15); // key = (key << 15) - key - 1;
    key = key ^ (key >>> 12);
    key = key + (key << 2);
    key = key ^ (key >>> 4);
    key = key * 2057; // key = (key + (key << 3)) + (key << 11);
    key = key ^ (key >>> 16);
    return key;
}

Redis对于Key是整数类型时用了这个算法。

Murmur

就纯哈希算法来说，这个算法算是综合能力不错的算法了。碰撞小、性能好。

Hash           Lowercase      Random UUID  Numbers
=============  =============  ===========  ==============
Murmur            145 ns      259 ns          92 ns
                    6 collis    5 collis       0 collis
FNV-1a            152 ns      504 ns          86 ns
                    4 collis    4 collis       0 collis
FNV-1             184 ns      730 ns          92 ns
                    1 collis    5 collis       0 collis▪
DBJ2a             158 ns      443 ns          91 ns
                    5 collis    6 collis       0 collis▪▪▪
DJB2              156 ns      437 ns          93 ns
                    7 collis    6 collis       0 collis▪▪▪
SDBM              148 ns      484 ns          90 ns
                    4 collis    6 collis       0 collis**
SuperFastHash     164 ns      344 ns         118 ns
                   85 collis    4 collis   18742 collis
CRC32             250 ns      946 ns         130 ns
                    2 collis    0 collis       0 collis
LoseLose          338 ns        -             -
               215178 collis

一般在分布式系统中用的比较多。对于一个Key做哈希，把不同的请求转发到不同的服务器上面。

推荐一个Go的实现。

CRC32

CRC32的哈希碰撞和murmur的差不多，但是CRC32可以使用CPU的硬件加速实现哈希提速。

在Codis上就使用了这个哈希算法做哈希分片，SlotId= crc32(key) % 1024。

Codis使用Go语言实现，CRC32算法直接用了Go的原生包hash/crc32。这个包会提前判断当前CPU是否支持硬件加速：

func archAvailableIEEE() bool {
    return cpu.X86.HasPCLMULQDQ && cpu.X86.HasSSE41
}

memhash

Go语言内置的哈希表数据结构map，也是一个哈希结构，它内置的哈希算法更讲究。

这里用到的哈希算法是memhash，源代码在runtime/hash32.go里面。它基于谷歌的两个哈希算法实现。大家有兴趣的可以去研究下具体实现。

// Hashing algorithm inspired by
//   xxhash: https://code.google.com/p/xxhash/
// cityhash: https://code.google.com/p/cityhash/

memhash在具体实现时也用到了硬件加速。如果硬件支持，会用AES哈希算法。如果不支持，才会去用memhash。

func memhash(p unsafe.Pointer, seed, s uintptr) uintptr {
    if GOARCH == "386" && GOOS != "nacl" && useAeshash {
        return aeshash(p, seed, s)
    }
    h := uint32(seed + s*hashkey[0])

性能比较

memhash并不是可导出函数，我在runtime包里增加了一个memhash_test.go的测试文件，执行go test -benchmem -run=^$ -bench ^BenchmarkMemHash$。

package runtime_test

import (
    . "runtime"
    "testing"
)

func BenchmarkMemHash(b *testing.B) {
    for i := 0; i < b.N; i++ {
        for _, g := range goldenMurmur3 {
            StringHash(g.in, 0)
        }
    }
}

type _Golden struct {
    out uint32
    in  string
}

var goldenMurmur3 = []_Golden{
    {0x00000000, ""},
    {0x3c2569b2, "a"},
    {0x9bbfd75f, "ab"},
    {0xb3dd93fa, "abc"},
    {0x43ed676a, "abcd"},
    {0xe89b9af6, "abcde"},
    {0x6181c085, "abcdef"},
    {0x883c9b06, "abcdefg"},
    {0x49ddccc4, "abcdefgh"},
    {0x421406f0, "abcdefghi"},
    {0x88927791, "abcdefghij"},
    {0x91e056d3, "Discard medicine more than two years old."},
    {0xc4d1cdf9, "He who has a shady past knows that nice guys finish last."},
    {0x92a09da9, "I wouldn't marry him with a ten foot pole."},
    {0xba22e6c4, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave"},
    {0xb3ba11cb, "The days of the digital watch are numbered.  -Tom Stoppard"},
    {0x941ada4d, "Nepal premier won't resign."},
    {0x03f1f7b4, "For every action there is an equal and opposite government program."},
    {0x03946117, "His money is twice tainted: 'taint yours and 'taint mine."},
    {0x91e89ce1, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977"},
    {0xdc39bd00, "It's a tiny change to the code and not completely disgusting. - Bob Manchek"},
    {0xe898a1fa, "size:  a.out:  bad magic"},
    {0xcb5affb4, "The major problem is with sendmail.  -Mark Horton"},
    {0xc84510d4, "Give me a rock, paper and scissors and I will move the world.  CCFestoon"},
    {0xd4466554, "If the enemy is within range, then so are you."},
    {0xe718d618, "It's well we cannot hear the screams/That we create in others' dreams."},
    {0xa6fb1684, "You remind me of a TV show, but that's all right: I watch it anyway."},
    {0x65cb8d60, "C is as portable as Stonehedge!!"},
    {0x164935d1, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley"},
    {0x33e03966, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction.  Lewis-Randall Rule"},
    {0x04944630, "How can you write a big system without C++?  -Paul Glick"},
}

结果：

BenchmarkMemHash-8   	 3000000	       475 ns/op	       0 B/op	       0 allocs/op

dgohash用Go实现了一些哈希算法，对比压测一下。

BenchmarkJava32-8          	  500000	      2548 ns/op	    1456 B/op	      30 allocs/op
BenchmarkDJB-8             	  500000	      2516 ns/op	    1456 B/op	      30 allocs/op
BenchmarkElf32-8           	  500000	      3204 ns/op	    1456 B/op	      30 allocs/op
BenchmarkJenkins32-8       	  500000	      3154 ns/op	    1456 B/op	      30 allocs/op
BenchmarkMarvin32-8        	  500000	      3375 ns/op	    1456 B/op	      30 allocs/op
BenchmarkMurmur-8          	 1000000	      2184 ns/op	    1456 B/op	      30 allocs/op
BenchmarkSDBM32-8          	  500000	      2789 ns/op	    1456 B/op	      30 allocs/op
BenchmarkSQLite32-8        	 1000000	      2419 ns/op	    1456 B/op	      30 allocs/op
BenchmarkSuperFastHash-8   	 1000000	      2003 ns/op	    1456 B/op	      30 allocs/op 硬件加速的和这些比确实可以碾压。

参考文献

Golang HTTP 服务路由查询

2018-02-07T00:00:00+00:00

Golang HTTP 原始包
路由
黑科技获取变量内部变量

Golang HTTP 原始包

Golang 的框架用过不少，越来越发现还是原生的好。我们一般只做接口，对于项目服务没有那么高的灵活性要求，原生的 HTTP 包已经够用。而且原生包通过接口的形式提供了扩展的方式，自己简单扩展一下就方便很多。Golang 的设计思想就是简单，还是用简单的方式比较好。

路由

原生包的路由非常简单，就用了一个哈希表来报存路由。

type ServeMux struct {
	mu    sync.RWMutex
	m     map[string]muxEntry
	hosts bool // whether any patterns contain hostnames
}

每次请求进来都要在m里查询路由。但是这个路由有个问题，它是局部变量，而且没有对应的getter函数，我们没法知道路由的内容。

黑科技获取变量内部变量

获取内部变量m的方法也不难，通过反射的方式。路由变量ServeMux可以拿到，通过反射是可以拿到它的局部变量的。反射也提供了操作哈希表的对于方法。直接上代码：

v := reflect.ValueOf(mux)
m := v.Elem().FieldByName("m")

keys := m.MapKeys()

routers := make([]string, 0, len(keys))
for _, key := range keys {
	routers = append(routers, key.String())
}

sort.Strings(routers)

题图：天津瓷房子。

最近半年更新少了很多，太忙了，Go代码写得也少了很多，实在惭愧。又要到新年了，希望明年更好。

Golang int 和 uint 天天用，那么问题来了，它多大？

2017-12-18T00:00:00+00:00

写在前面
int 和 uint 到底占多大空间？
More
Size of int on 64-bit platforms
PS

写在前面

今天调试一个问题，发现一个我无法理解的情况：

package main

import (
	"fmt"
	"math"
	"runtime"
)

func main() {
	var a uint = math.MaxUint64
	fmt.Println("Hello, playground", a, runtime.Version())
}

把64位的数字赋值给uint，我理解uint是32位的，为啥可以编译通过？但是我接着又在 playground 上试了一把，结果是编译不过了：

constant 18446744073709551615 overflows uint

int 和 uint 到底占多大空间？

其实我一直理解是32位的。因为别的语言是这样，惯性思维了。

直接看一下官方文档：

int is a signed integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for, say, int32.

uint和int情况差不多。翻译一下，就是说这个整形最少占32位，int和int32是两码事。

再看一下 davecheney 大神的回复（大神半夜回复 GitHub 真是敬业啊）：

uint is a variable sized type, on your 64 bit computer uint is 64 bits wide.

我的理解uint类型长度取决于 CPU，如果是32位CPU就是4个字节，如果是64位就是8个字节。我的电脑是64位的，而 playground 是32位的，问题就出在这里。

这里就会出现一个情况，int和uint是根据 CPU 变化的，如何知道当前系统的情况？

CPU 型号：runtime.GOARCH
int的长度：strconv.IntSize

写了这么多年 Golang，int天天用，一直被我当32位处理，说来惭愧。。。

Size of int on 64-bit platforms

经热心网友提醒，从 1.1 开始，Go 的int和uint长度发生了变化。

The language allows the implementation to choose whether the int type and uint types are 32 or 64 bits. Previous Go implementations made int and uint 32 bits on all systems. Both the gc and gccgo implementations now make int and uint 64 bits on 64-bit platforms such as AMD64/x86-64. Among other things, this enables the allocation of slices with more than 2 billion elements on 64-bit platforms.

x := ^uint32(0) // x is 0xffffffff
i := int(x)     // i is -1 on 32-bit systems, 0xffffffff on 64-bit
fmt.Println(i)

PS

今天看strconv.Itoa的源码，发现一个有意思的地方：

const host32bit = ^uint(0)>>32 == 0

它用到了int长度的特性来判断是不是32位的。

https://play.golang.org/p/Or99SPVNbm

题图：孜然牛肉。

Golang map 如何进行删除操作？

2017-11-02T00:00:00+00:00

map 的删除操作
map 的删除原理
如何清空整个 map
如何真正释放内存？
验证
为什么这么设计？
这样是内存泄漏么？

map 的删除操作

Golang 内置了哈希表，总体上是使用哈希链表实现的，如果出现哈希冲突，就把冲突的内容都放到一个链表里面。

Golang 还内置了delete函数，如果作用于哈希表，就是把 map 里面的 key 删除。

delete(intMap, 1)

map 的删除原理

可以直接看源码。

我简单摘几行：

func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
	for ; b != nil; b = b.overflow(t) {
		for i := uintptr(0); i < bucketCnt; i++ {
			b.tophash[i] = empty
			h.count--
		}
	}
}

外层的循环就是在遍历整个 map，删除的核心就在那个empty。它修改了当前 key 的标记，而不是直接删除了内存里面的数据。

empty          = 0 // cell is empty

如何清空整个 map

看了我上面的分析，那么这段代码可以清空 map 么？

for k, _ := range m {
	delete(m, k)
}

map 被清空。执行完之后调用len函数，结果肯定是0；
内存没有释放。清空只是修改了一个标记，底层内存还是被占用了；
循环遍历了len(m)次。上面的代码每一次遍历都会删除一个元素，而遍历的次数并不会因为之前每次删一个元素导致减少。

如何真正释放内存？

map = nil

这之后坐等垃圾回收器回收就好了。

如果你用 map 做缓存，而每次更新只是部分更新，更新的 key 如果偏差比较大，有可能会有内存逐渐增长而不释放的问题。要注意。

验证

下面来验证一下上面说的原理。我们申请一个全局map来保证内存被分配到堆上面。初始化这个map，分配比较大的空间，方便对比。每完成一次操作，进行一个垃圾回收，并且打印当前内存堆的情况。

var intMap map[int]int
var cnt = 8192

func main() {
	printMemStats()

	initMap()
	runtime.GC()
	printMemStats()

	log.Println(len(intMap))
	for i := 0; i < cnt; i++ {
		delete(intMap, i)
	}
	log.Println(len(intMap))

	runtime.GC()
	printMemStats()

	intMap = nil
	runtime.GC()
	printMemStats()
}

func initMap() {
	intMap = make(map[int]int, cnt)

	for i := 0; i < cnt; i++ {
		intMap[i] = i
	}
}

func printMemStats() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	log.Printf("Alloc = %v TotalAlloc = %v Sys = %v NumGC = %v\n", m.Alloc/1024, m.TotalAlloc/1024, m.Sys/1024, m.NumGC)
}

结果如下：

2018/05/31 10:54:25 Alloc = 100 TotalAlloc = 100 Sys = 1700 NumGC = 0
2018/05/31 10:54:25 Alloc = 422 TotalAlloc = 426 Sys = 3076 NumGC = 1
2018/05/31 10:54:25 8192
2018/05/31 10:54:25 0
2018/05/31 10:54:25 Alloc = 424 TotalAlloc = 429 Sys = 3140 NumGC = 2
2018/05/31 10:54:25 Alloc = 112 TotalAlloc = 431 Sys = 3140 NumGC = 3

结论很明显：

NumGC 是垃圾回收次数；Alloc 是对对象大小，单位是 KB；Sys 是从 OS 获取的内存大小，单位是 KB；
第一行，没有进行过 GC，默认真用了 100 KB 的内存；
map初始化完成之后进行一次 GC，此时内存占了 422 KB；
接下来就是执行delete操作，可以看到map已经被清空了，也执行了一次 GC，但是内存没有被释放；
最后把map置为空，内存才被释放。
我使用的版本go version go1.10.1 darwin/amd64。

为什么这么设计？

这么设计看起来不是那么完美，为什么要这么做呢？

query := map[string]string{}

query["test0"] = "0"
query["test1"] = "1"
query["test2"] = "2"

i := 0
for k, v := range query {
	delete(query, "test2")
	fmt.Println(query, k, v)
	i++
}

我们可以在遍历map的时候删除里面的元素，而且可以删除没有遍历到的元素，为了保证删除了之后遍历不发生异常，才这么设计的吧。

这样是内存泄漏么？

我觉得这样不算是内存泄漏。如果继续给这个map写入值，如果这个值命中了之前被删除的bucket，那么会覆盖之前的empty数据。

说说 JSONP 和 XSS

2017-10-27T00:00:00+00:00

JSONP
XSS
问题原因
Content-Type: application/json
Content-Type: text/html
解决方法

JSONP

先说 JSONP。通过 JavaScript 调用，被调用域名和当前页面域名不一致，就需要用到 JSONP。不过我不太推荐这么跨域调用。

如果真的要解决跨域问题，我觉得有几个不错的方法，一个是两组服务器配上相同的域名。还有就是自己的服务器 nginx 上做一个转发。

XSS

跨站脚本（英语：Cross-site scripting，通常简称为：XSS）是一种网站应用程序的安全漏洞攻击，是代码注入的一种。它允许恶意用户将代码注入到网页上，其他用户在观看网页时就会受到影响。这类攻击通常包含了HTML以及用户端脚本语言。

上面是维基百科的解释。实际一点的例子可以看看我文本的头图。页面被注入了一张图片。恶意的注入可以注入一段脚本。

问题原因

浏览器为了保证跨域访问的安全性，会默认发一个 callback 参数到后台，接口拿到这个参数之后，需要将返回的 JSON 数据外面包上 callback 参数。

具体的返回格式：

CALLBACK(JSON)

如果 ajax 请求是 JSONP 请求，返回的内容浏览器还会自动检测，如果不是按这个格式返回或者 callback 的内容不对，这次请求就算失败了。

这里有一个机制，那就是请求的 callback 会被放入返回的内容当中，这也是可能出问题的地方。

支持 JSONP 的链接如果直接放到浏览器里面访问，浏览器就不会做 callback 校验了。

Content-Type: application/json

浏览器渲染就是靠 Content-Type 来做的。如果返回内容标记是 json，哪怕 body 里面都是 html 的标签，浏览器也不会渲染。所以，如果接口返回的不是 html，千万不要写成 html。

Content-Type: text/html

如果返回的内容是页面，html类型。那么 callback 注入的 html 元素都可以直接放到页面上了。那么，html 页面必然不能支持 callback。

解决方法

就是前面说到的，Content-Type 不要乱用，严格按照标准协议来做。目前的框架默认肯定会检测一下内容类型，如果不是很必要，不要手动设置。因为有可能多转发几次 Content-Type 就被改了。
callback 做长度限制，这个比较 low。
检测 callback 里面的字符。一般 callback 里面都是字母和数字，别的符号都不能有。
callback 做一个编码，如果用 Go 语言做的话，如下。对所有 callback 都处理。

callback = template.JSEscapeString(callback)

完整代码可以参考这里。

开发了一个rarbg插件

2017-07-28T00:00:00+00:00

效果图
安装方法
一些问题

效果图

安装方法

安装浏览器插件Tampermonkey。支持的浏览器很多，居然连 UC 浏览器都支持，真不错。
去Greasy Fork下载我开发的rarbg插件，下载地址.

一些问题

服务器在国外，读取豆瓣的接口会比较慢，如果数据没有命中缓存响应会慢。大家尝试多刷一下就好。
目前只支持电影，有兴趣的可以帮忙扩充一下电视剧。

Golang 优化之路——自己造一个日志轮子

2017-07-14T00:00:00+00:00

写在前面
按日志级别打印和控制日志
日志文件自动分割
日志的异步输出
日志行号
线程安全
最后
GitHub
参考文献

写在前面

Golang 的log包内容不多，说实话，直接用来做日志开发有些简易。主要是缺少一些功能：

按日志级别打印和控制日志；
日志文件自动分割；
异步打印日志。

按日志级别打印和控制日志

我们实现的日志模块将会支持4个级别：

const (
	LevelError = iota
	LevelWarning
	LevelInformational
	LevelDebug
)

定义一个日志结构体：

type Logger struct {
	level int
	l     *log.Logger
}

func (ll *Logger) Error(format string, v ...interface{}) {
	if LevelError > ll.level {
		return
	}
	msg := fmt.Sprintf("[E] "+format, v...)
	ll.l.Printf(msg)
}

这样就能实现日志级别控制输出，并且打印的时候追加一个标记，比如上面的例子，Error 级别就会追加[E]。

这个实现已经可以了，但是还是有优化的空间。比如打印追加标记[E]的时候，用的是字符串加法。字符串加法会申请新的内存，对性能不是很优化。我们需要通过字符数组来优化。

但我不会这么去优化了。这个时候看一下 log 包的 API，可以发现原生包是支持设置前缀的：

func (l *Logger) SetPrefix(prefix string)

再去看一下具体的实现：

func (l *Logger) formatHeader(buf *[]byte, t time.Time, file string, line int) {
	*buf = append(*buf, l.prefix...)

原生包在写日志前缀的时候就用到了[]byte来提升性能。既然人家已经提供了，我们还是不要自己造了。那么问题来了，设置前缀是初始化的时候就要设置，打印的时候自动输出出来。一个log.Logger对象只能有一个前缀，而我们需要4种级别的前缀，这个如何打印？

type Logger struct {
	level int
	err   *log.Logger
	warn  *log.Logger
	info  *log.Logger
	debug *log.Logger
}

我们直接申请4个日志对象就能解决。为了保证所有级别都打印到同一个文件里面，初始化的时候设置成同一个io.Writer即可。

logger := new(LcLogger)

logger.err = log.New(w, "[E] ", flag)
logger.warn = log.New(w, "[W] ", flag)
logger.info = log.New(w, "[I] ", flag)
logger.debug = log.New(w, "[D] ", flag)

设置日志级别：

func (ll *Logger) SetLevel(l int) {
	ll.level = l
}

打印的时候根据日志级别控制输出。（讲一个我遇到的坑。之前有一次打印日志打太多了，磁盘都打满了，就寻思着把日志级别调高减少打印内容。把级别调成 Error 后发现还是没有效果，最后看了看代码发现出问题的日志打印的是 Error 级别。。。Error级别的日志要尽量少打。）

func (ll *Logger) Error(format string, v ...interface{}) {
	if LevelError > ll.level {
		return
	}
	ll.err.Printf(format, v...)
}

日志文件自动分割

日志文件需要自动分割。否则一个文件过大，清理磁盘的时候这个文件因为还是打印日志没办法清理。

日志分割我觉得简单的以大小分割就好。

那么日志分割功能如何接入咱们上面实现的日志模块呢？关键就在io.Writer。

type Writer interface {
    Write(p []byte) (n int, err error)
}

Writer这个接口只有一个方法，如此简单。原生包默认打印日志会输出到os.Stderr里面，这是一个os.File类型的变量，它实现了Writer这个接口。

func (f *File) Write(b []byte) (n int, err error)

写日志的时候，log 包会自动调用Write方法。我们可以自己实现一个Writer，在Write的时候计算一下写入此行日志之后当前日志文件大小，如果超过设定的值，执行一次分割。按日子分割日志也是这个时候操作。

推荐用 gopkg.in/natefinch/lumberjack.v2 这个包来做日志分割，功能很强大。

jack := &lumberjack.Logger{
	Filename: lfn,
	MaxSize:  maxsize, // megabytes
}

使用也很简单，jack对象就是一个Writer了，可以直接复制给Logger使用。

日志的异步输出

协程池也整个包：github.com/ivpusic/grpool。协程池就不展开说了，有兴趣的可以看看这个包的实现。

日志的结构体再一次升级：

type Logger struct {
	level int
	err   *log.Logger
	warn  *log.Logger
	info  *log.Logger
	debug *log.Logger
	p     *grpool.Pool
}

初始化：

logger.p = grpool.NewPool(numWorkers, jobQueueLen)

日志输出：

func (ll *Logger) Error(format string, v ...interface{}) {
	if LevelError > ll.level {
		return
	}
	ll.p.JobQueue <- func() {
		ll.err.Printf(format, v...)
	}
}

日志行号

如果你一步一步按上面的做了，打印日志设置了Lshortfile，展示行号的花，你可能会发现这个时候打印出来的行号有问题。打印日志的时候用到了runtime里面的堆栈信息，因为我们封装了一层，所以打印的堆栈深度会发生变化。简单的说就是深了一层。

原生的日志包提供了func (l *Logger) Output(calldepth int, s string) error来控制日志堆栈深度输出，我们再次对代码进行调整。

type Logger struct {
	level int
	err   *log.Logger
	warn  *log.Logger
	info  *log.Logger
	debug *log.Logger
	p     *grpool.Pool
	depth int
}

func (ll *Logger) Error(format string, v ...interface{}) {
	if LevelError > ll.level {
		return
	}
	ll.p.JobQueue <- func() {
		ll.err.Output(ll.depth, fmt.Sprintf(format, v...))
	}
}

我们只封装了一层，所以深度设置成3就可以了。

线程安全

原生包打印日志是线程安全的：

func (l *Logger) Output(calldepth int, s string) error {
	now := time.Now() // get this early.
	var file string
	var line int
	l.mu.Lock() // 看到这里了么？
	defer l.mu.Unlock()
	if l.flag&(Lshortfile|Llongfile) != 0 {
		// release lock while getting caller info - it's expensive.
		l.mu.Unlock()
		var ok bool
		_, file, line, ok = runtime.Caller(calldepth)
		if !ok {
			file = "???"
			line = 0
		}
		l.mu.Lock()
	}
	l.buf = l.buf[:0]
	l.formatHeader(&l.buf, now, file, line)
	l.buf = append(l.buf, s...)
	if len(s) == 0 || s[len(s)-1] != '\n' {
		l.buf = append(l.buf, '\n')
	}
	_, err := l.out.Write(l.buf)
	return err
}

有它的保证，我们也不需要考虑线程安全的问题了。

那么问题来了，fmt包打印日志是线程安全的么？println安全么？fmt和println打印日志都打印到了哪里？有兴趣的可以留言一下一起讨论。

最后

日志的打印会用到诸如fmt.Sprintf的东西，这个在实现的时候将会用到反射。反射会对性能有影响，但是不用反射的话代码过于恶心。

上面介绍的日志只是在针对输出到文件。如果你想输出有邮件、ElasticSearch等其它地方，不要在初始化的时候通过各种复杂配置参数来实现。

我说的是这样：

NewLogger("es", ...)
NewLogger("smtp", ...)

这样做的问题就是，我只能用你提供好的东西，如果想扩展只能修改日志包了。如果这个包是第三方的包，那让别人怎么扩展呢？而且这种实现也不是 Golang 的实现风格。

其实大家看看原生的这些包，很多都是通过接口串联起来的。原生的 log 包，你可以认为他提供的服务主要是流程方面的服务，拼接好要打印的内容，包括行号、时间等等，保证线程安全，然后调用Writer来打印。如果我们要把日志打印到 ES 里面，就实现一个ESWriter。这才是 Golang 风格的代码。

GitHub

完整的代码放到了 GitHub 上面，地址。欢迎大家 Star。

完整文档：godoc。

参考文献

【1】《Go 语言实战》

Golang 公共变量包——expvar

2017-06-12T00:00:00+00:00

写在前面
功能
调试接口
源码
不足
总结

写在前面

expvar包是 Golang 官方提供的公共变量包，它可以辅助调试全局变量。支持一些常见的类型：float64、int64、Map、String。如果我们的程序要用到上面提的四种类型（其中，Map 类型要求 Key 是字符串）。可以考虑使用这个包。

功能

它支持对变量的基本操作，修改、查询这些；
整形类型，可以用来做计数器；
操作都是线程安全的。这点很不错。相信大家都自己整过全局变量，除了变量还得整的锁，自己写确实挺麻烦的；
此外还提供了调试接口，/debug/vars。它能够展示所有通过这个包创建的变量；

所有的变量都是Var类型，可以自己通过实现这个接口扩展其它的类型；

 type Var interface {
     // String returns a valid JSON value for the variable.
     // Types with String methods that do not return valid JSON
     // (such as time.Time) must not be used as a Var.
     String() string
 }

Handler()方法可以得到调试接口的http.Handler，和自己的路由对接。

这些基础的功能就不多说了，大家可以直接看官方的文档。

调试接口

看源码的时候发现一个非常有意思的调试接口，/debug/vars会把所有注册的变量打印到接口里面。这个接口很有情怀。

func init() {
	http.HandleFunc("/debug/vars", expvarHandler)
	Publish("cmdline", Func(cmdline))
	Publish("memstats", Func(memstats))
}

源码

var (
	mutex   sync.RWMutex
	vars    = make(map[string]Var)
	varKeys []string // sorted
)

varKeys是全局变量所有的变量名，而且是有序的；
vars根据变量名保存了对应的数据。当然mutex就是这个 Map 的锁；

这三个变量组合起来其实是一个有序线程安全哈希表的实现。

 type Var interface {
     // String returns a valid JSON value for the variable.
     // Types with String methods that do not return valid JSON
     // (such as time.Time) must not be used as a Var.
     String() string
 }
	
 type Int struct {
     i int64
 }

 func (v *Int) Value() int64 {
     return atomic.LoadInt64(&v.i)
 }

 func (v *Int) String() string {
     return strconv.FormatInt(atomic.LoadInt64(&v.i), 10)
 }

 func (v *Int) Add(delta int64) {
     atomic.AddInt64(&v.i, delta)
 }

 func (v *Int) Set(value int64) {
     atomic.StoreInt64(&v.i, value)
 }

这个包里面的所有类型都实现了这个接口；

以 Int 类型举例。实现非常的简单，注意Add和Set方法是线程安全的。别的类型实现也一样

 func Publish(name string, v Var) {
     mutex.Lock()
     defer mutex.Unlock()
     if _, existing := vars[name]; existing {
         log.Panicln("Reuse of exported var name:", name)
     }
     vars[name] = v
     varKeys = append(varKeys, name)
     sort.Strings(varKeys)
 }
	
 func NewInt(name string) *Int {
     v := new(Int)
     Publish(name, v)
     return v
 }

将变量注册到一开始介绍的vars和varKeys里面；
注册时候也是线程安全的，所有的变量名在注册的最后排了个序；

创建对象的时候会自动注册。

 func Do(f func(KeyValue)) {
     mutex.RLock()
     defer mutex.RUnlock()
     for _, k := range varKeys {
         f(KeyValue{k, vars[k]})
     }
 }

 func expvarHandler(w http.ResponseWriter, r *http.Request) {
     w.Header().Set("Content-Type", "application/json; charset=utf-8")
     fmt.Fprintf(w, "{\n")
     first := true
     Do(func(kv KeyValue) {
         if !first {
             fmt.Fprintf(w, ",\n")
         }
         first = false
         fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)
     })
     fmt.Fprintf(w, "\n}\n")
 }

 func Handler() http.Handler {
     return http.HandlerFunc(expvarHandler)
 }

Do方法，利用一个闭包，按照varKeys的顺序遍历所有全局变量；
expvarHandler方法是http.Handler类型，将所有变量通过接口输出，里面通过Do方法，把所有变量遍历了一遍。挺巧妙；
通过http.HandleFunc方法把expvarHandler这个外部不可访问的方法对外，这个方法用于对接自己的路由；
输出数据的类型，fmt.Fprintf(w, "%q: %s", kv.Key, kv.Value)，可以发现，值输出的字符串，所以输出的内容是String()的结果。这里有一个技巧，虽然调用的字符串的方法，但是由于输出格式%s外面并没有引号，所有对于 JSON 来说，输出的内容是对象类型。相当于在 JSON 编码的时候做了一次类型转换。
```
 type Func func() interface{}

 func (f Func) Value() interface{} {
     return f()
 }

 func (f Func) String() string {
     v, _ := json.Marshal(f())
     return string(v)
 }
	
 func cmdline() interface{} {
     return os.Args
 }
```
这是一个非常有意思的写法，它可以把任何类型转换成Var类型；
Func定义的是函数，它的类型是func() interface{}
Func(cmdline)，使用的地方需要看清楚，参数是cmdline而不是cmdline()，所以这个写法是类型转换。转换完之后cmdline方法就有了String()方法，在String()方法里又调用了f()，通过 JSON 编码输出。这个小技巧在前面提到的http.HandleFunc里面也有用到，Golang 的程序员对这个是真爱，咱们编码的时候也要多用用啊。

不足

感觉这个包还是针对简单变量，比如整形、字符串这种比较好用。

前面已经说了，Map 类型只支持 Key 是字符串的变量。其它类型还得自己扩展，扩展的话锁的问题还是得自己搞。而且 JSON 编码低版本不支持 Key 是整形类型的编码，也是个问题；
Var接口太简单，只有一个String()方法，基本上只能输出变量所有内容，别的东西都没办法控制，如果你的变量有10000个键值对，那么这个接口基本上属于不能用。多说一句，这是 Golang 设计的常见问题，比如日志包，输出的类型是io.Writer，而这个接口只支持一个方法Write([]byte)，想扩展日志包的功能很难，这也失去了抽象出来一个接口的意义。
路由里面还默认追加了启动参数和MemStats内存相关参数。我个人觉得后面这个不应该加，调用runtime.ReadMemStats(stats)会引起 Stop The World，总感觉不值当。

总结

看到就写了，并没有什么沉淀，写得挺乱的。这个包很简单，但是里面还是有些可以借鉴的编码和设计。新版本的 Golang 已经能解析整形为 Key 的哈希表了，这个包啥时候能跟上支持一下？

Golang 优化之路——HTTP长连接

2017-05-31T00:00:00+00:00

写在前面
TCP 相关
HTTP 包如何使用 TCP 长连接？
我们的程序为啥长连接失效？
如何解决问题？
后续
参考文献

写在前面

压测的是否发现服务端TIME_WAIT状态的连接很多。

netstat -nat | grep :8080 | grep TIME_WAIT | wc -l   
17731

TIME_WAIT状态多，简单的说就是服务端主动关闭了TCP连接。

TCP频繁的建立连接，会有一些问题：

三次握手建立连接、四次握手断开连接都会对性能有损耗；
断开的连接断开不会立刻释放，会等待2MSL的时间，据我观察是1分钟；
大量TIME_WAIT会占用内存，一个连接实测是3.155KB。而且占用太多，有可能会占满端口，一台服务器最多只能有6万多个端口；

TCP 相关

长连接的概念包括TCP长连接和HTTP长连接。首先得保证TCP是长连接。我们就从它说起。

func (c *TCPConn) SetKeepAlive(keepalive bool) error

SetKeepAlive sets whether the operating system should send keepalive messages on the connection. 这个方法比较简单，设置是否开启长连接。

func (c *TCPConn) SetReadDeadline(t time.Time) error

SetReadDeadline sets the deadline for future Read calls and any currently-blocked Read call. A zero value for t means Read will not time out.这个函数就很讲究了。我之前的理解是设置读取超时时间，这个方法也有这个意思，但是还有别的内容。它设置的是读取超时的绝对时间。

func (c *TCPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline sets the deadline for future Write calls and any currently-blocked Write call. Even if write times out, it may return n > 0, indicating that some of the data was successfully written. A zero value for t means Write will not time out. 这个方法是设置写超时，同样是绝对时间。

HTTP 包如何使用 TCP 长连接？

http 服务器启动之后，会循环接受新请求，为每一个请求（连接）创建一个协程。

// net/http/server.go L1892
for {
	rw, e := l.Accept()
	go c.serve()
}

下面是每个协程的执行的代码，我只摘录了一部分关键的逻辑。可以发现，serve方法里面还有一个for循环。

// net/http/server.go L1320
func (c *conn) serve() {
	defer func() {
		if !c.hijacked() {
			c.close()
		}
	}()

	for {
		w, err := c.readRequest()
		
		if err != nil {
		}
		
		serverHandler{c.server}.ServeHTTP(w, w.req)
	}
}

这个循环是用来做什么的？其实也容易理解，如果是长连接，一个协程可以执行多次响应。如果只执行了一次，那就是短连接。长连接会在超时或者出错后退出循环，也就是关闭长连接。defer函数可以让协程结束之后关闭 TCP 连接。

readRequest函数用来解析 HTTP 协议。

// net/http/server.go
func (c *conn) readRequest() (w *response, err error) {
	if d := c.server.ReadTimeout; d != 0 {
		c.rwc.SetReadDeadline(time.Now().Add(d))
	}
	if d := c.server.WriteTimeout; d != 0 {
		defer func() {
			c.rwc.SetWriteDeadline(time.Now().Add(d))
		}()
	}
	
	if req, err = ReadRequest(c.buf.Reader); err != nil {
		if c.lr.N == 0 {
			return nil, errTooLarge
		}
		return nil, err
	}
}

func ReadRequest(b *bufio.Reader) (req *Request, err error) {
	// First line: GET /index.html HTTP/1.0
	var s string
	if s, err = tp.ReadLine(); err != nil {
		return nil, err
	}
	
	req.Method, req.RequestURI, req.Proto, ok = parseRequestLine(s)
	
	mimeHeader, err := tp.ReadMIMEHeader()
}

具体参与解析 HTTP 协议的部分是ReadRequest方法，而调用它之前，设置了读写超时时间。根据前面的描述，超时时间设置的是绝对时间。所以这里都是通过time.Now().Add(d)来设置的。不同的是写超时是defer执行，也就是函数返回后才执行。

我们的程序为啥长连接失效？

通过源码我们能大概知道程序流程了，按道理是支持长连接的。为啥我们的程序不行呢？

我们的程序使用的是 beego 框架，它支持的超时是同时设置读写超时。而我们的设置是1秒。

beego.HttpServerTimeOut = 1

我对读写超时的理解，读超时是收到数据到读取完毕的时间；写超时是从一开始写到写完的时间。我对这两个超时的理解都不对。

实际上，从上面的源码可以发现，写超时是读取完毕之后设置的超时时间。也就是读取完毕之后的时间，加上逻辑执行时间，加上内容返回时间的总和。按照我们的设置，超过1秒就算超时。

下面详细说说读超时。ReadRequest是堵塞执行的，如果没有用户请求，它会一直等待着。而读超时是ReadRequest之前设置的，它除了读取数据之外，还有一部分耗时，那就是等待时间。假如一直没有用户请求，此时读超时已经被设置成1秒后了，超过1秒之后，这个连接还是会被断开。

如何解决问题？

原因已经说明白了。大量TIME_WAIT是超时引起的，有可能是等待时间过长引起的读超时；也有可能是程序在压测情况下出现一部分执行超时，这样会导致写超时。

我们目前使用的是 beego 框架，它并不支持单独设置读写超时，所以我目前的解决方式是将读写超时调整得大一些。

从1.6版本开始，Golang 能够支持空闲超时IdleTimeout，可以认为读超时就是读取数据的时间，空闲超时来控制等待时间。但是它有一个问题，如果空闲超时没有设置，而读超时设置了，那么读超时还是会作为空闲超时时间来使用。我估计这么做的原因是为了向前兼容。再一个问题就是 beego 并不支持这个时间的设置，所以我目前也没有别的太好的方法来控制超时时间。

后续

其实服务端最合理的超时控制需要这几个方面：

读超时。就是单纯的读超时，不要包括等待时间，否则无法区分超时是读数据引起的还是等待引起的。
写超时。最好也是单纯的写数据超时。如果网络良好，因为逻辑执行慢就把连接断开，这样也不是很合适。读写超时都应该和目前逻辑设置的一样，设置得短一些。
空闲超时。这个可以根据实际情况配置，可以适当大一些。
逻辑超时。一般情况下是不会发生网络层面的读写超时的，压测情况下超时大部分都是由于逻辑超时引起的。Golang 原生包支持了TimeoutHandler。它可以控制逻辑的超时。可惜 beego 目前不支持设置逻辑超时。而我也没有想到太好的方法把 beego 中接入它。
```
 func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler
```

参考文献

Awesome Go

2017-05-09T00:00:00+00:00

Go 包
Go 工具

Go 包

beego。算起来用了三年beego了。当初选择用它的理由很简单，文档是中文的，开发者是中国的，交流方便。优点就是用得人较多，框架集成度高，工具比较多。不过从1.6开始兼容性大大降低开始对它无感。现在越来越觉得beego框架设计的太重，Golang的设计特点就是轻便，把各个功能包组装起来用。比如配置它的config包，不用又不行，因为框架启动就会调用。最近大家都在推荐gin，有兴趣可以试试。
beego/logs。日志包一直在用beego内置的logs包。它有一个特点就是支持日志自动分割，可以按行数分割或者按日期分割。目前还没有发现支持此功能别的日志包，有的话大家给我推荐一下。
beego/orm。我的服务对数据库操作很少，orm只是简单用用。之前还用过grop和xorm。Golang主要是用来做接口，对于数据库操作都比较简单，orm高级操作基本用不到。所以对我来说这些orm功能都差不多。。。
redigo。连Redis必备。功能很完善。
goquery。用来解析HTML。开发爬虫都会用到它。
goreq。一个HTTP请求包。之前会用它是因为它支持Gzip压缩。
viper。一个配置包。支持解析各种格式的配置文件，最让我惊喜的是它支持etcd。
gods。各种数据结构的Golang实现。这些代码生产环境没有直接用到过，不过自己写的时候可以借鉴一下。
ffjson。根据Golang的结构体自动生成MarshalJSON方法从而避免原生包通过反射编码引起的垃圾回收的问题。
godep。说实话Golang对包管理不太友好。有一个项目用了godep来做版本管理，每次都要执行好多命令真是麻烦。Golang新版内置包管理了，这个可以放弃使用了。
bitset。这个包已经在生产环境使用了，它是Bitmap的Golang实现。底层用uint64切片保存数据。性能是内置map的40倍。
jobrunner。一个Crontab包。beego内置的Crontab包之前有bug，只能找个新的。我关注这个的包的时候才100个Star，不过好在好用。

Go 工具

Cleaner Go。代码检测相关不错的文章。
- 静态代码检测 staticcheck.exe $(glide.exe nv)
- 无用代码检测 unused.exe $(glide.exe nv)
- 代码简化建议 gosimple.exe $(glide.exe nv)
- 原生检测 go vet
gojson。一个工具，可以通过Json格式的文本生成Golang结构体代码。

会持续更新。

Golang 优化之路——空结构

2017-04-11T00:00:00+00:00

写在前面
空对象
hashset
性能比较
结论
后续
参考文献

写在前面

开发 hashset 常用的套路：

map[int]int8
map[int]bool

我们一般只用 map 的键来保存数据，值是没有用的。所以来缓存集合数据会造成内存浪费。

空对象

空对象是个神奇的东西。它指的是没有字段的结构类型。

type Q struct{}

它牛逼的地方在于：

可以和普通结构一样操作

  var a = []struct{}{struct{}{}}
  fmt.Println(len(a)) // prints 1

不占用空间

  var s struct{}
  fmt.Println(unsafe.Sizeof(s)) // prints 0

声明两个空对象，它们指向同一个地址

  type A struct{}
  a := A{}
  b := A{}
  fmt.Println(&a == &b) // prints true

造成这个结果的原因是 Golang 的编译器会把这种空对象都当成runtime.zerobase处理。

var zerobase uintptr

hashset

有了上面的介绍，就可以利用空结构来优化 hashset 了。

var itemExists = struct{}{}

type Set struct {
	items map[interface{}]struct{}
}

func New() *Set {
	return &Set{items: make(map[interface{}]struct{})}
}

func (set *Set) Add(item interface{}) {
	set.items[item] = itemExists
}

func (set *Set) Remove(item interface{}) {
	delete(set.items, item)
}

func (set *Set) Contains(item interface{}) bool {
	if _, contains := set.items[item]; !contains {
		return false
	}
	return true
}

一个简易的 hashset 实现就完成了。

性能比较

func BenchmarkIntSet(b *testing.B) {
	var B = NewIntSet(3)
	B.Set(10).Set(11)
	for i := 0; i < b.N; i++ {
		if B.Exists(1) {

		}
		if B.Exists(11) {

		}
		if B.Exists(1000000) {

		}
	}
}

func BenchmarkMap(b *testing.B) {
	var B = make(map[int]int8, 3)
	B[10] = 1
	B[11] = 1
	for i := 0; i < b.N; i++ {
		if _, exists := B[1]; exists {

		}
		if _, exists := B[11]; exists {

		}
		if _, exists := B[1000000]; exists {

		}
	}
}

BenchmarkIntSet-2       50000000                35.3 ns/op             0 B/op          0 allocs/op
BenchmarkMap-2          30000000                41.2 ns/op             0 B/op          0 allocs/op

结论

性能，有些提升，但不是特别明显。尤其是线上压力不大的情况性能应该不会有明显变化；
内存占用。我们的服务缓存较多、占用内存较大，通过这个优化实测可以减少 1.6 GB 的空间。不过这个优化的空间取决于数据量。

后续

前面有个例子：

var a, b struct{}
fmt.Println(&a == &b) // true

从 Go1.6 开始输出的结果有了变化，之前是true，现在是false。

官方的解释：

Pointer values are comparable. Two pointer values are equal if they point to the same variable or if both have value nil. Pointers to distinct zero-size variables may or may not be equal.

不过这个处理并不影响对于空结构体的使用。官方对于空指针相等的判断进行了修改，至于原因并没有给出详细的解释。

参考文献

【1】The empty struct - Dave Cheney
【2】gods - emirpasic
【3】《Go 语言学习笔记》 - 雨痕。5.5 结构。

jsonfield——动态输出 Json 内容

2017-04-05T00:00:00+00:00

jsonfield
安装
使用
反馈

jsonfield

它能够动态输出指定字段，开发简单。我将它用于通过接口调试数据时使用。

安装

go get -v github.com/mnhkahn/jsonfield

使用

type A struct {
	A int
	B int
}

jj := new(A)
jj.A, jj.B = 111, 222

byts, err := Marshal(jj) // {"A":111,"B":222}

byts, err := Marshal(jj, "A") // {"A":111}

byts, err := Marshal(jj, "B") // {"B":222}

反馈

如果有疑问或者建议，可以通过微信联系我或者在 Github 里面提 Issue。

我常用的开发工具

2017-03-27T00:00:00+00:00

vagrant
SecureCRT
json.cn
heroku
Everything
WEB前端助手(FeHelper)
tampermonkey
ShadowSocks
Proxifier
Wingy

工具清单很多人都列过，我也来说说我的，看看对你有没有帮助。

vagrant

你有没有在 Windows 下面开发程序手动编译 C 程序的苦恼？你有没有因为 Windows 缺少 Linux shell 脚本无法痛快得使用命令的烦恼？你有没有换台电脑重新搭建开发环境的烦恼？vagrant 通通帮你排忧解难。

对我来说，在 Linux 环境下面开发是非常重要的。尝试过 N 种方法。安过虚拟机，太卡；用过 Powershell，太挫；后来用上了MobaXterm，这个用了很长时间，算是比较接近 Linux 环境的了，但是它还是基于封装 Powershell，差那么点意思。最后用上了 vagrant，一直用到了现在。

vagrant 也是基于 Virtualbox 的虚拟机。但是算是简化版，运行很流畅。对于虚拟机还有一点非常重要，就是 Windows 和虚拟机之间代码的同步，Windows 下面通过 IDE 编码，虚拟机里面编译、调试、运行程序。用它来搭建一整套开发环境要比自己动手方便很多。还有就是软件的安装，类似于 Ubuntu 的方式，安装命令可以通过 apt-get 搞定。

安装教程《Go实战开发——Vagrant安装配置》

系统开机之后需要 cd 到 vagrant 的目录执行 vagrant up 来启动虚拟机。它也不是那么完美，有时虚拟机会死掉，可以执行 vagrant reload 重启一下。

通过 SSH 的方式登录虚拟机，我一般都是用 SecureCRT。

SecureCRT

这个不用多说，基本上都是标配。我就说一个大家可能不了解的小功能：文件的上传和下载。一般如果向 Linux 服务器传文件，都是通过 FileZilla 这种工具，通过 FTP 协议来传输。实际上 SecureCRT 内置了文件传输工具。rz 可以帮助从本地上传文件到服务器；sz 可以从服务器下载文件到本地。

json.cn

一般数据传输都免不了用到 JSON 格式。我一般都是用 json.cn 来帮我格式化。感觉用这个操作步骤能少一些。其实我也没有正经数过^ ^。

heroku

免费又支持 Golang ，并且国内能访问的 PaaS 服务，我只知道 heroku 了。我的网站首页就放在这个上面。

它通过提交代码的方式来部署代码 git push heroku master。

需要安装 CLI 工具来辅助初始化和部署。安装可以参考其官方文档。其实访问速度也一般啦，开发小工具玩玩就好。

Everything

据说这是用 Windows 的唯一理由。用它来查找文件要比原生的快很多。

下载地址

WEB前端助手(FeHelper)

JSON 格式化插件大家肯定都安装了，大部分都是用的JSONView。我推荐一下狼长的FeHelper。在格式化 JSON 的时候这个工具可以帮助计算对象长度，比如它可以展示数组的长度。功能很简单是吧，但是我只知道这个工具有这个功能。

tampermonkey

一直在用 Chrome，也一直想开发个插件工具类的东西。但是开发一个完整的插件对我来说成本还是很高的。Tampermonkey是个浏览器插件，支持运行自定义脚本。这使得我可以高效得开发一些趁手的工具。我在公司就开发了一个检测页面调试信息的工具。

我还开发了一个 rarbg 页面翻工具，下载地址。不过接口那边缓存还有问题，大家多刷几次。。。

ShadowSocks

现在科学上网的成本是越来越高了，还是花钱靠谱一些。这个我已经用了两年了，支持支付宝，还是挺不错的。支持这个协议的客户端也比较多。好了，说这么多无非就是想放一个我的推荐链接，好像你用这个注册可以减免一个月的费用。

Proxifier

用 ShadowSocks 只能解决网页的问题，如果要在命令行也能使用，Windows 得用这个工具。

Wingy

这是最近发现的神器，算是 Shadowrocket 的免费版。这个可以在 iOS 系统上把 SS 协议转成 VPN，实现全局代理。它还支持自动路由。

下载地址。

Golang 通过fmt包输出完整struct信息

2017-03-06T00:00:00+00:00

结论
后续

通过fmt调试，是非常常见的做法，打印一个对象，我一直都是在用

fmt.Println(a)

或者

fmt.Printf("%v", a)

打印复杂对象不能用内置的println，这个只会打印出来指针，看不到内容。而上面两种方式是可以打印结构体内容的，但是没有值对应的名字。

func main() {
	a := new(AAA)
	a.A = "Hello"
	fmt.Println(a)
}

type AAA struct {
	A string
}

结果：

&{Hello}

如果结构很复杂，内部变量很多，多个值之间只会通过空格分隔，而且如果有的值是空字符串，这就是一件非常尴尬的事情了，肉眼根本就看不出来有一个空格。

所以我一直的方法就是把结构体通过Json编码，再输出。现在想想真蠢。

fmt包内置的方法，本来就可以展示类似Json的形式，没必要自己瞎搞。把上面的输出代码改了：

fmt.Printf("%+v\n", a)

结果：

&{A:Hello}

就是这么简单。

查看源码，fmt/print.go的926行：

if p.fmt.plusV || p.fmt.sharpV {
	if f := t.Field(i); f.Name != "" {
		p.buf.WriteString(f.Name)
		p.buf.WriteByte(':')
	}
}
p.printValue(getField(v, i), verb, depth+1)

通过反射拿到变量的Name，printValue方法也是通过反射拿到值，最后打印。这里就不展开说了。

结论

其实这个东西没多高端，官方文档上来就介绍了。想起来每次调试都那么费尽，以后还是得多看看这些。温故而知新，可以为师矣。

%v the value in a default format when printing structs, the plus flag (%+v) adds field names

后续

Go 的官方问题有个小缺陷就是太精简了，很多东西说明不是那么细致。今天看到一篇文章，详细说明了格式化输出的写法，How to format anything (string, number or arbitrary data) with fmt。

完整介绍 Golang 格式化输出：fmt 如何进行格式化？

Golang 优化之路——临时对象池

2017-02-08T00:00:00+00:00

写在前面
堆还是栈？
内存碎片化
临时对象池
结论

写在前面

在高并发的情况下，如果每次请求都需要申请一块用于计算的内存，比如：

make([]int64, 0, len(ids))

将会是一件成本很高的事情。为了定位项目中的慢语句，我曾经采用“二分法”的方式打印慢日志，定位程序变慢的代码位置。它并不是每次都慢，而是每过几秒钟就突然变得极其慢，TPS能从2000降到200。引起这个问题就是类似于上面这条语句。

初始化一个slice，初学者会用：

make([]int64, 0)

高级一些的程序员都会知道，这样第一次分配内存相当于没有分配，如果要后续append元素，会引起slice以指数形式扩充，可以参考下面的代码，追加了3个元素，slice扩容了3次。

a := make([]int64, 0)
fmt.Println(cap(a), len(a))

for i := 0; i < 3; i++ {
	a = append(a, 1)
	fmt.Println(cap(a), len(a))
}

0 0
1 1
2 2
4 3

每一次扩容空间，都是会重新申请一块区域，把就空间里面的元素复制进来，把新的追加进来。那旧空间里面的元素怎么办？等着垃圾回收呗。

简单的优化方式，就是给自己要用的slice提前申请好空间，类似于最开头的那行代码。

make([]int64, 0, len(ids))

这样做避免了slice多次扩容申请内存，但还是有问题的。

堆还是栈？

程序会从操作系统申请一块内存，而这块内存也会被分成堆和栈。栈可以简单得理解成一次函数调用内部申请到的内存，它们会随着函数的返回把内存还给系统。

func F() {
	temp := make([]int, 0, 20)
	...
}

类似于上面代码里面的temp变量，只是内函数内部申请的临时变量，并不会作为返回值返回，它就是被编译器申请到栈里面。申请到栈内存好处：函数返回直接释放，不会引起垃圾回收，对性能没有影响。

func F() []int{
	a := make([]int, 0, 20)
	return a
}

而上面这段代码，申请的代码一模一样，但是申请后作为返回值返回了，编译器会认为变量之后还会被使用，当函数返回之后并不会将其内存归还，那么它就会被申请到堆上面了。申请到堆上面的内存才会引起垃圾回收。

那么考考大家，下面这三种情况怎么解释？

func F() {
	a := make([]int, 0, 20)
	b := make([]int, 0, 20000)

	l := 20
	c := make([]int, 0, l)
}

a和b代码一样，就是申请的空间不一样大，但是它们两个的命运是截然相反的。a前面已经介绍过，会申请到栈上面，而b，由于申请的内存较大，编译器会把这种申请内存较大的变量转移到堆上面。即使是临时变量，申请过大也会在堆上面申请。

而c，对我们而言其含义和a是一致的，但是编译器对于这种不定长度的申请方式，也会在堆上面申请，即使申请的长度很短。

可以通过下面的命令查看变量申请的位置。详细内容可以参考我之前的文章《【译】优化Go的模式》

go build -gcflags='-m' . 2>&1

内存碎片化

实际项目基本都是通过c := make([]int, 0, l)来申请内存，长度都是不确定的。自然而然这些变量都会申请到堆上面了。Golang使用的垃圾回收算法是『标记——清除』。简单得说，就是程序要从操作系统申请一块比较大的内存，内存分成小块，通过链表链接。每次程序申请内存，就从链表上面遍历每一小块，找到符合的就返回其地址，没有合适的就从操作系统再申请。如果申请内存次数较多，而且申请的大小不固定，就会引起内存碎片化的问题。申请的堆内存并没有用完，但是用户申请的内存的时候却没有合适的空间提供。这样会遍历整个链表，还会继续向操作系统申请内存。这就能解释我一开始描述的问题，申请一块内存变成了慢语句。

临时对象池

如何解决这个问题，首先想到的就是对象池。Golang在sync里面提供了对象池Pool。一般大家都叫这个为对象池，而我喜欢叫它临时对象池。因为每次垃圾回收会把池子里面不被引用的对象回收掉。

func (p *Pool) Get() interface{}

Get selects an arbitrary item from the Pool, removes it from the Pool, and returns it to the caller. Get may choose to ignore the pool and treat it as empty. Callers should not assume any relation between values passed to Put and the values returned by Get.

需要注意的是，Get方法会把返回的对象从池子里面删除。所以用完了的对象，还是得重新放回池子。

很快，我写出了第一版对象池优化方案：

var idsPool = sync.Pool{
	New: func() interface{} {
		ids := make([]int64, 0, 20000)
		return &ids
	},
}

func NewIds() []int64 {
	ids := idsPool.Get().(*[]int64)
	*ids = (*ids)[:0]
	idsPool.Put(ids)
	return *ids
}

这样的实现，是把所有slice都放到同一个池子里面了。为了应对变长的问题，都是按照一个较大的值申请的变量。虽然是一种优化，但是使用超大的slice计算，性能并没有怎么提升。

紧接着参考了达达大神的代码sync_pool.go，又写了一版：

var DEFAULT_SYNC_POOL *SyncPool

func NewPool() *SyncPool {
	DEFAULT_SYNC_POOL = NewSyncPool(
		5,     
		30000, 
		2,     
	)
	return DEFAULT_SYNC_POOL
}

func Alloc(size int) []int64 {
	return DEFAULT_SYNC_POOL.Alloc(size)
}

func Free(mem []int64) {
	DEFAULT_SYNC_POOL.Free(mem)
}

// SyncPool is a sync.Pool base slab allocation memory pool
type SyncPool struct {
	classes     []sync.Pool
	classesSize []int
	minSize     int
	maxSize     int
}

func NewSyncPool(minSize, maxSize, factor int) *SyncPool {
	n := 0
	for chunkSize := minSize; chunkSize <= maxSize; chunkSize *= factor {
		n++
	}
	pool := &SyncPool{
		make([]sync.Pool, n),
		make([]int, n),
		minSize, maxSize,
	}
	n = 0
	for chunkSize := minSize; chunkSize <= maxSize; chunkSize *= factor {
		pool.classesSize[n] = chunkSize
		pool.classes[n].New = func(size int) func() interface{} {
			return func() interface{} {
				buf := make([]int64, size)
				return &buf
			}
		}(chunkSize)
		n++
	}
	return pool
}

func (pool *SyncPool) Alloc(size int) []int64 {
	if size <= pool.maxSize {
		for i := 0; i < len(pool.classesSize); i++ {
			if pool.classesSize[i] >= size {
				mem := pool.classes[i].Get().(*[]int64)
				// return (*mem)[:size]
				return (*mem)[:0]
			}
		}
	}
	return make([]int64, 0, size)
}

func (pool *SyncPool) Free(mem []int64) {
	if size := cap(mem); size <= pool.maxSize {
		for i := 0; i < len(pool.classesSize); i++ {
			if pool.classesSize[i] >= size {
				pool.classes[i].Put(&mem)
				return
			}
		}
	}
}

调用例子：

attrFilters := cache.Alloc(len(ids))
defer cache.Free(attrFilters)

重点在Alloc方法。为了能支持变长的slice，这里申请了多个池子，其大小是从5开始，最大到30000，以2为倍数。也就是5、10、20……

DEFAULT_SYNC_POOL = NewSyncPool(
	5,     
	30000, 
	2,     
)

分配内存的时候，从池子里面找满足容量切最小的池子。比如申请长度是2的，就分配大小为5的那个池子。如果是11，就分配大小是20的那个池子里面的对象；
如果申请的slice很大，超过了上限30000，这种情况就不使用池子了，直接从内存申请；
当然这些参数可以根据自己实际情况调整；
和之前的做法有所区别，把对象重新放回池子是通过Free方法实现的。

结论

为了优化接口，前前后后搞了一年。结果还是不错的，TPS提升了最少30%，TP99也降低很多。

Golang 优化之路——Cantor pair

2017-02-07T00:00:00+00:00

写在前面
Cantor pairing function 简介
Example
实现
与其它数据结构的对比
结论
GitHub

写在前面

某一种对象是通过两个ID唯一确定的，如何处理这种数据结构以便快速查找以及节约内存？先说一种笨方法——用字符串来处理。这是比较容易想到的（我觉得一般最容易想到的也是最简单粗暴的方法都是用字符串来搞搞搞）。

fmt.Sprintf("%d_%d", id1, id2)

这样就成了。存储的时候用字符串来保存，查询比较的时候用字符串的方法来计算。当然，把数字当作字符串来保存和计算本身就是极其浪费内存和CPU的。

Cantor pairing function 简介

康托尔配对 - Cantor pairing function，是一种将两个自然数转成唯一一个自然数的方法。具体原理我就不说了，我也看不懂。。。简单地说：

只支持自然数。自然数是整数（自然数包括正整数和零）；
支持反解；
f(k1, k2)和f(k2, k1)得到的结果是不同的。当然，如果你想得到相同的也是可以的，计算支持把两个数字排个序；
计算结果有可能比k1和k2都大很多，需要注意溢出的问题。

Example

这个算法只有一个公式，实现起来很容易。我索性自己造了一个轮子，pairing。公式的推导请移步维基百科。

import "github.com/mnhkahn/pairing"

pair := pairing.Encode(k1, k2)

k3, k4 := pairing.Decode(pair2)

支持正向编码以及反向解码。

实现

import "math"

func Encode(k1, k2 uint64) uint64 {
	pair := k1 + k2
	pair = pair * (pair + 1)
	pair = pair / 2
	pair = pair + k2

	return pair
}

func Decode(pair uint64) (uint64, uint64) {
	w := math.Floor((math.Sqrt(float64(8*pair+1)) - 1) / 2)
	t := (w*w + w) / 2

	k2 := pair - uint64(t)
	k1 := uint64(w) - k2
	return k1, k2
}

与其它数据结构的对比

其中一个要对比的就是和前面说的字符串的比较。还有一种代替方案：两个整数int32，这64位数字拼接一个int64里面，第一个数字占前32位，后一个数字占后32位，也是一个可行的方案。我们可以把这个方法叫做bit方法。

func EncodeBit(k1, k2 uint32) uint64 {
	pair := uint64(k1)<<32 | uint64(k2)
	return pair
}

func DecodeBit(pair uint64) (uint32, uint32) {
	k1 := uint32(pair >> 32)
	k2 := uint32(pair) & 0xFFFFFFFF
	return k1, k2
}

实现起来更简单。那和Cantor pair相比性能怎么样呢？

import (
	"fmt"
	"testing"
)

var TEST_PAIRS = [][]uint64{
	[]uint64{0, 0},
	[]uint64{0, 1},
	[]uint64{1, 0},
}

var TEST_RESs = []uint64{
	0,
	2,
	1,
}

var TEST_RESBits = []uint64{
	0,
	1,
	4294967296,
}

func TestPair(t *testing.T) {
	for i, p := range TEST_PAIRS {
		a, b := p[0], p[1]
		if pair := Encode(a, b); pair != TEST_RESs[i] {
			t.Error(a, b, pair)
		}
	}

	for i, p := range TEST_PAIRS {
		a, b := p[0], p[1]
		pair := TEST_RESs[i]
		if x, y := Decode(pair); x != a || y != b {
			t.Error(a, b, pair)
		}
	}

	fmt.Println(Encode(559, 83792))

	for i, p := range TEST_PAIRS {
		a, b := uint32(p[0]), uint32(p[1])
		if pair := EncodeBit(a, b); pair != TEST_RESBits[i] {
			t.Error(a, b, pair)
		}
	}

	for i, p := range TEST_PAIRS {
		a, b := uint32(p[0]), uint32(p[1])
		pair := TEST_RESBits[i]
		if x, y := DecodeBit(pair); x != a || y != b {
			t.Error(a, b, pair)
		}
	}

	fmt.Println(EncodeBit(559, 83792))
}

func BenchmarkEncode(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Encode(559, 83792)
	}
}

func BenchmarkDecode(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Decode(3557671568)
	}
}

func BenchmarkEncodeBit(b *testing.B) {
	for i := 0; i < b.N; i++ {
		EncodeBit(559, 83792)
	}
}

func BenchmarkDecodeBit(b *testing.B) {
	for i := 0; i < b.N; i++ {
		DecodeBit(2400886802256)
	}
}

func BenchmarkEncodeStr(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = fmt.Sprintf("%d_%d", 559, 83792)
	}
}

/*
go test -bench=. -benchmem
BenchmarkEncode-2       2000000000               0.37 ns/op            0 B/op          0 allocs/op
BenchmarkDecode-2       50000000                26.9 ns/op             0 B/op          0 allocs/op
BenchmarkEncodeBit-2    2000000000               0.37 ns/op            0 B/op          0 allocs/op
BenchmarkDecodeBit-2    2000000000               0.37 ns/op            0 B/op          0 allocs/op
BenchmarkEncodeStr-2     5000000               271 ns/op              32 B/op          3 allocs/op
*/

结论

用字符串保存的性能最差，剩余两个是这个性能的400倍；
Cantor pair和bit方法的性能相当，反解的时候性能还查一些；
既然性能相当，虽然本文着重介绍的是Cantor pair算法，但我还是建议，如果bit方法能满足你的需求，尤其是数字范围较小的时候，还是用这个比较好。简单的方法在维护方面会让你更加得心应手，即使你懂那些复杂的公式是如何推导出来的^ ^。

GitHub

我把代码整理了一下，放到了 GitHub 上面，欢迎 Star。

Swiftype的Golang API 发布！

2017-01-19T00:00:00+00:00

写在前面

我是一个Golang程序员，基本上我所有的东西都是用Go开发的。前不久想给我的个人网站接入搜索功能，使用了Swiftype这个工具。然而我发现它并没有Golang的API工具包。在GitHub上面找了一个包，却发现有bug不能用，遂自己fork了代码搞一套。

源码地址：https://github.com/mnhkahn/swiftype

安装

go get -v gopkg.in/mnhkahn/swiftype.v1

文档

文档可以在godoc上面查看。目前只支持搜索方法，因为我这边也只用这个，如果未来我这边有别的API需求，会考虑更新。

type Client

type SwiftypeResult

例子

SWIFTYPE := *swiftype.Client
SWIFTYPE_APIKEY := "YOUR OWN API KEY"
SWIFTYPE_HOST := "api.swiftype.com"
SWIFTYPE_ENGINE := "YOUR OWN ENGINE"

SWIFTYPE := swiftype.NewClientWithApiKey(SWIFTYPE_APIKEY, SWIFTYPE_HOST)

data, err := SWIFTYPE.Search(SWIFTYPE_ENGINE, q)
if err != nil {
    panic(err)
}
_ = data

Golang 优化之路——bitset

2017-01-18T00:00:00+00:00

写在前面
bitset 简介
Example
实现原理
与其它数据结构的对比
结论

写在前面

开发过程中会经常处理集合这种数据结构，简单点的处理方法都是使用内置的map实现。但是如果要应对大量数据，例如，存放大量电话号码，使用map占用内存大的问题就会凸显出来。内存占用高又会带来一些列的问题，这里就不展开说了。还有就是，大量数据存放于map，查找的哈希算法消耗也会很高。这时就该考虑对数据结构进行优化。之前浏览awesome-go时发现了一种叫bitset的数据结构，今天就介绍一下它。

bitset 简介

首先这是一个数据结构。从名字set不难发现，这是一个集合的数据结构。bit的含义也比较好懂，通过set是通过bit实现的。如果你需要一个集合，正好集合内的元素都是正整数，那么用这个就没错了。

注：biset 有时也会被叫做 Bitmap。

Example

import "github.com/willf/bitset"

var b bitset.BitSet // 定义一个BitSet对象
b.Set(10).Set(11) // 给这个set新增两个值10和11
if b.Test(1000) { // 查看set中是否有1000这个值（我觉得Test这个名字起得是真差劲，为啥不叫Exist）
	b.Clear(1000) // 情况set
}
for i,e := v.NextSet(0); e; i,e = v.NextSet(i + 1) { // 遍历整个Set
   fmt.Println("The following bit is set:",i);
}
if B.Intersection(bitset.New(100).Set(10)).Count() > 1 { // set求交集
	fmt.Println("Intersection works.")
}

这个包功能已经非常完善了，完整的文档可以参考它的godoc。我使用这些包，除了看重基础功能（对于集合，就是增删改查这些），还有就是得方便调试。bitset内部保存数字都是按位存的，如果调试的时候是把bitset的内部数据给我看，我也是看不懂的，还好这个包提供了String()方法，可以把我设置的数据已字符串的形式返回，棒棒哒。

实现原理

研究一下实现原理才是我的Style。大概说一下原理。正整数集合可以都放到一个大的整数里面，用位来表示数字。比如1001就可以表示0和2这两个数字。用一个bit代替了一个int，可以大大降低内存的占用。但是一个整数最大也就64位，也就是说最大表示的数字就是64了，所以可以通过多个int拼接的形式来表示大整数。

bitset的内部数据结构，很亲切有木有：

type BitSet struct {
	length uint // set的大小
	set    []uint64 // 这个就会被用来表示一个大整数
}

通过下面的测试代码对于内部实现一探究竟：

var b bitset.BitSet // 定义一个BitSet对象
fmt.Println(b.Bytes())
b.Set(0)
fmt.Println(b.Bytes(),0)
b.Set(10) // 给这个set新增两个值10
fmt.Println(b.Bytes(),0,10)
b.Set(64)
fmt.Println(b.Bytes(),0,10,64)
if b.Test(1000) { // 查看set中是否有1000这个值（我觉得Test这个名字起得是真差劲，为啥不叫Exist）
	b.Clear(1000) // 情况set
}

输出：

[]
[1] 0
[1025] 0 10
[1025 1] 0 10 64

新建的bitset，set是空[]
放入了一个0，用第一位表示，也就是0x00000001
放入了10，内部结构0x00000041
放入了64，这个时候一个整数已经存不下了，内部结构是0x00000041和0x00000001。set这个数组里面，从前往后表示的数据依次增加，但是在uint64内部，是从低位开始，低位表示小的数。

与其它数据结构的对比

表示正整数的集合，Golang有很多种方式，自带的map就可以，当然这是最差的一种选择，首先就是内存的浪费，其次是每次查找还涉及到hash计算，虽然理论上hashmap的复杂度是O(1)，实际上跟bitset比完全就是渣渣。此外，bitset都得升级版roaring也是不错的选择。如果你要保存的数据是10000000000这种级别的，那么用bitset就会存在低位浪费内存的情况，roaring可以用来压缩空间。

import (
	"testing"

	"github.com/RoaringBitmap/roaring"
	"github.com/willf/bitset"
)

func BenchmarkMap(b *testing.B) {
	var B = make(map[int]int8, 3)
	B[10] = 1
	B[11] = 1
	for i := 0; i < b.N; i++ {
		if _, exists := B[1]; exists {

		}
		if _, exists := B[11]; exists {

		}
		if _, exists := B[1000000]; exists {

		}
	}
}

func BenchmarkBitset(b *testing.B) {
	var B bitset.BitSet
	B.Set(10).Set(11)
	for i := 0; i < b.N; i++ {
		if B.Test(1) {

		}
		if B.Test(11) {

		}
		if B.Test(1000000) {

		}
	}
}

func BenchmarkRoaring(b *testing.B) {
	for i := 0; i < b.N; i++ {
		B := roaring.BitmapOf(10, 11)
		if B.ContainsInt(1) {

		}
		if B.ContainsInt(11) {
		}
		if B.ContainsInt(1000000) {

		}

	}
}

$ go test -bench=.* -benchmem 

BenchmarkMap-2          50000000                28.4 ns/op             0 B/op          0 allocs/op
BenchmarkBitset-2       2000000000               1.86 ns/op            0 B/op          0 allocs/op
BenchmarkRoaring-2       3000000               492 ns/op             152 B/op          6 allocs/op

结论

如果是比较连续的非负整数，推荐用bitset解决集合的问题。当然具体问题具体分析。

本文所涉及到的完整源码请参考。

【译】GOPATH的默认值

2017-01-09T00:00:00+00:00

从Go 1.8开始，如果GOPATH的环境变量为空，Go将会设置一个默认的GOPATH环境变量。

Go初学者第一次安装完Go之后，他们往往会因为忘记设置GOPATH环境变量而得到you have to set a GOPATH这样的错误。这个需求的优先级逐渐变高。对于Go的新用户来说，解释GOPATH的作用、指导他们如何设置GOPATH将会使它们不能专注使用Go。尤其是有些时候，这些人并不是要去使用Go语言去开发，而是使用go get去下载一些必要的命令。

Go 1.8将会设置默认的GOPATH。如果你自己没有设置GOPATH，Go将会使用默认值。默认GOPATH是：

在Unix-like系统上是在$HOME/go目录下
在Windows系统下是%USERPROFILE%\go

虽然已经有了默认的GOPATH，但是它并不能解决所有问题：

我们还是得自己把$GOPATH/bin添加到PATH里面，这样通过go get和go install`安装的二进制程序才能够被直接运行。（译者注：当然，通过绝对路径运行这些程序也是可以的，只不过比较麻烦）。
Go语言的开发者依然需要了解GOPATH的作用和它的目录结构。
如果你的GOROOT路径（就是你让Go源码的位置）和默认的GOPATH是一样的，并且你并没有设置一个默认的GOPATH，Go也并不为为你设置默认GOPATH，因为这样会把GOROOT里面的内容搞乱。

当你有疑问的时候，可以运行命令go env GOPATH来检查GOPATH的路径。如果有问题，比如上面说的情况，Go并没有自动生成GOPATH，这个命令将会打印空。

阅读原文The default GOPATH

【译】Golang中使用『弃用(Deprecate)』

2016-12-12T00:00:00+00:00

Go语言很长时间都没有一套标记弃用API的定义规范。这几年，出现了个规范可以在文档当中添加弃用注释。

现在，标准库开始使用这个格式了。

举个例子，Go 1.8的包中sql/driver.Execer被弃用，这里增加了一套注释，它可以被godoc识别。

// Execer is an optional interface that may be implemented by a Conn.
//
// If a Conn does not implement Execer, the sql package's DB.Exec will
// first prepare a query, execute the statement, and then close the
// statement.
//
// Exec may return ErrSkip.
//
// Deprecated: Drivers should implement ExecerContext instead (or additionally).
type Execer interface {
	Exec(query string, args []Value) (Result, error)
}

弃用的通知会出现在godoc里面，注释需要以Deprecated开头，后面再写上代替此API的提示。

// Deprecated: Use strings.HasPrefix instead.

使用API的用户就可以根据这个提示使用新的API了。

Additional to the notices, there is an effort going on to discourage users to keep depending on the deprecated APIs. 除了注释通知之外，还可以有一些方法来阻止用户一直使用被弃用的API。

可以参考下面的文章:

总之，可以使用这个注释格式来支持弃用通知。不要用DEPRECATED或者This type is deprecated。将来，你可以用一些工具来通知用户停止使用弃用的API。

阅读原文Deprecating things in Go

【译】Go工具要点

2016-09-27T00:00:00+00:00

你是刚开始使用Go工具么？或者你想扩展知识？这篇文章将会描述每个人都需要知道的Go工具参数。

免责声明：这篇文章可能会有些偏见。这篇文章描述了我个人会用到的Go工具参数，还有一些是我周围的人遇到的问题。如果你还有别的想法，在Twitter联系我。

$ go build -x

-x会列出来go build调用到的所有命令。

如果你对Go的工具链好奇，或者使用了一个跨C编译器，并且想知道调用外部编译器用到的具体参数，或者怀疑链接器有bug；使用-x来查看所有调用。

$ go build -x
WORK=/var/folders/00/1b8h8000h01000cxqpysvccm005d21/T/go-build600909754
mkdir -p $WORK/hello/perf/_obj/
mkdir -p $WORK/hello/perf/_obj/exe/
cd /Users/jbd/src/hello/perf
/Users/jbd/go/pkg/tool/darwin_amd64/compile -o $WORK/hello/perf.a -trimpath $WORK -p main -complete -buildid bbf8e880e7dd4114f42a7f57717f9ea5cc1dd18d -D _/Users/jbd/src/hello/perf -I $WORK -pack ./perf.go
cd .
/Users/jbd/go/pkg/tool/darwin_amd64/link -o $WORK/hello/perf/_obj/exe/a.out -L $WORK -extld=clang -buildmode=exe -buildid=bbf8e880e7dd4114f42a7f57717f9ea5cc1dd18d $WORK/hello/perf.a
mv $WORK/hello/perf/_obj/exe/a.out perf

$ go build -gcflags

这个参数将会传递给编译器。go tool compile -help列出来了所有我们可以传递给编译器的参数。

例如，禁用编译器优化和内联优化，你可以使用下面的参数：

$ go build -gcflags="-N -I"

$ go test -v

这个命令可以为测试提供完整的输出。它会打印测试名称、状态（成功或者失败）、测试所耗费的时间，还有测试的日志等等。

如果不使用-v参数来测试，输出很少很多，我经常使用-v参数来打开详细测试日志。例子：

$ go test -v context
=== RUN   TestBackground
--- PASS: TestBackground (0.00s)
=== RUN   TestTODO
--- PASS: TestTODO (0.00s)
=== RUN   TestWithCancel
--- PASS: TestWithCancel (0.10s)
=== RUN   TestParentFinishesChild
--- PASS: TestParentFinishesChild (0.00s)
=== RUN   TestChildFinishesFirst
--- PASS: TestChildFinishesFirst (0.00s)
=== RUN   TestDeadline
--- PASS: TestDeadline (0.16s)
=== RUN   TestTimeout
--- PASS: TestTimeout (0.16s)
=== RUN   TestCanceledTimeout
--- PASS: TestCanceledTimeout (0.10s)
...
PASS
ok  	context	2.426s

$ go test -race

现在可以使用Go工具提供的-race参数进行竞争检测。它会检测并报告竞争。开发的过程中用这个命令来检测一下。

注：完整的命令是：

$ go test -race mypkg    // to test the package
$ go run -race mysrc.go  // to run the source file
$ go build -race mycmd   // to build the command

$ go test -run

你可以在测试的时候通过-run参数来正则匹配过滤需要测试的代码。下面的命令只会运行test examples。

$ go test -run=Example

$ go test -coverprofile

当测试一个包的时候，可以输出一个测试覆盖率，然后使用命令go tool来在浏览器里面可视化。

$ go test -coverprofile=c.out && go tool cover -html=c.out

上面的命令将会创建一个测试覆盖率文件在浏览器打开结果。

注：测试fmt包

go test -coverprofile=c.out fmt

$ go test -exec

一般很少有人知道Go的这个功能，你可以通过-exec插入另一个程序。这个参数允许通过Go工具完成一些外部工作。

一个常见的需求场景是你需要在一些宿主机上面执行一些测试。我们可以通过-exec命令调用adb命令来把二进制文件导入安卓设备并且可以收集到结果信息。参考这个来在安卓设备上面执行。

$ go get -u

如果你通过go get命令获取Go包，而这个包已经存在于本地的GOPATH，那么这个命令并不会帮你更新包。-u可以强制更新到最新版。

如果你是一个库作者，你最好在你的安装说明上加上-u参数，例如，golint是这么做的：

$ go get -u github.com/golang/lint/golint

$ go get -d

如果你想clone一个代码仓库到GOPATH里面，跳过编译和安装环节，使用-d参数。这样它只会下载包并且在编译和安装之前停止。

当需要clone虚拟网址代码仓库的时候，我经常使用这个命令来代替git clone，因为这样可以把Go代码自动放入合适的目录下面。例如：

$ go get -d golang.org/x/oauth2/...

这样可以克隆到$GOPATH/src/golang.org/x/ouath2目录下面。假设golang.org/x/oauth2是一个虚拟网址，通过go get获取这个代码仓库要比找出仓库的真实地址(go.googlesource.com/oauth2)更简单。

$ go get -t

如果你的测试包的有附加的依赖包，-t可以一并下载测试包的依赖包。如果没有加这个参数，go get只会下载非测试包的依赖包。

$ go list -f

这个命令可以列出来Go的所有包，并且可以指定格式。这个写脚本的时候很有用。

下面这个命令将会打印所有依赖的runtime包

go list -f ‘’ runtime [runtime/internal/atomic runtime/internal/sys unsafe]

更多的格式化方法可以进一步阅读Dave Cheney的文章。

【译】优化Go的模式

2016-08-18T00:00:00+00:00

之前写过一篇文章《为什么SignalFx metric proxy通过Go语言开发》，这篇文章将会关注以我们的ingest服务为例，来讲述我们是如何优化Go代码的。

SingalFx基于流分析和时间报警序列，例如应用程序指标，可以为时间序列数据的现代应用开发的高级监控平台（“我的应用程序收到了多少请求？”），还有系统级指标（“我的Linux服务器使用了多少网络流量？”）。我们用户流量很大并且粒度很高，每次用户的流量都要先通过我们的ingest服务才能访问其它的SignalFx服务。

第一步：启用pprof

啥是pprof？

pprof是Go语言内置的标准方法用来调试Go程序性能。可以通过HTTP的方式调用pprof包，它能提取出来应用程序的CPU和内存数据，此外还有运行的代码行数和内容信息。

如何启用pprof？

你可以通过在你的应用增加一行代码 import _ "net/http/pprof"，然后启动你的应用服务器，pprof就算是启动了。还有一种方式，就是我们在做SignalFx的时候，为了在外部控制pprof，我们附加了一些处理程序，可以用过路由设置暴露出去，代码如下：

import "github.com/gorilla/mux"
import "net/http/pprof"
var handler *mux.Router
// ...
handler.PathPrefix("/debug/pprof/profile").HandlerFunc(pprof.Profile)
handler.PathPrefix("/debug/pprof/heap").HandlerFunc(pprof.Heap)

第二步：找到可以优化的代码

要执行什么？

curl http://ingest58:6060/debug/pprof/profile > /tmp/ingest.profile
go tool pprof ingest /tmp/ingest.profile
(pprof) top7

这是干嘛的？

Go语言包含了一个本地的pprof工具来可视化输出pprof的结果。我们配置的路由/debug/pprof/profile可以收集30秒数据。我上面的操作，第一步是保存输出到本地文件，然后运行保存后的文件。值得一提的是，最后一个参数可以直接输入一个URL来取代文件（译者注：go tool pprof ingest http://ingest58:6060/debug/pprof/profile）。命令top7可以展示消耗CPU最好的7个函数。

结果

12910ms of 24020ms total (53.75%)
Dropped 481 nodes (cum <= 120.10ms)
Showing top 30 nodes out of 275 (cum >= 160ms)
     flat  flat%   sum%        cum   cum%
   1110ms  4.62%  4.62%     2360ms  9.83%  runtime.mallocgc
    940ms  3.91%  8.53%     1450ms  6.04%  runtime.scanobject
    830ms  3.46% 11.99%      830ms  3.46%  runtime.futex
    800ms  3.33% 15.32%      800ms  3.33%  runtime.mSpan_Sweep.func1
    750ms  3.12% 18.44%      750ms  3.12%  runtime.cmpbody
    720ms  3.00% 21.44%      720ms  3.00%  runtime.xchg
    580ms  2.41% 23.86%      580ms  2.41%  runtime._ExternalCode

为啥是这个结果

我们可以发现，这些函数我们都没有直接调用过。然而，mallocgc、sacnobject还有mSpan_Sweep全部都会导致是垃圾回收的时候CPU占用高。我们可以深入了解这些函数，而不是去优化Go语言的垃圾回收器本身，更好的优化办法是我们来优化我们代码里面使用Go语言的垃圾回收器的方法。在这个例子中，我们可以优化的是减少在堆上面创建对象。

第三步：探究GC的原因

执行啥？

curl http://ingest58:6060/debug/pprof/heap > /tmp/heap.profile
go tool pprof -alloc_objects /tmp/ingest /tmp/heap.profile
(pprof) top3

做了啥？

可以注意到这次下载的URL和之前的有点像，但是是以/heap结尾的。这个将会给我们提供机器上面堆的使用总结的数据。我再一次保存成文件用户后面的比较。参数-alloc_objects将会可视化应用程序在执行过程中分配的对象数量。

结果

4964437929 of 7534904879 total (65.89%)
Dropped 541 nodes (cum <= 37674524)
Showing top 10 nodes out of 133 (cum >= 321426216)
     flat  flat%   sum%        cum   cum%
853721355 11.33% 11.33%  859078341 11.40%  github.com/signalfuse/sfxgo/ingest/tsidcache/tsiddiskcache.(*DiskKey).EncodeOld
702927011  9.33% 20.66%  702927011  9.33%  reflect.unsafe_New
624715067  8.29% 28.95%  624715067  8.29%  github.com/signalfuse/sfxgo/ingest/bus/rawbus.(*Partitioner).Partition

啥意思？

可以看出，11.33%的对象分配都发生在对象DiskKey的函数EncodeOld里面，我们预期也是这个结果。然而，没有料到的是Partition函数占用了全部内存分配的8.29%，因为这个函数只是一些基本的计算，我得着重研究一下这个问题。

第四步：找到为什么partitioner使用如此多内存的原因

执行啥？

(pprof) list Partitioner.*Partition

做了啥？

这个命令可以打印出来我关注的源代码行，还有就是函数内部哪些代码引起了堆的内存申请。这是pprof里面许多命令的其中一个。另一个非常有用的是查看调用方和被调用方。可以通过help命令查看完整的帮助并且都试一试。

结果

Total: 11323262665
ROUTINE ======================== github.com/signalfuse/sfxgo/ingest/bus/rawbus.(*Partitioner).Partition in /opt/jenkins/workspace/ingest/gopath/src/github.com/signalfuse/sfxgo/ingest/bus/rawbus/partitioner.go
927405893  927405893 (flat, cum)  8.19% of Total
        .          .     64: if ringSize == 0 {
        .          .     65: return 0, ErrUnsetRingSize
        .          .     66: }
        .          .     67: var b [8]byte
        .          .     68: binary.LittleEndian.PutUint64(b[:], uint64(message.Key.(*partitionPickingKey).tsid))
239971917  239971917     69: logherd.Debug2(log, "key", message.Key, "numP", numPartitions, "Partitioning")
        .          .     70: murmHash := murmur3.Sum32(b[:])
        .          .     71:
        .          .     72: // 34026 => 66
        .          .     73: setBits := uint(16)
        .          .     74: setSize := uint32(1 << setBits)
        .          .     75: shortHash := murmHash & (setSize - 1)
        .          .     76: smallIndex := int32(shortHash) * int32(k.ringSize) / int32(setSize)
687433976  687433976     77: logherd.Debug3(log, "smallIndex", smallIndex, "murmHash", murmHash, "shortHash", shortHash, "Sending to partition")
        .          .     78: return smallIndex, nil
        .          .     79:}
        .          .     80:

啥意思？

这个可以表示debug日志是引起变量从栈逃逸到堆的原因。因为调试日志并不是直接需要的，我能够直接删掉这些行。但是首先，还是让我们来确认这个假设。logherd.Debug2函数看起来封装了如下所示，如果日志级别debug没有符合条件，WithField对象并不会调用。

// Debug2 to logger 2 key/value pairs and message.  Intended to save the mem alloc that WithField creates
func Debug2(l *logrus.Logger, key string, val interface{}, key2 string, val2 interface{}, msg string) {
     if l.Level >= logrus.DebugLevel {
          l.WithField(key, val).WithField(key2, val2).Debug(msg)
     }
}

从pprof检测看起来是传递整数到Debug2函数引起的内存分配，让我们进一步确认。

第五步：找到日志语句引起内存分配的原因

执行什么：

go build -gcflags='-m' . 2>&1 | grep partitioner.go

这个用来干啥？

通过-m参数编译可以让编译器打印内容到stderr。这包括编译器是否能够在栈上面分配内存还是一定得将变量放到堆上面申请。如果编译器不能决定一个变量是否在外部继续被调用，他会被Go语言放到堆上面。

结果

./partitioner.go:63: &k.ringSize escapes to heap
./partitioner.go:62: leaking param: k
./partitioner.go:70: message.Key escapes to heap
./partitioner.go:62: leaking param content: message
./partitioner.go:70: numPartitions escapes to heap
./partitioner.go:77: smallIndex escapes to heap
./partitioner.go:77: murmHash escapes to heap
./partitioner.go:77: shortHash escapes to heap
./partitioner.go:68: (*Partitioner).Partition b does not escape
./partitioner.go:71: (*Partitioner).Partition b does not escape

注意第77行，smallIndex、murmHash还有shortHash全部逃逸到了堆上面。编译器为短生命周期的变量在堆上面申请了空间，导致我们在对上创建了很多我们并不需要的对象。

第六步：对partition函数压测

写什么？

func BenchmarkPartition(b *testing.B) {

     r := rand.New(rand.NewSource(0))

     k := partitionPickingKey{}

     msg := sarama.ProducerMessage {

          Key: &k,

     }

     p := Partitioner{

          ringSize: 1024,

          ringName: "quantizer.ring",

     }

     num_partitions := int32(1024)

     for i := 0; i < b.N; i++ {

          k.tsid = r.Int63()

          part, err := p.Partition(&msg, num_partitions)

          if err != nil {

               panic("Error benchmarking")

          }

          if part < 0 || part >= num_partitions {

               panic("Bench failure")

          }

     }

}

压测只是简单的创建了B.N个对象，并且在返回的时候做了一个基本的检查来确认对象不会被简单的优化掉。我们推荐当程序员在优化代码之前编写压测代码来确保你在朝着正确的方向进行。

第七步：对partition函数压测内存分配

执行啥？

go test -v -bench . -run=_NONE_ -benchmem BenchmarkPartition

做了啥？

压测会按照正则匹配符合“.”条件的函数，-benchmen将会追踪每次循环的堆使用平均情况。通过传递参数-run=_NONE_，我可以节约一些时间，这样测试只会运行有“NONE”字符串的单元测试。换句话说，不下运行任何一个单元测试，只运行全部的压力测试。

结果

PASS

BenchmarkPartition-8 10000000       202 ns/op      64 B/op       4 allocs/op

意味着啥？

每一次循环消耗平均202ns，最重要的是，每个操作有4次对象分配。

第八步：删掉日志语句

咋写？

@@ -66,7 +65,6 @@ func (k *Partitioner) Partition(message *sarama.ProducerMessage, numPartitions i

       }

       var b [8]byte

       binary.LittleEndian.PutUint64(b[:], uint64(message.Key.(*partitionPickingKey).tsid))

-       logherd.Debug2(log, "key", message.Key, "numP", numPartitions, "Partitioning")

       murmHash := murmur3.Sum32(b[:])

       // 34026 => 66

@@ -74,7 +72,6 @@ func (k *Partitioner) Partition(message *sarama.ProducerMessage, numPartitions i

       setSize := uint32(1 << setBits)

       shortHash := murmHash & (setSize - 1)

       smallIndex := int32(shortHash) * int32(k.ringSize) / int32(setSize)

-       logherd.Debug3(log, "smallIndex", smallIndex, "murmHash", murmHash, "shortHash", shortHash, "Sending to partition")

       return smallIndex, nil

}

干了什么？

我的修复方式是删除日志代码。测试期间/调试期间，我增加了这些调试代码，但是一直没有删掉它们。这种情况下，删掉这些代码最简单。

第九步：重新编译评估是否变量逃逸到了堆

如何执行？

go build -gcflags='-m' . 2>&1 | grep partitioner.go

结果

./partitioner.go:62: &k.ringSize escapes to heap

./partitioner.go:61: leaking param: k

./partitioner.go:61: (*Partitioner).Partition message does not escape

./partitioner.go:67: (*Partitioner).Partition b does not escape

./partitioner.go:68: (*Partitioner).Partition b does not escape

意味着什么？

可以发现smallIndex、murmHash和shortHash变量不在有逃逸到堆的消息。

第十步：重新压测评估每个操作的内存分配情况

如何执行？

go test -v -bench . -run=_NONE_ -benchmem BenchmarkPartition

结果

PASS

BenchmarkPartition-8 30000000        40.5 ns/op       0 B/op       0 allocs/op

ok   github.com/signalfuse/sfxgo/ingest/bus/rawbus 1.267s

啥意思？

注意到每个操作只消耗40ns，更重要的是，每个操作不再有内存分配。因为我是准备来优化堆，这对我来说很重要。

结束语

pprof是非常有用的工具来剖析Go代码的性能问题。通过结合Go语言内置的压测工具，你能够得到关于代码改变引起的变化的真正的数字。不幸的是，性能衰退会随着时间而攀升。下一步，读者可以练习，保存benchmark的结果到数据库，这样你可以在每一次代码提交之后查看代码的性能。

介绍一下Json的Number

2016-05-02T00:00:00+00:00

Json的使用基本没有什么难度，就拿Golang来说，直接来个encoding/json包里的func Marshal(v interface{}) ([]byte, error)和func Unmarshal(data []byte, v interface{}) error就能对Json进行编解码了。具体的文件就是采用反射的方法，可以参考我之前的文章『Golang通过反射实现结构体转成JSON数据』。

现在问题来了，如下的map需要大家是如何解析的？

{"10000000000":10000000000,"111":1}

如果直接定义一个map来解析，定义成map[string]int64，我们是肯定可以解析成功的，解析的时候会将数据转换为我们需要的数据类型。那么问题来了：如果把类型定义成map[string]interface{}会是如何解析的呢？

我一直是用显示定义的来解析，也就是map[string]int64，当我用map[string]interface{}解析的时候，我就想当然的认为，interface{}里面存的是int64的数据。后来调试了一通，最后才发现是本末倒置了。

Json数据其实就是一个字符串，里面按照一定的格式保存我们的数据。Json支持的数据类型与Golang语言的关系如下：

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

我们可以注意到，Json格式的数字和Golang语言里面的float64是相关联的。也就是说，默认情况下数字类型将会转换成float64类型。如果我们显示的指出了数字类型，比如int64，他会将数字再转成int64。

我们看一下源码，encoding/json/decode.go func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool)

func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) {
	...
	switch c := item[0]; c {
		case 'n': // null
		...
		case 't', 'f': // true, false
		...
		case '"': // string
		...
		default: // number
		if c != '-' && (c < '0' || c > '9') {
			if fromQuoted {
				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
			} else {
				d.error(errPhase)
			}
		}
		s := string(item)
		switch v.Kind() {
		default:
			if v.Kind() == reflect.String && v.Type() == numberType {
				v.SetString(s)
				break
			}
			if fromQuoted {
				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
			} else {
				d.error(&UnmarshalTypeError{"number", v.Type(), int64(d.off)})
			}
		case reflect.Interface:
			n, err := d.convertNumber(s)
			if err != nil {
				d.saveError(err)
				break
			}
			if v.NumMethod() != 0 {
				d.saveError(&UnmarshalTypeError{"number", v.Type(), int64(d.off)})
				break
			}
			v.Set(reflect.ValueOf(n))

		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			n, err := strconv.ParseInt(s, 10, 64)
			if err != nil || v.OverflowInt(n) {
				d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
				break
			}
			v.SetInt(n)

		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
			n, err := strconv.ParseUint(s, 10, 64)
			if err != nil || v.OverflowUint(n) {
				d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
				break
			}
			v.SetUint(n)

		case reflect.Float32, reflect.Float64:
			n, err := strconv.ParseFloat(s, v.Type().Bits())
			if err != nil || v.OverflowFloat(n) {
				d.saveError(&UnmarshalTypeError{"number " + s, v.Type(), int64(d.off)})
				break
			}
			v.SetFloat(n)
		}
	}
}

func (d *decodeState) convertNumber(s string) (interface{}, error) {
	if d.useNumber {
		return Number(s), nil
	}
	f, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return nil, &UnmarshalTypeError{"number " + s, reflect.TypeOf(0.0), int64(d.off)}
	}
	return f, nil
}

可以看出来，Json解析实现的时候通过反射来判断要生成的具体的类型。如果是interface{}类型，通过converNumber方法转成float64（里面是通过strconv.ParseFloat实现），如果类型是整形相关，通过strconv.ParseInt方法转换。无符号整形是通过strconv.ParseUint实现。

Golang 也提供了Number类型来解决这种情况，详细说明请看下一篇文章《介绍一下Json的Number（二）》。

狗日的slice

2016-01-18T00:00:00+00:00

首先推荐一下雨痕大神的新书：《Golang源码剖析（第五版）》。

进入正题。Golang和其它语言不通的是，他增加了一个slice，这不同于传统的数组，但是我们使用它又要按照数组的用法来，容易混淆。

先说一下我理解的传统数组，数组的名称就是数组在内存里面的首地址，访问每个子元素就是首地址加子元素长度访问。所以这应该是一个引用对象类型。

而Golang的slice，引用一下雨痕大神的文章说明：

runtime.h

struct Slice
{
	byte* array;
	uintgo len;
	uintgo cap;
}

slice底层是通过struct实现的，所以传递的时候是值拷贝传递，但是，slice的内容是通过数组指针实现的。就会发生这种现象：***通过值传递，len和cap都不会变，所以使用的时候不会感觉到内容有变化，但是实际上byte数组是发生变化的。

上代码：

package main

import "fmt"

func main() {
	testMap := make(map[int64]int64)
	fmt.Println(testMap)
	FuckMap(testMap)
	fmt.Println(testMap)
	FuckMap2(testMap)
	fmt.Println(testMap)

	testSlice := []int64{}
	fmt.Println(testSlice)
	FuckSlice(testSlice)
	fmt.Println(testSlice)
	
	FuckSlice2(&testSlice)
	fmt.Println(testSlice)
}

func FuckMap(t map[int64]int64) map[int64]int64 {
	t[1] = 1
	return t
}

func FuckMap2(t map[int64]int64) map[int64]int64 {
	t[1] = 2
	return t
}

func FuckSlice(a []int64) []int64 {
	a = append(a, 1)
	return a
}

func FuckSlice2(a *[]int64) *[]int64 {
	*a = append(*a, 1)
	return a
}

直接看后半部分。FuckSlice函数对于slice的修改是不起作用的，因为slice是按值传递的；然后我们强行改成按引用传递，就是传递slice的地址作为参数，这时的修改就是起作用的。所以，对于修改slice的操作要注意，有可能会修改失败。

最简单的HTTP SERVER

2015-12-11T00:00:00+00:00

到了新单位总算有点闲了，接着倒腾HTTP。之前的文章可以参考：《基于TCP套接字，通过Golang模拟HTTP请求》和《基于TCP套接字，通过Golang模拟HTTP请求（续）》。

之前都是研究的客户端，现在来研究一下服务端。《HTTP权威指南》上面有一个非常简单的用perl开发的一个服务器，我就用大Golang照着写一个。HTTP协议是基于传输层的TCP协议，监听80端口。简单来写（复杂的我也不会），就是最简单的TCP监听，接收消息，处理并返回。我是参考的《Go socket编程实践: TCP服务器和客户端实现》。主逻辑就是这样：

ln, err := net.Listen("tcp", fmt.Sprintf("%s:%d", "", *portFlag))
defer ln.Close()
if err != nil {
	panic(err)
}

log.Printf("<<<Server Accepting on Port %d>>>\n\n", *portFlag)
for {
	conn, err := ln.Accept()
	if err != nil {
		log.Panicln(err)
	}
	go handleConnection(conn)
}

我做东西喜欢从最简单开始，一个是因为我会的不多，一个是简单的来自己能理明白，以后维护其实更省事。

回归正题，这块其实从念书的时候就老写，分分钟搞定。然后就是HTTP协议的东西。当然，还是按最简单的来。HTTP分为三部分，起始行（start line）、首部（header）和主体（body）。

起始行只有一行，就是协议版本和状态码这些，以CRLF结尾，也就是\r\n；接着就是头，头里面的内容就是键值对，每组键值对以CRLF结尾；头和主体中间，还需要多一个CRLF，我猜是为了解析内容方便。主体之后不需要CRLF。

下图就是详细的请求格式。其中SP是空格。

一些必要的头（因为我发现如果没有，请求会失败），就是Content-Type和Content-length。Content-length就是Body的长度。

func handleConnection(conn net.Conn) {
	defer conn.Close()
	log.Printf("[%s]<<<Request From %s>>>\n", time.Now().String(), conn.RemoteAddr())

	serve_time := time.Now()
	buffers := bytes.Buffer{}
	buffers.WriteString("HTTP/1.1 200 OK\r\n")
	buffers.WriteString("Server: Cyeam\r\n")
	buffers.WriteString("Date: " + serve_time.Format(time.RFC1123) + "\r\n")
	buffers.WriteString("Content-Type: text/html; charset=utf-8\r\n")
	buffers.WriteString("Content-length:" + fmt.Sprintf("%d", len(DEFAULT_HTML)) + "\r\n")
	buffers.WriteString("\r\n")
	buffers.WriteString(DEFAULT_HTML)
	conn.Write(buffers.Bytes())
}

最后补充一点，连接记得关闭

参考文献

【1】《HTTP权威指南》
【2】James F.Kurose, Keith W.Ross.COMPUTER NETWORKING. A Top-Down Approach Featuring the Internet(Third Edition).
【3】NETWORKING INFO BLOG. HTTP Message Format.

京东工作记录

2015-11-23T00:00:00+00:00

9月份入职后，主要就是在熟悉业务和流程、熟悉代码，还有就是数据加载和集群切换的工作。我们的服务有两套集群，每个集群又包含三套机房，分别是黄村、永丰和廊坊机房。集群分为线上集群和线下集群。多个集群是为了保证数据加载不影响线上用户的正常使用。三级列表页有大约1000个分类，每个分类需要加载2万个商品，如果在线上集群进行加载数据的操作，哪怕是只加载一个分类，都会引起CPU和数据库的报警。所以，线上机群只是正常展示数据，线下集群进行全量数据加载。

接口部分使用Golang语言+MySQL+JimDB+twmeproxy(JimDB可以简单的认为是Redis)开发。由我们组其他同事将异构好的商品计算好之后持久化到MySQL里面。我负责将MySQL里面的数据加载到JimDB和内存里面。Twmeproxy用来当作JimDB的前台分片代理。

10月份开始，开始着手开始更重要的双11凤凰项目开发。我们组负责的是4免1的pop商品的活动页。凤凰项目是列表页项目的一个简化项目，逻辑相似且更为简单。这对我了解项目有很大帮助。开发倒是很顺利，大概用了不到1周就开发完成了。后来就是在解决坑的踩。

坑1，丢商品。数据加载完之后，有的专题会丢商品，而且很规律。每个专题固定丢的就是这些。但是排查起来很难。我们的服务都是分布式的集群，尤其是JimDB用了twmeproxy做分片，丢的这个商品是在哪个JimDB上面丢的，我都无从判断。而且是线上有问题，而测试环境没问题。当时只能是申请了一台机器转为预发，通过给代码加日志来跟踪问题。后来终于发现在保存商品的时候出错了。之前访问JimDB的代码封装的时候，保存到JimDB的函数返回值是error错误类型，但是在实际排查的时候它从来都没有返回过错误，后来深入看代码才发现所有错误都被过滤掉了，这里影响我的排查方向。最后，看到错误输出之后，发现是没有写入JimDB的权限，再比对twmeproxy的配置，发现有一台twmeproxy的配置项填错了，填成了从JimDB，故而写入失败。总结：错误不可避免，但是错误日志很重要。如果当时的逻辑能直接看到错误日志，排查的速度能从半天时间缩减到半小时。

坑2，twmeproxy分片问题。Twmeproxy分片是根据存入键值对的键进行处理的，所以分配到每个JimDB分片上面的键是均匀的。而实际使用的过程中发现，即使键是均匀的，我们保存的值大小是不可控的。这样，有可能某一个分片分配过来的值都很大，最后导致整个分片内存满了。而JimDB对于此种情况的处理并不是LRU，而且一旦内存满了，写入就会失败。我们对应的解决方案是发现哪个分片满了，就给这个分片单独申请增加内存。

坑3，JimDB连接数问题。最后压测的时候，发现集群压测性能不是很理想。排查了很多方面，磁盘IO、MySQL读写、Redis读写等。后来发现是程序与Twmeproxy连接数过低，与压测的同事沟通改为1000之后，压测效果理想，单台机器能够支持1800的TPS。由于不同的商品被打散到了不同的服务器上面，获取这些商品虽然是通过MGet的方式获取，其实底层还是串行从每台机器上面取的数据。这里还需要优化。

字符串横向对比：C、Golang、Redis

2015-09-15T00:00:00+00:00

C语言中的字符串

C语言的字符串是通过字符数组实现的，每个字符串以'\0'结束。C语言字符串的三大操作函数也是常见笔试题。

int strlen(char *s) {
	char *p = s;
	while (*p != '\0')
		p++
	return p -s;
}

void strcpy(char *s, char *t) {
	int i;
	i = 0;
	while ((s[i] = t[i]) != '\0')
		i++;
}

void strcmp(char *s, char *t) {
	for ( ; *s == *t; s++, t++)
		if (*s == '\0')
			return 0;
	return *s - *t;

}

具体实现的方式为就不说了，主要说说这里的问题。

在计算字符串长度的时候，每次都是需要遍历整个数组，直到'\0'为止，时间复杂度是O(n)，如果字符串较长，性能还是会受到影响；
在字符串复制的时候，有可能会导致越界。如果此时的内存结构是：

要给前面的一个字符串a赋值abc，那么结果就是后面紧跟着的字符串b也会被修改；

字符串相加的时候，也有可能会引起越界的问题。

Golang的字符串

在Golang1.5之前，底层代码是用C语言写的。Golang1.5实现了自举，这个我还不懂是怎么具体实现的，就说1.4的。字符串不再像C语言那样用比较简易的字符数组实现，而是封装了字符串类型string。

struct String
{
	byte* str;
	intgo len;
}

这里定义了一个结构体，包含str和len字段。新增的len字段用于保存字符串长度。这样计算字符串长度的时间复杂度就是O(1)，用空间换取了时间性能。
字符串数据依然是用数组存储，但是由于有了len字段存储长度，所以不再需要'\0'来表示结束了。
字符串的赋值就是指针指向对象的变化，不会有赋值操作，这样就不会导致越界问题了。
如果两个字符串相加，操作方案是重新申请内存，保存相加的两个字符串相加的结果，这样也不会导致越界。
但是还不是很完美，字符串是常量，不能通过数据下标的方式访问和修改。每次修改字符串，需要将字符串转换成[]byte数组。这样修改完之后，再转成字符串，这个字符串和之前的字符串已经不是同一个变量了。
字符串相加操作也是，任何修改都会导致重新申请内存，时间复杂度是O(m+n)。Golang字符串修改一般是用copy或者bytes包的bytes.WriteString实现。

Redis的字符串

Redis是用C语言开发的，Redis支持字符串保存数据。它肯定不会用字符数组来做字符串实现。。。它开发了一个叫做简单动态字符串（simpledynamic string，SDS）的类型来实现字符串。定义的结构体如下：

struct sdshdr {    
	// 记录buf数组中已使用字节的数量    
	// 等于SDS所保存字符串的长度，用空间解决时间问题
	int len;    
	// 记录buf数组中未使用字节的数量。用于避免缓冲区溢出，如果当前空间不够，则再分配一个符合大小的空间  
	int free;   
	// 字节数组，用于保存字符串。用这个是为了和C语言字符串兼容
	char buf[];
};

和Golang的实现相比，除了长度字段len和保存内容的数组buf。计算字符串长度的时间复杂度是O(1)。
Redis是用C语言开发的，为了和C语言兼容，buf是C语言的字符串，以'\0'结束。
它还增加了free字段表示空闲空间（别的类似实现可能是用容量字段，都差不多）。为了解决像Golang实现那样对于写操作不友好的问题，它会初始化一个较大的内存空间，字符串的增加会写入这些提前准备好的空间里面。一旦用完free的内容，就给buf追加空间。当追加空间的时候，性能会降到和Golang差不多的性能，一般情况还是很好的。

参考文献

How to efficiently concatenate strings in Go? - stackoverflow

离线版的Golang官方文档

2015-09-11T00:00:00+00:00

由于众所周知的原因，Golang不支持国内使用。当查文档或者升级版本的时候就会比较苦恼。有的时候实在是没辙，就用必应的缓存页看文档，下载升级包也是各种想辙。每次都很麻烦。

为了我自己能方便点用，我把Golang官方文档的页面都下载下来放在我的VPS上面。VPS也不是每天都能连得上，趁昨天有机会赶紧放上去，然后用CDN加速。链接：

https://cyeam.com/go/pkg/index.html

这让我想起前几天看到的一条微博。说古巴的一个网站，架设在了万恶的美帝，万恶的美帝不让他们用这个网站。古巴的屌丝们都是把这个网站整站下载到U盘里面偷出美帝进行浏览。异曲同工，哈哈哈。

下载整站用了命令：

wget -r -p -np -k http://URL
-r 递归下载
-p 下载html里面所有的图片
-np 不要追溯到父目录（应该是为了避免重复下载吧）
-k 相对路径转换为绝对路径

参考文献

每天一个linux命令（61）：wget命令 - 竹子

too many open files错误

2015-08-27T00:00:00+00:00

大家都知道，最近我模仿binux大婶的pyspider的害羞组在线上跑了一段时间了。后来加入了一些新的东西，比如代理池等。看瞅着代码越来越靠谱了，结果突然有一天，发现抓取停止了，紧接着去看日志：

2015/08/12 23:18:22 Post http://api.duoshuo.com/posts/import.json: dial tcp: lookup api.duoshuo.com: too many open files

作为一个菜鸟，我哪知道这是啥啊。后来用Google去搜，发现这是Linux套接字占满了。在目录/proc//fd/下，里面有该进程所有打开的文件标识符相关文件，套接字也属于文件的一种。默认Linux下规定每个进程的最大socket并发数是1024，就是对打开的文件有所限制。我最早是通过进入该目录，使用命令ll | wc -l查看当前进程的socket连接数。

这一看就是有东西申请了没释放，果断重启了服务好了。但是到底是哪里没释放，我还是不得而知。只能是用Google继续查，我懂得少，查了很多东西，把结论说一下。

在/proc/net/tcp文件里，保存的是当前计算机的TCP协议连接，我这边服务器的结果如下：

 sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
276: BE848368:80E5 2F80CFB7:0050 08 00000000:000019E4 00:00000000 00000000  1000        0 3748204 1 ffff8800182c1c00 116 4 30 10 -1

然后就是换算IP，这里面本地和远程IP都是16进制的，并且是倒着排的，换算完的本地IP是104.131.132.190:32997(BE848368:80E5)，远程IP是183.207.128.47:80(2F80CFB7:0050)，说明我的计算机连接这个IP没有正常断开。查了一下这个IP，他是我用的西祠代理里面提供的一个，说明代理那部分新写的代码有问题。

后来又得知，用netstat命令也成，而且比这个更牛逼。我一般还会用-p参数，这个能看到连接相关的进程，别的参数我也不懂了，大家想知道就Google把。netstat -p | grep haixiuzu这个就能看到我的害羞组程序的连接。当时显示出的一个结果如下表。此外，还发现一次抓取结束后会有30个CLOSE_WAIT状态的连接，其中118.144.80.201这个IP有20个，量也不小，他是多说API的IP，说明保存到多说的时候HTTP也没有释放连接。

Proto Recv-Q Send-Q Local Address         Foreign Address     State      PID/Program name
tcp        1      0 104.131.132.190:60059 118.144.80.201:http CLOSE_WAIT 14397/haixiuzu

网上查了查，大神们都说如果Recv-Q和Send-Q有不为0的就说明不对，这是发送和接受队列，说明一直在等待，一般需要两个小时操作系统才会自动释放这个资源，但是据我观察，两个小时也不会正常，要不也不会增加到1024个。

问题大体了定位好了，然后就是定位和修复。又去看了TCP连接的3次握手和断开的4次握手，大概猜测是握手握了一半没继续握。又去看了看Golang的net/http包，断开连接就是resp.Body.Close()，我没写这个，抱着试一试的态度改了一下，发现TCP连接恢复正常了。。。

我自己造的这个轮子还是可以的，让我学到了TCP的一些皮毛，还是很有成就感的。

本文所涉及到的完整源码请参考。

Golang strings包的TrimRight和TrimSuffix的区别

2015-08-19T00:00:00+00:00

昨天遇到一个问题，strings.TrimRight("cyeamblog.go", ".go")结果居然是"cyeambl"，这让我百思不得其解。当然，要看官方文档的解释：

func TrimRight(s string, cutset string) string TrimRight returns a slice of the string s, with all trailing Unicode code points contained in cutset removed.

func TrimSuffix(s, suffix string) string TrimSuffix returns s without the provided trailing suffix string. If s doesn’t end with suffix, s is returned unchanged.

TrimSuffix能看明白，这也是我想要用的，符合我的要求。但是这个TrimRight怎么看也不知道有啥区别。除了代码结果不一样以别的都不清楚了。今天去大Google上面去搜，看到这个标题Is this a bug? strings.TrimRight seems to be cutting too much，乐死我了。我也是这样想的呀，只不过不好意思上去问。

看了这个算是弄明白了。大概解释说明一下，TrimRight会把第二个参数字符串里面所有的字符拿出来处理，只要与其中任何一个字符相等，将其删除。也就是cutset参数所有字符排列组合的形式进行删除。

最否附上一个例子：

package main

import (
	"log"
	"strings"
)

func main() {
	log.Println(strings.TrimRight("abba", "ba"))
	log.Println(strings.TrimRight("abcdaaaaa", "abcd"))
	log.Println(strings.TrimSuffix("abcddcba", "dcba"))
}

结果：

2015/08/13 15:56:30
2015/08/13 15:56:30
2015/08/13 15:56:30 abcd

本文所涉及到的完整源码请参考。

参考文献

Is this a bug? strings.TrimRight seems to be cutting too much.. - golang-nuts

单件模式——Golang实现

2015-08-12T00:00:00+00:00

单件模式比较常见，算是创建型的设计模式，和工厂模式不同，他只能创建一个实例。他的应用场景很多，比如MySQL只能有一个实例这种都算。

单件模式能简单分成支持并发和不支持并发两种。不过并发这个很简单，满大街Golang实现的单件模式都是这样的。

普通的单件模式

package singleton

import (
	"fmt"
)

var _self *Singleton

type Singleton struct {
	Name string
}

func Instance() *Singleton {
	if _self == nil {
		_self = new(Singleton)
		return _self
	}
	return _self
}

func (o *Singleton) SetName(s string) {
	_self.Name = s
}

func (o *Singleton) GetName() {
	fmt.Println("Name:", _self.Name)
}

支持并发的单件模式也不算难，在这个基础上增加一个叫做Double Check的处理。当年在去哪儿网面试被虐的时候被问到过这个，所以这个东西一直也都记着。

单件模式在并发情况下，上面的代码就有问题了，有可能会被创建多次，上面的例子加个日志：

var _self *Singleton

type Singleton struct {
	Name string
}

func NewInstance(name string) *Singleton {
	fmt.Println("Create instance", name)
	time.Sleep(4 * time.Second)
	_self.Name = name
	return _self
}

func Instance(name string) *Singleton {
	if _self.Name == "" {
		return NewInstance(name)
	}
	return _self
}

func main() {
	_self = new(Singleton)
	go Instance("cyeam")
	go Instance("bryce")
	time.Sleep(10 * time.Second)
	fmt.Println(_self.Name)
}

结果如下。例子里面给实例化函数加了参数，方便判断实例化的次数和结果。从下面的结果看来，无锁的单件模式创建过两次实例，第二次创建的实例覆盖了第一个创建的实例。

Create instance cyeam
Create instance bryce
bryce

支持并发的单件模式

为了保证在并行调用的情况下只创建一个实例，就需要加锁来保证串行创建。简单粗暴的方法就是Instance()方法直接全部上锁。

var _self *Singleton

type Singleton struct {
	Name string
	sync.Mutex
}

func NewInstance(name string) *Singleton {
	fmt.Println("Create instance", name)
	time.Sleep(4 * time.Second)
	_self.Name = name
	return _self
}

func Instance(name string) *Singleton {
	_self.Mutex.Lock()
	defer _self.Mutex.Unlock()
	if _self.Name == "" {
		return NewInstance(name)
	}
	return _self
}

func main() {
	_self = new(Singleton)
	_self.Mutex = sync.Mutex{}
	go Instance("cyeam")
	go Instance("bryce")
	time.Sleep(10 * time.Second)
	fmt.Println(_self.Name)
}

简单粗暴的加锁，可以发现能够解决并发多次创建的问题。但是如此一来，整个创建流程就变成串行调用了。比如有1000次创建请求，只要创建一个实例就好，剩下999次完全没有必要加锁，直接将之前第一个创建的实例返回就好。而这样的写法会导致每一次都是带锁访问，影响速度。

Create instance cyeam
cyeam

接着上面的思路，我们可以不为这个函数整体加锁，在创建的时候加锁即可。

func Instance(name string) *Singleton {
	if _self.Name == "" {
		_self.Mutex.Lock()
		defer _self.Mutex.Unlock()
		return NewInstance(name)
	}
	return _self
}

在判断确认对象为空后，开始创建对象，结果如下：

Create instance cyeam
Create instance bryce
bryce

虽然已经加上了锁，但是可以看到，依然创建了两次对象。如果两个并行的创建调用，此时if _self.Name == ""这个调用也同时执行，自然也都是true，接着，虽然有锁，但是也就是串行得去创建对象，外面的if在无锁的情况是失效了。

这时就需要牛逼的Double Check了，在锁里面再加一次判空检查。

func Instance(name string) *Singleton {
	if _self.Name == "" {
		_self.Mutex.Lock()
		defer _self.Mutex.Unlock()
		if _self.Name == "" {
			return NewInstance(name)
		}
	}
	return _self
}

结果如下。如此一来，既兼顾了效率，又能够很好的支持并发。

Create instance cyeam
cyeam

上面写的这些都是传统的写法，对于一般语言使用的，对于我大Golang，还有一个更简单的实现。

import (
	"fmt"
	"sync"
	"time"
)

var _self *Singleton

type Singleton struct {
	Name string
	sync.Once
}

func NewInstance(name string) *Singleton {
	fmt.Println("Create instance", name)
	time.Sleep(4 * time.Second)
	_self.Name = name
	return _self
}

func Instance(name string) *Singleton {
	if _self.Name == "" {
		_self.Once.Do(func() { NewInstance(name) })
	}
	return _self
}

func main() {
	_self = new(Singleton)
	_self.Once = sync.Once{}
	go Instance("cyeam")
	go Instance("bryce")
	time.Sleep(10 * time.Second)
	fmt.Println(_self.Name)
}

本文所涉及到的完整源码请参考。

参考文献

设计模式(2) - Singleton单件模式 - shltsh

Thrift数据传输序列化

2015-07-31T00:00:00+00:00

Thrift的序列化是比Json更好用的结构（具体哪里好了我还没研究）。但是它有一个非常严重的问题：兼容性差。常年使用Json的我们已经被惯坏了，潜意识里就觉得数据默认是能保持兼容的。

先说一下那个线上问题。我与公司其它部门用Thrift对接，先上了一版，我是调用方。接着，二次升级的时候，合作的部门改了一下Idl，在函数返回结果结构体的最前面，插入了一个结构，是一个结构体，原本第一版第一个位置是整形。然后他们上线了，我还在排队上线。突然监控就报我接口返回了404(一般错误都转成404)。然后去排查，发现返回了一堆负数，负数导致后面的逻辑出问题了，哪怕返回了整数，也是非常不正常。

这个关键的时刻，我们组长（永远是他）给解释了bug的原因，是Thrift不兼容导致的。

struct Pair {
	1: required string key
	2: required string value
}

上面这个结构体，如果解析成Json，是按照键值对的形式展示，字段变量的名称是有意义的。而在Thrift里面，依然是键值对的形式，但是没有用变量名的名字作为键，而是通过序号和类型作为键，序号决定位置，类型决定解析方式。

Versioning in Thrift is implemented via ﬁeld identiﬁers. The ﬁeld header for every member of a struct in Thrift is encoded with a unique ﬁeld identiﬁer. The combination of this ﬁeld identiﬁer and its type speciﬁer is used to uniquely identify the ﬁeld. The Thrift deﬁnition language supports automatic assignment of ﬁeld identiﬁers, but it is good programming practice to always explicitly specify ﬁeld identiﬁers.

之前写过一篇《Golang开发Thrift接口》，这次接着以这个为基础修改进行实验。新增一个测试函数，返回我们要实验的这个结构体。

Pair helloPair()

通过Idl生成Golang包：

thrift -v --gen go:package_prefix=go_code/test_thrift Hello1.thrift

在helloimpl.go实现这个新增的方法：

func (h *HelloHandler) HelloPair() (*hello.Pair, error) {
	p := new(hello.Pair)
	p.Key = "rowkey"
	p.Value = "column-family"
	return p, nil
}

启动服务端：

go run helloserver.go helloimpl.go

在helloclient.go增加调用：

res, err := client.HelloPair()
fmt.Println(res.String())

结果如下：

$ go run helloclient.go
Pair({Key:rowkey Value:column-family})

结果正确，下面来模拟错误的情况。这个模拟很简单，修改Idl顺序：

struct Pair {
	2: required string key
	1: required string value
}

重新生成一遍Idl，为了对比，我把这个Idl命名为Hello1.thrift。然后复制原文件并重命名为helloimpl1.go和helloserver1.go。把引用的包名改成hello "go_code/test_thrift/hello1"。再启动服务端：

hello "go_code/test_thrift/hello1"

客户端不做任何修改：

$ go run helloclient.go
Pair({Key:column-family Value:rowkey})

结果正好相反，Amazing有没有。。。

本文所涉及到的完整源码请参考。

参考文献

Thrift 个人实战–Thrift 的序列化机制 - mumuxinfei

【译】并发、协程和GOMAXPROCS

2015-07-24T00:00:00+00:00

介绍

当有新人加入Go-Miami组，他们经常希望去学习的并发模型。当我刚刚开始听说Go语言的时候，并发似乎看起来是这门语言的热门词汇。当我看了Rob Pike的Go并发模式的视频之后，我认为我应该去学习这门语言了。

为了去理解是如何通过Go语言编写出更简单、难出错的并发程序，我们首先需要去理解什么是并发程序和并发程序的结果是什么这两个问题。我不会去讲述CSP（通信顺序进程、Communicating Sequential Processes），这是Go语言实现管道（channel）的基础。这篇文章将着重讲并发是什么，协程的角色是什么，环境变量GOMAXPROCS和运行时函数如何影响Go语言的程序的执行。

进程和线程

当我们运行一个应用，比如我写这篇文章用的浏览器，操作系统会为这个应用创建一个进程。进程的任务就像是一个容器，为这个应用运行的时候使用和管理资源。这些资源包括内存地址空间、指向文件的句柄、设备和线程。

线程是执行的一部分，它会被操作系统调度去执行进程里面、被我们在函数里面实现的代码。一个进程开始于一个线程，也叫做主线程，当这个线程结束整个进程也会随之结束。这是因为主线程是应用程序的来源。主线程可以反过来创建更多的线程，而这些线程还能创建更多的线程。

操作系统可以调度一个线程在一个可用的处理器上面执行，而不管处理这个线程的父线程在哪个处理器上面执行。每个操作系统都有自己的调度算法，并不是特定的一种，来决定最好的方式让我们开发并行程序。并且这些算法将会随着操作系统的每次升级发生改变，这个需要我们注意。

协程和并行

Go语言里面任何函数或者方法可以创建一个协程。我们可以认为主方法执行起来是一个协程，然而Go的运行时并没有启动这个协程。协程可以认为是轻量级的，因为它们占用很小的内存和资源，并且它初始化的栈空间也很小。早先的Go语言1.2版本栈空间会被初始化为4K，目前的1.4版本会被初始化为8K。这个栈可以随着需要自动增加空间。

操作系统调度可用的处理器来执行线程，Go的运行时会通过一个操作系统线程来调度协程。默认情况下，Go的运行时会分配一个逻辑处理器来执行代码里面定义的全部协程。甚至通过这一个逻辑处理器和操作系统线程，成百上千个协程可以被并发的高效迅速地调用执行。不建议添加更多的逻辑处理器，但如果你想在并行运行协程，Go提供了通过GOMAXPROCS环境变量或运行时函数来增加逻辑处理器。

并发并不是并行。并行是在多核处理器不能的核同时并行得执行两个或两个以上的线程。如果你配置运行时的逻辑处理器多于1个，调度器将会在这些逻辑处理器上面分配协程，这样做的结果就是在不同的操作系统线程上面执行多个协程。然而，想要真正的实现并行执行你的服务器必须是多核处理器。如果不是，即使Go的运行时被设置为需要多个逻辑处理器，协程仍会并发的在同一个处理处理器上面执行协程。

并发的例子

我们来创建一个小程序来展示Go并发执行协程s。这个例子我们是在默认设置下面执行，默认设置是要使用一个逻辑处理器。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    fmt.Println("Starting Go Routines")
    go func() {
	defer wg.Done()

	for char := 'a'; char < 'a'+26; char++ {
	    fmt.Printf("%c ", char)
	}
    }()

    go func() {
	defer wg.Done()

	for number := 1; number < 27; number++ {
	    fmt.Printf("%d ", number)
	}
    }()

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("\nTerminating Program")
}

这个程序通过关键字go启动了两个协程，声明了两个匿名函数。第一个协程打印了小写英语字母表，第二个打印了1到26这些数字。当我们运行这个程序，将会得到以下的结果：

Starting Go Routines
Waiting To Finish
a b c d e f g h i j k l m n o p q r s t u v w x y z 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
Terminating Program

我们来看一下输出的结果，代码被并发的执行。一旦这两个协程被启动，主的协程将会等待这两个协程执行结束。我们需要用这个方法否则一旦主协程运行结束，整个程序就结束了。WaitGroup是一个不错的方来用来在不同的协程之间通信是否完成。

我们可以发现第一个协程完整地展示了26个字母之后，第二个协程才开始展示26个数字。因为这两个协程执行速度太快，毫秒时间内就能执行结束，我们并没有能够看到是否调度器在第一个协程执行完之前中断了它。我们可以在第一个协程里面增加一个等待时间来判断调度器的策略。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    fmt.Println("Starting Go Routines")
    go func() {
	defer wg.Done()

	time.Sleep(1 * time.Microsecond)
	for char := 'a'; char < 'a'+26; char++ {
	    fmt.Printf("%c ", char)
	}
    }()

    go func() {
	defer wg.Done()

	for number := 1; number < 27; number++ {
	    fmt.Printf("%d ", number)
	}
    }()

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("\nTerminating Program")
}

这次我们在第一个协程里面增加了1秒钟的等待时间，调用sleep导致了调度器交换了两个协程的执行顺序：

Starting Go Routines
Waiting To Finish
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 a
b c d e f g h i j k l m n o p q r s t u v w x y z
Terminating Program

这次数字在字母前面。sleep会影响调度器停止第一个协程，先执行第二个协程。

并行的例子

我们上面的两个例子协程都是在并发执行，并不是并行的。我们改变一下代码来允许代码并行执行。我们需要做的就是为调度器增加一个逻辑处理器让他能够使用两个线程：

package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    runtime.GOMAXPROCS(2)

    var wg sync.WaitGroup
    wg.Add(2)

    fmt.Println("Starting Go Routines")
    go func() {
	defer wg.Done()

	for char := 'a'; char < 'a'+26; char++ {
	    fmt.Printf("%c ", char)
	}
    }()

    go func() {
	defer wg.Done()

	for number := 1; number < 27; number++ {
	    fmt.Printf("%d ", number)
	}
    }()

    fmt.Println("Waiting To Finish")
    wg.Wait()

    fmt.Println("\nTerminating Program")
}

这是程序的输出：

Starting Go Routines
Waiting To Finish
a b 1 2 3 4 c d e f 5 g h 6 i 7 j 8 k 9 10 11 12 l m n o p q 13 r s 14
t 15 u v 16 w 17 x y 18 z 19 20 21 22 23 24 25 26
Terminating Program

每一次我们运行这个程序将会得到不同的结果。调度器并不会每一次都执行得到相同的结果。我们可以看到协程这次真的是并行执行了。两个协程立刻开始运行，并且你可以看到两个都在竞争输出各自的结果。

结论

我们可以为调度器增加多个逻辑处理器，但这不意味着我们必须要这么做。Go团队把运行时的并行数默认设为1是有原因的。随意添加逻辑处理器和并行的协程并不会一定为你的程序提供更好的性能。要做好性能压力测试，确保修改Go运行时GOMAXPROCS一定能优化性能时再这么做。

在我们的应用里面创建并发的协程，这个问题最终将会导致我们的协程可以同时尝试访问同样的资源。读写共享资源一定要是原子性的。换句话说，读和写操作一定要在一个协程里面同一个时刻只有一个操作被执行，否则我们就需要在代码里面创建临界条件。学习更多的竞争条件可以读这篇文章。

管道是Go语言里面安全和优雅的编写并发程序的方法，它消除了编写竞争条件，可以使得开发并行程序更加有趣。我们现在已经知道协程是如何工作、被调度和如果并行执行，接下来我们将会讲述管道。

参考文献

Golang的垃圾回收

2015-07-03T00:00:00+00:00

我们公司服务端都是在用Golang，每天几百万的UV，过亿的PV一直没啥问题。后来改了一次逻辑，首页能展示一个列表，之前这个列表都没有做过缓存处理，一个是因为数据少，一共才一千多条；还有就是量不大。但是首页加了入口之后出了问题，内存疯涨，一般内存也就占200M+，这还是包含In Memory缓存的情况下，这下好家伙，最高我见过占用20G内存的情况，但是程序重启一下又能好。当然这是后知后觉了，当时也没把这两个东西联系到一起。

完整的说一下事情的经过。

上线之后内存疯涨，一开始会占10G左右，不知道为啥，只能kill掉。程序重启之后短时间内也会维持在200M左右，但是过个4、5天又会涨上来，而这个过程中内存大小都没有影响用户使用。最后只能跟运维说，看见内存大了就kill一次。。。

当时觉得内存这么大，肯定是GC的问题，不晓得是哪里内存泄漏了。我们用的是beego，我就用它封装好的内存pprof和CPU检测工具各种查，实在是没发现啥可疑的。毫无头绪。

后来机缘巧合去看了Gopher China 2015大会的视频，全程视频都放在了慕课网，大家也可以去看看。都是业内用Golang的大佬的演讲。推荐大家去看：

Go 语言在游戏项目的应用情况汇报，达达在GC方面在国内算是先驱了，很多人研究GC都是参考的他的数据。
Go 语言构建高并发分布式系统实践，Golang在360的应用。
Go 1.4 runtime，这个是真大神，雨痕，把整个runtime讲得很明白，我这种菜鸟都能听的懂，想看内存分配原理就去看这个。

再后来，又发生了一件事情，我们大促的时候，线上出现了Can't create more than max_prepared_stmt_count statements (current value: 16382)，数据库查询量太大，DBA把查询数调成了30000都不行。DBA怀疑是我们没有释放，但是这都是用现成的orm写的代码，并且去看了源码，确实释放了。

最后没辙，加缓存。这下邪了，数据库好了，再也没有那个错误了，而且内存也好了，再也不乱涨了。今天又在开发者头条看到了一篇文章《golang gc 探究》，跟我们的情况很类似。这也就能说明，我们之前内存离奇疯涨，是和Golang的GC机制有关。

下面说一下我对GC的理解。为了保证程序内内存的连续，Golang会申请一大块内存（有时候，只写一个hello, world可能监控内存可能都会发现占用内存比想象中的大）。当用户的程序申请的内存大于之前预申请的内存时，runtime会进行一次GC，并且将GC的阈值翻倍。也就是说，之前是超过10M时进行GC，那么下一次GC就是超过20M才进行。此外，runtime还支持定时GC。我们内存升高的原因，目前看来就是访问量过大，数据库访问的时候导致GC阈值变大，回收频率变低。而且在回收方面，Golang采用了一种拖延症策略，即使是被释放的内存，runtime也不会立刻把内存还给系统。这就导致了内存降不下来，一种内存泄漏的假象。

Golang在GC的时候会发生Stop the world，整个程序会暂停，然后去标记整个内存里面可以被回收的变量，标记完之后恢复程序执行，最后异步得去回收内存。一般这个过程会达到20ms。标记可回收变量的时间取决于临时变量的个数。临时变量数量越多，扫描时间会越长。

所以目前GC的优化方式原则就是尽可能少的声明临时变量：

局部变量尽量复用；
如果局部变量过多，可以把这些变量放到一个大结构体里面，这样扫描的时候可以只扫描一个变量，回收掉它包含的很多内存；

Golang目前一直在优化GC，目前整体效果来看和大Java差不多，但是稳定性上面来看，还是不行。一般压力测试第一波上面效果极差。

参考文献

Go 的垃圾回收机制在实践中有哪些需要注意的地方？ - 达达

Golang实现多线程并发下载

2015-07-02T00:00:00+00:00

大家都用过迅雷等下载工具，特点就是支持并发下载，断点续传。我们这里不介绍它，这个比较复杂了，逼人也不懂。本文只介绍狭义上的简易的断点续传和狭义上的多线程下载。跟之前一样，旨在研究原理，实际生活中基本没啥用，实测下来多线程下载比单线程下载还慢。。。太丢人了。

主要讲三个方面，如何HTTP的并发下载、通过Golang进行多协程开发、如何断点续传。

HTTP的并发下载

想要并发下载，就是把下载内容分块，然后并行下载这些块。这就要求服务器能够支持分块获取数据。大迅雷、电驴这种都有自己的协议，thunder://这种，我们只研究原理，就说说HTTP协议对于并发的支持。

HTTP头	对应值	含义
Content-Length	14247	HTTP响应的Body大小，下载的时候，Body就是文件，也可以认为是文件大小，单位是比特
Content-Disposition	inline; filename=”bryce.jpg”	是MIME协议的扩展，MIME协议指示MIME用户代理如何显示附加的文件。当浏览器接收到头时，它会激活文件下载。这里还包含了文件名
Accept-Ranges	bytes	允许客户端以bytes的形式获取文件
Range	bytes=0-511	分块获取数据，这里表示获取第0到第511的数据，共512字节

如果要下载一个文件，想知道这些文件的信息，例如文件名、文件大小、是否支持并发下载、文件类型都可以从响应的头里面获取。如何在下载前获得到这些内容而不是下载中获取，可以用HTTP提供的HEAD方法。HEAD方法只响应HTTP的头部分，不包含Body部分。

req, err := http.NewRequest("HEAD", get.Url, nil)
resp, err := get.GetClient.Do(req)

获取文件类型、文件名等参数。HTTP从Url到Head在到Body，你都可以认为是字符串，也确实是字符串，但是解析的时候不要自己以字符串的方式处理，要不恶心死你。Url的解析大Golang有net/url包支持，MIME有mime包支持，这都是原生包，别的语言必然也支持。

get.ContentLength = int(resp.ContentLength)
get.MediaType, get.MediaParams, _ = mime.ParseMediaType(get.Header.Get("Content-Disposition"))
log.Printf("Get %s MediaType:%s, Filename:%s, Length %d.\n", get.Url, get.MediaType, get.MediaParams["filename"], get.ContentLength)

输出

2015/07/02 09:56:47 Get https://res.cloudinary.com/cyeam/image/upload/v1537933530/cyeam/bryce.jpg MediaType:inline, Filename:bryce.jpg, Length 14247.

如果响应头里面还包含了Accept-Ranges，就说明服务器支持分块获取：

if get.Header.Get("Accept-Ranges") != "" {
	log.Printf("Server %s support Range by %s.\n", get.Header.Get("Server"), get.Header.Get("Accept-Ranges"))
} else {
	log.Printf("Server %s doesn't support Range.\n", get.Header.Get("Server"))
}

分模块下载，新建N个临时文件，我的命名规则是加个分块区间的后缀，例如bryce.jpg.0-512，这样可以省掉一个配置文件（主要是我懒的写）。将下载好的块存入临时文件里面，最后都下载完之后统一存入最终的文件里面。分块下载加个Range头就可以了。

range_i := fmt.Sprintf("%d-%d", get.DownloadRange[i][0], get.DownloadRange[i][1])
log.Printf("Download #%d bytes %s.\n", i, range_i)

defer get.TempFiles[i].Close()

req, err := http.NewRequest("GET", get.Url, nil)
req.Header.Set("Range", "bytes="+range_i)
resp, err := get.GetClient.Do(req)
defer resp.Body.Close()

最后将下载好的保持到文件里。这里是等这个块都下载完之后再写入硬盘，下载完之后都是保持在内存里面。

cnt, err := io.Copy(get.TempFiles[i], resp.Body)

多线程开发

并发下载的时候，要启动N个协程，主线程这时需要阻塞，等待这N个协程下载完毕。先开始想用channel自己写，不是特别会。。。用sync包辅助实现，它支持WaitGroup，正好可以解决我这里的问题。

在主线程里面启动N个协程，Add方法可以理解成增加一个任务，任务计数器加一；Wait方法用于阻塞，指导所有任务完成。

for i, _ := range get.DownloadRange {
	get.WG.Add(1)
	go get.Download(i)
}
get.WG.Wait()

在下载协程增加Done函数，协程结束之后通知任务完成，任务计数器减一。

defer get.WG.Done()

断点续传

这块最简单，如果任务下载暂停了，就是传输的内容不足。第一步创建临时文件的文件名后缀有派上用场了，读取到块应有的大小之后，检查块实际大小。通过文件的os.FileInfo就能获取到文件相关属性信息。这样再下载的时候就增加一个偏移量，跳过已经下载好的内容。

for i := 0; i < len(get.DownloadRange); i++ {
	range_i := fmt.Sprintf("%d-%d", get.DownloadRange[i][0], get.DownloadRange[i][1])
	temp_file, err := os.OpenFile(get.FilePath+"."+range_i, os.O_RDONLY|os.O_APPEND, 0)
	if err != nil {
		temp_file, _ = os.Create(get.FilePath + "." + range_i)
	} else {
		fi, err := temp_file.Stat()
		if err == nil {
			get.DownloadRange[i][0] += int(fi.Size())
		}
	}
	get.TempFiles = append(get.TempFiles, temp_file)
}

大概简单的原理就是这些，前面说了，比项目无法用于实际用途，原因如下：

需要有一个线程池来并发下载，目前的设计在下载大文件时会导致并发数过大。已经完成下载的线程还能继续下载未完成的块，这个又涉及到下任务的动态分配和动态拆分；
并发下载时的块大小，这个值也很讲究，一般4096和字节是一个内存块单位，以此数字的倍数下载比较节约内存，目前我这里的块大小是根据并发数计算的，比较水；
前面提到了，这是狭义的多线程下载，前提是服务器必须支持Range，否则还是无法并发获取数据，实际在做的时候最起码是会有几台下载完的服务器，这样自己的服务器就能开发支持分块取数据的协议来支持并发下载，市面上的也都是这么干；
还有下载进度条，就是类似于wget命令在控制台展示进度条和下载速度的日志，这个不太会写，查了查，据说可以通过fmt.Println("abc\rcde")实现，\r表示回车符，可以回到行首，我没试过，大家可以试试。

本文所涉及到的完整源码请参考。

参考文献

bee源码分析

2015-04-20T00:00:00+00:00

4 月 9 号那天，出了一个线上 bug，回家分析了半天，主观原因就不说了，客观原因就在于 beego 提供的编译打包工具 bee 不支持配置文件检查。。。研究了半天，关于配置文件的预编译检查，我也没啥想法，不过看了看 bee 的源码，还是懂了不少，记录一下。

围绕bee run命令说一下。

用这个命令，要进入当前包，检查目录./conf/app.conf文件，得到appname。
编译。go install controllers，编译生成静态链接库到 pkg 文件夹下面。此命令还可编译出执行文件到 bin 文件夹下面。
生成可执行文件go build -o Cyeam main.go，编译出可执行文件 Cyeam。可执行文件的名字就是第一步得到的 appnane。

启动应用。

appname = "./" + appname
cmd = exec.Command(appname)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Args = append([]string{appname}, conf.CmdArgs...)
cmd.Env = append(os.Environ(), conf.Envs...)

go cmd.Run()

关闭应用。启动和关闭都是用了exec包，创建进程和关闭进程进行操作的。

defer func() {
	if e := recover(); e != nil {
		fmt.Println("Kill.recover -> ", e)
	}
}()
if cmd != nil && cmd.Process != nil {
	err := cmd.Process.Kill()
	if err != nil {
		fmt.Println("Kill -> ", err)
	}
}

文件修改监控。bee 命令还有个比较厉害的特性，就是每当文件发生了变化，都能自动编译。这里它使用了开源包github.com/howeyc/fsnotify，这是一个开源的文件通知系统。

最后补充点其他的：

bee 命令还可以有配置文件，名称是bee.json。如果你要引用你自己的包，例如github.com/mnhkahn/maodou，就可以在 beego 目录下新建 bee.json 文件，内容如下。此外，bee 还支持很多命令，我这里只是抛砖引玉，大家可以自行研究。吐槽一下，bee 命令的文档实在是少，想详细了解还是得看代码。
```
{
	"version": 0,
	"gopm": {
		"enable": false,
		"install": false
	},
	"go_install": false,
	"watch_ext": [],
	"dir_structure": {
		"watch_all": false,
		"controllers": "",
		"models": "",
		"others": ["$GOPATH/src/github.com/mnhkahn/maodou"]
	},
	"cmd_args": [],
	"envs": [],
	"database": {
		"driver": "mysql"
	}
}
```
还有一个问题，bee 命令老给人一个错觉。如果你把项目复制到/tmp/目录下，执行 bee run，项目还是可以启动的，但实际上编译的是 GOPATH 下面的项目。编译 GOPATH 下面的代码也本来也无可厚非，因为这是 Golang 规定的，但是能编译过并且顺利执行，这就不是很好。经常我想在/tmp 目录下测试，然后测了半天发现改的东西没效果。我觉得应该检测出不再 GOPATH 目录下应该果断通知用户目录错了。

垂直搜索爬虫——maodou

2015-04-05T00:00:00+00:00

去年开始学习搜索引擎，目前主要研究的是爬虫这块。主要是因为爬虫相对简单一些，索引这块不是很了解，只能借助于Solr实现。

之前文档《如何开发搜索引擎——爬虫（一）》介绍了一个比较传统的抓取方式。就是把互联网当作是一张有向图，通过遍历这张图来抓取网站。后来也实现了抓取的爬虫，但一直没有啥实际用途，因为这么抓只能做成Google那种传统搜索引擎。

后来发现了大神binux的垂直搜索爬虫pyspider，用Python写的一个垂直抓取框架。试用了一翻，确实很好用，还有他的demo。这是他抓取豆瓣害羞组的效果页。看到这个才发现，做这个挺有意思的。

Python基本不会，索性就用Golang写了，看了看他的抓取效果，想着自己基于也有的知识也是能够实现的，就用Golang写了一个抓取框架maodou（maodou是媳妇的名字）。抓取害羞组的代码如下，我也是将结果存在了多说。

package main

import (
	"github.com/PuerkitoBio/goquery"
	"github.com/mnhkahn/maodou"
	"github.com/mnhkahn/maodou/cygo"
	"github.com/mnhkahn/maodou/dao"
	"github.com/mnhkahn/maodou/models"
	"strings"
)

type Haixiu struct {
	maodou.MaoDou
}

func (this *Haixiu) Start() {
	this.Index(this.Cawl("http://www.douban.com/group/haixiuzu/discussion"))
}

func (this *Haixiu) Index(resp *maodou.Response) {
	resp.Doc(`#content > div > div.article > div:nth-child(2) > table > tbody > tr > td.title > a`).Each(func(i int, s *goquery.Selection) {
		href, has := s.Attr("href")
		if has {
			this.Detail(this.Cawl(href))
		}
	})
}

func (this *Haixiu) Detail(resp *maodou.Response) {
	res := new(models.Result)
	res.Id = strings.Split(resp.Url, "/")[5]
	res.Title = resp.Doc("#content > h1").Text()
	res.Author = resp.Doc("#content > div > div.article > div.topic-content.clearfix > div.topic-doc > h3 > span.from > a").Text()
	res.Figure, _ = resp.Doc("#link-report > div.topic-content > div.topic-figure.cc > img").Attr("src")
	res.Link = resp.Url
	res.Source = "www.douban.com/group/haixiuzu/discussion"
	res.ParseDate = cygo.Now()
	res.Description = "haixiuzu"
	this.Result(res)
}

func (this *Haixiu) Result(result *models.Result) {
	if result.Figure != "" {
		Dao, err := dao.NewDao("duoshuo", `{"short_name":"cyeam","secret":"df66f048bd56cba5bf219b51766dec0d"}`)
		if err != nil {
			panic(err)
		}
		Dao.AddResult(result)
	}
}

func main() {
	maodou.Register(new(Haixiu), 30)
}

介绍一下抓取害羞租时候遇到的问题。抓取的难度就在于模拟浏览。因为小组里的东西肯定是不让随便抓走的，所以就要防止机器抓取。

第一个是请求头里面的UserAgent，本来想写自己的Cyeambot，发现不行，人家会拦掉不认识的设备；
第二个是请求头里面的Referer。这个代表了当前请求来源页面。如果是空，就认为是直接在浏览器打开的，或者是从书签打开的。。如果请求的来源一直是空，就有可能是爬虫。但是具体问题具体分析，比如害羞组的首页http://www.douban.com/group/haixiuzu/discussion，常用用户肯定会把这个地址保存在书签里面，所以前面的防爬虫机制尽量不起作用，而里面的帖子，http://www.douban.com/group/topic/73646091/，帖子地址是不可预估的，理论上只能通过前面讨论组的地址进入，那么如果打开具体帖子的Referer也还是空，这样就可以认为是爬虫。我抓取的时候就有遇到这样的问题，有时候会有302的情况出现，就是访问帖子，有一定的概率会跳转到登陆页，让你登陆来防范爬虫。这样应对也不难，就是抓取帖子的时候把Referer加上害羞组的地址即可；
关于访问次数限制，害怕被封杀IP，我都是没30分钟抓取一次，每访问一次就等待5秒钟，尽量模拟得像人一些。这样没半个小时会访问21次，量不算大。程序运行了快一个月了，IP没有被拦截的迹象。之前抓取CSDN，没有休息5秒钟这一步，爬了一周就不能爬了。。。

最后再说一些没用到的但是很牛逼的技术：

IP代理抓取。如果你有21台代理机器，那么上面的抓取可以同时进行。这样能大大降低抓取时间。这一般是企业级爬虫要用到的，对抓取速度有要求，像我这种半小时抓21页的就不需要用这个。如果有代理服务器，抓取豆瓣所有帖子也可以很快。当然，这样也会有问题，就是你抓取这么多东西就会有被封杀IP的风险了，所以大规模抓取还需要定时更换代理IP。其实这招可以被认为是黑科技，就是去搞中了病毒的电脑（俗称肉鸡），用这个进行代理，一般网上都有卖的；
关于封杀IP。你只要别太恶意去抓，一般也是不会去封你IP的。现在都还是IPv4，IP地址是有限的，而设备越来越多，封杀一个IP有可能导致整个小区都没办法访问该网站了，所以也不用特别担心；
如何更像人去抓取。有一个模拟器，叫做selenium。我发现Golang也有相应的客户端tebeka - selenium。用这个，你模拟登陆，自动记录你的Cookie并附带到抓取请求头里面，这样有了登陆信息，就更难进行封杀了。

最后就是展示部分，点这里访问。关于前端图片瀑布流的东西我一窍不通，完全抄袭了binux大神写的前端代码，请大神原谅。。。此爬虫并没有去抓取豆瓣小组里面的图片，只是记录了地址，所以在展示的时候还是需要访问豆瓣的图片地址，这就属于盗链图片。豆瓣肯定会对此进行处理。

你把豆瓣的图片放在你自己的网页上面展示，这就属于盗链了。浏览器在加载完HTML之后会去加载图片，这时图片请求会自动追加Referer，也就是你自己网页的地址，豆瓣的图片服务器发现请求来源是其他站点的，就会取消响应。

盗链图片有两种方式，第一种是在网页里面加iframe，这个标签能新建一个嵌套的HTML，这样浏览器在请求图片的时候不会自动追加Referer，图片就能打开了；
还有一种方式，就是用HTTPS发送请求。你把自己站点做成HTTPS的请求，这样在请求图片的时候，浏览器会把Referer去掉，保护用户隐私。搭建HTTPS服务器需要SSL证书，一般是一年$10。我去申请一个免费的，人家就是不同意。无奈之下，只能自己给自己颁发证书。坏处就是，用户第一次登陆我的站点的时候，浏览器会提示你不安全。铁道部不是也这样么。。。盗链图片的详细说明请参考最下面的两篇引用文章。

最近GitHub被DDos了，我的博客访问量也有点降低了。本来量就不多。。。是不是需要把博客牵走了。

最近有个同事离职了，跟我一起入职的，有点惋惜。可能互联网就是这样。

参考文献

探测局域网里面的设备

2015-03-16T00:00:00+00:00

之前用了一个牛逼的App，叫做Fing，它可以获取到本地局域网里面所有设备的IP、MAC地址和设备厂商。一直觉得很牛逼，今天好好想了想，发现也没那么多神秘。

穷举局域网里的IP

局域网IP一般有192和10两种形式。一般来说，10开始的局域网高端一些，能容纳的设备比较多。

穷举所有IP，有一个方式是通过trancert命令，记录访问某个网站经过的路径，那么第一条路径就是访问路由器，得到路由器IP之后，按最后一部分进行穷举。

但是这个方法有点麻烦，简化一点的，就是获取当前设备在局域网里面的IP，以此IP进行穷举。通过Golang获取IP的方法可以参考[1]。获取当前设备IP的方式可以参考：

func ExternalIP() (string, string, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return "", "", err
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 {
			continue // interface down
		}
		if iface.Flags&net.FlagLoopback != 0 {
			continue // loopback interface
		}
		addrs, err := iface.Addrs()
		if err != nil {
			return "", "", err
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.IsLoopback() {
				continue
			}
			ip = ip.To4()
			if ip == nil {
				continue // not an ipv4 address
			}
			return ip.String(), iface.HardwareAddr.String(), nil
		}
	}
	return "", "", errors.New("are you connected to the network?")
}

Ping穷举的IP，获取MAC地址。

Ping穷举的IP地址，得到在线设备的IP，然后通过arp协议得到设备的MAC地址。arp协议就是用来将IP转换成MAC的协议。这两步可以用在GitHub开源的github.com/j-keck/arping包辅助实现，这个包的文档可以参考[2]。简单的使用如下：

func Mac(ip string) (net.HardwareAddr, time.Duration, error) {
	dstIP := net.ParseIP(ip)
	return arping.Ping(dstIP)
}

获取设备的厂商，也就是俗称的Vendor

这步逼格最高。我一直以为设备的Vendor，就像HTTP协议里面的UserAgent，可以通过这个东西来获取。所以有个协议可以用来得到这些东西。但是没找到。后来发现百度知道（没想到这个东西还是有点用的）里面有位大哥写了。

MAC地址是国际上有个机构管理（好像是IEEE）的，它能保证每块网卡有不同的MAC地址。而它在分配这些地址的时候，也不是随机分配的。MAC地址有6个字节，简单的可以把前三个字节用来表示厂商编号，后3个字节用来区分厂商的网卡编号。那么，我们就能通过前3个字节来得到设备的Vendor。

在IEEE的网站上，提供了查询方式，我把那个接口提取了出来，是向http://standards.ieee.org/cgi-bin/ouisearch发送一个POST的FORM请求。还要将得到的HTML页面进行解析，就得到了Vendor。

func Vendor(mac string) (string, error) {
	macs := strings.Split(mac, ":")
	if len(macs) != 6 {
		return "", fmt.Errorf("MAC Error: %s", mac)
	}
	mac = strings.Join(macs[0:3], "-")
	form := url.Values{}
	form.Add("x", mac)
	form.Add("submit2", "Search!")
	res, err := goreq.Request{
		Method:      "POST",
		Uri:         "http://standards.ieee.org/cgi-bin/ouisearch",
		ContentType: "application/x-www-form-urlencoded",
		UserAgent:   "Cyeam",
		ShowDebug:   true,
		Body:        form.Encode(),
	}.Do()
	if err != nil {
		return "", err
	}
	body, err := res.Body.ToString()
	if err != nil {
		return "", err
	}
	vendor := body[strings.Index(body, strings.ToUpper(mac))+len(mac):]
	vendor = strings.TrimLeft(vendor, "</b>   (hex)")
	vendor = strings.TrimSpace(vendor)
	return strings.Split(vendor, "\n")[0], nil
}

HTTP请求通过goreq发送，FORM请求application/x-www-form-urlencoded格式，还需要用的net/url包。

结果

最后放上运行结果：

第一个是我当前运行的设备，网卡是Intel的，剩下的是路由器和手机。

我将上述完整的功能进行封装，本文所涉及到的完整源码请参考。

参考文献

网络协议的端口号

2015-03-14T00:00:00+00:00

今天同事问起一个问题，他建了一个thrift的服务器，用的是99999端口监听，启动不了，让我们帮着解决。

之前学习计算机网络的时候也学过，比如HTTP是80端口，DNS是53端口等等，直接网上查了一下，TCP和UDP端口支持都是16比特，也就是最大是0~65535。

扩展说一下，所有高层协议都是基于底层协议实现，在传输层的TCP和UDP协议决定了端口号占用2个字节，那么，高层协议所占用的端口范围不会超过16位。

UDP数据报文结构如下，从96位开始，来源连接端口和目的连接端口一共占用了32位。

位	0 – 7	8 – 15	16 – 23
0	来源地址
32	目的地址
64	全零	协议名	UDP报文长度
96	来源连接端口		目的连接端口
128	报文长度		检验和
160+	%%%

TCP也一样，从一开始，从0位到第31位，4个字节用来表示来源连接端口和目的连接端口。

偏移	位 0–3	4–7	8–15	16–31
0	来源连接端口			目的连接端口
32	序列号码
64	确认号码
96	报头长度	保留	标志符	窗口大小
128	检查码			紧急指针
160	选用项
160/192+	数据

Thrift这种应用层协议必须是给予传输层实现的，那么端口号也必须不能超过65535。

参考文献

DNS协议Golang实现

2015-02-03T00:00:00+00:00

DNS客户端的实现还是用了Go语言，毕竟这个最熟悉。我的实现只是简单的实现了发送DNS请求，解析响应内容这些功能，对于多线程并发等机制都没有考虑。

我最先参考了《计算机网络》，上面提了一句，DNS请求就是发送一个UDP数据包，然后我就天真了，直接把域名的字符串用UDP发送了。结果就是没有响应。

后来就老老实实的分析协议，协议的分析请参考上一篇文章《DNS协议分析》。

域名服务器选用了阿里提供的233.5.5.5，53端口。详情可以查看阿里DNS官网。

先说一下Golang发送UDP数据报的方法。所有语言这块儿好像都长差不多，我就不多介绍了。

service := "223.5.5.5:53"
udpAddr, err := net.ResolveUDPAddr("udp", service)
checkError(err)
conn, err := net.DialUDP("udp", nil, udpAddr)
checkError(err)

_, err = conn.Write(out.Pack())
checkError(err)

buf := []byte{}
buf = make([]byte, 512)
n, err := conn.Read(buf[0:])
checkError(err)

接着就是发送和接收要用到的消息体，它由一个TransationID、Flags、查询数Questions、Answer是响应数和查询Question组成。查询Question由域名、类别、分类组成。查询结果ANswer由查询域名、记录类型、分类、数据长度和Primaryname组成。这些结构可以定义为：

type DnsMsg struct {
	Id                                 uint16
	Bits                               uint16
	Qdcount, Ancount, Nscount, Arcount uint16
	Questions                          []dnsQuestion
	Answers                            []dnsAnswer
}

type dnsQuestion struct {
	Name   string `net:"domain-name"`
	Qtype  uint16
	Qclass uint16
}

type dnsAnswer struct {
	Name   uint16
	Qtype  uint16
	Qclass uint16
	QLive  uint32
	QLen   uint16
	CName  string `net:"domain-name"`
}

DNS协议规定是两个字节的，都用uint16进行处理，Question里面的Name和Answer里面定义的CNAME应该定义成[]byte，但是为了方便查看，先定义成了字符串，最后编码的时候再处理就行了。

有了结构体，就可以为这些结构体赋值，然后将其编码成字节码进行发送。编码方法如下：

func (this *DnsMsg) Pack() []byte {
	bs := make([]byte, 12)
	binary.BigEndian.PutUint16(bs[0:2], this.Id)
	binary.BigEndian.PutUint16(bs[2:4], this.Bits)
	binary.BigEndian.PutUint16(bs[4:6], uint16(len(this.Questions)))
	binary.BigEndian.PutUint16(bs[6:8], this.Ancount)
	binary.BigEndian.PutUint16(bs[8:10], this.Nscount)
	binary.BigEndian.PutUint16(bs[10:12], this.Arcount)

	ds := strings.Split(this.Questions[0].Name, ".")
	for _, d := range ds {
		bs = append(bs, byte(len(d)))
		bs = append(bs, []byte(d)...)
	}
	bs = append(bs, 0)

	temp := make([]byte, 2)
	binary.BigEndian.PutUint16(temp, this.Questions[0].Qtype)
	bs = append(bs, temp...)
	binary.BigEndian.PutUint16(temp, this.Questions[0].Qclass)
	bs = append(bs, temp...)
	return bs
}

DNS头是固定的12个字节，所以先bs := make([]byte, 12)申请12个字节空间。接着，填充这些字节。就是将结构体里面的uint16转成[]byte。这要用到binary包进行转换。最后就是填充Question，要将域名进行转换。转换剔除了域名里面的.，改成其后面部分长度的信息，也就是把www.cyeam.com换成3www5cyeam3com0。转换完成之后，还要添加一位0来表示结束。最后，再加上请求的类型和分类即可。

这些都请求成功之后，打印结果，终于能看到点东西了：一堆乱码里面有一些字母，能看得出来是我的域名的CDN地址。

最后，就是解析响应内容。响应和请求格式是一样的，区别就是最后比请求多了一些响应内容。

DNS头的12个字节和请求里面是完全一样的，返过来解析就可以了。需要注意两点，响应的头两个字节和请求的头两个字节是完全一样的，如果不一样，忽略这个请求。还有，请求的时候ancount是0，这个代表响应数量，在响应里面就会是找到的结果数。

查询请求的Question也会在响应里面，所以也需要进行解析。请求查询时Question有可能是多个，这里都处理了一下。从第13个字节开始处理：

i := 13
for ; j < int(res.Qdcount); j++ {
	domain_count := int(buf[i-1])
	question := dnsQuestion{}
	for buf[i] != 0 {
		if domain_count > 0 {
			question.Name += string(buf[i:i+domain_count]) + "."
			i += domain_count
			domain_count = 0
		} else {
			domain_count = int(buf[i])
			i++
		}
	}
	i++
	question.Name = strings.TrimRight(question.Name, ".")
	question.Qtype = binary.BigEndian.Uint16(buf[i : i+2])
	question.Qclass = binary.BigEndian.Uint16(buf[i+2 : i+4])
	i += 4
	res.Questions[j] = question
}

剩下的东西都是Answer。前5个部分都是固定长度，分别是2、2、2、4、2。

answer := dnsAnswer{}
answer.Name = binary.BigEndian.Uint16(buf[i : i+2])
i += 2
answer.Qtype = binary.BigEndian.Uint16(buf[i : i+2])
i += 2
answer.Qclass = binary.BigEndian.Uint16(buf[i : i+2])
i += 2
answer.QLive = binary.BigEndian.Uint32(buf[i : i+4])
i += 4
answer.QLen = binary.BigEndian.Uint16(buf[i : i+2])
i += 2

后面的CName是关键，解析也要按照类型进行。一种类型是CNAME类型，也就是别名，我的域名www.cyeam.com的别名就是vm68h.x.incapdns.net，这是我的CDN。还有一种就是真实IP，返回别名也没多大用，IP才能解决问题，所以Answer里面的第二个就是返回这个别名的真实IP149.126.77.152。所以一个按字符串处理，一个按数字处理。Answer里面的分类说明了解析类型，如果值是1，说明是A记录，也就是IP，如果值是5，是CNAME记录。解析Answer代码如下：

if answer.Qtype == dnsTypeCNAME {
	domain_count := int(buf[i])
	i++
	for buf[i] != 0 {
		if domain_count > 0 {
			answer.CName += string(buf[i:i+domain_count]) + "."
			i += domain_count
			domain_count = 0
		} else {
			domain_count = int(buf[i])
			i++
		}
	}
	i++
	answer.CName = strings.TrimRight(answer.CName, ".")
} else if answer.Qtype == dnsTypeA {
	for m := 0; m < int(answer.QLen); m++ {
		answer.CName += fmt.Sprintf("%d.", buf[i+m])
	}
	answer.CName = strings.TrimRight(answer.CName, ".")
}

Answer里面还会包含结果的长度信息，用这个来遍历得到结果内容。

完整请求如下：

service := "223.5.5.5:53"
udpAddr, err := net.ResolveUDPAddr("udp", service)
checkError(err)
conn, err := net.DialUDP("udp", nil, udpAddr)
checkError(err)

question := dnsQuestion{"www.cyeam.com", dnsTypeA, dnsClassINET}
out := DnsMsg{}
out.Id = 2015
out.Bits |= _RD
out.Questions = append(out.Questions, question)
fmt.Println(out.Pack())
_, err = conn.Write(out.Pack())
checkError(err)

buf := []byte{}
buf = make([]byte, 512)
n, err := conn.Read(buf[0:])
checkError(err)
fmt.Println(buf[0:n])
fmt.Println(out.Unpack(buf[0:n]))
os.Exit(0)

解析完成后的结构体打印结果如下：

&{2015 33152 1 2 0 0 [{www.cyeam.com 1 1}] [{49164 5 1 30 22 vm68h.x.incapdns.net} {49195 1 1 30 4 149.126.77.152}]}

涉及到的的数据包，可以从这里访问到。完整代码可以参考这里。

参考文献

《计算机网络（第五版）》谢希仁
What does a DNS request look like? - serverfault

DNS协议分析

2015-01-29T00:00:00+00:00

一直有一个愿望，能把知道的东西的原理搞明白：计算机网络、操作系统等等等等。今天好好研究了研究DNS协议。

DNS协议是应用层协议，一般是基于UDP协议，不过我看了Golangnet 包里相关源码用的是TCP协议传输。端口是53,这次写代码实现了一边DNS客户端，估计短时间内忘不了这个端口号了。

了解DNS这个协议，从书本上我基本没看懂过，书里我基本就记着DNS是递归查询的，如果查询服务器上没有找到相应的记录，则递归得去查询上一级服务器。还有就是根域名服务器在美国这些，反正我就是从来没搞懂过。

昨天在网上找到一篇文章[2]，上面提到说学习协议还是借助WireShark比较好，Linux之下就是通过tcpdump和WireShark结合进行抓取数据包。具体的方法可以参考我之前的文章。而模拟DNS请求，Linux下是host www.cyeam.com，Windows下是nslookup www.cyeam.com。

1	0.000000	10.0.1.23	10.0.1.1	DNS	73	Standard query 0x11ac  A www.cyeam.com
2	0.061714	10.0.1.1	10.0.1.23	DNS	123	Standard query response 0x11ac  CNAME vm68h.x.incapdns.net A 149.126.77.152

我的电脑IP是10.0.1.23,路由器IP是10.0.1.1,查询网站www.cyeam.com的DNS记录。

抓到的请求内容如下：

Domain Name System (query)
    [Response In: 2]
    Transaction ID: 0x11ac
    Flags: 0x0100 Standard query
	0... .... .... .... = Response: Message is a query
	.000 0... .... .... = Opcode: Standard query (0)
	.... ..0. .... .... = Truncated: Message is not truncated
	.... ...1 .... .... = Recursion desired: Do query recursively
	.... .... .0.. .... = Z: reserved (0)
	.... .... ...0 .... = Non-authenticated data: Unacceptable
    Questions: 1
    Answer RRs: 0
    Authority RRs: 0
    Additional RRs: 0
    Queries
	www.cyeam.com: type A, class IN
	    Name: www.cyeam.com
	    Type: A (Host address)
	    Class: IN (0x0001)

DNS协议头是12个字节，共两项内容，每个都是两个字节。

Transaction ID。是客户端随机生成的一个无符号整数，范围是0~2^16。在响应头里面会返回这个值用于校验。如果值不相等，丢弃响应内容。
Flags。具体每个位的含义这里就不复述了，上面抓到请来看，是标记了递归调用这一项。
查询数Questions。一次DNS请求能查询多个域名，这里只查了一个域名，所以是1。
Answer是响应数，请求里面响应数肯定是0。剩下两个目前没有用到，还没有研究具体含义。

协议头之后，就是消息体了。在请求里面，消息体是请求查询的内容，而在响应里面，则是查询到的内容。消息体由三方面组成：域名、类别、分类：

Name。我们要查询www.cyeam.com这个域名，分别用.将域名进行了切割，而DNS协议设计的时候，用了一个巧妙的方法，将点去掉，而是在每一部分之前加上这个部分占的位数。还有，就是在最后补上一个字节的0,表示Name的结束。那么域名就会变成3www5cyeam3com0这样。
Type。查询类型，有A、CNAME等。
查询分类，好像见到的都是IN。这两个值都是两个字节。

头是12个字节，消息体用了15+2+2=19个字节，一个是31字节。下面的表格是16进制计数的，一行是16个，一共也是15个。大家也可以根据协议头和消息体的内容计算看看。

0000   11 ac 01 00 00 01 00 00 00 00 00 00 03 77 77 77
0010   05 63 79 65 61 6d 03 63 6f 6d 00 00 01 00 01

响应的头如下：

Domain Name System (response)
    [Request In: 1]
    [Time: 0.061714000 seconds]
    Transaction ID: 0x11ac
    Flags: 0x8180 Standard query response, No error
	1... .... .... .... = Response: Message is a response
	.000 0... .... .... = Opcode: Standard query (0)
	.... .0.. .... .... = Authoritative: Server is not an authority for domain
	.... ..0. .... .... = Truncated: Message is not truncated
	.... ...1 .... .... = Recursion desired: Do query recursively
	.... .... 1... .... = Recursion available: Server can do recursive queries
	.... .... .0.. .... = Z: reserved (0)
	.... .... ..0. .... = Answer authenticated: Answer/authority portion was not authenticated by the server
	.... .... ...0 .... = Non-authenticated data: Unacceptable
	.... .... .... 0000 = Reply code: No error (0)
    Questions: 1
    Answer RRs: 2
    Authority RRs: 0
    Additional RRs: 0
    Queries
	www.cyeam.com: type A, class IN
	    Name: www.cyeam.com
	    Type: A (Host address)
	    Class: IN (0x0001)
    Answers
	www.cyeam.com: type CNAME, class IN, cname vm68h.x.incapdns.net
	    Name: www.cyeam.com
	    Type: CNAME (Canonical name for an alias)
	    Class: IN (0x0001)
	    Time to live: 10 seconds
	    Data length: 22
	    Primaryname: vm68h.x.incapdns.net
	vm68h.x.incapdns.net: type A, class IN, addr 149.126.77.152
	    Name: vm68h.x.incapdns.net
	    Type: A (Host address)
	    Class: IN (0x0001)
	    Time to live: 3 minutes, 47 seconds
	    Data length: 4
	    Addr: 149.126.77.152 (149.126.77.152)

协议头的含义和请求的一致。需要注意的是，Answer变成了2,因为找到了两条记录。消息体内也包含了请求的Queries的内容，含义和请求里的是一样的。多出来的就是响应的内容。

查询的结果由5部分组成：

Name，也就是查询的域名，两个字节。
Type，记录类型，第一条是CNAME类型。对应的值是5。两个字节。
Class，分类，两个字节，值是1(IN）。
Data length，数据长度。两个字节。
Primaryname，这是重点，主要就是在查这个东西。如果上面Type是CNAME类型，那么解析的方式要按照域名的方式解析，编码方式和上面请求里发送域名的方式一样。如果是A，那么解要按照IP解析，Data length也对应的是4(IPv4)。一个字节是一个IP里的块，然后用点连起来。16进制分别是95、7e、4d、98，那么换成能看懂的就是149.126.77.152。

0000 11 ac 81 80 00 01 00 02 00 00 00 00 03 77 77 77 0010 05 63 79 65 61 6d 03 63 6f 6d 00 00 01 00 01 c0 0020 0c 00 05 00 01 00 00 00 0a 00 16 05 76 6d 36 38 0030 68 01 78 08 69 6e 63 61 70 64 6e 73 03 6e 65 74 0040 00 c0 2b 00 01 00 01 00 00 00 e3 00 04 95 7e 4d 0050 98

上面抓到的数据包，可以从这里访问到。本来是想写Golang语言实现的，太晚了，明天再写。

参考文献

《计算机网络（第五版）》谢希仁
What does a DNS request look like? - serverfault

安全URL的Base64编码

2015-01-20T00:00:00+00:00

这是一个例子，可以先感受下：Base64编解码。

之前在《网址压缩的调研分析（续）》介绍过Base62算法，他是一种类似于Base64的哈希算法。今天发现了另一种优化的Base64算法，又参考了下Golang的源码，在encoding/base64/base64.go里面。

const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

传统的Base64用的是A-Z、a-z、0-9，还有+和/，一个64个编码串。

然而，标准的Base64并不适合直接放在URL里传输，因为URL编码器会把标准Base64中的“/”和“+”字符变为形如“%XX”的形式，而这些“%”号在存入数据库时还需要再进行转换，因为ANSI SQL中已将“%”号用作通配符。

为解决此问题，可采用一种用于URL的改进Base64编码，它不在末尾填充’=’号，并将标准Base64中的“+”和“/”分别改成了“-”和“_”，这样就免去了在URL编解码和数据库存储时所要作的转换，避免了编码信息长度在此过程中的增加，并统一了数据库、表单等处对象标识符的格式。

base64.go文件里还定义了专用于URL里传输的URL安全的Base64算法。

const encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"

把之前的加号换成了减号，斜线换成了下划线。

就是因为这个原因，我发现我的一个编码结果和应该得到的只相差一位，一个是加号，一个是减号。因为如果是编码串不同的原因，哪怕就是差一位，结果也是完全不同的，差一位肯定不是因为这个。原来是这样，懂得还是太少了。。。

参考文献

Base64 - 维基百科

使用Git工具统计代码

2015-01-17T00:00:00+00:00

1. git shortlog -s –since=2013-12-01 –before=2015-12-10 HEAD –no-merges
2. git show-ref –tags
3. git rev-list –pretty=format:”%at %ai %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD | grep -v ^commit
4. git rev-list –pretty=format:”%at %T” –since=2013-12-01 –before=2015-12-10 HEAD | grep -v ^commit
5. git ls-tree -r -l -z HEAD
6. git log –shortstat –first-parent -m –pretty=format:”%at %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD
7. git log –shortstat –date-order –pretty=format:”%at %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD
8. git –git-dir=.git –work-tree=./ rev-parse –short HEAD
- 参考文献

之前一直想写一个统计代码行数的工具，就是遍历一下文件目录，把里面文件的行数读一下。一直就是想这么干。但是这样干比较low，这是一锤子买卖，只能干一次，第二次统计就还是从头开始统计，没办法统计一个区间下修改行数。想要统计每天修改的行数，就更难，难到需要每天都运行一次并且把数字存下来么？还有，如果要统计每个人修改的情况改怎么办？这个办法就不行了。

GitStats项目，用Python开发的一个工具，通过封装Git命令来实现统计出来代码情况并且生成可浏览的网页。官方文档可以参考这里。

其实这个项目的核心就是Git命令，如果项目是在Git下托管的，那么围绕git log命令都能够实现。虽然Git是我常用的代码仓库，但是只会提代码、合并代码这些操作，还是得学。我就把阅读GitStats源码相关的Git笔记放到这里，和大家分享。

将会用到8个命令：

1. git shortlog -s –since=2013-12-01 –before=2015-12-10 HEAD –no-merges

git shortlog -s --since=2013-12-01 --before=2015-12-10 HEAD --no-merges

-s 显示提交次数和提交描述这个命令用来得到提交过代码的用户数量，用来计算用户平均提交次数。git log将日志按用户进行聚合。Suppress commit description and provide a commit count summary only，只显示用户及提交次数。wc是shell命令，用来统计单词数，-l参数用来统计行数。Git命令返回结果如下：

Bryce
git
lichao
mnhkahn

2. git show-ref –tags

git show-ref --tags

获取tag相关内容。显示本地commit ID和远程分支的关系。Git里面的tag我没有用过，暂且先不分析他。

3. git rev-list –pretty=format:”%at %ai %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD | grep -v ^commit

git rev-list --pretty=format:"%at %ai %aN (%aE)" --since=2013-12-01 --before=2015-12-10 HEAD | grep -v ^commit

倒序显示全部的时间片、日期、用户名和邮箱日志。计算出来最后一次提交时间、第一次提交时间。时间用来计算每小时、每天、每周、每月、每年的activity。为每一个用户计算第一次和最后一次提交的时间。根据时间片得到时间，记录当月、当年用户的提交次数和当月提交次数。记录作者的活动天数和最后活动日期。git rev-list按时间倒序。返回结果和参数解释如下：

420382132 2015-01-04 22:35:32 +0800 mnhkahn (lichao0407@gmail.com)

%at: 日期, UNIX timestamp
%ai: 日期, ISO 8601 格式
%aN: mailmap的作者名字
%aE: 作者邮箱
%T: tree hash

4. git rev-list –pretty=format:”%at %T” –since=2013-12-01 –before=2015-12-10 HEAD | grep -v ^commit

git rev-list --pretty=format:"%at %T" --since=2013-12-01 --before=2015-12-10 HEAD | grep -v ^commit

倒序显示时间片和哈希值。把这两个值保存到cache里面。

1420382132 dd29c4a84acc48c2d30583db0ac47235818142c3

5. git ls-tree -r -l -z HEAD

git ls-tree -r -l -z HEAD

100644 blob 6982c3544235f7c141bfe4e509eb5ed55bbfd0e0     675 wallpaper/win32api/kernel.go

-r 递归调用
-l 显示文件大小（和ls -a命令返回的大小数一样）。
-z 以\0作为行连接符显示所有文件的commit hash、大小、文件名。6982c3544235f7c141bfe4e509eb5ed55bbfd0e0是blob_id，675是文件大小，最后一个参数是文件路径。根据此计算后缀名提交次数。可以根据文件路径过滤指定路径和指定后缀的文件。像ls -a一样展示所有文件。

6. git log –shortstat –first-parent -m –pretty=format:”%at %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD

git log --shortstat --first-parent -m --pretty=format:"%at %aN (%aE)" --since=2013-12-01 --before=2015-12-10 HEAD

统计主分支代码行数，根据日期计算代码行数比直接遍历日志好。得到的是两行结果，分别得到时间片、用户名，增加和删除的代码行数。最后得到得到每天、每月、每年、一共增加、删除的代码行数。

1420382132 mnhkahn (lichao0407@gmail.com)
1 file changed, 20 insertions(+)﻿

–stat

commit 782226c323df77dfaf99c5e8cb188a04d1539ec4
Author: mnhkahn <lichao0407@gmail.com>
Date: Sun Jan 4 22:35:32 2015 +0800

sego

test_sego.go | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)

–shortstat 显示stat的最后一行，修改文件的总数
–first-parent 根据第一次父提交来查看合并提交。
-m 只关心主分支，不考虑合并代码
–date-order

7. git log –shortstat –date-order –pretty=format:”%at %aN (%aE)” –since=2013-12-01 –before=2015-12-10 HEAD

git log --shortstat --date-order --pretty=format:"%at %aN (%aE)" --since=2013-12-01 --before=2015-12-10 HEAD

再遍历一遍所有日志（不只是主分支），查询提交的人和内容。这样计算出每个人每天增加、删除、提交的行数和次数。

1420382132 mnhkahn (lichao0407@gmail.com)
1 file changed, 20 insertions(+)

8. git –git-dir=.git –work-tree=./ rev-parse –short HEAD

git --git-dir=.git --work-tree=./ rev-parse --short HEAD

获取git项目版本号。

782226c

最后说明一下，图片和二进制这些非文本文件不会被统计行数。上面所有的例子取自我的go_code项目下，如果大家想照着做一下，欢迎clone我的代码，地址点这里。

参考文献

字符串查找算法（二）

2015-01-15T00:00:00+00:00

接前面的《字符串查找算法》继续写。上一篇文章说过，神奇的数字16777619，当时不知道这个是干嘛用的，现在差不多知道了。

字符串哈希，会经常用到FNV哈希算法。FNV哈希算法如下：将字符串看作是字符串长度的整数，这个数的进制是一个质数。计算出来结果之后，按照哈希的范围求余数，结果就是哈希结果。

#define TRUE_HASH_SIZE ((u_int32_t)50000) /* range top plus 1 */
#define FNV_32_PRIME ((u_int32_t)16777619)
#define FNV1_32_INIT ((u_int32_t)2166136261)
#define MAX_32BIT ((u_int32_t)0xffffffff) /* largest 32 bit unsigned value */
#define RETRY_LEVEL ((MAX_32BIT / TRUE_HASH_SIZE) * TRUE_HASH_SIZE)
u_int32_t hash;
void *data;
size_t data_len;

hash = fnv_32_buf(data, data_len, FNV1_32_INIT);
while (hash >= RETRY_LEVEL) {
		hash = (hash * FNV_32_PRIME) + FNV1_32_INIT;
}
hash %= TRUE_HASH_SIZE;

下面给出了三个质数，分别是求范围是32位、64位、128位和256位哈希值时使用。当然，这三个质数是怎么得到的，我肯定不知道。

32 bit FNV_prime = 224 + 28 + 0x93 = 16777619 64 bit FNV_prime = 240 + 28 + 0xb3 = 1099511628211 128 bit FNV_prime = 288 + 28 + 0x3b = 309485009821345068724781371 256 bit FNV_prime = 2168 + 28 + 0x63 = 374144419156711147060143317175368453031918731002211

继续看Golang的代码，字符串字串匹配用的是无符号32位整数，那就是32位长度，自然，质数就需要选16777619了。结果会按照32位最大的整数求余，在这里，因为是将结果存在uint32里面的，所以超出范围的会被丢弃，也可以认为是求余操作。

const primeRK = 16777619

// hashstr returns the hash and the appropriate multiplicative
// factor for use in Rabin-Karp algorithm.
func hashstr(sep string) (uint32, uint32) {
	hash := uint32(0)
	for i := 0; i < len(sep); i++ {
		hash = hash*primeRK + uint32(sep[i])
	}
	var pow, sq uint32 = 1, primeRK
	for i := len(sep); i > 0; i >>= 1 {
		if i&1 != 0 {
			pow *= sq
		}
		// 只有32位，超出范围的会被丢掉
		sq *= sq
	}
	return hash, pow
}

剩下的就是上一篇文章提到的，RK算法，根据FNV哈希得到的值进行推算，能够在o(1)时间范围内计算得到下一条字串的哈希值。然而，FNV哈希算法能够保证大部分情况下哈希的结果都在指定范围内均匀分布，但不是全部。所以在最后判断字串是否相等的时候，还会再加上s[:n] == sep来保证完全一致，所以，RK算法的复杂度准确的说是o(m+n)。

if h == hashsep && s[:n] == sep {
	return 0
}

为啥判断相等的时候不直接用s[:n] == sep来判断每个字串是否相等？因为这样的话，复杂度又变回o(m*n)了。

参考文献

北京地铁视频播放原理猜想

2015-01-14T00:00:00+00:00

今天晚上乘坐8号线回家，一路都在地铁里面那个电视，当时正在播放那个《非常静距离》。看着看着，发现出bug了，屏幕最下面露出来了任务栏，赫然写着vlc播放器。嗯，用开源的，不错。此外，还能发现这东西用的是Windows系统，看着像Windows XP或者之前的系统。

VLC播放器处于任务栏选中状态，说明视频的内容最起码车厢内的客户端是VLC。如果是用VLC作为客户端，那说明它就是在播放视频。VLC播放的视频不应该是本地视频，这样的话太low了，并且很难管理报站。VLC支持RTSP、RTP等协议，能够播放远程流媒体信息，具体操作可以参考我之前的文章。

那么这个流媒体的服务器端在哪里呢？视频一般包含了到站信息、日期和时间等。知道当前是哪一站的是列车本身和控制台。我个人认为数据应该是控制台发送的，因为有时候会出现丢帧、卡顿的现象，并且是视频内容和到站信息都卡（据我观察是这样）。那么，说明数据应该都是远程传输过来的。列车内部传输的话应该都是有线传输，不应该出现那么严重卡顿。

所以大体流程是这样：控制台能监控到列车运行情况，并结合一些视频资源，动态拼接出当前列车的视频内容。通过一定的流媒体技术进行传输。这样，能够解耦合，列车长开车的时候不需要管这些有的没的，视频内容也不需要在修改的时候每辆车都去更新。

意淫结束了。

参考文献

如何开发搜索引擎——爬虫（一）

2014-12-26T00:00:00+00:00

爬虫抓取网页的过程可以抽象为数据结构里面的有向图，超链接就是图的边，网页内容是节点。那么抓取的遍历方式，也就是广度优先遍历或者是深度优先遍历。图当中比较复杂的是防止回路，实际抓取当中会由于网站设计的多样导致循环抓取，需要有一套完善的机制来防止回路。

网页内容的抓取也是一个复杂的问题，网页内部除了正文，还可能会有一些用户的联系信息、广告等其它数据。网页内容的抓取，微软最早设计了视觉抓取算法，就是模拟人通常观察一个网页会看的地方进行抓取。这个东西比较复杂，没有研究过。

简单点的解析方法，根据文字和HTML标签的比例进行抓取：通常，网页的正文都是连续的，并且其HTML标签不会很复杂，占比例较小，而其它部分，例如导航、广告等內容，通常HTML标签的数量会多余文字数量。可以对网页进行实验，拟合出一个近似的比例来进行抓取。

上面说的是通用的方法，还有一些情况，比如要去抓取今天NBA比赛的比分，这个通过上面的方式就很难了。一般去抓取这些内容的网页固定，比如都是去新浪体育去抓取，每个队的名字、比分都是在固定的HTML标签内，短时间内不会变化。这个时候就可以通过模板的方式进行抓取。

下面是一些当时学习的笔记，供大家参考：

为什么是图？在图论中，连通图基于连通的概念。在一个无向图G中，若从顶点v_i到顶点v_j有路径相连（当然从v_j到v_i也一定有路径），则称v_i和v_j是连通的。
用哪种遍历方式，深度还是广度遍历？网页的抓取策略可以分为深度优先、广度优先和最佳优先三种。深度优先在很多情况下会导致爬虫的陷入(trapped)问题，目前常见的是广度优先和最佳优先方法。广度优先搜索策略是指在抓取过程中，在完成当前层次的搜索后，才进行下一层次的搜索。最佳优先搜索策略按照一定的网页分析算法，预测候选URL与目标网页的相似度，或与主题的相关性，并选取评价最好的一个或几个URL进行抓取。它只访问经过网页分析算法预测为“有用”的网页。深度优先搜索策略从起始网页开始，选择一个URL进入，分析这个网页中的URL，选择一个再进入。重要网页通常距离种子较近，而过度深入抓取到的网页却价值很低。
遍历要防止回环，如果操作？欧拉回路：从图中一个节点出发，经过图中所有边一次且仅一次，最后回到出发点，当且仅当图中所有节点的度都是偶数。用哈希表防止回环，一般网址较长，用MD5或16位的MD5作为作为key用于验证重复。为了防止爬虫意外中断的情况，访问记录应该保存在硬盘当中而不是内存里面。可以用redis解决。布隆过滤器也可以用来防止回路。用最多抓取次数防止回路（节流）。
根据url判定是相同页面还是根据内容判断是相同页面？ url别名。内容指纹，通过MD5计算。
html解析提取超链接、提取缩略图、提取内容。单行匹配s从头到尾匹配，.可以匹配到任意字符，包括换行符；多行匹配m以换行符为单位进行匹配，所以此时.无法匹配到换行符。
- 匹配html：(?is)<.*?>。(?is)是模式修改符。意思是将后面的匹配模式修改成IGNORECASE和SINGLELINE，IGNORECASE就是忽略大小写，SINGLELINE就是规定特殊字符“.” 匹配任意的字符，包括换行符。默认情况下，特殊字符“.”不匹配换行符；
- 匹配超链接：(?is)<a .*?</a>；
- 匹配图片：(?is)<img .*?>；

参考文献

Golang通过邻接表实现有向图

2014-12-20T00:00:00+00:00

本科学习数据结构的时候就听前辈说过，学好数据结构、计算机组成、操作系统和计算机网络后就会成为大神，我也使劲学过，但是一直没发现数据结构的用处。实际编程用过比较多的就是哈希表了，一般语言也都会通过一些扩展包支持。

《数学之美》第九章——《图论和网络爬虫》，就浅显易懂的介绍了图的实际用途。搜索引擎里面的网络爬虫抓取网络数据，就是把互联网抽象成有向图这种数据结构，通过遍历这张图实现的互联网抓取。

图一般分为有向图和无向图，一般用来开发网络爬虫和地图（我就知道这两个）。图可以认为是节点和连接边的集合，有两种实现方式：邻接表和邻接矩阵。稀疏图用邻接表实现，稠密图用邻接矩阵实现。图的重点在于遍历，有深度优先遍历和广度优先遍历。深度优先遍历可以通过递归实现，而广度优先遍历要转换成类似于树的层序遍历来实现。还要注意一点，图的遍历要防止回路，否则无法结束遍历。

type Graph struct {
	edgnum int
	vexnum int
	adj    []Vertex
}

type Vertex struct {
	Data string
	e    *Edge
}

type Edge struct {
	ivex int
	next *Edge
}

定义了三个结构体， Graph是图的数据结构，它包含边数、顶点数和顶点的集合；Vertex是顶点数据结构，包含顶点的数据内容和边的头指针，Edge边的结构体定义了与此顶点相连的另一个顶点在图的顶点集合中的位置和下一个边的地址。

图是顶点和边的集合，adj对象就是顶点的集合，每一个顶点内部的e就是通过链表实现的边的集合。这也就实现了图。

在图中插入顶点，这个比较简单，加入顶点的集合即可：

func (this *Graph) InsertVertex(v Vertex) {
	this.adj = append(this.adj, v)
}

在图中插入边，需要指出相连的两个顶点的信息，然后把边的信息插入到链表的最后：

func (this *Graph) InsertEdge(v1, v2 Vertex) {
	var p *Edge = this.adj[this.get_position(v1.Data)].e
	if p == nil {
		// fmt.Println("nil...", v1.Data, v2.Data)
		this.adj[this.get_position(v1.Data)].e = NewEdge(this.get_position(v2.Data))
	} else {
		for ; p.next != nil; p = p.next {
		}
		p.next = NewEdge(this.get_position(v2.Data))
		// fmt.Println("append...", v1.Data, v2.Data)
	}
}

获取某个顶点的邻接顶点，找到顶点的边集合，就可以通过边集合找到与它相连的顶点了。也可以通过这个方法计算得到顶点的出度（Out Degree）：

func (this *Graph) Adjacent(v Vertex) []Vertex {
	res := make([]Vertex, 0)
	p := this.adj[this.get_position(v.Data)].e
	for ; p != nil; p = p.next {
		res = append(res, this.adj[p.ivex])
	}
	return res
}

func (this *Graph) OutDegree(v Vertex) int {
	res := 0
	p := this.adj[this.get_position(v.Data)].e
	for p != nil {
		res++
		p = p.next
	}
	return res
}

计算顶点的入度相比出度有点麻烦，因为图本身保存的边的集合是边的起始位置，结束位置，也就是入度，只能遍历整个边集合来计算：

func (this *Graph) InDegree(v Vertex) int {
	res := 0
	pos := this.get_position(v.Data)
	for _, a := range this.adj {
		p := a.e
		for p != nil {
			if pos == p.ivex {
				res++
			}
			p = p.next
		}
	}
	return res
}

广度优先遍历，这个遍历类似于层序遍历，每遍历一层，需要记住当前层的节点，然后与遍历当前层相连的节点，如此实现遍历。需要一个队列来记住当前层，先进先出。我是通过Golang的slice实现的简单队列。还有一个问题，就是需要防止回路，也就是说，一个节点不能遍历两次。这里用了Golang内置的map实现，随机存储、随机查找。遍历还要防止非完全图的情况，如果只有结点没有边还需要处理，所以这里用for循环来处理：

func (this *Graph) Bfs() {
	res := map[int]Vertex{}
	for _, a := range this.adj {
		Q := []Vertex{a}
		for len(Q) != 0 {
			u := Q[0]
			Q = Q[1:]
			if _, ok := res[this.get_position(u.Data)]; !ok {
				Q = append(Q, this.Adjacent(u)...)
				res[this.get_position(u.Data)] = u
				fmt.Printf("%s ", u.Data)
			}
		}
	}
	fmt.Printf("\n")
}

深度优先遍历，遍历完一个节点，接着遍历这个节点的这个节点相连的节点，直到结束。用递归非常简单：

func (this *Graph) Dfs() {
	res := map[int]Vertex{}
	for _, a := range this.adj {
		this.dfs(a, res)
	}
	fmt.Printf("\n")
}

func (this *Graph) dfs(u Vertex, res map[int]Vertex) {
	if _, ok := res[this.get_position(u.Data)]; !ok {
		res[this.get_position(u.Data)] = u
		fmt.Printf("%s ", u.Data)
		p := u.e
		for p != nil {
			if _, ok := res[p.ivex]; !ok {
				this.dfs(this.adj[p.ivex], res)
			}
			p = p.next
		}
	}
}

完整的测试代码，大Golang的单元测试工具，直接go test即可：

func TestMain(t *testing.T) {
	g := create_example_lgraph()
	g.Print()
	println("Bfs.............")
	g.Bfs()
	println("Dfs.............")
	g.Dfs()
	if g.InDegree(Vertex{Data: "E"}) != 2 {
		t.Error("indegree of E wanted 2 bug got", g.InDegree(Vertex{Data: "E"}))
	}
	if g.OutDegree(Vertex{Data: "E"}) != 2 {
		t.Error("outdegree of E wanted 2 bug got", g.OutDegree(Vertex{Data: "E"}))
	}
}

func create_example_lgraph() *Graph {
	vexs := []string{"A", "B", "C", "D", "E", "F", "G"}
	edges := [][2]string{
		{"A", "B"},
		{"B", "C"},
		{"B", "E"},
		{"B", "F"},
		{"C", "E"},
		{"D", "C"},
		{"E", "B"},
		{"E", "D"},
		{"F", "G"}}
	vlen := len(vexs)
	elen := len(edges)

	pG := Create()
	// 初始化"顶点数"和"边数"
	pG.vexnum = vlen
	pG.edgnum = elen
	// 初始化"邻接表"的顶点
	for i := 0; i < pG.vexnum; i++ {
		pG.InsertVertex(*NewVertex(vexs[i]))
	}
	// 初始化"邻接表"的边
	for i := 0; i < pG.edgnum; i++ {
		// 读取边的起始顶点和结束顶点
		pG.InsertEdge(*NewVertex(edges[i][0]), *NewVertex(edges[i][1]))
	}
	return pG
}

本文所涉及到的完整源码请参考。

参考文献

【1】wangkuiwu/datastructs_and_algorithm - GitHub
【2】《数据结构与算法——C语言描述》，Mark Allen Weiss著
【3】《算法导论》Thomas H. Cormen等著
【4】《数学之美》吴军著

Golang通过pup实现HTML解析

2014-12-01T00:00:00+00:00

上一周给我的网站加了一个搜索功能，能自动抓取我的博客和别人的CSDN博客。通过RSS抓取。这样数据格式规范，容易解析。问题是信息较少。后来发现在HTML源代码里面，会有为了方便搜索引擎索引的meta字段，能指出作者和详情。以我的博客《Golang实现HTTP发送gzip请求》为例。里面的meta信息如下：

<meta charset="utf-8">
<meta name="description" content="beego的httplib不支持发送gzip请求，自己研究了一下。">
<meta name="author" content="Bryce">
<meta name="google-translate-customization" content="a4136e955b3e09f2-45a74b56dc13e741-gf616ffda6e6360e0-11">
<meta name="viewport" content="width=device-width, initial-scale=1.0">

查了查，一般大家通过xpath进行解析。有一个现成的包https://github.com/go-xmlpath/xmlpath，按照说明做了一下，不行。看了一下源码，这个包内部是通过encoding/xml实现的，如果HTML的代码有问题，标签不是严格按照规范编写的，就会有解析问题。同理，如果把HTML当作XHTML处理，也是不行的。

后来发现一个神奇的工具https://github.com/EricChiang/pup，通过命令go get github.com/ericchiang/pup安装。它可以通过管道调用：

curl -s http://blog.cyeam.com | pup 'div div div div h2 a'

直接抓取作者和简介可以用如下命令：

curl -s https://blog.cyeam.com/golang/2014/11/29/golang_gzip | pup 'head meta[name="author"] attr{content}'
curl -s https://blog.cyeam.com/golang/2014/11/29/golang_gzip | pup 'head meta[name="description"] attr{content}' 

这个包能完美解决我的问题，进去看了一下源码，发现包名是main，再一个是因为它用来解析HTML不是那么方便，想了想，我囧的还是用cmd的方式通过管道执行。

req := httplib.Get("https://blog.cyeam.com/golang/2014/11/29/golang_gzip")
res, err := req.Bytes()
if err != nil {
	panic(err)
}

cmd := exec.Command("pup", `head meta`)
stdin, err := cmd.StdinPipe()
if err != nil {
	panic(err)
}
// defer stdin.Close()
var output bytes.Buffer
cmd.Stdout = &output

if err = cmd.Start(); err != nil { //Use start, not run
	fmt.Println("An error occured: ", err) //replace with logger, or anything you want
}
stdin.Write(res)
stdin.Close()

if err := cmd.Wait(); err != nil {
	panic(err)
}
fmt.Println(string(output.Bytes())) //for debug

通过shell命令行管道是通过|实现，而通过Golang代码，需要通过exec包提供的Stdin实现。把内容写入标准输入流，就相当于管道输入了。写完了要关闭输入流stdin.Close()，如果不关闭，输入流不会被写入。。。

本文所涉及到的完整源码请参考。

参考文献

Golang实现HTTP发送gzip请求

2014-11-29T00:00:00+00:00

互联网是基于HTTP协议的，但是数据量大的情况下，HTTP就显得有点慢了，接口API一般使用Facebook开源的Thrift。但是Thrfit使用场景有限。这个时候就只能考虑减少数据量来优化HTTP请求了。

压缩的原理就是服务器端将本来要返回的数据进行压缩，传输给客户端之后，客户端用双方约定好的方式再解压缩。通过Fiddler和Debug测试，一般用Gzip相对于原数据能压缩80%~90%。而响应时间并没有因此而增加。

客户端和服务器之间是通过请求时的HTTP头Content-Encoding和Accept-Encoding来通知服务器进行何种方式压缩数据。

Golang提供了”compress/gzip”包进行压缩和解压缩处理。这个包里的gunzip.go文件实现了解压方法。结构体Reader实现了”io”包里的接口Reader：

type Reader interface {
	Read(p []byte) (n int, err error)
}

通过包io/ioutil包里的ReadAll函数，可以自动调用实现类里的Read函数。下面是基于Golang原生包net/http发送Gzip请求的完整代码。打印出来了解压前和解压后的数据量。

client := http.Client{}
req1, err := http.NewRequest("GET", "http://blog.cyeam.com", nil)
req1.Header.Add("Content-Encoding", `gzip`)
req1.Header.Add("Accept-Encoding", `gzip`)
resp1, err := client.Do(req1)
if err != nil {	
	panic(err)
}
defer resp1.Body.Close()
body, err := ioutil.ReadAll(resp1.Body)
fmt.Println("Length of uncompress: ", len(body))
compressedReader, err := gzip.NewReader(resp1.Body)
body1, err := ioutil.ReadAll(compressedReader)
if err != nil {
	panic(err)
}
fmt.Println("Length of gzip: ", len(body1))

虽然接口定义了Read函数，能够通过此函数将数据读取出来，但是提取数据还是比较麻烦的。Golang提供了io/ioutil包辅助实现数据的读取，可以通过ioutil.ReadAll方法进行自动读取，它里面自动调用了io包的Read方法。我把源码里面调用的函数都贴了过来。

func ReadAll(r io.Reader) ([]byte, error) {
	return readAll(r, bytes.MinRead) // 调用realAll
}

func readAll(r io.Reader, capacity int64) (b []byte, err error) {
	buf := bytes.NewBuffer(make([]byte, 0, capacity))
	// If the buffer overflows, we will get bytes.ErrTooLarge.
	// Return that as an error. Any other panic remains.
	defer func() {
		e := recover()
		if e == nil {
			return
		}
		if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
			err = panicErr
		} else {
			panic(e)
		}
	}()
	_, err = buf.ReadFrom(r) // 调用ReadFrom
	return buf.Bytes(), err
}

func (devNull) ReadFrom(r io.Reader) (n int64, err error) {
bufp := blackHolePool.Get().(*[]byte)
readSize := 0
for {
	readSize, err = r.Read(*bufp) // 在这里自动调用了实现类的Read函数进行读取操作。
	n += int64(readSize)
	if err != nil {
		blackHolePool.Put(bufp)
		if err == io.EOF {
			return n, nil
		}
		return
	}
}

本文所涉及到的完整源码请参考。

Golang字符串切割函数Split

2014-11-22T00:00:00+00:00

先说结论：大Golang里面，如果一个空字符串通过strings包的Split函数进行切割，那么结果是一个长度为1的数组，里面的内容是一个空字符串。

为了验证，分别在1.0.1、1.1、1.2.2、1.3.3、1.4rc上面进行了测试，验证了上面的结论是正确的。

func main() {
	a := strings.Split("", ";")
	fmt.Printf("%d****%s****\n", len(a), a[0])
}

这个也很好理解。切割一个空字符串，肯定是没办法切的，那么结果就是没切开，把原字符串直接加入结果数组里面而已。只不过一开始有点难理解，因为我们都会认为如果是空字符串去切，结果数组里应该是空的。

最近升级了beego1.4.2，谢大把beego控制器获取请求参数函数Controller.GetInt函数的返回值，由之前的int64改成了int，本来最早用的时候就别扭，如果想取到int64，那直接再加个函数Controller.GetInt64就可以了，结果这么一搞，还得自己惦记着。结果这次谢大果断把Controller.GetInt返回值改了，项目直接编译不过了。

当然，这不算什么，编译不过最起码知道问题出在哪里了。还有一个坑，beego.AppConfig.Strings函数，之前是可以将配置里的字符串通过分号自动切割成数组。结果更新之后，之前的代码返回是空的了（也就是里面是长度是1的空字符串）。这个可害苦了我。看了下源码，发现config包解析配置文件的方法进行了大幅度更新，但是我经过分析，认为并不是这里的错误，反而是另一个地方beego/config.go第111行

func (b *beegoAppConfig) Strings(key string) []string {
	v := b.innerConfig.Strings(RunMode + "::" + key)
	if len(v) == 0 {
		return b.innerConfig.Strings(key)
	}
	return v
}

从runmode里获取配置的值，如果没有取到，去取默认值。这里说一下，beego的配置文件支持dev、prod和default三种模式。如果配置了runmode，根据其在配置文件内查找相应的配置，否则去取默认值。上面的代码大体是这个含义。但是如果没有找到runmode下的配置，此时if的判断是len(v) == 0，而之前从配置文件的实现ini.go里取值的函数如下：

func (c *IniConfigContainer) Strings(key string) []string {
	return strings.Split(c.String(key), ";")
}

它会把取到的字符串进行切割，结合我们上面提到的，无论怎么切割，长度最少是1,所以if判断永远是false，取默认值的逻辑永远不会被执行。修改的方法也很简单，判断语言改成if v[0] == ""即可。完成的beego/config包介绍可以看我之前的文章。我已经给谢大提了Merge Request，但是他一直没有理我。。。

24号谢大合并了我的代码，开心开心开心。

本文所涉及到的完整源码请参考。

beego/config包源码分析

2014-11-12T00:00:00+00:00

从去年12月底开始接触golang，用过revel和beego框架。最后选择了beego，用beego的原因也很简单，因为beego是中国人开发的，有中文文档。

golang起源于C语言，虽然不支持面向对象编程，但还是提供了接口interface、匿名字段等方式。虽然进行面向对象编程还是有点别扭，但是好歹都能实现。这里借花献佛，介绍一下beego的config包，顺便提一下golang的面向对象编程。

config包的config.go文件定义了两个接口，ConfigContainer和Config，ConfigContainer定义了如何从原始数据里面获取配置信息的方法。Config接口是一个适配器，定义了把原始数据解析到ConfigContainer的方法。

config包里的其它文件是这两个接口的实现。xml文件夹实现了解析XML数据格式的方法，yaml文件夹实现了解析YAML格式的方法，ini和json分别解析INI格式和JSON格式。这里主要说一下INI格式的实现。

ini.go文件定义了两个结构体IniConfigContainer和IniConfig，分别实现了上面的两个接口。golang接口的实现语法可以参考之前的文章《Golang 接口实现》。其中，IniConfigContainer不光实现了接口，还定义了内部变量来辅助实现。

filename       string
data           map[string]map[string]string // section=> key:val
sectionComment map[string]string            // section : comment
keyComment     map[string]string            // id: []{comment, key...}; id 1 is for main comment.
sync.RWMutex

data是用map实现的，用来保存配置文件的键值对。IniConfigContainer还有一个匿名对象sync.RWMutex，这是golang继承的语法，说明IniConfigContainer继承了同步锁，在这里用于互斥修改配置文件的值。config包和INI格式的实现可以参考下图。

Apache Bench 压力测试

2014-11-11T00:00:00+00:00

项目开发，尤其是接口开发完之后，都需要进行压力测试。这样做可以帮助我们检验接口的平均响应时间。比如我们接口是查询数据库，我们可以将压力测试的结果和一般常见的相比，如果明显变慢，那么可能就是逻辑有问题或者是SQL查询有问题。这样可以在宏观上避免失误。在压力测试的时候，还可以顺便用top命令监控一下内存情况，看一下是否存在内存泄漏。

Apache提供了ab工具，直接安一个就成。也可以使用wrk进行测试。ab工具有个坑，测试的url后面需要加个/，要不会提示invalid Url。

ab -c 10 -n 100 http://www.baidu.com/
Requests per second:    47.46 [#/sec] (mean)
Time per request:       210.682 [ms] (mean)
Time per request:       21.068 [ms] (mean, across all concurrent requests)

-c是并发数，-n是压力次数。并发10的情况下，处理响应时间是210ms，那么响应一次就是21ms，每秒的响应次数就是1000/21=47次。一般还会预估系统响应能力，如果要求每秒能够响应1000次，再假设前面压的是一台机子，那么就最少需要21台服务器。

再补充一些。压力测试最好直接连到服务器上去压本机IP和端口，而不是去呀域名，因为CDN或者Nginx，还当前网络情况都会影响到响应时间。这样做可以简化流程，便于分析结果。并且我们本身只负责开发，其它的交给运维去处理就好了。

如果一套接口是相关的，比如用户增加购物车，购物车列表接口。我们不光要单独去压这些接口，最好再进行一次集合测试。比如，批量去压添加购物车的接口，然后去压购物车列表接口。观察一下列表接口能够正常返回之前批量压添加购物车接口的时间。但是具体怎么做，我目前也不是很明白，希望大神指教。

MySQL的find_in_set函数

2014-10-13T00:00:00+00:00

之前学校念书的时候，学过各种范式。范式里一般要求，就是只要遇到一对多或者多对多的关系，就把多这边拆出去。这样做一来是为了节约空间，如果关联的是字符串或者占用比较大的东西，拆出去用一个id来关联；还有一个就是可以防止多对多关系的变化，比如关联性别，已经有男和女了，如果加一个不男不女还行，但是要删一个女，那么就需要这个了，一般数据库也支持关联的修改。

但是我们都是比较懒的，还死活拿性别来说。性别就俩，男和女。为来也不会增加和减少，那么就不必要创建性别表，因为就是建了，也没有必要；一般我们也会省略关联表。而是只用一列进行关联，关联男或女就用1或0，如果关联两个，是用0,1表示。这也可能是大辉哥说的“反模式”。

这样数据库设计比较省事，但是查的时候不太好查。如果列里面是1,2,3，查里面有没有1，一般我也是笨笨得遍历一下。今天同事告诉我一个新牛逼的MySQL函数FIND_IN_SET()。

FIND_IN_SET(str,strlist)

Returns a value in the range of 1 to N if the string str is in the string list strlist consisting of N substrings. A string list is a string composed of substrings separated by “,” characters. If the first argument is a constant string and the second is a column of type SET, the FIND_IN_SET() function is optimized to use bit arithmetic. Returns 0 if str is not in strlist or if strlist is the empty string. Returns NULL if either argument is NULL. This function does not work properly if the first argument contains a comma (“,”) character.

这个是专门针对用逗号分隔的串的查找。如果没有找到，返回0；找到了，返回位置，位置从1开始。

参考文献

【1】12.5 String Functions - FIND_IN_SET()

用Golang写了一个更新壁纸的小程序

2014-10-09T00:00:00+00:00

之前安装了安了Ubuntu 14.04，还写了个小程序，能开机更新桌面壁纸——《Ubuntu通过Bing壁纸自动更新》。结果谁知道Ubuntu这个版本是怎么回事，一把开发环境配置好，就开不了机了。。。我这种学渣实在是处理不了，只能换Windows 8了。

换了Windows 8还是惦记着我的更新壁纸程序。Windows系统和Linux不同，并没有提供修改壁纸的命令，只能提供Windows API编程进行修改。本科学游戏开发的我对这个还是比较熟悉的。

#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <string>

using namespace std;

int main(int argc, char** argv)
{
	LPWSTR file_path = L"C:\\wallpaper.jpg";

	int result;
	result = SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, file_path, SPIF_UPDATEINIFILE);

	if (result == TRUE)
	{
		cout << "Wallpaper set" << result;
	}
	else
	{
		cout << "Wallpaper not set";
		cout << "SPI returned" << result;
	}

	return 0;
}

修改也很好做，然后就是获取Bing每日更新的壁纸。需要发送HTTP请求获取列表和解析RSS的XML文件。学渣我只用过Qt自带的库处理过，做这个东西不需要做界面，用这样的库意思也不大。果断想到了我大Golang和cgo。我大Golang是C语言之父设计的，cgo支持调用C语言，但是不支持C++。

cgo需要mingw提供gcc编译器，如果是64位系统还需要mingw64，这个可以去下载编译好的，默认官网下载的是32位的。

接着就是将上面的代码改写成调用C语言包的Golang语法。调用的难度在于传入壁纸文件地址。大Golang语言级别实现了字符串，而C语言只有用字符数组表示字符串。先开始都是用字符串来存的，然后传入字符串的指针，一直不成功。

这个函数SystemParametersInfo只有四个参数，SPI_SETDESKWALLPAPER表示用来设置壁纸，第二个参数表示壁纸位置（好像是这样。。。），SPIF_UPDATEINIFILE表示修改之后直接展示。这三个参数应该都没错，都是整形往里面传。有错误的可能就是文件路径了，他是LPWSTR类型。查了一下，它的定义typedef _Null_terminated_ WCHAR *NWPSTR, *LPWSTR, *PWSTR;，也就是typedef wchar_t WCHAR;。它是2个字节的Unicode字符类型。也就是说，LPWSTR是一个字符数组，函数调用的时候就是传入字符数组的指针进去。后来我就把字符串转换成数组[]byte类型（文件路径不会有中文，所以用[]byte还是[]rune都没有影响）。然后像C语言一样，把数组名称传进去（C语言里面，字符数组名称就是这个数组的指针）。结果还是不行，后来发现大Golang的数组名称不是地址。。。大Golang获取数组地址应该是这样&path[0]。

大Golang做json解析非常简单，我起初也是按照json的方式来解析XML，结果不行。后来参考了谢大的《Go Web 编程》。具体原因我没有去了解。关于XML的后面再补。

编译程序：

go build go_code/wallpaper/win32api
go install go_code/wallpaper/win32api

go build go_code/wallpaper/app
go install go_code/wallpaper/app

最后，将编译好的程序放到目录C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup下面，就可以咯。

本文所涉及到的代码可以参考这里。如果是64位系统，可以直接用里面编译好的文件。主要还是在讲我做过程中的思路，具体的实现，比如cgo这些，可以直接看我的代码，我这里就不详细写了。

参考文献

基于TCP套接字，通过Golang模拟HTTP请求（续）

2014-09-29T00:00:00+00:00

HTTP报文的格式问题

接着昨天的写。昨天的文章有个不确定的地方，就是建立TCP连接之后，向服务器发送的数据，包括命令、头和主体的格式。这三个部分是如何分割的，我是参考了POSTMAN预览的格式和telnet发送的格式猜测的，原认为行直接是通过\n进行区分的，而头和主题是两个\n进行区分。这样发送也是能够正常解析的，今天去读了一下《HTTP权威指南》和Golangnet/http包，具体了解了下到底是如何区分的。

《HTTP权威指南》第三章3.2节，报文的组成部分当中提到：

每行都以一个由两个字符组成的行终止序列作为结束，其中包括一个回车符\r和一个换行符\n，这个终止序列可以写作CRLF。尽管HTTP规范中说明应该用CRLF来表示终止，但稳健的应用程序也应该接受单个换行符\n作为行的终止。

这也就解释了我昨天留下的疑问。简单的说，我那样猜测是能够发送成功，原因是人家服务器牛逼。而标准的写法是两个CRLF，而不是\n。HTTP的写入是在net/http/request.go第365行的Write函数中。可以看到，每一次写入都是以\r\n结束。这里是写入命令和写入头中的User-Agent。

// Header lines
fmt.Fprintf(w, "Host: %s\r\n", host)

// Use the defaultUserAgent unless the Header contains one, which
// may be blank to not send the header.
userAgent := defaultUserAgent
if req.Header != nil {
	if ua := req.Header["User-Agent"]; len(ua) > 0 {
		userAgent = ua[0]
	}
}
if userAgent != "" {
	fmt.Fprintf(w, "User-Agent: %s\r\n", userAgent)
}

HTTP的超时问题

通过阅读Golang源码，再结合昨天的理解，明白了谢大的github.com/astaxie/beego/httplib包，设置请求超时为啥是两个参数。

func (b *BeegoHttpRequest) SetTimeout(connectTimeout, readWriteTimeout time.Duration) *BeegoHttpRequest

HTTP协议首先要和服务器建立TCP连接，接着再向服务器发送HTTP报文。这里涉及到两个和服务器端的步骤，也就需要两次超时判断。一次是判断TCP连接建立是否超时，另一次是需要判断HTTP报文发送和响应是否超时。

发送超时在net/http/client.go第278行的doFollowingRedirects函数中进行。

if c.Timeout > 0 {
	type canceler interface {
		CancelRequest(*Request)
	}
	tr, ok := c.transport().(canceler)
	if !ok {
		return nil, fmt.Errorf("net/http: Client Transport of type %T doesn't support CancelRequest; Timeout not supported", c.transport())
	}
	timer = time.AfterFunc(c.Timeout, func() {
		reqmu.Lock()
		defer reqmu.Unlock()
		tr.CancelRequest(req)
	})
}

TCP建立连接超时判断是在net/http/transport.go的495行dialConn函数中处理。

if d := t.TLSHandshakeTimeout; d != 0 {
	timer = time.AfterFunc(d, func() {
		errc <- tlsHandshakeTimeoutError{}
	})
}

对于超时的判断都是基于time包的AfterFunc函数，它会在指定时间后调用函数。如果超过指定时间还没有收到响应或者建立连接，就取消这次请求。

参考文献

【1】《HTTP权威指南》
【2】《计算机网络 - 谢希仁》

基于TCP套接字，通过Golang模拟HTTP请求

2014-09-28T00:00:00+00:00

最近买了本书《HTTP权威指南》，看了第一章，看到书上说通过telnet模拟HTTP请求，我这个学渣就发现自己没学过计算机网络。

今天翻了一下考研指定教材《计算机网络》，里面也以访问清华大学主页为例详细讲了通信过程：

浏览器分析链接指向页面的URL。
浏览器向DNS请求解析www.tsinghua.edu.cn的IP地址。
域名系统DNS解析出清华大学服务器的IP地址为166.111.4.100。
浏览器与服务器建立TCP连接（在服务器端IP地址是166.111.4.100，端口是80）。
浏览器发出取文件命令：GET /chn/yxsz/index.htma
服务器www.tsinghua.edu.cn给出响应，把文件index.htm发送给浏览器。
释放TCP连接。
浏览器显示“清华大学院系设置”文件index.htm中的所有文本。

HTTP协议就是：与指定IP和端口建立TCP连接，然后通过连接发送请求命令、头和数据。服务器响应的数据也会通过这个请求得到。

考过研的连这个都不懂的伤不起啊。

在这里我主要想自己基于TCP连接来模拟一次HTTP请求。测试是否能发送HTTP的头信息，通过User-Agent字段来模拟。还要发送Body信息测试Body的发送。

1. telnet模拟请求

$ telnet blog.cyeam.com 80
GET / HTTP/1.0

此命令可以建立连接，建立之后，输入请求命令，方法为GET，路径是根路径\，端口是80。然后再输入两个回车，就可以发送请求了。这里会返回响应状态码、响应头和Body。响应返回后，这次的telnet请求也会随之关闭。POST的发送可以参考HTTP POST via telnet - Burak’s logs

2. POSTMAN模拟请求

POSTMAN是一个Chrome插件，很强大，能够模拟HTTP请求，查看请求和响应的全部内容。我一般还会用它的Preview功能，这样能看到所有的请求数据。

3. beego模拟服务器

也可以用公网上的服务器进行测试，但是没有办法查看服务器端收到的请求详细内容，用beego搭了服务器来测试（服务器还是beego最熟。。。）。

beego当中获取User-Agent通过this.Ctx.Request.UserAgent()实现。获取Body内容通过string(this.Ctx.Input.RequestBody)实现，还需要在配置文件加入copyrequestbody = true，默认取到的Body是空的。beego服务器功能的验证可以通过POSTMAN模拟。

4. 基于TCP套接字实现HTTP的POST请求

通过POSTMAN的Preview查看完整请求和telnet使用，发现HTTP请求的命令、头和Body是通过换行符\n来区分的。POSTMAN抓到的如下：

POST  HTTP/1.1
Host: localhost:8080
Cache-Control: no-cache
Postman-Token: 649dbec6-4f13-7064-67f0-11461281ceb2

This is body

可以得到结论：HTTP命令、头和Body通过换行符来区分。第一行是请求命令，跟着是HTTP头，他们之间通过一个换行符区分，头直接也是通过一个换行符区分。两个换行符之后，是Body信息。

通过大Golang发送请求：

conn.Write([]byte("POST / HTTP/1.0\nUser-Agent: Cyeam\nContent-Length: 4\n\nBody\r\n\r\n"))

需要注意一点，如果要传入Body内容，必须在头当中加入长度信息Content-Length: 4，否则服务器依然无法获取，反正beego是这样，可能是获取Body前会先判断一下长度，如果是0就不读取Body信息了。完整代码借鉴了《Go 语言编程》第五章的内容。

本文所涉及到的完整源码请测试客户端和测试服务器。

参考文献

【1】《HTTP权威指南》
【2】《计算机网络 - 谢希仁》
【3】HTTP POST via telnet - Burak’s logs

Go语言的测试

2014-09-25T00:00:00+00:00

之前看过一本书，说：“凡大神都是先写好单元测试用例，才去写代码的”。我一直都记在心里。今天终于有空，就看了看Golang的测试包testing。

谢大的书和Golang官方的文档讲的差不多，Golang提供了两个测试方式：用例测试和压力测试。

1. 用例测试

用例测试的规则我是复制谢大的：

文件名必须是_test.go结尾的，这样在执行go test的时候才会执行到相应的代码
你必须import testing这个包
所有的测试用例函数必须是Test开头
测试用例会按照源代码中写的顺序依次执行
测试函数TestXxx()的参数是testing.T，我们可以使用该类型来记录错误或者是测试状态
测试格式：func TestXxx (t *testing.T),Xxx部分可以为任意的字母数字的组合，但是首字母不能是小写字母[a-z]，例如Testintdiv是错误的函数名。
函数中通过调用testing.T的Error, Errorf, FailNow, Fatal, FatalIf方法，说明测试不通过，调用Log方法用来记录测试的信息。

以我之前写好的堆排序为例进行测试，测试需要以包为单位。对于Golang，就是以文件夹为单位。需要将堆排序文件quicksort.go和测试文件quicksort_test.go放到一起。

验证堆排序测试用例：

func TestHeapSort(t *testing.T) {
	test0 := []int{49, 38, 65, 97, 76, 13, 27, 49}
	test1 := []int{13, 27, 38, 49, 49, 65, 76, 97}
	heapSort(BySortIndex(test0), 0, len(test0))
	for i := 0; i < len(test0); i++ {
		if test0[i] != test1[i] {
			t.Fatal("error")
		}
	}
}

$ go test -v

2. 压力测试

用例测试要用到的是testing.T，而压力测试需要testing.B。它的原型如下：

type B struct {
	common
	N                int
	previousN        int           // number of iterations in the previous run
	previousDuration time.Duration // total duration of the previous run
	benchmark        InternalBenchmark
	bytes            int64
	timerOn          bool
	showAllocResult  bool
	result           BenchmarkResult
	parallelism      int // RunParallel creates parallelism*GOMAXPROCS goroutines
	// The initial states of memStats.Mallocs and memStats.TotalAlloc.
	startAllocs uint64
	startBytes  uint64
	// The net total of this test after being run.
	netAllocs uint64
	netBytes  uint64
}

此结构里面有一个属性N，它表示的是进行压力测试的次数。可以通过b.N = 1234来设置压力次数。

func BenchmarkHeapSort(b *testing.B) {
	b.StopTimer()  //调用该函数停止压力测试的时间计数
	b.StartTimer() //重新开始时间

	b.N = 1234

	for i := 0; i < b.N; i++ {
		test0 := []int{49, 38, 65, 97, 76, 13, 27, 49}
		test1 := []int{13, 27, 38, 49, 49, 65, 76, 97}
		heapSort(BySortIndex(test0), 0, len(test0))
		for i := 0; i < len(test0); i++ {
			if test0[i] != test1[i] {
				b.Fatal("error")
			}
		}
	}
}

$ go test -v -test.bench=".*"
=== RUN TestHeapSort
--- PASS: TestHeapSort (0.00 seconds)
PASS
BenchmarkHeapSort           1234              1620 ns/op
ok      go_code/test    0.051s

这里我只是抛砖引玉，简单写了一点。今后写代码，我也得像大神一下写用例了。大家共勉，哈哈哈。

本文所涉及到的完整源码请参考。

参考文献

【1】Go怎么写测试用例 - astaxie

Ubuntu通过Bing壁纸自动更新

2014-09-17T00:00:00+00:00

在我自己的Nexus 7上面自己写了一个小程序，每天可以定时获取Bing当日的最新壁纸。每天早上起来看到都是不一样的画面，还是很开心的。

后来，也想自己写一个桌面的。本来想说用Qt去写，这样就能同时在我的Ubuntu和公司的Windows运行了。写了一半，就是读取图片这部分，设置壁纸这块不同的系统需要根据系统自身提供的接口才能修改，Windows有点麻烦，当时也有点事情，暂且作罢。

之前我的想法比较复杂，希望通过HTTP得到图片之后，将其转换成二进制编码，通过设置壁纸接口直接修改。这样做的好处是不需要保存临时文件，就是编码比较复杂。后来找了一个用Python写的Qt代码。他的思路是将文件保存到本地临时目录里面，然后通过Linux命令来修改壁纸。如此一来，省去了Linux系统接口编码的繁琐。

他的代码直接下载下来是有问题的，如果没有记错的话，是最后的madWindow函数对齐错了，加个缩进就可以了。后来，我还改了一下壁纸文件目录，我放到了home下，现在觉得放在/tmp/更好一点。最后应该是一个Linux修改壁纸命令gsettings set org.gnome.desktop.background picture-uri "file:///home/%s/%s.jpg"，并没有去研究这个，大家有兴趣可以看一下。

本文所涉及到的完整源码请参考。

【1】Ubuntu下实现用Python开机自动更新壁纸为bing壁纸

Go语言的插入排序实现

2014-09-01T00:00:00+00:00

这个算法还是我考研的时候看懂的。插入排序大体有两种，头插法和尾插法。区别就是插入的位置是头部还是尾部。

简单说一下插入排序的思路：

从第二个元素开始遍历，第一个元素认为是有序的；
将要插入的元素依次与已有序队列比较，插入到合适的位置；
循环执行，直到遍历结束。

Golang包里的实现和我上面说的严奶奶的有点区别。将遍历得到的元素倒着与有序队列依次比较。如果比有序队列的小，交换这两个元素。

这样的方法和传统的相比，插入步骤同样都是通过从后向前依次移动实现的插入。而这个方法更加简单一点，不需要声明临时变量。

package main

import "fmt"

func insertionSort(data Interface, a, b int) {
	for i := a + 1; i < b; i++ {
		for j := i; j > a && data.Less(j, j-1); j-- {
			data.Swap(j, j-1)
		}
	}
}

type BySortIndex []int

func (a BySortIndex) Len() int      { return len(a) }
func (a BySortIndex) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a BySortIndex) Less(i, j int) bool {
	return a[i] < a[j]
}

func main() {
	test0 := []int{49, 38, 65, 97, 76, 13, 27, 49}
	insertionSort(BySortIndex(test0), 0, len(test0))
	fmt.Println(test0)
}

type Interface interface {
	// Len is the number of elements in the collection.
	Len() int
	// Less reports whether the element with
	// index i should sort before the element with index j.
	Less(i, j int) bool
	// Swap swaps the elements with indexes i and j.
	Swap(i, j int)
}

本文所涉及到的完整源码请参考。

【1】数据结构 - 严蔚敏

Go语言的堆排序实现

2014-08-29T00:00:00+00:00

关于堆排序的算法，可以参考我去年的文章《堆排序(HEAP SORT)》。那篇文章讲的是建立小顶堆进行的排序，这里说的是建立大顶堆建立的排序，差不多。

在Golang源码的sort包里，自带了排序函数。该函数可以对各种类型进行排序，只不过该类型需要实现三个函数，使得该类能够实现Interface接口。

type Interface interface {
	// Len is the number of elements in the collection.
	Len() int
	// Less reports whether the element with
	// index i should sort before the element with index j.
	Less(i, j int) bool
	// Swap swaps the elements with indexes i and j.
	Swap(i, j int)
}

这三个函数分别是，获取排序队列长度、队列任意两个元素比较大小和交换任意两个元素。

func (a BySortIndex) Len() int      { return len(a) }
func (a BySortIndex) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a BySortIndex) Less(i, j int) bool {
	return a[i] < a[j]
}

如果是整形数组，可以像上面这样实现。Golang支持多值赋值，所以交换值很简单。自带的len也使得长度遍历很简单。比较大小，可以根据实际情况自己定义。

堆排序的核心就是建立大顶堆和交换值，它是本地排序，不需要新分配空间。Golang的源码我已经加了注释，也不难，大家直接阅读即可。

func heapSort(data Interface, a, b int) {
	first := a
	lo := 0
	hi := b - a

	// Build heap with greatest element at top.
	for i := (hi - 1) / 2; i >= 0; i-- {
		siftDown(data, i, hi, first)
	}

	// Pop elements, largest first, into end of data.
	// 二叉树结构当中最后一个有子结点的结点
	for i := hi - 1; i >= 0; i-- {
		data.Swap(first, first+i)
		siftDown(data, lo, i, first)
	}
}

// 建立树函数
// 父节点root的左孩子2*root + 1
func siftDown(data Interface, lo, hi, first int) {
	root := lo
	for {
		child := 2*root + 1
		if child >= hi { // child 超出了数组长度，也就是该结点无孩子结点，返回
			break
		}
		if child+1 < hi && data.Less(first+child, first+child+1) { // 右孩子结点存在
			child++
		}
		// 以上是为了在孩子结点当中找到较大的结点，用child表示
		if !data.Less(first+root, first+child) {
			return
		}
		// 如果根结点小于较大的孩子结点，则进行交换；该孩子结点的堆结构可能会被影响，继续去处理孩子结点
		data.Swap(first+root, first+child)
		root = child
	}
}

本文所涉及到的完整源码请参考。

参考文献

【1】堆排序(HEAP SORT) - Cyeam

龙哥与刘翔的约战

2014-08-28T00:00:00+00:00

自从刘翔前几天放出锤子手机测评视频，我就预感，那句“认真可以，但别任性”会激怒龙哥。没有想到的是，龙哥居然忍了这么久。可能是要先去找证据吧。

从我对他们的称呼也能看出来，这两个人我都不喜欢。先说刘翔。我从他第一个视频，翻译谷歌收购一个手势界面系统的视频开始注意他，到后来他自己买机器测，再到现在的Zealer，虽然他的视频我依然都会看，但是对于他来讲，我是越来越不喜欢。

自从他说他要开始创业，我就觉得不对劲。之前的东西，说白了，就是一个脱口秀节目。看完之后出去吹吹牛，既能吹出些花开，又能帮刘翔宣传。而且以这种形式测评，完全可以和手机厂商和平共处，测评基本不会影响消费者，那也就不会影响友商了。这是一个比较好的发展模式。但问题就出在这里，刘翔并不甘于此，他想一呼百应。这就是他创业的原因，而且当时在接受某个节目采访的时候，他还专门提到，有个公司因为他的测评开掉了整个照相机团队，这是他想要的。再到后面他拿了雷布斯200万，到最近又爆出李侃拿了oppo一千多万，这应该都是所谓创业的妥协。

提到钱，做脱口秀是可以发财的，高晓松从优酷转会爱奇艺，据说转会费上亿元。以刘翔的视频访问量，从优酷拿钱又不是不可能。可惜从他开始创业开始，他就选择往所有视频网站上传视频，所以当时优酷就直接取消在首页推荐他的视频了。

还有一种可能，刘翔想借测评作为一个跳板。最近他们刚刚推出了zeal fix，可能就是借视频所做的另一件事情，可能刘翔最终的目的是做手机，这也不是不可能。

虽然说视频还是公正的，但是总感觉多了点不该有的东西。

再说说老罗。说实话，我是通过刘翔知道他的。也看过他的《我的奋斗》。口才不错，书一般。他去做手机我还是挺喜欢的，毕竟他不走寻常路。但是我也见证了自己一步一步从粉转黑。。。他总想通过自己的嘴巴解决各种问题，产能不行，就发长微博道歉，还暗指是富士康得问题，当你去问他为啥冤枉富士康，人家长微博又没明确说。他就是爱耍这种文字游戏，但说实话，耍嘴皮子解决不了任何问题。斗了这么长时间的嘴，虽然没输过，但是不少人已从粉转黑，这也包括我。

关于手机，有一个问题，锤子到底为啥要比国内其他牌子手机贵。华为技术过硬，有自己的soc，而且那个超薄的也做的很好。小米和魅族，最起码价格便宜。

昨天晚上，优酷直播了二人的当面对质。龙哥不太要脸，不过他一直是这样，最后都人格攻击了，而刘翔还是嫩了点。最要命的那个测评里面的屏幕拍摄问题，果断当场验啊，可能被龙哥的攻势搞得招架不住了。我觉得当时当场验，老罗觉得没那么嚣张了，并且可以继续说手机问题。可惜老罗习惯性的切话题，刘翔也跟着跑了。

这架吵的，老罗赢得了不少粉丝，不过这件事会为销量增加多少呢？反正我是不会买的。而对于王，虽然公信力受到了影响，但是毕竟是测评界的一哥，如果他垮了，测评界就垮了，所以彭林站出来想帮帮他。如果他接受了彭林，并且放弃那些拿到的投资，那么，其实还是老罗输了。但如果他从此一蹶不振，或者继续这么做下去，可能也就这样了。

这架的核心，不在于锤子手机，而在于王自如人品。这也怨不得别人，谁叫他那么膨胀，给测评这个单纯美好的东西加上了他自己那些梦想。梦想都是虚的，有梦想也没办法创业，有模式才行。他也就是做了一些错误的选择，视频还是教了我很多东西呢，不能因为有一些错而否定全盘。

本文介绍摘自网络。

Solr里的整形字段

2014-08-27T00:00:00+00:00

今天一个项目，要在后台配置好id信息，用逗号分隔，然后我读取配置好的id信息，从Solr里查询，将结果返回。结果出了错误，接口并没有按照配置返回id信息，并且一条都没有返回。

看到错误，果断去抓Solr查询请求，请求很长，不太好看，不过运行一下就知道问题了。运行结果是返回了错误：Invalid Number: 。报整数错误，第一反应了超出了范围，因为id之间是通过逗号分隔的，看来是因为少打了逗号导致的。

知道问题了，就去看看Solr的配置。id字段是int类型，而schema.xml里面配置的是：

<fieldType name="int" class="solr.TrieIntField" precisionStep="0" positionIncrementGap="0"/>

再顺着去查TrieIntField：

A numeric field that can contain 32-bit signed two’s complement integer values. Min Value Allowed: -2147483648 Max Value Allowed: 2147483647

验证了我的猜想。

参考文献

【1】Class TrieIntField

Golang的map迭代

2014-08-25T00:00:00+00:00

Golang不同于Java等常见的语言，字节在语言层面支持了map。map类似于Java当中的Set，是数学中集合的概念。集合当中不会出现重复元素，并且是无序的。与此相关的就是数组和队列，它们是有序的。

前几天要做一个接口调用，需要用到安全机制，将请求参数编码出一个签名，一并用来发送请求。相关的可以参考《接口安全机制》。这里会涉及到两次取请求URL的步骤，一次是用来拼请求，一次是用来计算签名。当时机制的我，为了方便写代码，就将参数放在了map当中，遍历两次map就能够实现了。一般情况下都能够正常访问。极少数情况下是会提示调用失败的，其实就是签名或者参数错误。因为概率极低，所以没有引起注意。

但是一直觉得代码有点bug，大概位置自己也知道，肯定是发送HTTP请求的模块。后来，就去review了一下自己的代码，又测了一下，发现了问题。

import (
	"fmt"
)

func main() {
	query := map[string]string{}
	// 需要按照字典排序
	query["test0"] = "0"
	query["test1"] = "1"
	query["test2"] = "2"

	for i := 0; i < 100; i++ {
		for _, v := range query {
			fmt.Print(v)
		}
		fmt.Println()
	}
}

map遍历100次，把结果grep了一下，里面有82个012，9个120，9个201。

首先，map并不是完全随机，我执行了几次结果都一样；而之前也试过一次，同样也都是使用Go playground，结果全是210（结果不是很确定），可能随机还和时间有关；
其次，结果也不是很平均，按理说，这三个数，打散应该是6种结果，而这里只有3种。而且数量也相差很大。

所以，由于遍历map随机得不是很彻底，我始终没有发现这个bug的问题。安装上面测试的结果，012出现概率82%，其它概率是18%，那么，接口调用出错的概率就是82%×82%=67.24%。出问题的概率还是很高，看来测试也有问题。。。

本文所涉及到的完整源码请参考。

参考文献

【1】Map iteration - Go 1.3 Release Notes

接口安全机制

2014-08-18T00:00:00+00:00

HMAC-SHA1（基于SHA1哈希算法的消息验证代码）是一种键控哈希算法。此 HMAC 进程将密钥与消息数据混合，使用哈希函数对混合结果进行哈希计算，将所得哈希值与该密钥混合，然后再次应用哈希函数。输出的哈希值长度为 160 位。

虽然安全哈希算法（Secure Hash Algorithm，简称SHA1）是一种不可逆的加密算法，但是由于同样的内容计算之后结果是相同的，且不会重复，所以通过暴力计算，也是能够还原数据。所以HMAC-SHA1就在SHA1的基础上，增加一个密钥。如此一来，只要密钥不被泄漏，就无法破解信息内容。

在接口验证过程中，将要发送的数据参数，再加上要发送时刻的时间片和密钥，通过HMAC-SHA1一并进行计算，请求的时候将计算得到的签名作为参数发送给服务器。服务器也要根据本地保存的密钥再计算一次，与客户端提供的签名进行对比。相同则为授权成功。

通过HMAC-SHA1做加密处理，可以防止请求参数被恶意修改。如果参数被修改，签名也会随之变化，所以单纯的修改参数将会导致服务器授权验证失败。再传入的参数之中再加入时间片信息，如果和服务器时间相差过大，该请求也会被抛弃。

基于beego框架实现接口验证，使用它提供的过滤器就能实现。过滤器函数如下所示：

beego.InsertFilter(pattern string, postion int, filter FilterFunc)

三个参数：

路由规则，可以根据一定的规则进行路由，如果你全匹配可以用*
postion 执行 Filter 的地方，四个固定参数如下，分别表示不同的执行过程
- BeforeRouter 寻找路由之前
- BeforeExec 找到路由之后，开始执行相应的 Controller 之前
- AfterExec 执行完 Controller 逻辑之后执行的过滤器
- FinishRouter 执行完逻辑之后执行的过滤器
filter filter 函数type FilterFunc func(*context.Context)

路由规则用来匹配过滤器。过滤的位置有4个。我们这里是要校验请求参数，那么调用得靠前一些，能够减少后面不必要的计算。所以用BeforeRouter较好。校验函数如下：

func FilterOauth(ctx *context.Context) {
	timestamp, err := strconv.ParseInt(ctx.Input.Query("timestamp"), 10, 64)
	if err != nil {
		ctx.Abort(http.StatusUnauthorized, "")
	}
	timestamp_t := time.Unix(timestamp, 0)
	now_t := time.Now()
	if now_t.Sub(timestamp_t).Minutes() > 10 {
		fmt.Println(timestamp_t, "Duration is too long")
		ctx.Abort(http.StatusUnauthorized, "")
	}

	size := ctx.Input.Query("size")
	if size == "" {
		ctx.Abort(http.StatusUnauthorized, "")
	}

	sign := ctx.Input.Query("sign")
	if sign == "" {
		ctx.Abort(http.StatusUnauthorized, "")
	}

	if CheckMAC(size+timestamp_t.String(), sign, "seckey") {
		fmt.Println("Verify error")
		ctx.Abort(http.StatusUnauthorized, "")
	}
}

校验是根据传入的参数size和timestape进行，还需要传入sign签名用于比对。过滤器函数传入了上下文对象*context.Context。如果传入的时间片和系统时间相差超过10分钟，会被认为是过期请求。

校验函数用了Golang的crypto/hmac和crypto/sha1包：

func CheckMAC(message, sign, key string) bool {
	mac := hmac.New(sha1.New, []byte(key))

	mac.Write([]byte(message))
	return hex.EncodeToString(mac.Sum(nil)) == sign
}

加密的结果是[]byte类型，还需要转换成可读的16进制编码，通过包encoding/hex即可实现。

接口加密还可以使用HTTPS加密的传输方式，这个我还不懂，以后明白了再写。

参考文献

【1】过滤器 - beego开发文档

Golang实现大数乘法

2014-08-15T00:00:00+00:00

大数乘法，简单的说，就是把小学学的列竖式计算的方法进行了实现。这其实也就是个乘法分配率的变形。

5 * 12 = 5 * (2 + 10) = 5 * 2 + 5 * 10

所以第二行竖式，12的十位1与5相乘的时候，需要再最后空一位，其实是在最后省略了一个0。十位就是省略一个0，也就是左移一位，那么百位就是左移两位。以此类推。

通过代码实现，相乘的两个数就不能用整形表示了，因为存不了很大的整数。需要用字符串表示。按位相乘，最后把结果错位相加就行。乘法的结果等于乘数的位数，所以可以申请一个和乘数位数相同的数组，然后错位相加即可。但是这样太麻烦了。

乘法是从个位开始，但是遍历字符串是从最高为开始的，所以要首先将输入字符串反转。用i表示被乘数的遍历索引，j表示乘数的索引。前面说了左移的位数和乘数当前遍历的位相等，也就是j。相乘的时候，如果结果大于9，需要进位，现在暂不考虑进位问题。那么，结果的位数和乘数的长度将会是相等的，例子当中，都是6。如果不考虑偏移，那么乘法的结果将会和遍历的索引i相等。所以，可以得出，任意两位相乘，结果的位置是i + j。

func LargeNumberMultiplication(a string, b string) (reuslt string) {
	a = strings.Reverse(a)
	b = strings.Reverse(b)
	c := make([]byte, len(a)+len(b))

	for i := 0; i < len(a); i++ {
		for j := 0; j < len(b); j++ {
			c[i+j] += (a[i] - '0') * (b[j] - '0')
		}
	}

	var plus byte = 0
	for i := 0; i < len(c); i++ {
		if c[i] == 0 {
			break
		}
		temp := c[i] + plus
		plus = 0
		if temp > 9 {
			plus = temp / 10
			reuslt += string(temp - plus*10 + '0')
		} else {
			reuslt += string(temp + '0')
		}

	}
	return strings.Reverse(reuslt)
}

字符串的反转可以参考《字符串反转》。相乘的过程中，需要将字符和整数进行转换，通过a[i] - '0'和temp + '0'就能实现。进位在最后一并进行。通过变量plus保存上一次的进位数目。

本文所涉及到的完整源码请参考。

参考文献

【1】大数乘法

字符串反转

2014-08-14T00:00:00+00:00

字符串反转的Golang实现，应该是最简单的了。废话不多说，代码如下：

package main

func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}
func main() {
	a := "Hello, 世界"
	println(a)
	println(Reverse(a))
}

Golang本身支持计算字符串长度，并且由于支持多值赋值，交换值也是格外的简单。其他语言无非要单独处理一下这两个部分，通过遍历计算出字符串长度，再通过异或或者加法交换值。为了能够处理字符串里面包含中文的情况，这里使用rune进行处理。

本文所涉及到的完整源码请参考。

把一个字符串中的字符从小写转为大写

2014-08-12T00:00:00+00:00

将字符串里面的英文小写转成大写，是一个很简单的操作。每个字符的编码可以认为是整数，Golang里面的byte和rune是uint8和int32。其它语言大同小异。在编码表当中，位置是是从A到Z，接着是a到z，A对应的整数是65，a对应的整数是97，中间差了26个英文字母和6个其它字符的长度共32。所以转换的方法就是，将小写字母的值，剪掉32即可。

还是编码的问题。最早的出现的编码是ASCII，从128个增加到256个字符。再到后面的Unicode、GBK等，这些新出的编码和最早的ASCII都是兼容的，也就是说，不同的编码里面，前256位都是一样的。所以，在这里的英文字符转大写问题，不存在编码问题。

这个题目在Golang的strings包里有专门的实现ToUpper，此函数内部封装了unicode包，在此包的letter.go文件内，是具体的实现。

const MaxASCII = '\u007F'

func toUpper(r rune) rune {
	if r <= MaxASCII {
		if 'a' <= r && r <= 'z' {
			r -= 'a' - 'A'
		}
		return r
	}
	return r
}

func ToUpper(s []rune) (res []rune) {
	for i := 0; i < len(s); i++ {
		res = append(res, toUpper(s[i]))
	}
	return res
}

func main() {
	a := "Hello, 世界"
	fmt.Println(string(ToUpper([]rune(a))))

}

大Golang支持UTF8和Unicode两种编码方式。分别对应的数据类型是byte和rune。通过[]byte(str)和[]rune(str)可以将字符串转成UTF8和UTF16两种解析方式。解析的字符串可能是中文，所以要按照rune处理。对于中文等其他字符，不做处理，所以增加了if r <= MaxASCII过滤。

还有要注意的一点，Golang语言层面实现了字符串string。它不同于C语言里面的字符数组，所以不能够通过下标修改字符串内容。只能通过下标读取。

本文所涉及到的完整源码请参考。

参考文献

Golang通过反射实现结构体转成JSON数据

2014-08-11T00:00:00+00:00

Golang的结构体可以增加类似于Java里面@JsonProperty("id")注释。在结构体里面通过反引号包含的字符串被称为Tag。

type Cyeam struct {
	Url   string `json:"url"`
	Other string `json:"-"`
}

在Tag里加入对json的Tag的定义，就可以实现对输出的格式控制。而且，如果json字段的Tag定义为-的话，不会被解析。

这么强大的功能，借助reflect包，实现起来也不难。

c := Cyeam{Url: "blog.cyeam.com", Other: "..."}
var t reflect.Type
t = reflect.TypeOf(c)
var v reflect.Value
v = reflect.ValueOf(c)
json := "{"
for i := 0; i < t.NumField(); i++ {
	if t.Field(i).Tag.Get("json") != "-" {
		json += "\"" + t.Field(i).Tag.Get("json") + "\":\"" + v.FieldByName(t.Field(i).Name).String() + "\""
	}
}
json += "}"
fmt.Println(json)

{"url":"blog.cyeam.com"}

对于每一个对象，都能够得到它的类型Type以及值Value。t.NumField()方法能够得到结构体内包含值的数目，t.Field(i)能够得到索引值处变量的值Value。通过这两个方法，就能够对结构体变量进行遍历。t.Field(i).Tag.Get("json")可以获取当前字段的Tag，并且从中获取json的Tag值。如此一来，就能够完成结构体的遍历和最后JSON流的拼接生成。

本文所涉及到的完整源码请参考。

参考文献

Golang源码剖析——字符串查找算法

2014-08-08T00:00:00+00:00

发现好多笔试题，都问的是库函数。往简单的做，有效率不太高的算法，往复杂的做，就得看源码了。

写一个在一个字符串（n）中寻找一个子串（m）第一个位置的函数

暴力字符串匹配方法（Brute forceing matching）。这个写法不难，复杂度O(n*m)。

func IndexFuck(s, sep string) int {
	for i := 0; i < len(s); i++ {
		if s[i] == sep[0] {
			is := true
			j := 0
			for ; j < len(sep); j++ {
				if sep[j] != s[i] {
					is = false
					break
				}
			}
			if is {
				return i
			}
		}
	}
	return -1
}

Rabin-Karp算法，能把复杂度最小减到O(n)。设要匹配的子串为sep，查找的字符串为s。通过一个哈希算法，把sep哈希成一个数字，以sep的长度，依次遍历s中长度和sep相同的串，直到计算出的值是相等的。

计算哈希的方法是，把原本的字符串看作是一种E进制的编码，然后将该编码转成10进制用数字表示。Golang用16777619作为该进制数。（这是我的理解，至于为什么选择这个整数，我也不是很清楚，只不过发现很多哈希算法都用过这个神奇的数字16777619 = (2^24 + 403)）。

举个例子，原始串s是12345，匹配串sep是45。第一次用12和45比较计算出串的哈希值，1*E+2 != 4*E+5。然后计算23和45的值。

这里有一个问题，如果要匹配的字串长度比较长，是1000位，那么，每一次匹配都得对这1000位进行计算。这时的复杂度就是O(n*m)了，而且还需要计算，这比暴力判断算法还要复杂。仔细观察，发现每次计算的长度的都一样，而且是依次进行的，前后两个串12和23有共同部分2，如果子串sep长度是1000，那么前后两次子串的共同部分就是999的长度了。所以，只需要保留共同部分，把前面的头去掉，后面的尾补上，就能够完成新串的计算。

上面的例子，(1*E+2)*E+3-1*E*E = 2*E+3。如此一来，一个简单的运算，就能够得到新串的哈希值。Golang里面strings包的实现：

const primeRK = 16777619

// hashstr returns the hash and the appropriate multiplicative
// factor for use in Rabin-Karp algorithm.
func hashstr(sep string) (uint32, uint32) {
	hash := uint32(0)
	for i := 0; i < len(sep); i++ {
		hash = hash*primeRK + uint32(sep[i])
	}
	var pow, sq uint32 = 1, primeRK
	for i := len(sep); i > 0; i >>= 1 {
		if i&1 != 0 {
			pow *= sq
		}
		// 只有32位，超出范围的会被丢掉
		sq *= sq
	}
	return hash, pow
}

func Index(s, sep string) int {
	n := len(sep)
	// Hash sep.
	hashsep, pow := hashstr(sep)
	var h uint32
	for i := 0; i < n; i++ {
		h = h*primeRK + uint32(s[i])
	}
	if h == hashsep && s[:n] == sep {
		return 0
	}
	for i := n; i < len(s); {
		h *= primeRK
		h += uint32(s[i])
		h -= pow * uint32(s[i-n])
		i++
		if h == hashsep && s[i-n:i] == sep {
			return i - n
		}
	}
	return -1
}

最后面的for循环，i表示计算新串新加的字符，也就是例子里面的3。所以，i-n+1就是新串的头地址。

一般，按照这种算法算出的值都会超过整形的范围。上面的16777619，计算一下平方就超unit32的范围了。常用的做法，是再取一个比较大的质数，求余，用余数作为哈希值。这样就能保证高位不会被截取丢弃了。而Golang包里的代码是不操作，直接丢弃，太霸气了。

本文所涉及到的完整源码请参考。

参考文献

Golang——append的可变参数

2014-08-07T00:00:00+00:00

合并slice，跟合并数组一样，是比较常见的操作。映像中C++运算符重载以后，直接用加号就可以了。Golang果断不行。先开始用copy解决。

func copy(dst, src []Type) int

从来没用过这个函数，返回值和append还不一样，返回的是复制的数目。而且只能针对slice操作，不支持其他类型。能参数表也能看出，两个参数必须是同一种类型，不可以是[]Type和[]interface{}这种形式。此函数也不是追加到dst后面，而是从头开始复制。如果要追加到后面，还需要指出位置信息。copy实现的合并数组完整代码：

a := []int{1, 2, 3, 4}
b := []int{5, 6, 7}
c := make([]int, len(a)+len(b))
copy(c, a)
copy(c[len(a):], b)

在copy的过程中，如果dst空间不足，是不会自动追加空间的。所以，合并之前要申请一个足够的空间。接着就是复制两次。第二次复制还需要指出slice位置，防止被覆盖。

这个代码虽然功能上没问题，但是总觉得比较脏。后来无意中发现，append函数的参数是支持变长参数类型的。

func append(slice []Type, elems ...Type) []Type

这样，三行复杂的代码变成了一行：

a := []int{1, 2, 3, 4}
b := []int{5, 6, 7}
d := append(a, b...)

参考结果：

0xfeee1f74
0xfeee1f38
[1 2 3 4 5 6 7]
0xfeee1f2c
[1 2 3 4 5 6 7]
0xfeee1f20
[5]

本文所涉及到的完整源码请参考。

最近在看Effective Go，觉得不错，推荐给大家。

参考文献

【1】slice 删除一个或多个项 - Go中文社区
【2】Go语言中合并slice - 达达的主页
【3】Package builtin - The Go Programming Language
【4】数组(Array)和切片(Slice) - 烈冰
【5】Go Slices: usage and internals - The Go Blog
【6】看范例学 Golang （十四）- 可变参数函数 - G_will’s Blog

Golang——for循环的两种用法

2014-08-06T00:00:00+00:00

从大一开始学C++，所接触过的for循环只有一种方式，for (int i = 0; i < count; i++) {...}。后来接触了Java，知道Java 5 引入了一种新特性，可以通过for (a : aa)遍历整个数组。虽然知道，但是也没用过，因为之前那种方法足够了。

现在主力语言是Go。Go也支持传统的写法for i := 0; i < count; i++ {...}。同样，还有一种for i, a := range aa {...}。这个跟Java相比，除了能够遍历，还能得到当前遍历的索引值，所以在Go中，更倾向于后面这种方法，灵活度更高。

今天要对一个数据进行遍历，对每个元素进行稍加修改，才发现，原来这两种方式是有很大区别的。当时使用第二种方式修改之后，一直发现没有修改成功。后来进过调试，才发现是for循环的问题。

测试代码在这里

a := []string{}
a = append(a, "hello")
a = append(a, ", ")
a = append(a, "world")
fmt.Println(a)

for i := 0; i < len(a); i++ {
	fmt.Println(&a[i])
}

for _, aa := range a {
	aa += "@"
	fmt.Println(&aa)
}
for i := 0; i < len(a); i++ {
	a[i] += "@"
	fmt.Println(&a[i])
}
fmt.Println(a)

通过range方式获得的变量，打印出它的地址，和之前的数组a的地址相比，是不同的地址。

[hello ,  world]
0x10322280
0x10322288
0x10322290
0x1030e100
0x1030e100
0x1030e100
0x10322280
0x10322288
0x10322290
[hello@ , @ world@]

这里就可以证明，通过range方式获得的变量，和a[i]变量是不同的，只是里面存的值一样而已。所以，如果做出了修改操作，也不会修改到原来的数组。

果断再去看一下大Java的语法。结果也是一样的。

class TestFor {

	public static void main(String[] args) {
		String[] a = {"hello", ", ", "world"};
		System.out.println(a[0] + a[1] + a[2]);

		for (String aa : a) {
			aa += "@";
		}
		System.out.println(a[0] + a[1] + a[2]);
	}

}

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

传统的for，写起来不太方便，但是功能强大；如果只是单纯得遍历，可以使用新的写法，简化代码。

推荐阅读：「通过两个例子介绍一下 Golang For Range 循环原理」

参考文献

【1】JAVA5.0新特性 - 子默

Golang——json数据处理

2014-08-04T00:00:00+00:00

今天让官方文档虐了几条街。

需要能够对JSON数据进行编码，将内部的中文字符串转成Unicode编码。编码这种东西接触也不少了，随便搜一下就能解决。果断去搜了一下。本文所有编码

rs := []rune("golang中文unicode编码")
j := ""
html := ""
for _, r := range rs {
	rint := int(r)
	if rint < 128 {
		j += string(r)
		html += string(r)
	} else {
		j += "\\u" + strconv.FormatInt(int64(rint), 16) // json
		html += "&#" + strconv.Itoa(int(r)) + ";"       // 网页
	}
}
fmt.Printf("JSON: %s\n", j)
fmt.Printf("HTML: %s\n", html)

Golang里面，所有UTF8字符串里的单个字符，可以使用byte类型表示，经过[]byte(str)转换成数组之后，就能进行遍历获取。而对于Unicode，Golang提供了另一种数据类型rune，经过[]rune(str)转换之后，就能获取单个Unicode字符。对于英文字符以及英文标点，Unicode编码不变，而中文编码，转成16进制即可。

我们一般认为：UTF-16就是Unicode，以16位两字节为单位，最少为两字节，最多4个字节。

所以，一般情况下，转出的Unicode是4个16进制数字（2字节）组成。最后，为其追加\u头即可完成。

写完之后，就准备这么转了。结构体数据拼接完之后，把有中文的项单独编码一下。现在想想，硬编码太渣了。

看看官方文档的说法：

Marshal traverses the value v recursively. If an encountered value implements the Marshaler interface and is not a nil pointer, Marshal calls its MarshalJSON method to produce JSON. The nil pointer exception is not strictly necessary but mimics a similar, necessary exception in the behavior of UnmarshalJSON.

调用json.Marshal方法之后，会递归的访问传入的结构体的每个项，如果遍历到的项实现了Marshaler的方法，并且该项不是空指针，将会自动调用实现的MarshalJSON方法。

type QuoteString struct {
	QString string
}

func (q QuoteString) MarshalJSON() ([]byte, error) {
	return []byte(strconv.QuoteToASCII(q.QString)), nil
}

type ColorGroup struct {
	ID     int         `json:"id,string"`
	Name   QuoteString `json:"name"`
	Colors []string
}

上面定义了一个结构体QuoteString，它实现了Marshaler，所以会自动进行Unicode编码。转码，用了strconv包里的函数QuoteToASCII。这个方法应该是我上面提供的升级版。

源码很重要。

参考文献

【1】Package json - The Go Programming Language
【2】golang中文unicode编码 - 豆蔻
【3】Package strconv - The Go Programming Language

布隆过滤器

2014-07-30T00:00:00+00:00

这篇文章可能涉及到一些拓扑知识，可以参考之前的文章：

布隆过滤器的原理不算复杂。对数据进行查找，简单点的可以直接遍历；对于拍好顺序的数据，可以使用二分查找等。但这些方法的时间复杂度都较高，分别是O(n)和O(logn)。无法对大量乱序的数据进行快速的查找。

哈希，将给定的数据通过哈希函数得到一个唯一的值，此值可以作为数据的唯一标识，只要通过该标识，再通过哈希函数逆向计算，就能还原出来原始的数据。在前面的网址压缩的调研分析里面介绍的压缩网址的方法，其实也就是一种哈希，只不过借助了数据库的支持。

布隆过滤器就是借助了哈希实现的过滤算法。通过将黑名单的数据哈希之后，可以得到一个数据。申请一个数组空间，长度是黑名单的长度。将前面的数据转换成数组中唯一的一个单元，并且标记为1，标识此位置对应的数据是黑名单。如此一来，过滤的时候，将数据哈希之后，去前面的数组当中查找，如果对应的位置值为1，表明需要被过滤，如果是0，则不需要。如果黑名单有一亿个黑名单数据，每个数据需要1bit来记录，最后也就会占用1G空间，放在内存里面妥妥的。而哈希函数计算时间可以认为是O(1)，所以过滤算法效率也很高。

然而，哈希算法不可能保证不发生碰撞。尤其是黑名单这种字符串，可能会包含各种字符，也不能单纯的当作数字来处理。布隆过滤器的做法就是通过调用多个哈希函数，降低碰撞的概率。比如有3个哈希函数，碰撞概率都是10%，并且哈希方式不同，那么一个数据通过三次哈希得到的碰撞概率是单独哈希一次的 10%×10%×10%/10%=1%，也就是说，原本哈希一次碰撞概率为10%，现在三次是0.1%。黑名单误过滤的概率大大降低，而存在于黑名单当中的肯定会被过滤掉。而三次哈希的结果也直接放进之前的数组里即可。判断是否在黑名单当中，三次结果计算结果都匹配才需要过滤。

上面提到的需要用三个哈希函数只是举例子，数目没有限制。而哈希函数的选取，也会是一个问题。这些明天再说吧。

参考文献

Golang binary包——byte数组如何转int？

2014-07-29T00:00:00+00:00

在C语言笔试的时候，比较喜欢考这个东西，如何将一个char数组转成int类型。当年看过，不过早就忘记了。后来看到这种东西binary.BigEndian.Uint32(a)，直接瞎了。后来去看文档，看了半天也没搞明白。

在这里直接说一下，源码。下面这个是uint8，也就是byte数组，大小为4，转换成int32的代码。

package main

import "fmt"
import "encoding/binary"

func main() {
	var a []byte = []byte{0, 1, 2, 3}
	fmt.Println(a)
	fmt.Println(binary.BigEndian.Uint32(a))
	fmt.Println(binary.LittleEndian.Uint32(a))
}

执行结果：

[0 1 2 3]
66051
50462976

转换有两种不同的方式，也就是大端和小端。大端就是内存中低地址对应着整数的高位。按照上面的例子说，就是按照0123的顺序拼成int32，整数的最高8位是0，接着是1，以此类推，所以是66051。小端就是反过来，最高8位是3，也就是00000101，这样最后得到50462976。

在Golang源码目录encoding/binary.go下，有函数的实现。不过里面没有对byte数组长度的检查，如果传入的数组长度小于4，自然会报错：panic: runtime error: index out of range。

func (bigEndian) Uint32(b []byte) uint32 {
	return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
}

上面讲的BigEndian和LittleEndian都是实现类，都是实现的类ByteOrder。

type ByteOrder interface {
    Uint16([]byte) uint16
    Uint32([]byte) uint32
    Uint64([]byte) uint64
    PutUint16([]byte, uint16)
    PutUint32([]byte, uint32)
    PutUint64([]byte, uint64)
    String() string
}

参考文献

常见哈希函数FNV和MD5

2014-07-28T00:00:00+00:00

介绍哈希函数之前，先说一下Golang的哈希结果。在包/hash/下的hash.go文件，定义了哈希函数的接口。所有哈希函数都要实现此接口。

// Hash is the common interface implemented by all hash functions.
type Hash interface {
	// Write (via the embedded io.Writer interface) adds more data to the running hash.
	// It never returns an error.
	io.Writer

	// Sum appends the current hash to b and returns the resulting slice.
	// It does not change the underlying hash state.
	Sum(b []byte) []byte

	// Reset resets the Hash to its initial state.
	Reset()

	// Size returns the number of bytes Sum will return.
	Size() int

	// BlockSize returns the hash's underlying block size.
	// The Write method must be able to accept any amount
	// of data, but it may operate more efficiently if all writes
	// are a multiple of the block size.
	BlockSize() int
}

此接口提供了常用的Sum等函数，此外，它还继承了io.Writer接口。该接口定义在io包里的io.go文件里。该接口定义了Write写入函数。

// Writer is the interface that wraps the basic Write method.
//
// Write writes len(p) bytes from p to the underlying data stream.
// It returns the number of bytes written from p (0 <= n <= len(p))
// and any error encountered that caused the write to stop early.
// Write must return a non-nil error if it returns n < len(p).
type Writer interface {
	Write(p []byte) (n int, err error)
}

常见的哈希函数调用过程大体如此，初始化hash.Hash之后，通过Write写入数据，通过Sum函数得到哈希结果。其中，Sum(b []byte) []byte函数的参数b，当传入nil的时候，将直接返回哈希结果，而b不为空的时候，就会将哈希结果追加到b后面。

MD5的加密算法调用如下，源码：

package main

import (
	"crypto/md5"
	"encoding/hex"
)

func main() {
	m := md5.New()
	m.Write([]byte("hello, world"))
	s := hex.EncodeToString(m.Sum(nil))
	println(s)
}

FNV的加密调用也很简单，源码。fnv.New32()使用的是32位的FNV-1算法进行的哈希。

package main

import "fmt"
import "hash/fnv"
import "encoding/hex"

func main() {
	a := fnv.New32()
	a.Write([]byte("hello"))
	fmt.Println(hex.EncodeToString(a.Sum(nil)))
}

FNV是一种非加密的哈希算法，支持32位、64位、128位、256位、512位和1024位的哈希。碰撞还算比较低，具体的碰撞的对比可以网上查一下。

直接哈希得到的都是整数类型，直接输出的话就会是乱码了，如果想查看正常的哈希结果，需要将结果转成对应表示的字符即可。使用包encoding/hex可以帮助实现十六进制编码。

补充一下。。。基础不好的坑自己。。。

MD5加密结果是32个16进制数，而一个字节能表示的范围是0～255，256=16×16，也就是两个十六进制数代表一个字节。所以Sum函数得到的byte数组长度是16，纠结了我半天。。。

参考文献

【1】Package fnv - The Go Programming Language
【2】Fowler–Noll–Vo hash function - wikipedia
【3】FNV哈希算法 - 思思入code

网址压缩的调研分析（续）

2014-07-25T00:00:00+00:00

上文提到在GitHub找到一个Python实现的打散ID压缩成62进制的算法，今天抽空翻译成了Golang。虽然说代码都看懂了，但是动手翻译的时候发现还是有一些细节的东西挺有意思的。代码放到了go_code项目下。源码也贴在这里。

import (
	"bitbucket.org/tebeka/base62"
	"fmt"
)

var (
	DEFAULT_BLOCK_SIZE = uint(24)
	DEFAULT_ENCODER    *UrlEncoder
	MIN_LENGTH         = 5
)

type UrlEncoder struct {
	BlockSize uint
	Mask      uint64
	Mapping   []uint
}

func NewUrlEncoder(blocksize uint) (u *UrlEncoder) {
	u = new(UrlEncoder)
	u.BlockSize = blocksize
	u.Mask = (1 << blocksize) - 1
	for i := uint(0); i < blocksize; i++ {
		u.Mapping = append(u.Mapping, blocksize-i-1)
	}
	return u
}

func (this *UrlEncoder) Encode(n uint64) uint64 {
	return (n & ^this.Mask) | this.encode(n&this.Mask)
}

func (this *UrlEncoder) encode(n uint64) (result uint64) {
	for i, b := range this.Mapping {
		if n&(1<<uint(i)) > 0 {
			result |= (1 << b)
		}
	}
	return result

}

func (this *UrlEncoder) Decode(n uint64) uint64 {
	return (n & ^this.Mask) | this.decode(n&this.Mask)
}

func (this *UrlEncoder) decode(n uint64) (result uint64) {
	for i, b := range this.Mapping {
		if n&(1<<uint(b)) > 0 {
			result |= (1 << uint(i))
		}
	}
	return result
}

func (this *UrlEncoder) Enbase(n uint64) string {
	return base62.Encode(n)
}

func (this *UrlEncoder) Debase(n string) uint64 {
	return base62.Decode(n)
}

func (this *UrlEncoder) EncodeUrl(n uint64) (short_url string) {
	return DEFAULT_ENCODER.Enbase(DEFAULT_ENCODER.Encode(n))
}

func DecodeUrl(short_url string) (n uint64) {
	return DEFAULT_ENCODER.Decode(DEFAULT_ENCODER.Debase(short_url))
}

func init() {
	DEFAULT_ENCODER = NewUrlEncoder(DEFAULT_BLOCK_SIZE)
}

func Disperse(i uint64) (disperse_i uint64) {
	fmt.Println(DEFAULT_ENCODER)
	a := DEFAULT_ENCODER.Encode(i)
	b := DEFAULT_ENCODER.Enbase(a)
	c := DEFAULT_ENCODER.Debase(b)
	disperse_i = DEFAULT_ENCODER.Decode(c)
	fmt.Println(i, a, b, c, disperse_i)
	return disperse_i
}

里面用到了别人实现的62进制压缩包。实现原理在上一篇文章《网址压缩的调研分析》的最后一篇文章里面已经说得很清楚了，可以参考那篇文章。

下面接着说一下短网址的调研情况。这之前，都只是讲了算法的实现，而具体的存储数据库还没有介绍。GitHub上面与此相关的项目都是使用MySQL实现的。用数据库实现确实很方便，表很简单，两个字段ID和网址就可以了。但是，在数据结构是如此简单的情况下，一般都是使用Redis来实现。Redis是将Key缓存在内存当中，查询速度快。然而，MySQL有一个Redis无法比拟的优势：Redis只能通过Key查询Value的值，而数据库可以实现双向映射。在用户添加网址的时候，需要去库里查询是否已经存在于库中了，这时需要使用网址来作为查询字段；而在解析短网址的时候，还会需要通过ID查询原始网址。这里就用到了双向查询。

看来使用ID进行编码短网址的方式，目前只能使用传统数据库了。

参考文献

【1】short_url.py - mozillazg/ShortURL

网址压缩的调研分析

2014-07-24T00:00:00+00:00

现在新浪、谷歌都提供了网址压缩服务，访问被压缩的网址，可以自动跳转到目标网址。对于访问者来说，除了网址节约了一些存储空间，别的也没啥好处吧，不过确实越来越火。

要开发短网址，一般有两种思路。第一种，就是生成个码，把码和原始网址的对应关系放到数据库里面，压缩的时候存进去，读取的时候去库里找；还有一种方式是把原始网址按照一定方式压缩，压成比较短的。

先开始肯定是想着用第二种方式，不用数据库，只用算法就能实现压缩，听着就很牛逼。有人说可以用gzip压缩，用Python试了一下，压出来的比原始的还长。。。要是用AES这种去压，估计也短不了。看来必须要借助数据库了。

用数据库，肯定要存一个原始网址，问题就是解决短码（就是短网址后面跟着的那个乱码）的问题。比较传统的方法，就是用整数来存，从1开始，这样。先开始出来的就是00001、00002这种，而且短码都是递增的，随机不起来，看着也不好看。

压缩文本还有一种思路，将文本视为数字，增加这些数字的底数。如果原本的底数是10进制，升到100进制，长度肯定缩短。进制越高越好。下面就是要看HTTP自身URL支持多少字符。HTTP的URL支持0到9十个数字，52个字母（包括大小写），还有一些其它字符，如下表所示。但是这些特殊字符在URL里面都是用用途的，所以不能用来编码。那么，显而易见，只能使用数字和大小写字母，也就是62个。将URL压缩成62进制，是最短的压缩方式了。

除了普通的字母，数字，中文，还有特殊字符，但是规范的使用应该是使用字符转义。
“+” URL 中+号表示空格 %2B
“空格” URL中的空格可以用+号或者编码 %20
“/” 分隔目录和子目录 %2F
“?” 分隔实际的 URL 和参数 %3F
“%” 指定特殊字符 %25
“#” 表示书签 %23
“&” URL 中指定的参数间的分隔符 %26
“=” URL 中指定参数的值 %3D
“" 表示目录路径 %5C
“.” 句号 %2E
“:” 冒号 %3A

MD5加密，可以将任意文本生成一个32位的数字，每一位用16进制表示。然后转成上面提到的62进制数字，这样既不会发生碰撞，又能够起到压缩效果。试了一下，压缩完长度是12。去查了一下，谷歌提供的短网址提供5位压缩码，而新浪提供的是7位编码。看来这样还是不行。

最后，短码就只能是用ID来表示了，从0算起，这样可以保证长度不会太长，并且不会碰撞。5位62进制数字，可以表示62^5个短网址，算下来是9亿多个。我觉得妥妥够用了。

最后还有一个问题，就是上面提到的，ID是连续分配的，短网址也无法打散。去Github找了一个用Python写的打散算法，设定一个区间，将区间内的数字反转。比如，设定区间位8，要打散的ID是100000001，共9位，那么，反转之后就是110000000。这样，下一个数字100000010，打散之后是101000000。再对其进行62进制压缩之后，两个连续的URL也可以保证短网址完全打散，并且不会发生碰撞。

参考文献

【1】short_url.py - mozillazg/ShortURL
【2】url中可以包括哪些字符 - segmentfault问答

Golang开发Thrift接口

2014-07-22T00:00:00+00:00

三个月没在公司，回来后发现公司内部已经用上了facebook开源的Apache Thrift。大概看了一下介绍，传统接口编写是使用json或者xml作为信息格式进行传输。一般Web Service里面，SOAP这种，使用的就是xml（不过我从来没用过。。）；而轻量级网络服务REST，则用的是json作为传输媒介。json相较于xml，传输的内容变少了许多，传输更加便捷。这两种都是基于HTTP的传输方式。

而Apache Thrift，是更加轻量级的Web Service。本科做网络游戏的时候也接触过，叫RPC（Remote Procudure Call，远程过程调用）。这应该也算是一种RPC吧。调用起来更加简单，根本不需要发送HTTP请求，解析返回结果这些操作。只需要预先定义好类和对应函数，调用的时候创建一个类，调用函数即可。返回内容也是直接映射到类当中的。

完整地了解了一下Apache Thrift，这篇文章主要介绍hello, world的编写。如果你之前还没接触过Thrift，可以参考我之前写过的几篇文章所谓参考。

Apache Thrift安装——如何离线完成go get——安装Apache Thrift有感
编译官方例子时会涉及到命令行参数的解析——Golang 处理命令行启动参数
服务器端要实现定义好的接口，接口相关知识——Golang 接口实现

Apache Thrift给了一个完整的例子，包含很多语言版本的，Golang的完整代码可以看这里。文档方面官网没对这个例子介绍多少，代码也没贴全，找到这个就好办多了，直接复制下来编译就行了。其他语言的实现，返回向上一级目录即可。

这篇文章要讲的hello, world 主要根据developWorks的文章Apache Thrift - 可伸缩的跨语言服务开发框架进行介绍。

Thrfit文件定义如下：Hello.thrift。接口Hello，包含五个函数，五个都必须实现，否则编译器会认为该接口并没有被实现。

namespace java service.demo 
service Hello{ 
	string helloString(1:string para) 
	i32 helloInt(1:i32 para) 
	bool helloBoolean(1:bool para) 
	void helloVoid() 
	string helloNull() 
}

.thrfit文件就是定义了一套接口。通过命令可以生成对应语言的接口定义。会在当前目录下生成gen-go文件夹，把里面的内容放到gopath里即可。

$ thrift --gen go Hello.thrift

自动生成的接口定义如下hello.go：

type Hello interface {
	// Parameters:
	//  - Para
	HelloString(para string) (r string, err error)
	// Parameters:
	//  - Para
	HelloInt(para int32) (r int32, err error)
	// Parameters:
	//  - Para
	HelloBoolean(para bool) (r bool, err error)
	HelloVoid() (err error)
	HelloNull() (r string, err error)
}

上述操作用来生成接口，有了接口之后，就是要实现接口、开发客户端和开发服务器端这三个部分。参考的例子是使用大Java实现的，果断用Go重写helloimpl.go。Go语言实现接口可以参考Golang 接口实现。

type HelloHandler struct {
}

func NewHelloHandler() *HelloHandler {
	return &HelloHandler{}
}

func (h *HelloHandler) HelloString(para string) (string, error) {
	return "hello, world", nil
}

func (h *HelloHandler) HelloBoolean(para bool) (r bool, err error) {
	return para, nil
}

func (h *HelloHandler) HelloInt(para int32) (r int32, err error) {
	return para, nil
}

func (h *HelloHandler) HelloVoid() (err error) {
	return nil
}

func (h *HelloHandler) HelloNull() (r string, err error) {
	return "hello null", nil
}

服务器端的实现helloserver.go

func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string) error {
	var err error
	transport, err = thrift.NewTServerSocket(addr)

	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%T\n", transport)
	handler := NewHelloHandler()
	processor := hello.NewHelloProcessor(handler)
	server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory)

	fmt.Println("Starting the simple server... on ", addr)
	return server.Serve()
}

func main() {
	transportFactory := thrift.NewTTransportFactory()
	protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
	transportFactory = thrift.NewTBufferedTransportFactory(8192)
	runServer(transportFactory, protocolFactory, "localhost:9090")
}

启动服务器

$ go run helloserver.go helloimpl.go
Starting the simple server... on localhost:9090

客户端代码helloclient.go

func handleClient(client *hello.HelloClient) error {
	str, err := client.HelloString("")
	fmt.Println(str)
	fmt.Println("----------------")
	return err
}

func runClient(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string) error {
	var transport thrift.TTransport
	var err error

	transport, err = thrift.NewTSocket(addr)

	if err != nil {
		fmt.Println("Error opening socket:", err)
		return err
	}
	transport = transportFactory.GetTransport(transport)
	defer transport.Close()
	if err := transport.Open(); err != nil {
		return err
	}
	fmt.Println(transport, protocolFactory)
	return handleClient(hello.NewHelloClientFactory(transport, protocolFactory))
}

func main() {
	transportFactory := thrift.NewTTransportFactory()
	protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
	transportFactory = thrift.NewTBufferedTransportFactory(8192)
	runClient(transportFactory, protocolFactory, "localhost:9090")
}

启动客户端及运行结果：

$ go run helloclient.go
hello, world

参考文献

【1】Apache Thrift - 可伸缩的跨语言服务开发框架 - developWorks

Golang 接口实现

2014-07-20T00:00:00+00:00

面向对象程序语言已经是非常普及了。再过去的十几年内，面向对象的代表Java语句一直稳坐编程语言前三名的宝座。面向对象开发的学习，是每一个程序员的必修课。

对于我来说，学完C++和Java之后，看了一堆各种特性，却发现花了不少时间，项目却依然没啥功能。。。由于面向对象的引入，使得编程语言一下子多了好多语法特性，致使开发效率低下。尤其是像我这种学渣，体现得尤为明显。

后来，大家意识到一个问题：编程主要是用来解决一个问题，面向过程最符合人类正常的思维，也是最快的用来解决问题的方式；然而，在工程层面，面向对象的优势更加明显，虽然OO会使得开发效率降低，但是高度的解耦还是能够做到复用和稳定。所以一般大公司会采用Java作为主力开发语言，例如阿里巴巴、IBM，而一般创业小公司，喜欢用便捷的开发语言，例如Python，而我们则是Golang。

习惯性跑题。。。Golang是C语言之父创建的面向过程语言，被誉为“互联网界的C语言”。当然，好的东西还是需要借鉴的，Golang的设计也添加了一些OO的东西，例如接口。

Java中实现接口用interface和implements这两个关键字就能够实现了，而Golang不是面向对象语言，所以写出来的代码总感觉有点别扭，一直都记不住到底要怎么写。后来发现和Java对比一下，很容易理解。

#	Golang	Java
接口定义	type Phone interface {…}	interface Phone {…}
定义实现类	type iPhone struct {…}	class iPhone implements Phone {…}
实现接口函数	func (p *Android) Company() string {…}	String Company() {…}

其实这两个语法没差多少，而C++里面，struct也可以认为是类的一种，只是其内部变量和函数都是public的。

完整示例test_inte.go。

package main

type Phone interface {
	Company() string
}

type Android struct {
}

func (p *Android) Company() string {
	return "Google"
}

type iPhone struct {
}

func (p *iPhone) Company() string {
	return "Apple"
}

func main() {
	android := Android{}
	iphone := iPhone{}
	println(android.Company())
	println(iphone.Company())
}

测试结果：

$ go run test_inte.go
Google
Apple

参考文献

【1】GOLANG学习笔记-接口 - 0X55AA’博客

Golang 处理命令行启动参数

2014-07-20T00:00:00+00:00

最近要做Apache Thrift相关的项目。大概看了一下，觉得不难。Thrift目前已经至此和Go语言了。照着官方提供的一个例子在学。周五搞了一上午，终于编译通过了。下午去读例子源码，发现一个从来没见过的包——flag。

不管是C开发还是Java，都接触过命令行开发。像大Java的main函数public static void main(String []args)直接参数里面就能读取到命令行启动参数。而Go语言的主函数是func main()果断啥也没，需要用这个包。

虽然Go不像大Java，在主函数里面直接就能获取到命令行参数，但是Go通过flag包获取到的参数类型，不像Java那样，只能是String类型。

再获取之前，需要自定义要获取的参数名称、参数默认值、参数使用方法，还有参数类型。返回的是指针类型。也可以使用函数StringVar，用处一样，只是参数表和返回值的变化。

func String(name string, value string, usage string) *string
func StringVar(p *string, name string, value string, usage string)

定义好之后，通过调用flag包的Parse函数，就会自动解析。完整例子如下testflag.go：

package main

import (
    "flag"
)

var strFlag = flag.String("s", "", "Description")
var boolFlag = flag.Bool("bool", false, "Description of flag")

func main() {
    flag.Parse()
    println(*strFlag, *boolFlag)
}

还有一点需要注意的是，Go的命令行参数和大Java对应方式是不同的，默认情况下不能只写值，还需要传入对于值的名称，也就是前面提到的String函数的第一个参数。如果定义的是name，那么传的时候就需要加上-name {NAME}。

运行命令及结果：

$ go run testflag.go -s 123
123 false

现在在GitHub上面新建了一个Go语言相关用例的库，里面都是平时的测试代码。从今天开始添加。

https://github.com/mnhkahn/go_code

参考文献

【1】Package flag - http://golang.org/

Linux Mint 下ShadowSocks安装试用

2014-07-18T00:00:00+00:00

随着墙越垒越高，梯子也得赶得上趟才行。发现现在各路神仙都是在用ShadowSocks（简称SS）。

它与goagent的区别就在于，goagent是用过GAE所以代理服务器。在本地，通过Chrome浏览器的插件Proxy SwitchySharp，将请求代理到本地的goagent客户端，一般是8087端口。goagent客户端再将请求发送到GAE上面，从而达到梯子的作用。GAE的域名appspot.com一直是处于无法访问的状态，而解决访问GAE服务器的方法也很简单。强大的Google服务器集群，能够做到，访问Google的URL请求，发送到任意一个Google的服务器，都能够正常工作。如果我没有记错的话，GoAgent PAC就是用的这个方法。也就是说，只要墙有一道缝，就可以轻易化解。

然而，自从方教授去和病魔抗争离开工作岗位之后，据说来了一位女士接替他的工作。女人发狠起来比男人礼拜多了，实在是堵的太严实了。

下面是正题。其实，ShadowSocks与goagent最大的区别就是，ShadowSocks并不是通过GAE服务器访问网络，而是通过好心人共享出自己的网络实现上网的功能。这就需要在国外的热心人士安装上对应的客户端，共享出自己家的带宽了。这样的话，由于IP分布很广，所以通过IP拦截的方式就很难起作用了。然后，有人发现，如果GFW发现网络上在发送加密的包，那么，可能会自动做丢包处理，或者为该包选择最差路由路径传输。还有，使用VPN的用户，长时间连接的都是同样的地址，虽然内容无法侦测，但是会自动屏蔽掉改IP。

有一个中文版的ShadowSocks公益组织https://www.shadowsocks.net/，这里面提供了Windows下DOT NET开发的客户端程序，我的Mint果断不能用。如此高大上的东西，绝对不只是Windows平台的，所以继续找，http://shadowsocks.org/en/download/clients.html这个好像是官方网站，在Linux平台下依然写着shadowsocks-go，这应该是我大Golang开发的，但是去下载，发现是404。。。对node.js没有好感，果断选择了Python客户端。

我不会用Python，电脑上只有简单的开发环境，要安装程序，还需要安装必要的依赖:

sudo apt-get install python-m2crypto

接着，安装ShadowSocks客户端。如果安不上，可以选择豆瓣提供的源。而Ruby，可以选择淘宝提供的源。为这两个公司点个赞：

pip install shadowsocks

安装教程2，要在/etc/shadowsocks目录下创建文件config.json。去ShadowSocks中文网站，可以免费申请到帐号，按照此格式填入即可：

{
    "server":"remote-shadowsocks-server-ip-addr",
    "server_port":8883,
    "local_address":"127.0.0.1",
    "local_port":8883,
    "password":"whosyourdaddy",
    "timeout":300,
    "method":"aes-256-cfb",
    "fast_open":false,
    "workers":1
}`

最后，启动客户端。这个东西应该能直接加到开机启动里面，我不会，先这样吧。。。

sslocal -c /etc/shadowsocks/config.json

最后，配置Proxy SwitchySharp。它和goagent配置差不多，只是它用的是SOCK5传输，而不是HTTP，所以要在SOCKS Host里面填入localhost和配置文件里写的端口号，并选择SOCKS v5。

在Android和iOS端也都有相应的实现，iOS端由于权限的原因，只是一个浏览器，但是很好用。我的Nexus 7也安上了客户端，看着功能比较强，但是无法启动，可能需要root吧。ShadowSocks大家都知道是啥，但是为啥只提供Google Play一种安装方式，安起来好辛苦的说。。。

参考文献

【1】ShadowSocks公益组织
【2】Shadowsocks (简体中文)
【3】Chrome谷歌浏览器代理插件Proxy SwitchySharp简要教程

Android虚拟机模拟摄像头

2014-07-17T00:00:00+00:00

一开始默认会提醒叫你插入SD卡，按照网上教程给模拟器加了一个。那个Front Camera也都试了一下，也不太行。后来发现有个CPU/ABI，果断选了Intel。可能跟这个有关。

参考文献

【1】在 Android 模拟器中启用摄像头支持 - oschina

Linux下定时执行——crontab

2014-07-16T00:00:00+00:00

想做一个服务，能够每天定时调用执行。比如，每天定时推送微信，或者发送邮件，又或者为Android端推送消息。形式多种多样，内容主要是能有一个地方能够提醒展示今天要做的事情。像结婚纪念日、好朋友生日这种，还是挺重要的。

获取上面提到的这些内容都不难，比较难的是定时执行。

在语言层面，都实现了计时执行。比如，经过5分钟之后调用。计时器和定时器不同，可以比作是沙漏和闹钟。go语言可以使用time.NewTicker就能实现。但这个并不是定时执行。如果我们想每天早上6点都能执行，用这个就很费劲。我之间就做过这个尝试。

先获取当前时间，再根据定时时间，相减得到计时器时间；
执行改计时器时间，结束后执行操作；
然后，将计时器修改为24小时为一个周期。

后来，我在Github上面看别人写的时钟，好像也是这么干的。这样做太蹩脚了。

再后来，了解到，Android平台可以使用AlarmManager来辅助实现定时器。其实就是能够调用系统自身的闹钟。自己比较熟的常见语言，都没找到语言层面实现的定时器，而Android平台的AlarmManager让我意识到，可能这个东西本来就不是语言负责的东西，而是系统层面的东西。

意识到这个问题之后，问题就迎刃而解了。直接发现Linux系统内置命令crontab就支持定时调用，并且服务器端也都是靠这个来做定时调用的。

定时调用需要写配置文件，Ubuntu默认是使用nano作为默认编辑器，果断不会用，先换成vi。

echo export EDITOR=/usr/bin/vim >> ~/.bashrc
source ~/.bashrc

接着，编写定时调用规则：

crontab -e 编写调用规则；
在最后添加一行记录。记录分为两部分，执行时间和命令。这里的命令是/root/day >> $HOME/test.txt，执行day命令，并且将结果输出到文件test.txt当中；

0 */1 * * * /root/day » $HOME/test.txt

第一部分，时间规则如下：

段	含义	取值范围
第一段	代表分钟	0—59
第二段	代表小时	0—23
第三段	代表日期	1—31
第四段	代表月份	1—12
第五段	代表星期几，0代表星期日	0—6

最后，重启服务service cron restart即可。

参考文献

【1】Linux下crontab命令的用法 - sipsir

Go 语言简单实现HashSet

2014-07-15T00:00:00+00:00

公司有个需求，就是能够对列表去重。本屌原本想直接用for循环实现，后来去查了查Java的实现方式，大开眼界。

Set，是指数学里的集合。集合当中不能有重复的元素。判断是否有重复，可以使用哈希的方法。Java容器当中有基于哈希实现的HashSet。把元素都放入HashSet当中，如果有重复，则会插入失败。这样就能判断出来是否重复了。

而Golang并没有这种高级的容器。只是找了一个大神实现的，稍微改了一下，能够支持字符串检测。

http://play.golang.org/p/_FvECoFvhq

type HashSet struct {
	set map[string]bool
}

func NewHashSet() *HashSet {
	return &HashSet{make(map[string]bool)}
}

func (set *HashSet) Add(i string) bool {
	_, found := set.set[i]
	set.set[i] = true
	return !found //False if it existed already
}

func (set *HashSet) Get(i string) bool {
	_, found := set.set[i]
	return found //true if it existed already
}

func (set *HashSet) Remove(i string) {
	delete(set.set, i)
}

内部使用map来保存哈希结果。而哈希函数直接就是使用字符串作为哈希结果。

还可以看我之后的文章Golang 优化之路——空结构，这个方案更好一些。

参考文献

Android L 预览版试用

2014-07-14T00:00:00+00:00

官方安装教程 https://developers.google.com/android/nexus/images#instructions 官方下载系统镜像地址 http://developer.android.com/preview/setup-sdk.html

我的平板是Nexus 7（2013版），选择razor下载即可。安装也很简单。将设备通过USB连上电脑。这里可能需要配置驱动，如果需要，请参考《Linux Mint下安装Nexus 7 驱动》

启动设备进入fastboot模式。adb reboot bootloader
解压镜像文件
执行脚本flash-all。./flash-all.sh

安装挺简单的，第一次这么安东西，挺爽。自打安上之后，我就开始找微博上面提到的东西。最喜欢的那个就是开机画面，然后再我真机上面看，还有竖屏变横屏时的问题。。。截了两张图：

接着就是更都的问题。微博启动不了，QQ各种显示问题。虽说是预览版，但是跟我想像还是差了好多。。。今天晚上把系统刷回了4.4。不过电池确实好了许多。

Nginx根据域名转发

2014-07-12T00:00:00+00:00

Nginx的安装这里就不提了。安装成功之后，能显示默认的页面。

首先，要测试通过Nginx将不同的域名转发到不同的服务器，要注册一个域名。我通过免费域名提供商dot.tk注册了cyeam.tk这个域名，并且新建了两个A记录，将两个子域名都绑定要同一个IP上面。

接着，在服务器上面启动两个服务。我使用beego进行测试。通过命令bee new很方便的创建了两个应用，然后修改conf/app.conf里面的监听端口，修改其中一个即可。这两个服务就可以正常启动了。

最后，就是编写转发规则。Nginx的配置文件在/usr/local/nginx/conf里面。之前在公司群里看到过转发规则，后来又去Stackoverflow找了一篇大概介绍配置文件写法的进行参考，照猫画虎了写了，成功了。将访问域名，分别转发到了331端口和8080端口。

location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host $http_host;

if ($http_host = "blog.cyeam.tk") {
    proxy_pass http://127.0.0.1:331;
}

if ($http_host = "www.cyeam.tk") {
    proxy_pass http://127.0.0.1:8080;
}
    root   html;
    index  index.html index.htm;
}

修改完之后，通过命令sbin/nginx -t检查配置文件是否正确，然后通过命令sbin/nginx -s reload重新载入配置文件。

可以通过这两个域名访问到这两个应用，我对页面稍微做了修改，可以看出来转发到了不同的端口。

昨天成功了，今天再来看，就不行了。。。是因为我没有备案。没有办法展示效果了。

这样做可能还不是很完善，因为可以通过域名加端口的方式访问到具体服务。比如，blog.cyeam.tk设定是转发到331端口，如果通过blog.cyeam.tk:8080依然可以访问8080端口的服务。我觉得还需要对防火墙进行设定，不允许从外网访问除80等一些常见端口以外的端口。

参考文献

数据库访问的缓存与最大连接数

2014-07-11T00:00:00+00:00

今天查看我写的错误日志，里面报出了Too many connections这个错误。没见过啊，果断去问我大哥，他说是连接数的问题。我又去看之前已经上线的我的代码，才想起来数据库连接需要设置最大连接数的。当连接数超过范围之后，就是报这个错误。

我用的是xorm作为ORM工具，直接使用engine.SetMaxConns(dbMaxConns)就能设置最大连接数。

后来，又优化了一下缓存。一般ORM还是支持缓存机制的。如果缓存命中，就不会去数据库查找数据了，而是会直接返回。添加缓存需要增加缓存时间和最大缓存数。

cacher := xorm.NewLRUCacher2(xorm.NewMemoryStore(), time.Duration(interval)*time.Second, max)
engine.SetDefaultCacher(cacher)

很简单的问题，但是老是忘记加。今天用wrk对项目做了简单的压力测试，就出了这个问题。以前一直觉得压力测试就是用来测性能的，今天有了新的认识。

数据库访问时区问题

2014-07-09T00:00:00+00:00

今天是第二次跳进这个坑里面。

我要做的接口有一个需求，就是根据设定好的开始时间和结束时间过滤掉未开始和过期的内容。我用xorm作为ORM引擎进行数据库开发。直接一条解决了问题。当时还大概测了一下，没有任何问题。

Where("displayorder<>0 AND effectivetime< ? AND expirationtime> ?", time.Now(), time.Now())

今天iOS开发要调用我的接口开发，因为我写的测试数据不完整，他叫测试配了几条测试数据。测试妹子很专业的，加了一条过期的，一条要显示的，一条未开始的，然后我这三条一条都没展示。。。

问题报给我之后，很明显就知道问题出在哪里了。肯定是那个Where查询错了。xorm支持记录SQL语句日志，一开始开发我就配置上了。果断去看日志。把SQL复制到Navicat里面运行，发现没有任何问题。。。这就邪了。百思不得其解。我就开始瞎猜。是不是传入的time.Now()有问题。我就把日期格式化了一下，可以了。

const DATE_LAYOUT = "2006-01-02 15:04:05"
now := time.Now()
now_str := now.Format(DATE_LAYOUT)

这一次歪打正着让我觉得很不对劲（我的直觉还是很准确的！！！），然后就去请教了一下我万能的大哥，他说应该是UTC的问题。意思就是时区的问题，我才恍然大悟，之前我也踩过这个坑。在MySQL连接字符串里面加上时区信息就可以了。

parseTime=true&loc=Asia%2FChongqing

最后，我万能的大哥还告诉我，根本不需要传时间进去，直接使用MySQL的函数NOW()就可以了。嗯，大哥就是大哥。。。

Where("displayorder<>0 AND effectivetime< NOW() AND expirationtime> NOW()")

我团的Ruby团队据说是国内比较牛逼的Ruby团队了，因为主站一直用Ruby做开发的。我们Team只有5个人，选用了Golang作为主力开发语言，Golang又比较新，我们Team会不会成为国内比较牛逼的Golang团队呢？哈哈哈

Go语言接口开发——不确定JSON数据结构的解析

2014-07-09T00:00:00+00:00

在公司主要做接口的开发，会经常遇到接口对接的情况。有的时候，同一个请求返回的JSON数据格式并不一样。如果是正常，则可能只返回一个status字段，说明正常；如果中间出错，除了在status字段里面说明错误类型，还会通过error_message附带错误详细信息。比如要给用户加积分，如果加分失败，还会附带用户id等信息。那么，请求一个接口可能的返回值就是不确定的。

我最初就是定义两个结构体，我处理的数据都共有一个字段status，如果能够解析并且status表示操作成功，那么用封装成功内容的结构体解析；否则，用封装失败的结构体解析。这就是传说中的DIRTY HACK。。。

后来，偶然发现封装正确的结构体也会解析错误的字符串，当然，只会解析共有字段。那么，这个问题就好解决多了。把两个结构体放到一起即可，如果没有该字段，就不会被解析放入值。也就是说，未被解析的变量放的是默认值。

package main

import (
	"encoding/json"
	"fmt"
)

type Result struct {
	Status       int    `json:"status"`
	Message      string `json:"message"`
	ErrorCode    int    `json:"error_code"`
	ErrorMessage string `json:"error_message"`
}

func main() {
	json_str0 := `{"status":0,"message":"success"}`
	json_str1 := `{"status":1,"error_code":5,"error_message":"error"}`

	res0 := Result{}
	res1 := Result{}

	err0 := json.Unmarshal([]byte(json_str0), &res0)
	err1 := json.Unmarshal([]byte(json_str1), &res1)

	fmt.Println(res0, err0)
	fmt.Println(res1, err1)

}

这么简单的东西，Go语言的基本语法，但是看书的时候没有注意过，关键是做的时候没有认真分析，就直接DIRTY HACK了，我都不能忍自己了。。。

最后，还有一点，Go支持未知JSON数据结构的解析。创建一个interface，把它的地址传进去解析就行了，会解析出map[string]interface类型的数据。

参考文献

【1】Go语言编程

百度云推送——Go语言实现类库

2014-07-08T00:00:00+00:00

快速开始

下载安装

go get github.com/mnhkahn/BaiduYunPush

创建文件pushtest.go

package main

import (
    "fmt"
    "github.com/mnhkahn/BaiduYunPush"
)

var apikey = "**************************"
var seckey = "******************************"
var method = "POST"
var url_base1 = "channel.api.duapp.com/rest/2.0/channel/channel"

func main() {
    push := BaiduYunPush.New(apikey, seckey)
    s, err := push.Push("推送成功", "这是我的个人博客blog.cyeam.com")
    fmt.Println(s, err)
}

编译运行

go run pushtest.go

当控制台显示true之后，推送成功。这时，通过SDK绑定的设备就会展示推送消息。

参考文献

【1】百度开放云文档

如何离线完成go get——安装Apache Thrift有感

2014-07-03T00:00:00+00:00

今天公司事情不多，我手上的项目还需要等其他同事才能继续，有一段时间比较闲。之前有 3 个月不在公司回学校了，我们部门用了一个新的开发工具——Apache Thrift，就趁这个时间了解一下。

准备把 Thrift 安装到阿里云上面。这个东西大概了解了一下，是 Facebook 开源的一套远程调用的框架，比目前流行的基于 REST 传输 JSON 性能好，更优于基于 SOAP 的 XML。关键是它支持多种语言，当然包括我们 Team 使用的 Golang。

从官网下载压缩包安装有问题，没有官网上面描述的bootstrap.sh文件，还会会报错误。

libtool: link: ar cru .libs/libtestgencpp.a .libs/ThriftTest_constants.o
.libs/ThriftTest_types.o
ar: .libs/ThriftTest_constants.o: No such file or directory

在 Ubuntu 安装需要安装依赖。后来观察安装输出，发现还需要 Ant 和 Maven。

sudo apt-get install libboost-dev libboost-test-dev libboost-program-options-dev libevent-dev automake libtool flex bison pkg-config g++ libssl-dev

Thrift 会自动检查当前机子的环境变量里面存在的开发语言进行编译。它帮我自动支持了 Java、Python 和 Golang。

重点来了。在安装 Golang 的时候，出错了，日志说go get code.google.com/p/gomock/gomock连接超时。以我多年的经验来看，被拦截了。我在本机遇到这种情况的时候，都是使用 Goagent，直接export http_proxy="http://127.0.0.1:8087和export https_proxy="http://127.0.0.1:8087就设置好代理了。但是这次是阿里云，那边没办法代理。后来在本机试了试，能够下载。看来 GFW 是分区域拦的。通过 FTP 上传到gopath目录下，进入该目录，通过go install进行编译即可。可以再输入go get code.google.com/p/gomock/gomock，检测是否安装成功。

准备下个月发工资之后咬咬牙去买 Linode 的$10 的业务，希望今后能愉快的上网。

参考文献

【1】脆弱的 Go 远程包 - qinhui99
【2】ubuntu 12.04 中安装 thrift-0.9.1 - iAm333 的专栏
【3】Debian or Ubuntu setup

正则表达式

2014-07-02T00:00:00+00:00

正则表达式有几个用途：用于验证输入、通过grep查看日志、匹配HTML里面的标签。

正则表达式验证工具Kodos http://kodos.sourceforge.net/

#	正则表达式	解释
1	`hi`	最常见的查找方式，可以查找任何包含`hi`这两个连续字符的字符
2	`\b`	【元字符】代表单词的开头或结尾，也就是单词的分界处。只代表位置，不代表字符
3	`*`	【元字符】【重复】代表数量，它前面的字符可以重复任意次来匹配
4	`.`	【元字符】【重复】表示除了换行符以外的任意一个字符
5	`\d`	【元字符】表示一位数字，大括号表示两个连续数字
6	`\s`	【元字符】任意的空白符（space），包括空格，制表符(Tab)，换行符，中文全角空格等
7	`\w`	【元字符】匹配字母或数字或下划线或汉字等（word）
8	`^`	【元字符】和`\b`类似，表示字符串开始位置
9	`$`	【元字符】和`\b`类似，表示字符串结束位置
10	`\`	【字符转义】查找元字符本身时使用
11	`+`	【重复】重复一次或更多次
12	`?`	【重复】前面的字符重复零次或一次
13	`{n}`	【重复】重复n次
14	`{n,}`	【重复】重复n次或更多次
15	`{n,m}`	【重复】重复n到m次
16	`[]`	【范围】里面填入候选集合，这表示存在于集合中的一个字符。`[aeiou]`就匹配任何一个英文元音字母；`[0-9]`表示0到9之间任意一个数字
17	`\|`	【分枝条件】满足其中任意一种规则都应该当成匹配。`\d{5}-\d{4}\|\d{5}`可以认为存在优先级，`\|`优先级高于`-`
18	`\W`	【反义】匹配任意不是字母，数字，下划线，汉字的字符
19	`\S`	【反义】匹配任意不是空白符的字符
20	`\D`	【反义】匹配任意非数字的字符
21	`\B`	【反义】匹配不是单词开头或结束的位置
22	`[^x]`	【反义】匹配除了x以外的任意字符
23	`(exp)`	【后向引用】【捕获】匹配exp,并捕获文本到自动命名的组里
24	`(?<name>exp)`	【后向引用】【捕获】匹配exp,并捕获文本到名称为name的组里，也可以写成(?’name’exp)
25	`(?:exp)`	【后向引用】【捕获】匹配exp,不捕获匹配的文本，也不给此分组分配组号
26	`(?=exp)`	【零宽断言】匹配exp前面的位置
27	`(?<=exp)`	【零宽断言】匹配exp后面的位置
28	`(?!exp)`	【零宽断言】匹配后面跟的不是exp的位置
29	`(?<!exp)`	【零宽断言】匹配前面不是exp的位置
30	`*?`	【懒惰限定符】重复任意次，但尽可能少重复
31	`+?`	【懒惰限定符】重复1次或更多次，但尽可能少重复
32	`??`	【懒惰限定符】重复0次或1次，但尽可能少重复
33	`{n,m}?`	【懒惰限定符】重复n到m次，但尽可能少重复
34	`{n,}?`	【懒惰限定符】重复n次以上，但尽可能少重复
35	`(?'group')`	【递归匹配】把捕获的内容命名为group,并压入堆栈(Stack)
36	`(?'-group')`	【递归匹配】从堆栈上弹出最后压入堆栈的名为group的捕获内容
37	`(?(group)yes\|no)`	【递归匹配】如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
38	`(?!)`	【递归匹配】零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

	正则表达式		解释
	`^\d{5,12}$`		QQ号必须为5位到12位数字
	`^\w+`		匹配一行的第一个单词
	`\(?0\d{2}[) -]?\d{8}`		(010)88886666，或022-22334455，或02912345678
	`0\d{2}-\d{8}\|0\d{3}-\d{7}`		8位本地号(如010-12345678)和7位本地号(0376-2233445)
	`(\d{1,3}\.){3}\d{1,3}`		IP地址匹配
	`((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)`
	`\b(\w+)\b\s+\1\b`		匹配重复的单词
	`\b\w+(?=ing\b)`		匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I’m singing while you’re dancing.时，它会匹配sing和danc

参考文献

【1】正则表达式30分钟入门教程 - deerchao
【2】正则表达式 - 维基百科

grep与日志开发

2014-07-01T00:00:00+00:00

后台开发离不开日志，日志能帮助检查bug。日志开发本身没有太高的难度，就是把数据追加输出到文件即可。然而，日志往往数据量非常大。大量的日志并不能通过人工阅读进行检查，一般都是借助grep工具。这里将通过学习grep命令来对日志的打印方式进行分析。

grep全称是Global Regular Expression Print，表示全局正则表达式版本。

[options]主要参数：

	-c		只输出匹配行的计数
	-I		不区分大小写(只适用于单字符)
	-h		查询多文件时不显示文件名
	-l		查询多文件时只输出包含匹配字符的文件名
	-n		显示匹配行及行号
	-s		不显示不存在或无匹配文本的错误信息
	-v		显示不包含匹配文本的所有行

pattern正则表达式主要参数：

	\		忽略正则表达式中特殊字符的原有含义
	^		匹配正则表达式的开始行
	$		匹配正则表达式的结束行
	<		从匹配正则表达式的行开始
	>		到匹配正则表达式的行结束
	[ ]		单个字符，如[A]即A符合要求
	[ - ]		范围，如[A-Z]，即A、B、C一直到Z都符合要求
	.		所有的单个字符
	*		字符，长度可以为0

按照目录搜索grep magic /usr/src/Linux/Doc/*
查找单个文件more size.txt | grep '[a-b]'
安装日期查找
```
  $ cat 1.log | grep '2014-07-02'
```

按照中间内容查找

  $ cat /cygdrive/c/Users/Thinkpad/Desktop/1.log | grep /cyeam/test/url/aaa

2014-07-01T09:41:00 /cyeam/test/url/aaa 12
2014-07-02T09:41:01 /cyeam/test/url/aaa 12
2014-07-02T09:42:01 /cyeam/test/url/bbb 12
2014-07-02T09:46:01 /cyeam/test/url/ccc 12
2014-07-02T09:49:01 /cyeam/test/url/aaa 12
2014-07-02T09:51:01 /cyeam/test/url/bbb 12
2014-07-02T09:52:01 /cyeam/test/url/aaa 12
2014-07-02T09:59:01 /cyeam/test/url/ccc 12

参考文献

【1】linux grep命令 - 风生水起 - 博客园

Nutch和Solr的安装和简单测试

2014-06-21T00:00:00+00:00

之前在公司使用过Solr，这是基于Lucene实现的索引引擎。后来了解到，还有Nutch这个Java实现的网络爬虫。这两个搭配起来使用，就可以认为是一个完整的搜索引擎了。自己对Solr算是比较熟了，那么Nutch上手应该也不算难。果断尝试一下。

首先是去下载，网速不够给力，国内下载国外资源老是这样。果断使用360网盘帮我缓冲。我优先使用的百度云，结果他云端没有，还得去下载，速度跟我本机一样。据我猜想，他们两个的原理都一样，服务器只会保留一份文件，如果有人要下载，提供的URL一致，就会为其直接缓冲好。难道程序员都是用的360云？

apache-nutch-1.8-bin http://yunpan.cn/QhfHpuGMfP84d （提取码：bea3）
solr-4.8.1.zip http://yunpan.cn/QhfHIdV8pjzVT （提取码：2f5e）

Solr启动很简单，直接解压，进入example文件夹，默认提供了Jetty作为Servlet容器，使用java -jar start.jar就能启动了。

Nutch的安装是按照官网的教程。

NutchTutorial http://wiki.apache.org/nutch/NutchTutorial

修改文件conf/nutch-site.xml；

  <property>
   <name>http.agent.name</name>
   <value>My Nutch Spider</value>
  </property>

接着我就报错了，No agents listed in ´http.agent.name´ property。需要再修改conf/nutch-default.xml，再增加value的值即可；

  <property>
    <name>http.agent.name</name>
    <value>Cyeam's Spider</value>
    <description>HTTP 'User-Agent' request header. MUST NOT be empty -
    please set this to a single word uniquely related to your organization.

    NOTE: You should also check other related properties:

          http.robots.agents
          http.agent.description
          http.agent.url
          http.agent.email
          http.agent.version

    and set their values appropriately.

    </description>
  </property>

创建urls目录并且创建seed.txt文件，这个文件用于存放要爬的网站地址。我拿自己的网站来测试，写入了http://blog.cyeam.com/；
```
  mkdir -p urls
  cd urls
  touch seed.txt
```

修改conf/regex-urlfilter.txt文件，修改成如下的形式；

  # accept anything else
  #+.
  +^http://([a-z0-9]*\.)*blog.cyeam.com/

还需要增加字段，向example/solr/collection1/conf/schema.xml文件里加入

  <field name="digest" type="string" stored="true" indexed="false"/>
  <field name="segment" type="string" stored="true" indexed="false"/>
  <field name="boost" type="float" stored="true" indexed="false"/>
  <field name="tstamp" type="date" stored="true" indexed="false"/>

  <field name="anchor" type="string" stored="true" indexed="true"
          multiValued="true"/>
  <field name="cache" type="string" stored="true" indexed="false"/>

最后，启动爬虫，爬到的数据就会被存入Solr当中。

  Usage: bin/crawl <seedDir> <crawlID> <solrURL> <numberOfRounds>
  Example: bin/crawl urls/seed.txt TestCrawl http://localhost:8983/solr/ 2

使用Solr查看数据，http://localhost:8983/solr/collection1/select?q=*%3A*&rows=100&wt=json&indent=true。只有22个结果，我的文章不只这么多，而且内容也有问题，第一条好像是爬的首页。大体就搭建完成了。我的博客差不多就搭建好了，在blog.cyeam.com。接下来是搭建主站，准备工作了去购买Linode。主站也要能够展示一些博客文章。原本想基于jekyll进行修改，现在算了，直接用爬虫搞定好了。

{
    responseHeader: {
        status: 0,
        QTime: 1,
        params: {
        indent: "true",
        q: "*:*",
        wt: "json",
        rows: "100"
    }
    },
        response: {
            numFound: 22,
            start: 0,
            docs: [
            {
            content: [
                "Archive Home Categories Archive Tags Pages 2014 June June 19, 2014 » 流程图打脸 June 17, 2014 » AndroidHTTP库——Asynchronous Http Client for Android June 15, 2014 » Android端RTSP解决方案——libstreaming June 11, 2014 » 百度云推送 May May 15, 2014 » 『hello, world』 如何运行 May 14, 2014 » 笔试题总结 May 7, 2014 » 浪潮之巅——腾讯帝国？ April April 23, 2014 » Android 配置 April 19, 2014 » 查看自己的top10 Linux命令 April 18, 2014 » 基于流媒体的对讲机系统——UI设计 April 18, 2014 » 基于流媒体的对讲机系统——数据库模块 April 18, 2014 » Android 通知 April 18, 2014 » 基于流媒体的对讲机系统——系统用户界面的设计和实现 April 17, 2014 » 视频编解码技术H264 April 17, 2014 » SDP协议及开发设计 April 17, 2014 » 实时流媒体协议RTSP April 17, 2014 » 实时传输协议RTP April 17, 2014 » 基于流媒体的对讲机系统——系统开发准备 April 17, 2014 » 基于流媒体的对讲机系统——Android的开发准备 April 13, 2014 » 基于流媒体的对讲机系统的设计与实现 March March 5, 2014 » SIP协议的分析以及opensips注册和通话的研究 February February 25, 2014 » 上周在知乎上关于朝鲜问题的争吵 February 7, 2014 » iPhone的CSS显示 February 5, 2014 » Android Quick Start February 4, 2014 » 安卓对讲机开发评估 February 1, 2014 » Linux Mint下安装Nexus 7 驱动 January January 28, 2014 » 对联 January 22, 2014 » Linux命令整理 January 21, 2014 » beego介绍 January 14, 2014 » 一些网站架构中常见的术语和技术 January 13, 2014 » 2013读书总结 January 12, 2014 » Markdown January 11, 2014 » Linux Mint 64bit下安装Dota 2 January 7, 2014 » 青帝使用手册 January 2, 2014 » Java面试宝典 2013 November November 25, 2013 » 电影《色|戒》最后王佳芝为什么没有吃下那颗为特工准备的自杀胶囊？ November 23, 2013 » 搜狗2014校园招聘笔试题 November 5, 2013 » 中科曙光2014校园招聘笔试 October October 30, 2013 » 方正国际2014校园招聘笔试 October 25, 2013 » 神州航天软件2014校园招聘笔试 October 24, 2013 » 乐视2014校园招聘笔试 October 24, 2013 » 趣游2014校园招聘笔试 October 21, 2013 » 巨人网络2014校园招聘笔试 October 19, 2013 » 去哪网2014校园招聘Java开发面经 October 19, 2013 » 完美世界2014校园招聘笔试 October 17, 2013 » 广联达2014校园招聘笔试 October 15, 2013 » 触控科技2014校园招聘笔试题 October 13, 2013 » 百度2014校园招聘后台开发笔试 September September 16, 2013 » 阿里巴巴2014校园招聘面经 September 9, 2013 » 神州航天软件发展规划部实习笔试 April April 20, 2013 » 微软2012年实习生笔试题 March March 5, 2013 » 又一年 January January 23, 2013 » 你永远都不知道自己有多傻逼 January 23, 2013 » Connect the dots January 13, 2013 » 2012读书总结 2012 November November 2, 2012 » 请求网页所需协议 May May 23, 2012 » 沉淀心情 March March 26, 2012 » 很多事情感觉都来不及计划 2010 November November 3, 2010 » 3Q大战 May May 31, 2010 » 我的阿凡达 2009 February February 16, 2009 » 又要走了，可是不怎么想走啊 2008 December December 31, 2008 » 又过了一年 © 2014 Bryce with help from Jekyll Bootstrap and Twitter Bootstrap Cyeam by Bryce is licensed under a Creative Commons Attribution 4.0 International License ."
            ],
            title: [
                "Archive"
            ],
            segment: "20140621215120",
            boost: 0.10709364,
            digest: "c4b54b8331f0759333cd03dbf7e84032",
            tstamp: "2014-06-21T13:53:08.412Z",
            id: "http://blog.cyeam.com/archive.html",
            url: "http://blog.cyeam.com/archive.html",
            _version_: 1471528486701105200
        },

参考文献

【1】 CentOS 6.4环境下的Apache Nutch 1.7 + Solr 4.4.0安装笔记

AndroidHTTP库——Asynchronous Http Client for Android

2014-06-17T00:00:00+00:00

项目做了一个REST服务器，提供给Android客户端访问。Android为了保证界面交互，目前不能够在主线程当中使用发起HTTP请求。简单的做法是建立一个线程，在里面发送HTTP请求，收到结果之后，再创建一个Handler，通过Handler发送出更新界面的消息，在Handler里面更新。这样做比较麻烦，要创建Thread和Handler才能完成一次请求。当时我要做的是能够重复发送请求，就在线程中加了一个while判断，需要更新时更新。这样做功能上是可以了，我就去睡觉了。睡觉以前还有75%的电，起来后发现没电关机了。我被我牛逼的代码震惊了。

后来去Github找了一个开源的Android Http异步请求库android-async-http，非常好用。官方网站。调用之后会异步返回，返回之后仍然在界面类当中，所以也不需要再新建Handler发送消息就能够直接处理界面响应了。

请求的发送基于org.apache.http.impl.client.DefaultHttpClient封装。尽管Android官网推荐在2.3及后续版本中使用HttpURLConnection作为网络开发首选类，但在连接管理和线程安全方面，HttpClient还是具有很大优势。DefaultHttpClient提供了一套拦截器，用来处理即将离开的请求和即将到达的响应。

httpClient.addRequestInterceptor(new HttpRequestInterceptor() {
        @Override
        public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
        }
});

此外，它还使用了org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager来管理连接。

httpClient = new DefaultHttpClient(cm, httpParams);

Android端RTSP解决方案——libstreaming

2014-06-15T00:00:00+00:00

本来是想自己实现RTP传输的，看了好多资料，还看了libstreaming的源代码。大体步骤是这样的：

使用MediaRecorder采集，放入流当中；
然后建立本地发送线程，sipdroid封装UDP直接实现的，而libstreaming是通过多播实现；
采集到的音视频数据不能直接发送到发现线程当中，需要再建立两个本地套接字用于发送和接收；
在发送线程里，读取H264的流信息，跳过mp4容器的头信息；
接着就是获取NALU分割标记，一般是用00000001分隔不同的包，而libstreaming源码讲的是NAL头内存放的是包长度数据；
然后，放入NAL和视频帧发送；
一个RTP包最大容量是1200字节，如果H264包长度大于1300-sizeof(RTP Header)-sizeof(NAL)=1287字节的话，就要分包发送；

RTSP用于建立RTP会话，可以认为是RTP的一层封装。libstreaming也封装了RTP封包发送的代码，我就基于此进行了二次开发。原本准备直接用sipdroid进行RTP二次开发的，后来解了半天，也没有办法得到H264流，后来才发现它用的是H263，一群草你马奔驰而过。自己新建的一个多播和libstreaming的进行通信，可以获取到RTP包。通过解析RTP包的头，发现头信息基本正确，证明此法可用。然后接着开发，将H264流重新组包播放。

这里却遇到了一个非常大的问题。H264如果是用多个连续的包发送一个大的H264帧的时候，得到的包有可能是乱续的，还需要重新组装排序。我开发的时候想直接丢掉这些包，只解析包含单个H264的RTP包，但是又不成功。我猜测是被分包的大包是视频流的关键帧，而小包是基于关键帧的运动补偿信息（鄙人对视频压缩基本不懂，只能猜测这么多。。。）。如果是这样的话，那么我之前的做法就不行了。由于时间有限，学校催着交论文呢，而且也没找到简单的方法解决组包问题，这个就没继续做了。

不废话了，下面是本文的重点。。。

用RTP自己发送不成功，那么还是用libstreaming传输吧。我有一台Nexus 7和借来的联想A3000-H。做Demo我的Nexus 7 没有任何问题，而联想的用同样的代码就不行。一直以为是编码器的问题，因为Logcat一直提示找不到编码器。后来才发现是我太弱了。应该是联想的摄像头支持的参数和Nexus这些主流的不一样，导致的问题。有时候也会提示说分辨率不对，但其实是帧率不对，逗我呢。。。

通过Camera.Parameters.getSupportedPreviewSizes可以获得预览尺寸，通过Camera.Parameters.getSupportedPreviewFpsRange可以获得预览帧率。

百度云推送

2014-06-11T00:00:00+00:00

百度云推送支持通知、消息和富媒体的发送。我只实现了最简单的群推送通知的功能。还有针对指定ID的发送，指定通知布局，指定打开网页等一系列设置都没有包含。接下来还要用到这个的时候再去进行开发好了。

关于Android端的推送，有Google的官方支持，但是大家懂得，只能另寻它法。Android不同于iOS，它运行程序在后台有常驻进程。所以就有了其它通知方法。这样就可以由后台进程获取到通知内容后自行展示。发送通知还能用IBM的MQTT，虽然我在他们部门实习过，但是这个东西不会用。。。还有自己实现HTTP长连接Keep-Alive，发送Request之后等待Response。这些都是目前常用的方法，我都不会。那么，我就去找了现成的百度云推送。

百度提供了两种实现方式：SDK和REST API。SDK包括了PHP、JAVA、Python、Node.js和C#这些语言。而我选择比较熟悉的Go语言开发REST接口发送。接口请参考百度提供的文档。

http://developer.baidu.com/wiki/index.php?title=docs/cplat/push/api/list

发送消息需要验证用户身份，需要按照百度的规则将内容计算出的MD5码一并发送用于验证。先开始验证逻辑的时候，一直用的Javascript的encodeURI和网上找的MD532位加密算法验证，都不成功。十分受挫。后来去Github找了前辈OopsWare用Java写的SDKBaiduPush-Server-SDK。通过调试抓取它的sign码的计算结果，然后我再用Go照着结果去写。结果发现一下子就连上了，可能是我验证用的工具不对的原因把。。。愁

这个东西我原本是要在毕设当中使用的，毕设用了beego做服务器开发，这里也就一并用来开发了。等到答辩结束之后，争取能够开发出第一个Go语言实现的SDK。

百度提供的签名算法：http://developer.baidu.com/wiki/index.php?title=docs/cplat/push/api#.E7.AD.BE.E5.90.8D.E7.AE.97.E6.B3.95

Android客户端的开发可以直接参考百度提供的Demo和Android开发文档，照着样子挪到自己的项目里就可以了。

当时下载了百度提供的PushDemo，看到libs文件夹里的这三个文件夹，瞬间槽点满满。怪不得人们都说：“Android只是玩具，要开发应用，还得靠iOS”。Google管理下乱七八糟的硬件生态圈（包括软件也是。。。），通过NDK开发就要针对三个平台分别编译，如果是大型游戏，那么应用占用空间将会是iOS的三倍。除非你只想支持一种。而且其平台的混乱，还使得基于芯片的代码优化困难重重。这也就是为什么Android至今都没有大型应用的原因。

再加上最新得知Google香港也对中国进行了关键字屏蔽，曾经的好感又少了不少。。。每一个Android程序员开发过一阵程序之后，都会说要转iOS开发，我想说我也是这么想的。。。

『hello, world』如何运行

2014-05-15T00:00:00+00:00

以经典的“hello, world”为例，分析编译的各个阶段。

/* $begin hello */
#include <stdio.h>
int main() 
{
    printf("hello, world\n");
}
/* $end hello */

预处理阶段。将include要引入的文件载入并替换掉include。将.c文件转换为.i文件。使用gcc命令加上参数-E。
```
  `gcc -E hello.c -o hello.i`
```
预处理结束后，生成了845行的hello.i文件。
编译阶段。将.i文件编译成.s文件。
```
  `gcc -S hello.i -o hello.s`
```
将其翻译成汇编语言。
```
      .file   "hello.c"
      .section    .rodata
  .LC0:
      .string "hello, world"
      .text
      .globl  main
      .type   main, @function
  main:
  .LFB0:
      .cfi_startproc
      pushq   %rbp
      .cfi_def_cfa_offset 16
      .cfi_offset 6, -16
      movq    %rsp, %rbp
      .cfi_def_cfa_register 6
      movl    $.LC0, %edi
      call    puts
      popq    %rbp
      .cfi_def_cfa 7, 8
      ret
      .cfi_endproc
  .LFE0:.LC0:
      .size   main, .-main
      .ident  "GCC: (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1"
      .section    .note.GNU-stack,"",@progbits
```
- .section .rodata后面定义了一个只读字符串常量.LC0，用来储存hello, world。
- .text后面开始是代码区，.globl main定义了主函数入口。
- .cfi_startproc用在每个函数的开始，用于初始化一些内部数据结构。
- rbp寄存器是ebp寄存器64位扩展，ebp寄存器扩展基址指针寄存器(extended base pointer)　　其内存放一个指针，该指针指向系统栈最上面一个栈帧的底部。
  
  以 %r 开头的表示 64-bit 寄存器；以 %e 开头的是 32-bit 寄存器。
  
  pushq，64位，所以是q。保存rbp，以便使用rbp作为栈指针。
- .cfi_endproc在函数结束的时候使用与.cfi_startproc相配套使用。
- movq %rsp, %rbp保存栈frame，现在有些编译器开发者致力于优化函数调用，优化这个frame就是其中一项。
- movl $.LC0, %edi把字符串”hello, world”的地址放入edi。
- call puts打印并且在后面自动追加换行符\n。
汇编阶段。将上一步生成的汇编代码通过汇编器编译成目标文件.o。

gcc -c hello.s -o hello.o
链接阶段。将上一步得到的目标文件与printf.o链接合并到可执行文件hello中。编译完成。

gcc hello.o -o hello

参考文献

笔试题总结

2014-05-14T00:00:00+00:00

整理准备按照语言进行分类，先做C/C++相关的题，然后是Java相关。最后是算法题。

##C/C++

##Computer Science

##Algorithm

##笔试题

题图，北京卧佛寺。当时找工作，差点去拜拜。。。

浪潮之巅——腾讯帝国？

2014-05-07T00:00:00+00:00

昨天，腾讯成立了微信事业群。原文查看这里。

引用一下微信事业群总裁张小龙的鸡汤：

做对用户有价值的事情。

保持我们自身的价值观，因为它会体现在我们的产品和服务中。

保持小团队，保持敏捷。

学习和快速迭代比过去的经验更重要。

系统思维。

让用户带来用户，口碑赢得口碑。

思辨胜于执行。

联通、电信、移动这三大电信服务商，作为互联网的载体，在过去的十几年里，除了移动网络从2G升级到3G，3G再到4G，ASDL升级到光纤，就基本没有任何作为了。微信的出现，直接跃居到这三大电信商头上，中国未来的通信方式可能由此改变。

微信刚开始，还没怎么引起大家的注意，总觉得就是手机QQ。但是发展这些年之后，微信却越来越热，去吃个饭，服务员都叫你扫个二维码，给你打个折。中央五台还天天叫你关注微信，猜球队输赢。不知不觉的变得炙手可热。

让我觉得眼前一亮的，就是微信公共帐号。从一开始关注Fenng，再到MacTalk，后来吃饭为了打折、买东西为了得到优惠，还关注了宜家这些帐号。招商银行的服务帐号也非常好用，绑定之后可以很简单的使用，都不用去下载它们的App了。

公共帐号的出现，使得微信从一个简单的IM工具变成了一个内容消费型App，大家有了一个地方可以交流，说出自己的想法。以前也有博客或者牛博网这些地方可以，但是在移动互联网时代，这样的形式更好一些。这几天了解了一下微信的开发文档，微信最近增加了搜搜地图的API支持，未来微信公共号内容的形式又增加了。虽然腾讯自家的地图市场份额不行，但是有微信的支持，赶上百度妥妥的。。。

前几天想申请一个微信号做开发使用，才发现自从微信5.0 版本之后，就只能通过手机进行注册了，我以前通过QQ号注册的方式不行了(当然也不是绝对不行，去山寨Android App市场下载一个老版本的，安上还是有通过QQ号注册的。。)。微信如果要成功，就必须摆脱QQ，摆脱腾讯原来主要收入群体。所以，微信不能再使用QQ登录，昨天的成为腾讯第七个事业群，和QQ有相同战略地位，也就顺利成章了。众所周知，腾讯的用户主要集中在小学生和较不发达地区(反正我周围是这样)，这里的用户目前依然是QQ的忠实用户。而微信后来不能使用QQ登录的原因也很简单，躲开这些用户。如果每天微信群里都是马化腾老婆生日到了，朋友圈里面都是转发这条保全家平安(朋友圈好像就没这个功能。。。)，那么微信也就是QQ的下场了。

腾讯一直以来主要的收入群体都是小学生和不发达地区，小学生玩游戏，村子里的办黄钻，玩QQ空间。这虽然让腾讯游戏成为世界上最赚钱的游戏公司，QQ成为中国最牛逼的IM，但是也就如此了。一个产品不能照顾到所有的用户类型，而不照顾社会最中间的力量，也不可能做出改变世界的产品。有舍，有得。

老对手，阿里，在这方面就做得很好。很多创业公司都是靠淘宝起家的，不管是主要用户和主要卖家，都包含了社会的中坚力量，因为小学生不会用支付宝。最近推出的余额宝，也同样改变了中国，让那些大银行的活期利息提高了10倍。今天，阿里好像就要上市了。最高估值，全球第四，嗯嗯，挺好。未来几年，也就是这两个公司的竞争了。

最后提一下度厂。刚才提到了用户群体，貌似百度忠实的用户就是宅男，主要的产品就是AV。从最早的百度下吧，到后来的百度影音，现在的百度网盘。还有当年排名贴吧第三的片种吧。我严重怀疑我的老乡Robin老婆是卖卫生纸的。

最近Robin在内部邮件里说，要求员工10点以前上班。还有狼性。

以我这个没有去过百度上班的外人来看，它们的问题主要是出在高层，高层领导利用职权谋私，部门之间利益内斗消耗，是百度在移动互联网上失败的主要原因。改变这个很难，而老板给了压力，Robin只能惹的起码农，邮件就来了。

Android 配置

2014-04-23T00:00:00+00:00

android.content.SharedPreferences配置内容可以在Activity、Service、Broadcast和Content Provider中使用。在程序运行时动态获取配置信息，可以通过android.preference.PreferenceManager.getDefaultSharedPreferences()获取实例。

1. 读取配置信息

SharedPreferences 提供如下方法直接获取配置的信息。

	#		方法
	1		getString
	2		getBoolean
	3		getInt
	4		getLong
	5		getFloat

2. 修改配置信息

修改配置需要用到android.content.SharedPerferences.Editor。Editor提供了如下方法修改首选项内容。获取Editor通过SharedPerferences.editor()获得。

	#		方法
	1		putString
	2		putBoolean
	3		putInt
	4		putLong
	5		putFloat

Editor edit = settings.edit();
edit.putBoolean(PREF_MESSAGE, true);
edit.commit();

3. PreferenceActivity

使用PreferenceActivity，通过addPreferencesFromResource以界面的形式展示，并且可以在此界面中对配置的值进行修改。展示的布局将会按照首选项的配置文件自动生成。每一项都是由指定的android:title和该项的值组成。

用户更新了设置之后，还要将最新用户设置的内容展现出来，能够让用户判断是否选择正确。

getPreferenceScreen().findPreference(PREF_ROLE).setSummary(role);

4. 首选项内容

单选提供了android.preference.ListPreference，它类似于HTML的下拉列表，可以为其提供选项值和选项标签。

<string-array name="role">
    <item>指挥</item>
    <item>协调</item>
    <item>默认</item>
</string-array>
<string-array name="role_values">
    <item>commander</item>
    <item>coordinator</item>
    <item>default</item>
</string-array>

<ListPreference
    android:defaultValue="默认"
    android:entries="@array/role"
    android:entryValues="@array/role"
    android:key="role"
    android:title="@string/settings_current_role" />

5. 监听配置信息的修改

设置监听需要实现android.content.OnSharedPreferenceChangeListener接口，通过settings.registerOnSharedPreferenceChangeListener(this);进行注册监听。事件处理在onSharedPreferenceChanged。

registerOnSharedPreferenceChangeListener
unregisterOnSharedPreferenceChangeListener

参考文献

【1】How to create RadioButton group in preference.xml window? - Stackoverflow
【2】SharedPreferences - Android Developers
【3】Marko Gargenta, Learning Android[M]. 电子工业出版社, 2012.7.

查看自己的top10 Linux命令

2014-04-19T00:00:00+00:00

history | awk '{CMD[$2]++;count++;}END { for (a in CMD)\
print CMD[a] " " CMD[a]/count*100 "% " a;}' | grep -v "./" \
| column -c3 -s " " -t | sort -nr | nl | head -n10

来晒晒你使用过的 Linux 命令的 top 10 吧! - V2EX

我的结果是：

133  26.5469%   git
111  22.1557%   sudo
58   11.5768%   cd
53   10.5788%   ls
24   4.79042%   grep
22   4.39122%   go
10   1.99601%   jekyll
10   1.99601%   gor
10   1.99601%   adb
7    1.39721%   ssh

最近都在GitHub Pagers上面写论文，所以git和jekyll都榜上有名。。。

不过感觉次数少了点，查了一下，history默认保存500条命令(可以通过echo $HISTSIZE查看)。不过直接用history命令，能看到多于500条的命令，看到了519条。原因是如果你不注销或者关机，那么执行hisotry命令只要永久保存，可能记录大于500。如果你注销了以后，.bash_history只保存最近的500条记录。

awk是一个强大的文本分析工具。awk其名称得自于它的创始人 Alfred Aho 、Peter Weinberger 和 Brian Kernighan 姓氏的首个字母。awk工作流程是这样的：读入有'\n'换行符分割的一条记录，然后将记录按指定的域分隔符划分域，填充域，$0则表示所有域,$1表示第一个域,$n表示第n个域。默认域分隔符是"空白键" 或 "[tab]键”,所以$1表示登录用户，$3表示登录用户ip,以此类推。

linux awk命令详解 - 简单，可复制

head可以用来查看文件头部指定行数，所以最后的head -n10就是要显示前10行，就是前10个，去掉就是显示全部了。

Android 自定义形状

2014-04-18T00:00:00+00:00

Android中的drawable不仅只能是图片，还可以是自定义的图形(Shape)，用XML文件来描述。Shape可以被其他控件，例如按钮(Button)使用，显示出指定形状的按钮来。这里我们要进行扁平化处理，所以需要一个圆形的Shape。

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval" >
    <!-- 填充的颜色 -->
    <solid android:color="#FFFFFF" />
    <!-- 设置按钮的四个角为弧形 -->
    <corners android:radius="50dip" />
</shape>

我们的控件只要设置android:background="@drawable/round"，就能限定成圆形的。但这还不够，我们还需要在圆形的控件内绘制图片，需要使用ImageView控件，为其增加android:src属性。

参考文献

Drawable Resources - Android Developers

基于流媒体的对讲机系统——数据库模块

2014-04-18T00:00:00+00:00

移动设备中的数据库是对在线网络存储的一个重要补充。本课题的需求中，要求能保存关注的联系人和通话历史，所以使用SQLite来实现。SQLite可以像普通数据库一样机型增删改查的操作。

###游标查询指令会返回游标，可以通过moveToNext方法进行遍历处理。

###android.content.ContentValues ContentValues是Android提供的一个容器，类似于Map，可以通过Key-Map的方式加入值。

###SQLiteOpenHelper

###SQLiteDatabase

参考文献

《Learning Android》马尔科·加尔根塔电子工业出版社 ISBN: 9787121172632

Android 通知

2014-04-18T00:00:00+00:00

Android在通知栏方面相对于苹果来说比较开放。允许服务常驻后台，所以能够方便实现消息推送。而苹果的进程等待几分钟没有操作之后，就会自动退出，远程发送消息只能经过苹果的远程推送实现。鄙人曾经在公司尝试开发百万级的消息推送接口，说来惭愧，没能成功。

1. 显示通知

发送通知需要用到android.app.NotificationManager和android.app.Notification。调用流程如下：

NotificationManager mNotificationMgr = (NotificationManager) mContext
            .getSystemService(Context.NOTIFICATION_SERVICE);
Notification notification = new Notification();
// 初始化notifacation
mNotificationMgr.notify(type, notification);

Notifaction提供flags、icon、sound等设置通知的类型，图标和声音。可以通过设置contentIntent为通知增加点击启动的Activity。

2. 远程推送通知

关于远程推送，发现有使用IBM的MQTT的，还有建立长连接的。待我调研一翻，再来修改这里。

参考文献

【1】Android中通知的使用—–Notification详解
【2】Notification - Android Developers
【3】NotificationManager - Android Developers
【4】Push Notification （2）HTTP长连接

视频编解码技术H264

2014-04-17T00:00:00+00:00

http://blog.csdn.net/tjy1985/article/details/7963531 MPEG正式审核程序是Moving Picture Experts Group的简称。这个名字本来的含义是指一个研究视频和音频编码标准的“动态图像专家组”组织，成立于1988年，致力开发视频、音频的压缩编码技术。现在我们所说的MPEG泛指由该小组制定的一系列视频编码标准正式审核程序。该小组于1988年组成，至今已经制定了MPEG-1、MPEG-2、MPEG-3、MPEG-4、MPEG-7等多个标准，MPEG-21正在制定中。MPEG是ISO和IEC的工作组，它的官方头衔为：第一技术委员会第二十九子委员会第十一号工作组正式审核程序，英文头衔为ISO/IEC JTC1/SC29 WG11。MPEG大约每2-3个月举行一次会议，每次会议大约持续5天，在会议期间，新的建议和技术细节先在小组中讨论，成熟后进入标准化的正式审核程序。与MPEG工作组相关的其他几个视频标准化工作组包括ITU-T VCEG以及JVT。

MPEG-1：第一个官方的视訊音訊压缩标准，随后在Video CD中被采用，其中的音訊压缩的第三级（MPEG-1 Layer 3）简称MP3，成为比较流行的音频压缩格式。
MPEG-2：广播质量的视訊、音訊和传输协议。被用于無線數位電視-ATSC、DVB以及ISDB、数字卫星电视（例如DirecTV）、数字有线电视信号，以及DVD视频光盘技术中。
MPEG-3：原本目标是为高解析度电视（HDTV）设计，随后發現MPEG-2已足夠HDTV應用，故MPEG-3的研發便中止。
MPEG-4：2003年发布的视訊压缩标准，主要是扩展MPEG-1、MPEG-2等標準以支援視訊／音訊物件（video/audio “objects”）的編碼、3D內容、低位元率編碼（low bitrate encoding）和數位版權管理（Digital Rights Management），其中第10部分由ISO/IEC和ITU-T联合发布，称为H.264/MPEG-4 Part 10。
H.264/MPEG-4第10部分，或称AVC（Advanced Video Coding，高级视频编码），是一种面向块的基于运动补偿的编解码器标准。H.264因其是蓝光碟片的一种编解码标准而著名，所有蓝光碟片播放器都必须能解码H.264。它也被广泛用于网络流媒體数据如Vimeo、YouTube、以及iTunes Store，网络软件如Adobe Flash Player和Microsoft Silverlight，以及各种高清晰度電視陆地广播（ATSC，ISDB-T，DVB-T或DVB-T2），线缆（DVB-C）以及卫星（DVB-S和DVB-S2）。

H264的功能分为两层，视频编码层（VCL）和网络提取层（NAL）。视频编码层负责高效的视频内容表示，而网络适配层负责以网络所要求的恰当的方式对数据进行打包和传送。引入NAL并使之与VCL分离带来的好处包括两方面：其一、使信号处理和网络传输分离，VCL 和NAL 可以在不同的处理平台上实现；其二、VCL 和NAL 分离设计，使得在不同的网络环境内，网关不需要因为网络环境不同而对VCL比特流进行重构和重编码。

H.264 的基本流由一系列NALU （Network Abstraction Layer Unit ）组成，不同的NALU数据量各不相同。H.264 草案指出[2]，当数据流是储存在介质上时，在每个NALU 前添加起始码：0x000001，用来指示一个 NALU的起始和终止位置。在这样的机制下，在码流中检测起始码，作为一个NALU得起始标识，当检测到下一个起始码时，当前NALU结束。每个NALU单元由一个字节的 NALU头（NALU Header）和若干个字节的载荷数据（RBSP）组成。

参考文献

【1】H264码流打包分析 - szu030606的专栏

SDP协议及开发设计

2014-04-17T00:00:00+00:00

会话描述协议SDP(Session Description Protocol)完全是一种会话描述格式，它不属于传输协议，它只使用不同的适当的传输协议，包括会话通知协议（SAP）、会话初始协议（SIP）、实时流协议（RTSP）、MIME 扩展协议的电子邮件以及超文本传输协议（HTTP）。本课题是要先通过SIP建立通信连接，再通过RTSP进行传输。连接这两个协议的就是SDP。

SDP描述多媒体信息与协商具体参数。具体做法是：主叫方将己方SDP消息放入INVITE请求消息的主体中，当被叫方收到后，对SDP消息分析，若兼容对方的编码格式，则创建一个协商后的SDP消息，放入确认响应消息中，若不兼容则发送失败响应。可参考上一节中的SIP请求协议分析。

SDP基于文本协议，消息包括：会话名称、用户名、地址、媒体类型、传输协议、媒体编码格式、端口等，主要参数及格式为：

o：<用户名><会话编号><版本><网络类型><地址类型><地址>
c：<网络类型><地址信息><连接地址>
a：<属性>或<属性>：<值>
t：<开始时间><结束时间>
m：<媒体><端151><传输协议><媒体编码格式列表>

上一节SIP请求中的SDP信息如下：

请求用户名mint。
请求IPv4地址：10.14.5.218。
音频在7078端口，通过RTP进行传输，通过speex编码，支持8000、16000、32000三种采样率。视频在9078端口，支持MP4V-ES和H263-1998两种视频编码格式。

参考文献

【1】SDP 协议分析博水

实时流媒体协议RTSP

2014-04-17T00:00:00+00:00

即时串流协定（Real Time Streaming Protocol，RTSP）是用来控制声音或影像的多媒体串流协议，并允许同时多个串流需求控制，传输时所用的网络通讯协定并不在其定义的范围内，服务器端可以自行选择使用TCP或UDP来传送串流内容，它的语法和运作跟HTTP 1.1类似。RTSP协议提供RTP流媒体发送会话的控制方法。。

RTSP主要信令如下：

OPTIONS：获得服务器支持的RTSP消息类型。
DESCRIBE：获取服务器返回的SDP消息，其中包含媒体流ID、支持编解码、序列参数集SPS与图像参数集PPS等。
SETUP：交互双方的RTP端口号，客户端获取服务器分配的会话ID。
PLAY：通知服务器传输流媒体，请求必须包含在SETUP响应中的会话ID。
PAUSE：暂停当前会话，即停止媒体流传输，但是并不释放端口与资源。
TEARDOWN：结束当前会话，并释放端口、连接与资源。

RTSP流程

查询服务器端可用方法

客户端请求(OPTION request):—询问服务器有哪些方法可用

  "OPTIONS rtsp://192.168.1.122/TestSession RTSP/1.0"
  "CSeq: 2"
  "User-Agent: LibVLC/1.1.9 (LIVE555 Streaming Media v2011.01.06)"

服务器回应(OPTION response):—回复的所有方法在Public字段

  "RTSP/1.0 200 OK"
  "CSeq: 2"
  {"Public: OPTIONS, DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE"}
  ""    //最后这个也很重要，最后一个消息头需要有两个CR LF

得到媒体描述信息

客户端请求(DESCRIBE request):—–要求得到媒体描述信息

  "DESCRIBE rtsp://192.168.1.122/TestSession RTSP/1.0"
  "CSeq: 3"
  "User-Agent: LibVLC/1.1.9 (LIVE555 Streaming Media v2011.01.06)"
  "Accept: application/sdp"

服务器回应(DESCRIBE response):—回应媒体描述信息，一般是sdp信息

  "RTSP/1.0 200 OK"
  "CSeq: 3" //和请求的序号要对应
  {"Server: RTSP Service"
   "Content-Base: rtsp://192.168.1.122/TestSession"
   "Content-Type: application/sdp"         //表示回应的是sdp信息 
   "Content-Length: 367"
  }
  ""    然后再发送生成的sdp信息，sdp信息也可以和上面的字符串组合一起发送。

建立RTSP会话。SETUP成功之后，服务器就会开始录制，等待客户端播放。

客户端请求(SETUP request):—–通过Transport头字段列出可接受的传输选项，建立会话

  "SETUP rtsp://192.168.1.122/TestSession/trackID=1 RTSP/1.0"
  "CSeq: 4"
  "User-Agent: LibVLC/1.1.9 (LIVE555 Streaming Media v2011.01.06)"
  "Transport: RTP/AVP;unicast;client_port=2274-2275"

服务器回应(SETUP response):–建立会话，通过Transport头字段返回选择的具体传输选项，并返回建立的Session ID;

  "RTSP/1.0 200 OK"
  "CSeq: 4"
  "Session: 68422540987712"
  "Transport:RTP/AVP;unicast;source=192.168.1.122;server_port=8000-8001;client_port=2274-2275;ssrc=3969838262"
  ""    

请求开始传送数据

客户端请求(PLAY request): —–请求服务器开始发送数据

  "PLAY rtsp://192.168.1.122/TestSession RTSP/1.0" 
  "CSeq: 5"
  "User-Agent: LibVLC/1.1.9 (LIVE555 Streaming Media v2011.01.06)"
  "Session: 68422540987712"
  "Range: npt=0.000-"

服务器回应(PLAY response):——回应该请求的信息

  "RTSP/1.0 200 OK"
  "CSeq: 5"
  "Session: 68422540987712"
  "RTP-Info: url=rtsp://192.168.1.122/TestSession/trackID=1"
  ""   

数据传输

服务器->客户端：发送流媒体数据，通过RTP协议传输数据

关闭会话，退出

客户端请求(TEARDOWN request):———请求关闭会话

  "TEARDOWN rtsp://192.168.1.122/TestSession RTSP/1.0"
  "CSeq: 6"
  "User-Agent: LibVLC/1.1.9 (LIVE555 Streaming Media v2011.01.06)"
  "Session: 68422540987712"

服务器回应(TEARDOWN response):

  "RTSP/1.0 200 OK"
  "CSeq: 6"
  "Session: 68422540987712"
  "Connection: Close"
  ""

参考文献

【1】RTSP 协议分析（一）博水
【2】rtsp 交互流程

实时传输协议RTP

2014-04-17T00:00:00+00:00

1. RTP

实时传输协议（Real-time Transport Protocol，RTP）是一个网络传输协议，它是由IETF的多媒体传输工作小组1996年在RFC 1889中公布的。RTP协议详细说明了通过互联网上传递音频和视频的标准数据包格式。

每一个RTP数据报都由头部（Header）和载体（Payload）两个部分组成，其中头部前12个字节(96 bit)的含义是固定的，而负载则可以是音频或者视频数据。

Ver.（2 bits）是目前协定的版本号码，目前版号是 2。
P（1 bit）是用于RTP 封包（packet）结束点的预留空间，视封包是否需要多余的填塞空间。
X（1 bit）是否在使用延伸空间于封包之中。.
CC（4 bits）包含了 CSRC 数目用于修正标头（fixed header）.
M (1 bit) 是用于应用等级以及其原型（profile）的定义。如果不为零表示目前的资料有特别的程序解译。
PT（7 bits）是指payload的格式并决定将如何去由应用程式加以解译。
SSRC 是同步化来源。

实时传输控制协议（Real-time Transport Control Protocol 或RTP Control Protocol或简写RTCP）是实时传输协议的一个兄弟协议。RTCP为RTP媒体流提供信道外控制。RTCP本身并不传输数据，主要用来和RTP一起协作将要发送的音频和视频数据打包发送。RTCP的主要功能是为RTP所提供的服务质量提供反馈，保证流媒体发送实时同步。

RTP的同步控制是通过RTCP协议的Sender Report和Receiver Report实现。

Sender Report：发送端报告，所谓发送端是指发出RTP数据报的应用程序或者终端，发送端同时也可以是接收端。
Receiver Report：接收端报告，所谓接收端是指仅接收但不发送RTP数据报的应用程序或者终端。

2. 基于sipdroid完成RTP包解析播放

sipdroid默认建立链接之后会判断当服务器是否是sipdroid官方提供的服务器，如果不是，则只会建立音频通话，不建立视频通话。注释掉该判断语句，发现它实现了发送RTP流媒体功能，通过与linphone的通话，能够在linphone端看到视频信息。然而，无法播放linphone发送的视频信息。又通过查看代码，发现播放视频的方法是通过RTSP接收。

    if (Receiver.call_state == UserAgent.UA_STATE_INCALL && socket == null
            && Receiver.engine(mContext).getLocalVideo() != 0
            && Receiver.engine(mContext).getRemoteVideo() != 0 && PreferenceManager.getDefaultSharedPreferences(this).getString(org.sipdroid.sipua.ui.Settings.PREF_SERVER, org.sipdroid.sipua.ui.Settings.DEFAULT_SERVER).equals(org.sipdroid.sipua.ui.Settings.DEFAULT_SERVER)))

 mVideoFrame
         .setVideoURI(Uri.parse("rtsp://"
         + Receiver.engine(mContext).getRemoteAddr() + "/"
         + Receiver.engine(mContext).getRemoteVideo()
         + "/sipdroid"));

sipdroid播放视频流还需要建立RTSP会话。而linphone直接发送的是RTP包，所以sipdroid无法播放linphone的视频。在此之前一直使用WireShark分析RTSP建立，结果就是没找到建立过程。后来看源码才发现。。。上面提到的代码分别是在包org.sipdroid.sipua.ui内的类CallScreen的函数onResume中和类VideoCamera的函数onResume中。

但是现在依然有疑问，上面的代码是通过直接请求远程客户端建立RTSP请求，通过MediaPlayer播放。并没有关系到服务器，那么RTSP是怎么建立的？而且，它专门指定要自己的服务器才能去建立视频连接，既然RTSP建立又没有关系到服务器，这个逻辑又是为什么？而且这两个疑问又互相矛盾，如果大家有想法，不妨屈尊指导一下学渣

抛开上面的问题不管，只要自行进行视频解码，还是可以播放的。通过从rtp_socket读取包，发现每次都能读取到1414字节的数据。应该可以证实是从linphone传来的数据，包大小也正常。下面开始着手解包和播放。

整个RTP包的实现就是基于UDP进行传输的。也可以从代码的实现验证这一点，RtpSocket类内部拥有UDPDatagramPacket数据报。RTP可以认为是为UDP加了12字节协议包。类RtpPacket提供自动解析的能力。下面是解析后的结果和协议头的对比。

#	RTP协议	抓取到的内容	描述
1	Version	2	版本号，为2
2	hasPadding	false	没有加塞空间
3	hasExtension	false	没有额外空间
4	CscrCount	0	Cscr数目
5	hasMarker	false	没有特别程序解释
6	PayloadType	103	Payload的格式 h263-1988
7	SequenceNumber	325
8	Timestamp	468900
9	Sscr	488792334
10	CscrList
11	Payload
12
13

3. RTP解包

由于前期调研的疏忽，给自己挖了一个坑。绕了好多弯路。前期通过查看论文，了解到目前流行的方法都是通过RFC 3984进行开发。通过RTP发送H264格式的视频。H264格式的视频数据由分隔符00000001、NAL和VCL组成。进行RTP封包就是去掉分隔符进行发送，解包的时候再加上分隔符即可。还看了C++和Java实现的RTP解包方法，愣是和sipdroid的封包方法对不上。后来才意识到，我看的是H264的，而sipdroid用的是H263。

经过调研，决定使用libsteaming基于RTSP开发。Android支持H264的编码和解码，但是没有直接提供编码和解码接口。编码只能使用MediaRecorder编码到文件当中，而解码更是只能依靠MediaPlayer播放文件时才能被调用解码器。所以使用libstreaming编码，直接使用MediaPlayer进行RTSP播放即可。如果要自行封装RTP包的话，还需要跨平台编译H264的解码器。

##乱续、同步

参考文献

【1】RTMP/RTP/RTSP/RTCP的区别 - FrankieWang008的专栏
【2】RFC3984 RTP Payload Format for H.264 Video
【3】鲍轩. 基于Android手机音视频监控的软件研发与同步实现[D]. 杭州电子科技大学, 2013年10月.
【4】fly2700. FU-A分包方式，以及从RTP包里面得到H.264数据和AAC数据的方法. http://www.cnweblog.com/fly2700/archive/2012/02/23/319718.html
【5】jasonhwang. Wireshark Lua: 一个从RTP抓包里导出H.264 Payload，变成264裸码流文件（xxx.264）的Wireshark插件. http://blog.csdn.net/jasonhwang/article/details/7359095
【6】mcodec, H264解码器源码(Android 1.6 版)[EB/OL], http://www.cnblogs.com/mcodec/articles/1780598.html.
【7】熊荣海,刘立柱. H263码流的RTP封装的研究与实现.

基于流媒体的对讲机系统——系统开发准备

2014-04-17T00:00:00+00:00

工欲善其事，必先利其器。写代码也一样，借鉴优秀的工具辅助开发，可以帮助学习和了解相关知识和技术。

1. tcpdump

开发网络通信程序需要能监测到网络通信流程以及通信内容，以便了解整个通信流程以及问题。在Linux下，一般是通过tcpdump和WireShark来实现该功能。tcpdump负责监控制定设备，从该设备抓包，而WireShark可以用来查看和解析包内容。甚至可以帮助我们分析整个通信流程。在此项目中，就可以用WireShark监测SIP注册和呼叫流程和RTSP和RTP流的传输过程。

tcpdump -i wlan0 -w cInterphone.cap

在此命令中，-i用于指出要采集的设备，这里指出的是无线网卡wlan0；-w要指出采集到的数据输出的目录，这里指出是文件cInterphone.cap。此外，启动此命令还需要使用管理员权限。本项目中要监控的是手机的网络通信，所以还需要将手机的网络设成PC的网络代理，这样才能通过监控PC的网卡监控到手机的网络访问情况。

在使用WireShark的时候，采集到的数据量很大，所以需要进行过滤。查看我们需要的数据。

通过网络协议过滤。如果我们要查看RTP协议或者RTSP协议的数据，在过滤器中输入RTP即可。
通过IP过滤。本项目中是两个设备互相访问，采集到的数据也都是两个设备互相传输的全部数据。为了方便分析流程，可以只所以单独查看一个设备的。可以通过ip.src=192.168.1.103实现过滤。

2. linphone

SIP呼叫部分的开发，如果呼叫和被叫方同时进行开发和测试，难度较大。本课题采用了Linux下的linphone作为辅助开发工作，用于测试SIP呼叫流程。

3. VLC

本课题另一个比较重要的部分，就是流媒体的读取和播放。读取和播放展示是两个流程，需要分开进行开发。这就需要到一个辅助工具来进行测试开发。我们选取了VLC。VLC是一个非常优秀的跨平台流媒体播放器。既可以用来做RTSP服务器，也可以用来做RTSP客户端。

RTSP方式搭建服务器

vlc -vvv sample1.avi –sout “#transcode{vcodec=h264,vb=0,scale=0,acodec=mpga,ab=128,channels=2,samplerate=44100}:rtp{sdp=rtsp://:8554/test}”
RTSP方式搭建客户端

vlc rtsp://127.0.0.1:1234/

限于条件有限，只有一台平板，而且由于大Android硬件千变万化，光个摄像头分辨率就像天上的星星数也数不清，找了几台设备，都是因为摄像头分辨率以及支持的帧率不一样没有办法实现视频对讲。只是用Google自家的Nexus 5和我的Nexus 7能够兼容。使用Android设备测试测想法也就此作罢。

后来写了一个shell脚本，这样测试的时候方便一点。shell是一点不会，大概说一下。定义变量和Python一样，直接用等号就行，只不过不能有空格；启动lc是阻塞式的，所以需要并发启动，在第一个命令后面加上&就可以了；sleep能够暂停5秒钟；使用$引用到变量的值。

port=1234
client=192.168.1.102

{  
    echo "Start vlc server at rtsp://:$port/---------------------------------------------"
    vlc -vvv ~/Downloads/Justice.League.War.2014.720p.BluRay.x264.DTS-HDWinG.mkv --sout "#transcode{vcodec=h264,vb=0,scale=0,acodec=mpga,ab=128,channels=2,samplerate=44100}:rtp{sdp=rtsp://:1234/}"
}&

sleep 5

echo "Start vlc client at rtsp://$client:$port/--------------------------------"

vlc rtsp://192.168.1.102:1234/

4. adb

Android官方提供的开发工具，用于控制Android手机，adb服务器等。最好将adb加入到环境变量中，调试起来比较方便。

安装Android程序。在此之前都是先将安装包放入手机再安装。。。

adb install *.apk
启动和关闭adb服务

adb start-server adb kill-server
神器，用于排查问题。一般adb启动不了都是因为端口被占用。我在Windows下都是被QQ占用。。。

adb nodaemon server

5. ffmpeg

ffprobe 查看视频文件编码格式等详细信息。

6. 视频录制

Android 4.4 支持了自带录制屏幕视频的功能，使用adb工具就能够实现视频的录制。

adb shell screenrecord /sdcard/test.mp4

参考文献

用vlc搭建简单流媒体服务器（UDP和TCP方式）

基于流媒体的对讲机系统——Android的开发准备

2014-04-17T00:00:00+00:00

根据系统的大体设计并结合Android自身特性，将会主要用到下列几个Android自身控件。下面做简单介绍：

用户交互界面由Activity实现，对该部分的详细介绍。
系统主要模块都是在后台自动调用并执行的，这样能简化系统设计并提高系统运行速度。Android平台提供了Service组件，支持在后台自动启动和停止，系统的音视频通话模块、SIP模块都可以直接基于Service实现。。

Service运行于后台，没有任何用户界面。它们可以于Activity执行相同的操作。特别说明一下，Android中的Service是指在后台运行的程序，与Acitivity的区别是没有界面而已。它依然是在主线程中，并不是新创建的子线程，虽然看上去很像。一般的策略是在Service启动之后，为其单独创建一个子线程。

在Android 3.0之后，考虑到网络访问影响用户交互，Android禁止在主线程中进行网络访问。如果要实现此功能，就要像前面说的创建子线程在子线程中实现。
为了将系统设计成高内聚，低耦合，将各个模块进行了封装。用户交互界面和后台通信逻辑等模块进行了分离。这几个模块消息的传输，就要通过一个控制模块来订阅观察系统状态以及及时的对其作出响应。例如，对于SIP注册状态要及时响应，如果注册失败，要及时通知用户，增加系统的友好性和不必要的时间浪费。

Android平台提供了Broadcast Receiver。Broadcast Receiver是Android在系统级别对Observer模式(Pub-Sub)的实现。接收器一直等待，直到其订阅的事件发生时，才被激活。系统的核心引擎使用了该设计模式。
Android平台还提供了更加友好的Notification来增加和用户的交互。这个部分将在5.3.2节进行详细介绍。

基于流媒体的对讲机系统的设计与实现

2014-04-13T00:00:00+00:00

研究生毕业设计从4月13号开始写，历时了三个版本：复制网络凑字数版、全篇废话凑字数版、和目前的基本完成版。前前后后也码了不少字了。之前准备在这里写论文的，因为这里是Github Pager，而我写的也是论文。后来发现修改起来太麻烦，还是乖乖的去用Office写了。况且之前的版本主要都是凑字数的，就不用拿来在这里献丑了。

论文为什么有会三个版本？因为这个课题我很不喜欢去做。既不是我相关的东西，做了又没有实际用途，所以就一直不想去开发。先开始就是想毕业就好。后来觉得这样复制来的肯定审查过不了，遂编了一堆系统特性和需求实现。后来又发现，我编的这堆有的没的到了答辩的时候还是会露馅，因为编的实在太烂。最后，觉得好好编一编，第三个版本诞生了。

对于这个课题，一开始很抵触，觉得没用。后来被迫开始编之后，才真正发现认真做一个东西原来能学到很多。以前觉得特别牛逼，下不了手的，比如网络通信协议的代码实现。之前充其量就是看看包头，看看协议格式，现在能基本会编码，了解协议格式的指定。这也是我心目中一道难以翻越的高山阿！感觉我这种菜鸟主要就是因为态度差，能学的看不起，牛逼的又看不懂。。。编的过程中还熟悉了Android开发，现在觉得对Android已经有一个大体认识了。

课题本来就是VOIP，但是VIOP算是比较成熟的了，再加上我能力有限，实在没办法在Android端开发出啥新颖的东西，比如H264的RTP传输。后来就寻思着加点啥进去。要在短时间内加点料，就得挑自己最擅长的了。那就是REST接口开发，我用过Java和Go语言开发接口，比较熟悉，一晚上搞定接口。然后就是Android端加点控件，与服务器通信。前几天又灵机一动，因为在公司解除过iOS的消息PUSH开发，知道Android端比iOS简单一万倍，遂又想把这个加进来充数。本来想自己用HTTP长连接自己实现的，后来还是发现能力有限，用了百度云推送。瞬间高上大有木有。我严格按照导师的意思，“如果没有技术含量，就不要让评审觉得也没有工作量”的宗旨，完成了所有的工作。

而对于RTP协议，鄙人确实是花了大量时间去实现H264的传输，也看了不少论文。在最后解码方面却一直没有能够成功，也算是一憾。回想本科时候毕设的人脸识别，瞬间觉得自己自学能力太过于有限。。。

论文已经交去盲审了，但是我还是觉得有必要好好整理一下。留给有缘人。

2014年6月3日家

盲审结果出来了，有惊无险的过了。不过室友挂了。。。为啥每次觉得水水的东西到后来又觉得不是那么水。。。

2014年6月13日家

1 开发准备与评估

####1.1 前期开发方案
####1.2 系统开发准备

2 协议分析与实现

####2.1 系统采用的多媒体编码标准分析
- 2.1.1 视频编解码技术
####2.2 系统采用的网络通信协议分析
- 2.2.1 会话发起协议SIP
- 2.2.2 会话描述协议SDP
- 2.2.3 实时传输协议RTP
- 2.2.4 实时流媒体协议RTSP

3 Android控件的实现

####3.1 Android的开发准备
####3.2 百度云推送

4 系统调试与测试

SIP协议的分析以及opensips注册和通话的研究

2014-03-05T00:00:00+00:00

本系统要基于网络进行对讲通话，SIP协议(会话发起协议)用于建立、保持、销毁会话，其功能和日常打电话的流程是一致的。SIP是完成是完成本系统要用到的核心协议。

SIP协议位于网络七层协议中的会话层，位于TCP/IP协议中的应用层。虽然没有做过验证，但是我觉得iOS上的Facetime也是基于此协议。一个手机可以绑定多个SIP地址，注册之前也是要指明要绑定的地址。只不过iOS的注册是自动完成的。

OPTIONS请求可以作为建立会话的一部分，用来查询对方的SIP能力。常见的返回值，也就是SIP执行能力：

INVITE。用于发起SIP会话请求。
ACK。用于确认SIP请求。
CANCEL。用于取消SIP请求。
OPTIONS。用于查看对方SIP执行能力。
BYE。用于结束SIP请求。

##SIP注册

SIP协议注册到服务器的一般过程：向SIP服务器发起请求，此处为asteriskguide.com。并发送自己的用户名，此处为8500。此外，还要附带本机IP地址，作为将来通信使用。Contact代表的就是当前用户的通信地址，其他用户可以通过此地址联系到当前用户，实现发送呼叫请求。

我从WireShark[1]截到的图，也可以看到此通信过程，10.14.5.218向121.199.55.106发起注册请求REGISTER。接着，收到了状态码，200 OK。SIP协议的设计借鉴了HTTP，返回状态码和HTTP的相同。此处为200。

其中，中间的PUBLISH是向服务器发送消息，告诉它我们在线[3]。

REGISTER请求[4]:

TO 是为哪一个用户注册的。是一个完整的SIP用户的SIP URI。发出注册请求的并不一定是SIP用户本身。所以要有FROM头域
FROM 谁发起的注册，就是谁的SIP URI
Call-ID 同一个SIP客户端的Call-ID是相同的。因为同一个sip客户端会间隔一定的时间就注册一次。在注册服务器里面用户的注册信息保留一定的时间，保存的时间并不是SIP规定的。
CSeq CSeq 值保证REGISTER 请求适当的排序。对于每个使用相同的Call-ID 的REGISTER 请求，UA 必须逐一增加Cseq 值。
Expires 注册绑定时间为3600s

此处返回的状态码为200，表示注册成功。此外，相比REGISTER还增加了Contact，返回当前用户所有注册过的SIP URI，我用多台设备注册过，所以返回了多个结果。

##SIP发起会话

使用WireShark绘制的连接、通信、以及断开连接的流程图更直观一些。由sip:mint@121.199.55.106:5060向sip:ad@10.14.5.202发送通话请求。当ad收到请求后，会立刻返回100 TRYING响应，等一段时间之后，再返回180 RINGING，接通之后，响应200 OK[5]。

该图中，由mint@121.199.55.106:5060向ad@10.14.5.202:10060发起连接请求，内容格式是SDP描述格式，该格式内容会包含音视频传输参数和传输端口。详细内容参考下一节。

系统所用的SIP服务器是opensips。该部分的配置和使用超出了本文范围，不作详细介绍。

参考文献

RFC3261 SIP: Session Initiation Protocol
使用Wireshark进行SIP包解析
《Building Telephony Systems with OpenSIPS 1.6》
sip PUBLISH 与 SUBSCRIBE 方法的区别
SIP注册过程
sip “100 trying” instead of “180 ringing”
SIP中SDP及其RTP的工作过程

iPhone的CSS显示

2014-02-07T00:00:00+00:00

1. 通过给图片加CSS实现

做这个是为了做cInterphone贴图片用的。代码很简单，只要给想加iPhone显示的CSS就行。调用代码如下：

<div class="iphone">
    <img src="https://res.cloudinary.com/cyeam/image/upload/v1537933530/cyeam/nexus7_screenshot.png" />
</div>

一位大神提供的前端代码，我也懒得去读了，直接拿来用。以后有兴趣再去研究。CSS代码直接贴这里了：

/* iPhone */
/* First, we'll make the body. After that we'll use :after and :before elements to make other things like buttons */

.iphone {
	position: relative;
	height: 495px;
	width: 250px;
	border-radius: 35px;
	margin: 50px auto;
	
	/* We are going to use multiple background images (linear-gradients) here to create the main background, the shine and the screen */
	/* This is our first gradient, to draw more, we'll have to write them before this one separated by a comma */
	/* Now, we'll draw the screen */
	/* The screen should be below the shine, right? */
	background: 
		linear-gradient(-165deg, rgba(255,255,255,0.4), rgba(255,255,255,0.15) 35%, transparent 35%),
		linear-gradient(top, transparent 85px, #222222 85px, #151515 410px, transparent 410px),
		linear-gradient(top, #000, #0a0a0a);
	
	/* Something isn't right... */
	/* Now, it's perfect. Try playing with the values below to get a better understanding */
	background-repeat: no-repeat;
	background-size: 100% 100%, 220px 100%, 100% 100%;
	background-position: 0 0, 15px 0, 0 0;
	
	
	
	/* Now we need the aluminium borders and the top button */
	/* We'll use box shadows for that */
	box-shadow: 0 0 0 3px black,
							/* A small divider */
							-40px -128px 0 -123px black,
							0 0 0 5px #a09f9d,
							/* Some metallic shine on the button */
							49px -130px 3px -123px #777,
							46px -130px 2px -123px #ddd,
							/* Top button from here */
							62px -111px 0 -105px #8e8d8b,
							62px -112px 0 -105px #b4b3b1,
							62px -113px 0 -105px #666;
}


/* Our phone's body is complete! Now we'll move onto the home button, front cam and the speaker.. */
/* We are going to use :after pseudo element for that and a lot of box-shadow awesomeness */
.iphone:after {
	content: '▢';
	line-height: 46px;
	text-align: center;
	font-size: 28px;
	color: #666;
	position: absolute;
	width: 46px;
	height: 46px;
	border-radius: 50%;
	background: white;
	bottom: 18px;
	left: 100px;
	border: 2px solid #0a0a0a;
	
	
	
	/* We'll use gradients for the depth */
	background-image:
		linear-gradient(left, rgba(0, 0, 0, 0.85), black); /* Looking good */

	/* Now some box-shadow magic to create speaker and front cam */
	box-shadow:
		/* Front Cam: looking good */
		-39px -410px 0 -23px #000f31,
		-39px -410px 0 -22px #0a1c5a,
		-40px -410px 0 -21px #0d1216,
		-40px -410px 0 -19px #1b191a,
		
		
	
		/* Speaker, it's a mess. Really. */ 
		/* now the outer covering of speaker, another mess */
		-12px -410px 0 -22px #333,
		-8px -410px 0 -22px #333,
		-4px -410px 0 -22px #333,
		-0px -410px 0 -22px #333,
		4px -410px 0 -22px #333,
		8px -410px 0 -22px #333,
		12px -410px 0 -22px #333,
		16px -410px 0 -22px #333,
		20px -410px 0 -22px #333,
		24px -410px 0 -22px #333,
		
		-12px -410px 0 -18px #0a0a0a,
		-9px -410px 0 -18px #0a0a0a,
		-6px -410px 0 -18px #0a0a0a,
		-3px -410px 0 -18px #0a0a0a,
		0px -410px 0 -18px #0a0a0a,
		3px -410px 0 -18px #0a0a0a,
		6px -410px 0 -18px #0a0a0a,
		9px -410px 0 -18px #0a0a0a,
		12px -410px 0 -18px #0a0a0a,
		15px -410px 0 -18px #0a0a0a,
		18px -410px 0 -18px #0a0a0a,
		21px -410px 0 -18px #0a0a0a,
		24px -410px 0 -18px #0a0a0a;

}

/* Looks good till now. But we are still missing the side buttons and those are pretty easy to make. We'll only use gradient for that ;) */
.iphone:before {
	position: absolute;
	content: '';
	width: 2px;
	height: 117px;
	background: transparent;
	top: 40px;
	left: -7px;
	
	/* The shape is building up */
	background-image:
		/* This is going to be a long top to bottom linear gradient so see the output and code */
		/* A final touch ;) */
		linear-gradient(left, transparent 0px, transparent 1px, #7a7879 2px),
		linear-gradient(top, #383838 1px, #b9b9b9 3px, #b9b9b9 10px, #383838 19px, #b9b9b9 23px, transparent 23px, transparent 53px, #383838 53px, #b9b9b9 54px, #dadada 58px, #383838 62px, black 62px, black 66px, #383838 66px, #b9b9b9 67px, #dadada 68px, #383838 70px, transparent 70px, transparent 100px, #383838 100px, #b9b9b9 101px, #dadada 105px, #383838 109px, black 109px, black 113px, #383838 113px, #b9b9b9 114px, #dadada 115px, #383838 117px);
	
}

.iphone img {
	position: absolute;
	left: 6px;
	top: 65px;
}

http://cssdeck.com/labs/iphone_with_css3

2. 通过嵌套DIV实现

今天无意间在百度Site App里看到的可以模拟Android的，iPhone和Android凑齐了，哈哈。

.phone-bg {
    margin-top: 10px;
    padding-top: 60px;
    background: url(http://siteapp.baidu.com/static/webappservice/pic/new-bg-mobile_dafd5fd.png) no-repeat 0 -10px;
    height: 614px;
    width: 332px;
    margin-right: -10px;
    position: relative;
}
.phone-bg .phone_display {
    margin-left: 34px;
    width: 272px;
    height: 465px;
    background-color: #fff;
}

<div class="phone-bg ">
    <div class="phone_display"></div>
</div>

这个显示需要加入额外的CSS。

效果效果

Android Quick Start

2014-02-05T00:00:00+00:00

MediaCodec MediaPlayer MediaRecorder Handler Notification Thread Thread.interrupted() MulticastSocket FileWriter http://endual.iteye.com/blog/1128541

###Activity

Activity 定义

一个Acitvity，通常是指在某一时刻，在设备上看到的单独界面。对用于而言，这就是程序的外观部分。

Activity Manager

启动一个活动可能会消耗大量资源。它可能会涉及新建一个Linux进程、为UI对象申请内存空间、从XML布局填充所有对象，以及创建整个界面。既然我们在启动一个活动上花费了这么多工夫，一旦用户离开该界面，如果只是将它销毁那就实在太浪费了。为了避免这种浪费，Android通过活动管理器(Activity Manager)来管理活动的生命周期。

Activity 生命周期 Android编程主要是围绕程序的状态改变做出响应。

启动状态

当一个活动太不存在于内存中时，我们称其处于启动状态。

从启动状态到运行状态的转换是最耗时的操作，对电池续航也有直接影响。所以不要轻易销毁Activity。

运行状态

获得焦点(in focus)的Activity，是处于运行状态的，与用户进行交互。正在运行的Activity可以优先获得系统资源。

暂停状态

当Activity没有获得焦点，但是仍然显示的情况下(e.g. 上面出现了对话框)，就是暂停(pause)状态。最好在暂停状态执行保存数据的重要工作。

停止状态

当Activity不显示却依然驻留在内存中时(e.g. 切换到其他应用程序)，处于停止(stopped)状态。停止状态的Activity可能随时被从内存中移除。

销毁状态

销毁状态的活动不再留住于内存中。

创建用户界面

创建用户界面分为声明式和编程式两种，分别用到了XML和JAVA实现。这类似于HTML和Javascript的关系。

Layout

Layout负责为子元素安排位置。布局如果嵌套太深，会浪费较多的CPU时间，电池的续航也会受到影响。

LinearLayout

纵向或者横向排列(layout_orientation vertical/horizontal)子元素。

TableLayout

类似于html中的<table>标签。stretch columns指定那一列展开并占据所有空间。

FrameLayout

将其下的子元素重叠起来，只留最后一个在外面。

RelativeLayout

需要为每一个子元素提供一个ID。

AbsoluteLayout

灵活性不够，无法自动适应。

Intent

Intent是指在主要构建之间传递的消息。它们能够触发并启动一个Activity，告诉一个服务启动还是停止，或者只是简单的广播。Intent是异步的。

Intent分为显式的和隐式的两种。explicit需要指明接收Intent的组件。implicit只需指定接收者的类型。所有能完成该操作的程序”竞相“完成这个操作。

###Service

Service运行于后台，没有任何用户界面。它们可以于Activity执行相同的操作。

Service 生命周期 Android编程主要是围绕程序的状态改变做出响应。

onStartCommand有三种返回值：

START_STICKY：sticky的意思是“粘性的”。使用这个返回值时，我们启动的服务跟应用程序”粘”在一起，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务。当再次启动服务时，传入的第一个参数将为null;
START_NOT_STICKY：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。

特别说明一下，Android中的Service是指在后台运行的程序，与Acitivity的区别是没有界面而已。它依然是在主线程中，并不是新创建的子线程，虽然看上去很像。一般的策略是在Service启动之后，为其单独创建一个子线程。

在Android 3.0之后，考虑到网络访问影响用户交互，Android禁止在主线程中进行网络访问。如果要实现此功能，就要像前面说的创建子线程在子线程中实现。

###Thread

###Broadcast Receiver Broadcast Receiver是Android在系统级别对Observer模式(Pub-Sub)的实现。接收器一直等待，直到其订阅的事件发生时，才被激活。

###Content Provider

Content Provider是应用程序之间共享数据的接口，提供了一套很好的符合CRUD(insert(), update(), delete(), query())原则的接口。数据存储与用户界面程序的分离，为系统各部分之间的组合提供了更大的灵活性。

###Application Context Android四大组建Activity, Service, Content Provider, Broadcast Receiver构成了整个应用程序，共同处于同一个Application Context中。允许在不同的组建中共享数据和资源。

###Design Principle(多年来开发深有体会！！！)

渐进式开发
保持完整，保持可用
重构代码

参考文献

《Learning Android》马尔科·加尔根塔电子工业出版社 ISBN: 9787121172632

安卓对讲机开发评估

2014-02-04T00:00:00+00:00

毕业设计准备在Android平台上开发一个音视频通话软件，基于流媒体实现。项目的目的就是做一个山寨版的Faceime。目前了解到的实现技术是FFmpeg实现流媒体编码，RTP实现传输控制，SIP实现通话建立。我自己还想把SIP服务器部署到GAE上面，使其成为一个可用的项目。

#####音视频采集，压缩，发送，解码，显示的流程

1. 流媒体编码

视频采集可以直接使用硬件编码，而解码需要使用到软件解码。使用开源的C库FFmpeg进行解码。这是比较熟悉的一个部分，之前做过，而且用JNI调用成功了hello, world。。。现在考虑去Github找，使用开源的编译好的库。

Android的MediaPlayer和MediaRecoder是支持H264和AAC编码的，目前先采用这两个来进行硬件编解码，如果需要使用ffmpeg来软件解码时，再换。

2. 流媒体传输

将采集到的音视频分别进行传输。_ref_AndroidRTC里面只有c的源文件，没有编译好的动态链接库。可能还需要自己编译。

流媒体传输用的RTSP协议，有一个开源的实现libstreaming，还有一个封装了该库的ipcamera实现spydroid-ipcamera。大概看了一下代码，RTSP封装难度应该也不大，到时候可以自行尝试封装。

**可以使用VLC Linux

iOS

Android进行测试开发，验证传输。**

3. SIP(Session Initiation Protocol)

这块因为我想部署到GAE上面，所以不能使用C++，考虑使用Java的开源库。此外，还要调研GAE上面执行C++动态链接库的可行性。

原本打算在GAE开发SIP服务器的，天真了。。。后来找到了opensips，这是用C语言开发的，可以完全支持SIP协议。而且还有支持在线管理opensips的应用SerMyAdmin。

而在Android端，提供了SipManager，这样可以实现客户端呼叫。

使用Linphone Linux|Windows|iOS|Android进行测试开发，验证opensips服务器配置和SIP通信建立。 使用tcpdump WireShark监控网络，查看协议调用过程。

jitsi感觉太过成熟，先放弃使用。如果能移植到GAE，以后可以试试。

开发流程

Android Quick Start
SIP Sip注册和建立通信
RTSP 双通道通信传输
Android 视频编码
Android 音频编码
Android 视频解码
Android RTP 传输

开发环境

Nexus 7
- Android version 4.4.2
- Kernel version 3.4.0-gac9222c
Java

java version “1.7.0_45”
Java(TM) SE Runtime Environment (build 1.7.0_45-b18)
Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode)

adt-bundle-linux-x86_64-20131030.zip API

android-ndk-r9c-linux-x86_64.tar.bz2

Google App Engine(Java) 发现一神器，使用*.appsp0t.com可以访问自己的域名。这个通过反向代理实现。这样就能实现跨墙访问。Fuck GFW!目前计划在 https://brycelinux.appsp0t.co m测试和发布。
- Google App Engine SDK
  
  Version 1.8.9
  Download
eclipse

Eclipse Java EE IDE for Web Developers.
Version: Kepler Service Release 1
Build id: 20130919-0819

opensips

opensips-1.10.0-tls

SerMyAdmin

sermyadmin-install-2.0.1a

参考文献

《基于Android的移动VoIP高清视频通话系统的设计与实现》曹建龙
Android 中如何使用SIP服务
jitsi打包
App Engine Java 概述
《Building Telephony Systems with OpenSIPS 1.6》

Linux Mint下安装Nexus 7 驱动

2014-02-01T00:00:00+00:00

整个越狱的大体过程，是按照这篇文章Steps to Root Nexus 7 2013 in Linux来做的。先开始讲的挺详细的，最后在Linux下Android设备驱动和fastboot mode下启动少写了一些，对于我这种小白来讲果断是不能自己处理的，所以搞了好几天才搞定。

里面用到的TWRP无法下载，使用百度网盘提供的下载

在一切都搞定，执行最后一步的时候，出现了<wait for devices>的错误，是因为Linux下设备的驱动问题，没有配置好。在Windows在需要安装设备对应的驱动就能搞定，Mac下都不需要操作，而Linux下需要配置udev才能正常运行。

简单的说一下，Linux是通过udev来管理设备的，udev的入门资料可以参考——《使用 udev 高效、动态地管理 Linux 设备文件》。一些基本的udev配置文件规则可以在这里找到。
接着是去写配置文件。基本上所有Google到的文章里面都说了要在/etc/udev/rules.d里面创建51-android.rules，里面的写法也是基本一致的，但是没有说明为什么这么写，所以可能具体到个人，那样复制过来就不行了。
文件51-android.rules命名的缘由——《为什么是“51-android.rules”？》
51-android.rules的配置。《Adding udev rules for USB debugging Android devices》
- 使用命令lsusb找到Android设备的Bus和Device
```
  Bus 003 Device 006: ID 18d1:d001 Google Inc. Nexus 7 (debug)
```
- 看到上面的Google的Bus是003，Device是006，Linux是通过文件来管理设备的，所以该Android设备对应的文件就是/dev/bus/usb/003/006，查看其文件权限。ls -l /dev/bus/usb/003/006查看其文件权限。
```
  crw-rw----+ 1 root audio 189, 261  2月  2 14:56 /dev/bus/usb/003/006
```
- 编辑/etc/udev/rules.d/51-android.rules。该文件内需要添加用户组和用户名，之前不确定是什么，试了好几次，也不知道对了没有，可以通过上一步直接查看到其权限。我的配置如下：
```
  SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="d001", MODE="0666", OWNER="root", GROUP="plugdev", SYMLINK+="android%n"
```
- 按照之前查看到的设备vendor和productid，还有访问权限，在配置完之后，重新插上设备，会在/dev目录下生成android的文件，其后面会带一个数字。前面几步贴的结果都是配置好之后重新执行命令得到的结果，可能不准确。
如果在/dev下面生成了以android开头的文件，表明已经配置好了，可以通过adb devices看到设备序列号了。接着是在fastboot mode下启动系统。那篇文章中并没有强调说在fastboot mode下执行，而我也不懂。。。所以，这个也搞了很久还发现的。。。还是靠这个提问《Android Fastboot devices not returning device》，才想到可能是在fastboot mode下执行，因为按照之前的步骤，都是在recovery mode下，所以切换了mode，果断可以了。此时，成功的标志是fastboot devices会返回设备序号。

参考文献

ubuntu下galaxy nexus的fastboot连接不上的问题
Setting up a Device for Development
51-android.rules
http://www.janosgyerik.com/adding-udev-rules-for-usb-debugging-android-devices/
https://code.google.com/p/51-android/

对联

2014-01-28T00:00:00+00:00

#####大門宗親平實居寶地
美育華果近高鄰
橫批：耕讀傳家

#####屋子向陽花木三春秀
得意馬蹄一路風
橫批：一馬當先

好雨知時群卉盛
春風得意四蹄輕
橫批：馬到成功

福照家門萬事興
喜居寶地千年旺
橫批：萬事如意

#####廚房五味烹調香千裏
三鮮蒸炸樂萬家
橫批：天地同歡

#####奶奶壽星伴子子長壽
童嬰映老老還童
橫批：壽比南山

#####店铺錦善秀美窗十裏百鄉
厚德載物簾千家萬戶
橫批：景上添錦

Linux命令整理

2014-01-22T00:00:00+00:00

1. curl

查看网页源码
```
  curl blog.cyeam.com
```

显示网页头

  curl -i blog.cyeam.com

头信息（后面的Body省略）：

  HTTP/1.1 200 OK
  Server: GitHub.com
  Content-Type: text/html; charset=utf-8
  Last-Modified: Wed, 17 Sep 2014 14:02:08 GMT
  Expires: Thu, 25 Sep 2014 03:42:26 GMT
  Cache-Control: max-age=600
  Content-Length: 13070
  Accept-Ranges: bytes
  Date: Thu, 25 Sep 2014 03:33:37 GMT
  Via: 1.1 varnish
  Age: 72
  Connection: keep-alive
  X-Served-By: cache-lo83-LHR
  X-Cache: HIT
  X-Cache-Hits: 1
  X-Timer: S1411616017.770794,VS0,VE0
  Vary: Accept-Encoding

显示通信过程

  curl -v http://blog.cyeam.com/pages.html
  * About to connect() to blog.cyeam.com port 80 (#0)
  *   Trying 199.27.79.133... connected
  * Connected to blog.cyeam.com (199.27.79.133) port 80 (#0)
  > GET /pages.html HTTP/1.1
  > User-Agent: curl/7.19.7 (x86_64-redhat-linux-gnu) libcurl/7.19.7 NSS/3.13.1.0 zlib/1.2.3 libidn/1.18 libssh2/1.2.2
  > Host: blog.cyeam.com
  > Accept: */*

  curl --trace output.txt blog.cyeam.com

设置UserAgent

  curl -i -A "Cyeam" http://blog.cyeam.com/linux/2014/01/22/linux/

安静模式-s。只显示结果。

2. grep

查找文件里符合条件的字符串

grep -n "/cyeam" -r .

-n，显示行号。
-r，递归查找。
-c，显示数目。

3. git

Force Synchronize

git reset –hard HEAD git clean -f git pull
Commit

git add -A git status git commit -a”” git push origin master

4. mysql

create user 'bryce'@'localhost' identified by '';
	mysqldump -u root -p ROOT > C:/Users/Bryce/Documents/GitHub/Cyeam/data/cyeam.sql
mysql -u bryce -p ROOT < C:/Users/Bryce/Documents/GitHub/Cyeam/data/cyeam.sql

5. unzip

	unzip upload.zip -d [DIRECTRY]

6. lsof

list of open files

-i select IPv[46] files查看占用端口

lsof -i:8080

7. kill

kill -9 [pid]

8. history

Linux系统当你在shell(控制台)中输入并执行命令时，shell会自动把你的命令记录到历史列表中，一般保存在用户目录下的.bash_history文件中。默认保存1000条，你也可以更改这个值。

9. aptitude

sudo aptitude install
sudo aptitude remove #用于完整删除软件

10. file

通过file指令，我们得以辨识该文件的类型

11. lsusb

查看系统中的USB设备

12. cat

一次显示整个文件
从键盘创建一个文件。

$ cat > filename
Cat命令将几个文件合并为一个文件。

$cat file1 file2 > file

13. top

top命令是Linux下常用的性能分析工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器。

参考文献

beego 介绍

2014-01-21T00:00:00+00:00

beego

https://beego.me/
go get github.com/astaxie/beego

bee工具

1. 安装

go get github.com/beego/bee

2. 新建工程

在$GOPATH目录下，用命令行输入bee new [PROJECT_NAME]，就会在$GOPATH/src目录下新建一个工程。

3. 运行工程

进入创建好的工程根目录下，使用bee run [PROJECT_NAME]，项目便会启动，此命令支持热编译。

beego

1. Router

package routers

import (
	"beego.test/controllers"
	"github.com/astaxie/beego"
)

func init() {
	beego.Router("/", &controllers.MainController{}, "*:Get")
	beego.Router("/user/:username:string", &controllers.UserController{}, "get:GetUser")
	beego.Router("/user", &controllers.UserController{}, "post:AddUser")
}

注册路由的函数

Router(rootpath string, c ControllerInterface, mappingMethods ...string) *App

init函数会在import之后被自动执行
在这里是注册路由的步骤，采用REST的方式，将请求转发到Controller
rootpath绑定的URL路径，以”/”为开头
c是个interface，指出要绑定的Controller
mappingMethods绑定控制器中的指定方法。格式为"HTTP_METHOD:FUNC_NAME"。可以为空，为空时会默认绑定指定Controller中的Get、Post等方法（Get请求调用Get函数，一次类推）
所有注册需要在beego.Run()之前进行

2. beego.Run()

package main

import (
	_ "beego.test/routers"
	"github.com/astaxie/beego"
)

func main() {
	beego.Run()
}

beego.Run()会启动服务器，在此之前需要做路由监听。可以将所有需要注册路由的代码放到一起，一般放在[PROJECT]/routers/router.go里面，通过_ "beego.test/routers"初始化

解析配置文件

beego 会自动在 conf 目录下面去解析相应的配置文件 app.conf，这样就可以通过配置文件配置一些例如开启的端口，是否开启 session，应用名称等各种信息。
开启 session

会根据上面配置文件的分析之后判断是否开启 session，如果开启的话就初始化全局的 session。
编译模板

beego 会在启动的时候把 views 目录下的所有模板进行预编译，然后存在 map 里面，这样可以有效的提供模板运行的效率，无需进行多次编译。
启动管理模块

beego 目前做了一个很帅的模块，应用内监控模块，会在 8088 端口做一个内部监听，我们可以通过这个端口查询到 QPS、CPU、内存、GC、goroutine、thread 等各种信息。
监听服务端口

3. Controller

Golang中的继承

使用Controller的时候需要用到继承，使得每个新建的Controller都能有处理Request的能力，而不必重写一遍该功能。下面先介绍继承的实现。
```
  type TestController struct {
      beego.Controller
  }
```
自定义的控制器都包含beego.Controller这个控制器，模拟继承。这是匿名字段。这里添加了beego.Controller这个struct，但是没有为其命名，在这种情况下，这个struct(beego.Controller)所拥有的全部字段都被隐式地引入了当前定义的这个struct(TestController)。这样就继承到了父类所有的属性了。
冲突和遮蔽

如果有两个字段具有相同的名字(可能是一个继承类型的名字)，代码将遵循下面规则：
- 外层的名字遮蔽内层的名字。这提供了一个重写字段/方法的方式。
- 如果在同一层次上出现了相同的名字，如果名字被使用，那么将是一个错误。(如果没有使用，不会出现错误)
匿名字段冲突提供了一种重写的方法，如果没有冲突，使用父类的字段；如果冲突，使用子类的字段。
```
  func (c *Controller) Get() {
      http.Error(c.Ctx.ResponseWriter, "Method Not Allowed", 405)
  }
```
在beego/controllers.go中已经实现了所有方法，例如Get、POST、PUT、DELETE，如果没有为新创建的Controller的GET方法添加Get()处理函数，beego会默认处理，返回405。

4. Model

系统中存在数据库访问处理操作，如果整个系统逻辑简单，可以直接在Controller中处理。如果系统比较复杂，有大量并且重复的数据库操作代码，可以抽象到Model层。

Golang命名规范：采用驼峰命名。如果首字母大写，为public，如果为小写，只能被当前package访问到

beego会自动解析URL里面的Query，可以通过Controller的函数GetInt, GetString获得

  GetString(key string) string
  GetStrings(key string) []string
  GetInt(key string) (int64, error)
  GetBool(key string) (bool, error)
  GetFloat(key string) (float64, error)

5. View

返回HTML。
View层需要用到的模板存放在[PROJECT]/views目录下，支持.html和.tpl两种后缀名的文件。在 Controller 里面把数据赋值给了Data（map 类型），在这里通过进行取值组装。
```
  func (this *MainController) Get() {
      this.Data["Website"] = "blog.cyeam.com/kaleidoscope/2014/01/12/beego"
      this.Data["Email"] = "lichao0407@gmail.com"
      this.TplNames = "index.tpl"
  }
```

返回JSON

  func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["json"] = &mystruct
      this.ServeJson()
  } ### Golang语法及常见包 ##### 1. net/http

发送Get请求

  resp, err := http.Get([URL])   + URL需要以`http://`开头

获取resp中的Body(byte[])

  import "io/ioutil"
  reply, err := ioutil.ReadAll(resp.Body)

2. fmt

类型转换
- string转int
```
  fmt.Sprintf("%d", (page-1)*size)
```

3. encoding/json

解析json到struct

  err = json.Unmarshal(reply, &solrBody) 

  type SolrBody struct {
      ResponseHeader SolrResponseHeader `json:"responseHeader"`
      SolrResponse   SolrResponse       `json:"response"`	
  }

4. Array & Slice

声明
```
  ids := []int{}
```
增加值 append
```
  ids = append(ids, value)
```

5. len

The len built-in function returns the length of v, according to its type:

Array: the number of elements in v.
Pointer to array: the number of elements in *v (even if v is nil).
Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
String: the number of bytes in v.
Channel: the number of elements queued (unread) in the channel buffer;
if v is nil, len(v) is zero.

6. make & new

都可以用来申请内存，make返回对象，new返回指向对象的指针

一些网站架构中常见的术语和技术

2014-01-14T00:00:00+00:00

1. KPI

KPI的理论基础是二八原理，是由意大利经济学家帕累托提出的一个经济学原理，即一个企业在价值创造过程中，每个部门和每一位员工的80%的工作任务是由20%的关键行为完成的，抓住20%的关键，就抓住了主体。

二八原理为绩效考核指明了方向，即考核工作的主要精力要放在关键的结果和关键的过程上。于是，所谓的绩效考核，一定放在关键绩效指标上，考核工作一定要围绕关键绩效指标展开。

2. PV/UV

单页点阅率（Page View），网页自服务器呼叫后，被读者浏览的次数。单页点阅率是网站分析的一个术语，用以衡量网站用户访问的网页的数量。对于网站所有者，可以看到网页的变化（如信息和信息的编排方式）是否带来了更大的流量。对于广告主（如果网页上有广告），单页点阅率的关注点在于预期它可以带来多少广告收入。出于这个原因，它成为一种广泛用于基于互联网的市场营销和广告术语。

UV(独立访客)：Unique Visitor,访问您网站的一台电脑客户端为一个访客。00:00-24:00内相同的客户端只会被计算一次。

IP(独立IP)：指独立IP数。00:00-24:00内相同IP地址之被计算一次。

3. channel公司

中国频道成立于1996年，是国际知名的为全球企业用户、组织机构、商务人士及个人用户提供互联网应用服务的提供商（ISP）。10几年来，公司在激烈的市场竞争中始终走在行业前列，实现了跨越式发展，为社会各界提供专业的企业邮局、虚拟主机、独立主机、域名注册、网站建设、网站推广和个人邮箱、网络游戏等服务。

4. Passenger(ruby)

Phusion Passenger is a web server and application server, designed to be fast, robust and lightweight. It takes a lot of complexity out of deploying web apps, adds powerful enterprise-grade features that are useful in production, and makes administration much easier and less complex.

5. Varnish 应对雪崩反向代理 1000个请求，1个访问后台，999个等待，访问数据库结束后，1000个返回

Varnish 是一款高性能且开源的反向代理服务器和 HTTP 加速器，其采用全新的软件体系机构，和现在的硬件体系紧密配合，与传统的 squid 相比，varnish 具有性能更高、速度更快、管理更加方便等诸多优点，很多大型的网站都开始尝试使用 varnish 来替换 squid，这些都促进 varnish 迅速发展起来。

6. MangoDB存储图片半线下服务

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

当附件数量海里去了~~ 那这样存就蛋疼了，备份是个问题，硬盘IO瓶颈那会也会凸显出来。问题接踵而来。那会，就需要分布式文件存储了。利用GridFS存储文件，再利用MangoDB的分片(sharding) 就可以做到海量存储了。

7. 表冷热不一 InnoDB行锁死

8. CDN内容分发系统

CDN节点会在多个地点，多个不同的网络上摆放。这些节点之间会动态的互相传输内容，对用户的下载行为优化，并借此减少内容供应者所需要的带宽成本，改善用户的下载速度，提高系统的稳定性。

9. Crontab冗余计算定时计算

crontab命令常见于Unix和类Unix的操作系统之中，用于设置周期性被执行的指令。该命令从标准输入设备读取指令，并将其存放于“crontab”文件中，以供之后读取和执行。

10. Solr查询

Solr是开放源码的企业搜索服务器（Enterprise Search Server）软件，由Apache软件基金会所研发。Solr 使用Lucene程式库以及需要Servlet容器作执行环境。Solr本身提供XML/HTTP与JSON的应用程式接口。

11. MySql集群

https://www.cnblogs.com/zhishan/p/3385631.html

12. 首页不应该访问DB，要么静态文件，要么缓存

13. Dos攻击

DoS是Denial of Service的简称，即拒绝服务，造成DoS的攻击行为被称为DoS攻击，其目的是使计算机或网络无法提供正常的服务。

14. Redis

Redis是最流行的键值对存储数据库。

15. HTTP 502/503

502 Bad Gateway The server was acting as a gateway or proxy and received an invalid response from the upstream server.
503 Service Unavailable The server is currently unavailable (because it is overloaded or down for maintenance). Generally, this is a temporary state. Sometimes, this can be permanent as well on test servers.

16. 部署流程

17. 分层单元测试回归测试自动化

18. 反向代理和前向代理

在计算机网络中，反向代理是代理服务器的一种。它根据客户端的请求，从后端的服务器上获取资源，然后再将这些资源返回给客户端。[1]与前向代理不同，前向代理作为一个媒介将互联网上获取的资源返回给相关联的客户端，而反向代理是在服务器端作为代理使用，而不是客户端。

2013读书总结

2014-01-13T00:00:00+00:00

最近在整理之前写过的东西，都准备放到GitHub上面。找到了之前在豆瓣上面放着的日记，有一篇是《2012年读书总结》。最近也正好有总结2013年的打算，便准备开始写2013年读书总结。写的时候发现上一篇正好是一年前的今天，13号写的。有意思。

2013年阅读量比2012年大了许多。

年初开始读《程序员的自我修养 : 链接、装载与库》。这本书确实很经典，讲述了底层C语言代码编译、链接、运行的原理。我原打算读了去做跨平台编译的，发现学了不少，一点没用上，又全忘了。。。
《Servlet&JSP学习笔记》。一个台湾人写的，Servlet入门书里面我觉得很不错的。
《Struts 2实战》。之前去IBM面试Java的时候被张斌鄙视了。后来寒假的时候用一天的时间读了一下这本书，读完感觉可以完虐张斌啊，^_^。
《Learning Android》。一本很不错的Android入门书籍，过几天做毕业设计的时候准备再看一下。
《打造Facebook : 亲历Facebook爆发的5年》。一个中国留学生讲述了他在Facebook工作的事情。
《明朝那些事儿》。去年影响我一年的书是《乡关何处》。今年影响我的是这本，非常精彩，在IBM实习的半年就在读这本书。作者用自己的观点讲述了他所理解的明朝。以后闲下来要去读一读王阳明的书。
《HTML与CSS入门经典》
《浪潮之巅》。这本也很精彩，吴军博士讲了硅谷各大公司的发展史。
《剑指Offer : 名企面试官精讲典型编程题》。虽然这本书出来时间也很久了，但是各大公司面试题和笔试题还是会考。
《慢慢来.一切都来得及 : 心慢下来，行动才能快起来》。蛋疼的时候读一读，还是很管用的。我读过一篇，之后就没继续了。希望以后也不用读了。话说，前几天看了一部电影，《等风来》，差不多。
《Java/Java EE软件工程师就业求职手册》。我纠结的就业过程中，是这本书陪伴着我。没错，我自己都不敢相信，我这种只读经典书籍的，居然看了这种书。不过书还可以，知识点都覆盖了。当然，也可以想象，讲的多而不精。不过我还是有基础的，所以搭配上自己的总结，还是学到了不少。
《1980年代的爱情》。野夫今年的新书，排行榜很考前，可能是因为去年的《乡关何处》太火了。这本还好，纯纯的爱情。
《数学之美》。我曾经因为这本书改了我的毕业设计论文题目。当然，有我牛逼的导师的存在，让这一切化为了泡影。吴军博士将整个自然语言处理的算法讲的我这种行外人都能看得懂，可见其实力。这本书还需要读几遍。

Markdown

2014-01-12T00:00:00+00:00

1. 修改图片CSS

![IMG-THUMBNAIL]({IMAGE URL}) 添加CSS

img[alt=IMG-THUMBNAIL] {
   
}

2. 超链接

[{文本}]({超链接地址})

3. 粗斜体

粗体和斜体：用星号*或者下划线_

一个表示斜体；
两个表示粗体；
三个表示粗斜体。

4. Anchor

跳到Anchor

[配置](#config) 创建Anchor

<a name="config"></a>配置

5. 引用

用右尖括号 (>) 表示 blockquote，你一定见过邮件中这样表示引用别人的内容。可以嵌套，可以包含其它的 Markdown 元素

6. Table

这个算是Markdown的扩展语法 https://github.com/trentm/python-markdown2/wiki/wiki-tables

|| *Year* || *Temperature (low)* || *Temperature (high)* ||
|| 1900 || -10 || 25 ||
|| 1910 || -15 || 30 ||
|| 1920 || -10 || 32 ||

Linux Mint 64bit下安装Dota 2

2014-01-11T00:00:00+00:00

为了能在Linux下玩Dota 2，前前后后折腾了好几个礼拜，先写一下Linux下安装环境的难度，这也是这个解决问题的思路。

Linux下Nvidia显卡驱动不支持自动切换显卡的功能，需要安装第三方驱动。Nvidia显卡切换技术叫做Optimus，也就是擎天柱现在在Linux下面柱子无效，因此第三方开发团队的开发了好基友Bumblebee大黄蜂；
Bumblebee在开发的时候也对Nvidia原生驱动进行了修改，所以还需要安装第三方的驱动（如果已经安装了Nvidia的驱动，需要删除）;
最恶心人的不是这些还不算。Steam是开发的32位版本，而如果你是64位电脑，那么还要注意，Steam提供的解决方案默认是32位的解决方案，所以你还得去找找64位的安装方案。这也是一直让我纠结的地方，所有都安好了，就是一直报错You appear to have OpenGL 1.4.0, but we need at least 2.0.0!，让我一直以为是OpenGL的原因，在这里绕弯子了。

1. 安装Bumblebee的方法参考下面的网址，我就不抄了。

https://cjenkins.wordpress.com/2013/01/01/steam-for-linux-on-optimus-enabled-computer-running-ubuntu-12-04-64bits/#install_bumblebee

2. 测试安装要用到glxspheres，64位系统的安装方法也比较特殊。。。

wget https://goo.gl/L7rsGZ -O virtualgl_2.3.3_amd64.deb 
sudo dpkg -i --force-depends virtualgl_2.3.3_amd64.deb 
sudo apt-get -f install

运行的命令如下，也可以创建一个快捷方式到/usr/bin下，这样用起来方便一些。

/opt/VirtualGL/bin/glxspheres64

https://www.upubuntu.com/2013/11/how-to-check-3d-acceleration-fps-in.html

3. 安装好之后，出现了这个问题

一般等这些都安好以后，安装提示，将运行Dota 2的命令改成primusrun %command%，运行Dota 2，就会出现这个错误了。

PROBLEM: You appear to have OpenGL 1.4.0, but we need at least 2.0.0!

第一次装的时候一直一位是OpenGL的问题，今天又去查了查，无意中发现了Steam文档中的一句话：

Note - Primus must be installed with 32-bit support because Steam for Linux (and most games downloaded from Steam) are 32-bit.

https://support.steampowered.com/kb_article.php?ref=6316-GJKC-7437

我意识到可能是我安装成64位Primus造成的。所以开始着手安装32位版本。Steam官方也没特别明确的提供，还得自己找。。。

4. Linux 64位系统下32位Primus安装

sudo apt-get install primus-libs-ia32:i386

https://www.webupd8.org/2012/11/primus-better-performance-and-less.html

5. 查看Nvidia显卡是否启动

lspci |grep VGA

类似结果如下

00:02.0 VGA compatible controller: Intel Corporation 3rd Gen Core processor Graphics Controller (rev 09)
01:00.0 VGA compatible controller: NVIDIA Corporation GF108M [NVS 5400M] (rev ff) rev代表启动状态，ff为未启动。其他为已启动（其实电脑发热量大了，风扇开始响了，就代表启动了。。。）。 https://www.webupd8.org/2012/11/primus-better-performance-and-less.html

6. 跳过Training

进入Dota 2以后，还要蛋疼的强迫你Training，作为资深Dota玩家的我，果断是要跳过的啊。在Steam里面启动Dota 2的环境变量最后加上如下参数，就可以跳过了。

+dota_full_ui 1

完整的变量如下：

primusrun %command% +dota_full_ui 1

7. 游戏修改为中文界面

增加启动参数，改为完美世界的

-perfectworld -language schinese 完整的变量如下：

primusrun %command% +dota_full_ui 1 perfectworld -language schinese

https://www.douban.com/group/topic/41787706/

8. 连接完美世界服务器游戏

配置好所有的之后，可以打AI了，但是还是有问题，就是不能和人打。匹配区域只能显示欧洲、东南亚这些，匹配很久也匹配不到。

解决方案，还是修改启动参数

-perfectworld steam

完整的变量如下：

primusrun %command% +dota_full_ui 1 perfectworld -language schinese -perfectworld steam

最后奉上游戏截图，我最爱的Pom

Java面试宝典

2014-01-02T00:00:00+00:00

1. Java标识符，命名规范？

不能以数字开头；rake post title=”hello world” category=”life” date=”2013-04-21” tags=”” description=”description”
区分大小写；
不能有@、‘-‘（运算符）；
可以出现中文；
java关键字不能做为变量名；

2. Java基本类型及其范围

基本类型	大小	最小值	最大值	包装器	默认值	说明
boolean	-	-	-	Boolean	false	没有大小
char	16bits	Unicode 0	Unicode 216-1	Character	\u0000‘ ‘	可以用来表示中文
byte	8bits	-128	127	Byte	0	与C++中的char相同
short	16bits	-215	215-1	Short	0
int	32bits	-231	231-1	Integer	0
long	64bits	-263	263-1	Long	0
float	32bits	IEEE754	IEEE754	Float	0.0	指数8位
double	64bits	IEEE754	IEEE754	Double	0.0	指数16位
void	-	-	-	Void	null	Void可以定义变量

3. Java中变量的初始化

局部变量必须初始化，如果没有初始化而使用，会编译错误。数组会自动初始化；
类中的变量可以在调用构造函数的时候自动初始化，且有默认值；
Java对于变量初始化赋值很严格，float f = 0.0(0.0为double类型)，这在C++中是会有警告，而在Java中是编译不过的。

4. Java操作有优先级？

优先级	运算符	结合性
1	() [] .	从左到右
2	! +(正) -(负) ~ ++ --	从右向左
3	* / %	从左向右
4	+(加) -(减)	从左向右
5	<< >> >>>	从左向右
6	< <= > >= instanceof	从左向右
7	== !=	从左向右
8	&(按位与)	从左向右
9	^	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	?:	从右向左
14	= += -= *= /= %= &= \|= ^= ~= <<= >>= >>>=	从右向左

5. 自加++、自减–操作符

前缀操作，可以理解为先加再赋值，后缀操作是先赋值再加；
如果为后缀自加，加的操作在该语句执行结束后执行；
当有多种可以解析的情况下，如下，可以解析成test1+(++test2)或者test1++ + test2，会从左至右就近的匹配。test3是1而不是2。
```
  int test1 = 0;
  int test2 = 1;
  int test3 = test1+++test2;
```

6. 负数如何进行取模运算？

对于负数，先对其绝对值取模，再加上符号。

7. 是什么操作符？

Java中新增了一种操作符，无符号右移»>，无论正负数，高位都是补0；
有符号右移»，正数时高位补0，负数时高位补1(1是符号位)；
移位运算符可以高效的实现与2的倍数的乘除法。

8. &与&&的区别？

&是按位与运算，也可以进行boolean运算；
与&&的区别是，&&可以进行短路求值。

9. 8 | 9 & 10 ^ 11的运算结果？

|、&、^操作符的优先顺序是&、^、|，首先9(1001)&10(1010)=8(1000)，然后8(1000)^11(1011)=3，最后(0011)8(1000)|3(0011)=11(1011)。

10. 下面代码的输出是什么？

int n = 7;
n <<= 3;
n = n & n + 1 | n + 2 ^ n + 3;
n >>= 2;
System.out.println(n); n向左移3位，相当于乘以8，得到56。+的优先级高于按位操作符的优先级，先进行加法，变成`56&57|58^59`，剩下的操作与9题类似，得到14。

11. 下面代码的执行结果是什么？

x = 5;
y = 3;
int z = x + (x++) + (++x) + y; 根据优先级，要先执行x++，x后加，先赋值5，最后再加，现在还不加；然后执行++x，先加，再赋值，此时x为6。注意，此时第一个x也是6，这是比较容易出错的地方。最后再加y，6+5+6+3=20。

12. equals()和==的区别？

==是二元运算符，在判断基本数据类型的时候，是判断其值，值相等则为true；在判断引用对象的时候，是判断其内存地址，是同一个变量则为true；
equals()是Object的一个函数，默认通过hashCode()来判断时候相等，而hashCode()是通过计算引用对象的内存地址得到的。可以重写这两个函数来判断两个引用对象的内容是否相等；
==用于判断原生类型(primitive)相等，equals()用于判断对象的相等。

13. 描述一下Java中的参数传递？

对于基本类型，Java采用按值传递，参数的值是不能够修改的；
而如果传递的是对象的引用，则会按引用传递。这个也不矛盾，如果是对象的引用，可以理解成是传递的是对象的地址，这个地址是按值传递的，我们不能修改，而这个地址的对象，我们是可以修改的，这和C++中的是一样的。

14. 如何获得数组的长度？

int arr[] = new int[4];
arr.length;

15. private和protected是否可以是class的访问修饰符？

不能。class只支持public和friendly(不写，默认的)访问修饰符，其余的都不支持；
一个.java文件中最多只能有一个public类，作为该文件对外的接口，且该类要与文件名相同(一个文件中可以有多个类)；
如果想定义成private那样的类，可以将其构造函数定义成private的访问权限，也可达到目的。

16. final、finally、finalize的区别？

final用来定义常量，使其初始化之后不能修改。定义函数，使其在继承类中不能被覆盖，也能实现内嵌调用，从而提高效率。定义类，该类则不能被继承，例如String；
finally是try/catch块之后执行且总是被执行，会在return之前被调用；
finalize()是Object中的一个方法，释放内存时会被调用，可以覆盖该函数来实现内存的释放。

17. Java访问修饰符？

	当前类	当前包	继承类	其他包
public	√	√	√	√
protected	√	√	√	×
包访问权限(friendly)	√	√	×	×
private	√	×	×	×

18. 下面代码的执行结果是什么？

class AA extends BB {
    private int radius = 1;
    public void draw() {
        System.out.println("A.draw(),radius=" + radius);
    }
    public AA(int radius) {
        this.radius = radius;
        System.out.println("A constructor");
    }
}
class BB {
    private int radius = 10;
    public void draw() {
        System.out.println("B.draw(),radius=" + radius);
    }
    public BB() {
        System.out.println("B constructor");
        draw();
    }
    public BB(int radius) {
        System.out.println("B constructor with parameter");
        draw();
    }
}
B constructor
A.draw(),radius=1
A constructor 调用构造函数的一般顺序：

父类的静态变量初始化；
子类的静态变量初始化；
父类的非静态变量初始化；
父类的静态代码块初始化(只在声明的时候初始化)；
父类的非静态代码块初始化；
父类的无参数构造函数初始化；
子类的非静态变量初始化；
子类的静态代码块初始化；
子类的非静态代码块初始化；
子类被调用的构造函数初始化。

此题中，先调用父类的无参数构造函数，输出B constructor，再调用draw函数，draw是自己的draw函数(draw函数被覆盖)。

19. 下面语句有什么问题？

if (x) {
    x = 0;
} Java中的if条件表达式只支持boolean类型，这不同于C++中还可以支持整型。

20. 可以用于switch条件表达式的类型是什么？

switch支持整型表达式，默认支持int；
byte、char、short可以自动向下转换，不会造成数据丢失，所以也可以使用；
long、float、double转换成int时会丢失数据，不能使用。
Java 7之后，switch开始支持字符串String。

21. 下列代码的执行结果是什么？

int i = 10, j = 18, k = 30;
switch(j - i) {
case 8: System.out.println(++k);
case 9: System.out.println(k+=3);
case 10: System.out.println(k<<=1);
default: System.out.println(k/=j);
} 如果匹配到case，从该case开始执行，直到遇到break为止。该题目中，四个语句都执行过，++k得到31，k+=3得到34，k乘以2得到68，再除以18得到3(小数部分抹掉)。

22. Throwable的子类是哪两个？

Error
Exception

23. 下面代码的输出结果是什么？

try {
    String a = null;
    a.length();
} catch(nullPointerException e) {
    System.out.println("NullPointerException");
} catch(Exception e) {
    System.out.println("Exception");
} finally {
    System.out.println("finally");
} 会输出NullPointerException和finally，并列的多个catch，要先写子类，再写父类，匹配到一个catch后，不再匹配，执行finally语句。

**补充一点： **处理异常的机制是为了保证程序正常的运行。比如，一段代码用来处理一段文本，当文本格式发生变化之后，可以修改代码，增加if等判断语句；也可以之前就增加catch语句，一开始就能提供默认处理方式。

24. throw和throws的区别？

throws定义函数，声明这个方法会抛出这种类型的异常，使其他地方调用它时知道要捕获这个异常。使用try/catch来捕获；
throw是具体向外抛异常的动作，所以它一定会抛出一个异常实例。

25. Java支持多继承么？

Java默认只支持单继承extends，C++中的多继承对于继承的概念不是很严谨，因为继承多个对象无法确定该对象到底是属于哪个类型。而Java又提供了接口，可以被实现implements，一个类可以实现多个接口。这也是实现多继承的一种方式，而且也符合继承的概念，一个类只能有一个父类，这样不会造成混乱，实现多个接口，又能增加其他类中才有的功能。

26. 什么是重载？

对于同一个动作，可以有不同的执行方法，这时就需要重载；
重载函数名必须相同；
参数表必须不同，只能通过参数表来区别重载函数；
返回值不能用来区别重载函数。如果只有返回值不同，由于返回值可以转换类型，所以不能用来区别重载函数。

27. 什么是重写？

在继承关系中，子类可以重写继承到的父类的函数，来定义自己的功能实现；
重写的函数，函数名，返回值，参数表必须完全相同；
子类重写的函数的访问修饰符不能比父类的小；
子类重写的函数抛出的异常不能比父类的多。

28. 下面代码的执行结果是什么？

public class Parent{
    public int x;
    public int y;
    public Parent(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public void increaseX(int x) {
        this.x = getX() + x;
    }
    public int getX() {
        return x;
    }
    public void increaseY(int y) {
        this.y = getY() + y;
    }
    public int getY() {
        return y;
    }
}
public class Child extends Parent {
    private int x;
    private int y;
    public Child(int x, int y) {
        super(x, y);
        this.y = y + 250;
        this.x = x + 150;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
}
Child child = new Child(50, 50);
child.increaseX(100);
child.increaseY(100); x和y结果分别是200和300。在重写当中，具体还可以分为覆盖和隐藏。对于函数，子类中重写的函数会覆盖掉父类的函数，而对于变量，子类中重写的变量将会隐藏掉父类的变量。在new Child(50, 50)的时候，调用父类的带参数构造函数，在这里对x和y赋值，x和y是父类的x和y，不会影响到子类的x和y。接着this.y = y + 250，这里修改的是子类的x和y，得到200和300。接着执行increaseX和increaseY，子类并没有定义这两个函数，调用的是父类的这两个函数，而调用的时候修改的是父类中x和y的值，不会影响到子类的结果。

29. 下列代码插入标记处不会编译出错的是哪一个？

class MyTest extends Test {
    int count;
    public MyTest(int cnt, int num) {
        super(num);
        count = cnt;
    }
    // insert code here
}
public class Test {
    int number;
    public Test(int i) {
        number = i;
    }
} + MyTest() {} + MyTest(int cnt) {count = cnt} + MyTest(int cnt) {super(); count = cnt;} + MyTest(int cnt) {count = cnt; super(cnt);} + MyTest(int cnt) {this(cnt, cnt);} + MyTest(int cnt) {super(cnt); this(cnt, 0)}

首先，Java中子类的构造函数会默认有一句super()，来调用父类的构造函数，该语句可以省略。该语句需要放在构造函数第一行； Java中this()也可以用在构造函数的第一行，用来调用本类的其他构造函数。this()和super()不能同时使用；如果为super增加参数，那可以调用父类对应带参数的构造函数；如果父类不定义构造函数，会自动为其分配一个不带参数的构造函数。如果父类定义了构造函数，那么将不再会自动分配。也就是说，定义了一个带参数的构造函数，那么该类就没有不带参数的构造函数了；上题中，A、B、C、都显示或隐式地调用了super()函数，而父类没有定义不带参数的构造函数。D中super不在第一行。F同时使用了super和this。答案为E。

30. Java是否可以手动释放内存？

Java提供了一个方法，System.gc()，建议Java虚拟机去释放内存，当JVM决定去释放内存是，会调用该对象的finalize()方法。Java中申请内存由程序员实现，内存会申请到堆中，释放内存由GC实现。

31. Java是否会出现内存泄漏？

GC会自动回收垃圾，GC采用有向图的方法，一般情况下，如果一个对象没有被引用，则该对象所占的内存将会被释放。例如，o2=o1后，o2原本引用的内存将会被释放；

Vector v = new Vector(10);
for (int i=1;i<100; i++)
{
    Object o=new Object();
    v.add(o);
    o=null;        
} 但是当一个对象没有被引用，但是在有向图中又是可达的，而且又没有用处，那么此时就发生了内存泄漏。o=null后，由于之前指向的内存可以从v可达，那么该部分内存将不可被释放，知道v=null或v的内存释放为止。

32. Thread的五个状态？

创建状态
就绪状态
运行状态
阻塞状态
死亡状态

33. Thread中run()和start()的区别？

start()会立刻返回。调用start()方法，会创建一个线程，处于就绪状态，调用run()方法运行线程体，运行结束后，该线程结束；
run()就是一个方法，不会创建新线程。

34. Thread中run()和start()的区别？

start()会立刻返回。调用start()方法，会创建一个线程，处于就绪状态，调用run()方法运行线程体，运行结束后，该线程结束；
run()就是一个方法，不会创建新线程。

35. synchronized和java.util.concurrent.Locks.Lock的区别？

synchronized可以作用域函数，代码块，静态函数中。在函数中使用，以当前实例为锁，表示当前实例this在不同的线程中要互斥访问。在代码块中使用，要为synchronized增加参数，要以对象为锁，互斥访问，如果以this同步，和之前的以函数同步含义相同。也可以指定对象来同步。如果同步的是静态函数，函数调用的时候可能还没有实例，不能使用this，可以使用Foo.class作为锁。

Public synchronized void method(){
    //......
}
public void method()
{
    synchronized (this)
    {
        //......
    }
}
public void method(SomeObject so) {
    synchronized(so)
    {
        //......
    }
} + 所有对象都自动含有单一的锁。 JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。 只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 + Lock有比Synchronized更精确的线程域城予以和更好的性能。Synchronized会自动释放锁，但是Lock一定要求程序员手工释放，并且必须在finally从句中释放。

36. wait()、notify()、notifyAll()的作用？

这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。
如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。

Java面试中也会常常去问对于Java包源码的理解。下面按照根据Java包来介绍。 java.lang包，Java的基础包，编译时会自动导入，主要包含Java基类Object，包装类Boolean、Character、Byte、Short、Integer、Long、Float、Double，Enum，String、StringBuffer、StringBuilder，Thread，Process，Math，Throwable，Error，Exception。

37. java.lang.Object

方法	说明
public final native Class<?> getClass();	返回一个对象的运行时类
public native int hashCode();	返回该对象的哈希码值，将对象在内存中的地址转成int并返回
public boolean equals(Object obj) { return (this == obj); }	指示某个其他对象是否与此对象“相等”。默认使用==来判断引用对象的地址。
protected native Object clone() throws CloneNotSupportedException;	创建并返回此对象的一个副本。该对象要实现Cloneable接口，否则会抛出CloneNotSupportedException异常
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }	返回该对象的字符串表示，用hashCode()辅助实现
public final native void notify();	唤醒在此对象监视器上等待的单个线程
public final native void notifyAll();	唤醒在此对象监视器上等待的所有线程
public final native void wait(long timeout) throws InterruptedException;	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量
public final void wait(long timeout, int nanos) throws InterruptedException	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量
public final void wait() throws InterruptedException { wait(0); }	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
protected void finalize() throws Throwable { }	当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

38. java.lang.Math

Math是一个final类，不能被继承，提供了一套静态方法，实现数字计算的常见功能。

方法	说明
public static double ceil(double a) { return StrictMath.ceil(a); // default impl. delegates to StrictMath }	向上取整
public static double floor(double a) { return StrictMath.floor(a); // default impl. delegates to StrictMath }	向下取整
public static int round(float a) { if (a != 0x1.fffffep-2f) // greatest float value less than 0.5 return (int)floor(a + 0.5f); else return 0; }	加0.5后向下取整。 ceil和floor返回的都是double，round返回的是int和long

39. java.lang.String

String是一个final类，不可以被继承。Java里是没有运算符重载的，String+是StringBuffer的append()方法来实现的，如：String str = new String(“abc”);编译时等效于String str = new StringBuffer().append(“a”).append(“b”).append(“c”).toString();

类方法或变量	说明
private final char value[];	String是封装的字符数组，而且被定义成final类型，一经赋值，不能修改
private int hash;	默认为0，hashCode()的返回值
public String() { this.value = new char[0]; }
public String(String original) { this.value = original.value; this.hash = original.hash; }
public String(char value[]) { this.value = Arrays.copyOf(value, value.length); }
public String(char value[], int offset, int count);	根据字符数组一部分对象创建字符串对象
public String(int[] codePoints, int offset, int count);
public int length() { return value.length; }	返回字符数组长度
public char charAt(int index) { if ((index < 0) \|\| (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }
public boolean equals(Object anObject);	根据字符数组逐个比较
public int compareTo(String anotherString);	相同返回0，当前字符串大，返回整数；小，返回负数
public int indexOf(int ch) { return indexOf(ch, 0); }	返回字符ch首先出现的位置，没有返回-1
public String substring(int beginIndex, int endIndex);	通过索引和value，创建一个新的String并返回。不包括endIndex所指的字符。 Java 6之前，String类内部还有两个成员变量count和offset，当调用substring并返回时，同样还是引用的同一个字符数组，只是改变了count和offset。当你有一个非常长的字符串，而你只是想保留其中的一小部分，Java 6会一直保存着整个字符串，这样会造成性能问题。解决的方法是x = x.substring(i, j) + “”; Java 7会帮你new一个新的字符串并只保留substring要用到的字符。
public String concat(String str);	创建一个新的字符数组，将当前字符数组和str的都放到该数组中，用这个数组创建一个新的String并返回
public String replace(char oldChar, char newChar);	用newChar替换所有当前字符串中oldChar并创建一个新String返回

40. java.lang.StringBuilder

StringBuilder是可变长字符串，是Java 5.0新增的，之前的是StringBuffer，相比于StringBuffer，StringBuilder是线程不安全的，但性能得到提升。这两个类的接口是保持一致的。Java 5.0之后，字符串+操作符采用StringBuilder实现

类变量或方法	说明
char[] value;	AbstractStringBuilder类中，可以返回capacity
int count;	AbstractStringBuilder类中
public StringBuilder(String str) { super(str.length() + 16); append(str); }	默认空的StringBuilder的capacity为16，以String初始化的capacity为String的长度加16
public StringBuilder append(String str) { super.append(str); return this; }
public StringBuilder delete(int start, int end) { super.delete(start, end); return this; }
public StringBuilder insert(int index, char[] str, int offset, int len) { super.insert(index, str, offset, len); return this; }
public int length() { return count; }
public int capacity() { return value.length; }	capacity与length不同，length()个返回保存的字符串长度，capacity()返回申请的字符数组大小
public void setLength(int newLength)

41. 包装类java.lang.Integer

public final class Integer extends Number implements Comparable<Integer>

类变量或方法	说明
public static final int MIN_VALUE = 0x80000000;
public static final int MAX_VALUE = 0x7fffffff;
public static int parseInt(String s, int radix) throws NumberFormatException
public static int reverse(int i)

java.util包包含Date，容器类Collection，日历Calendar，随机数Random。其中，容器类是常见的面试内容。集合类主要分类两大类，Collection和Map。Collection允许有重复对象。继承Collection的有List、Set、Vector、Stack接口。List要求有序，可以有重复元素。Set表示集合，无序，但不能有重复元素。

42. java.util.Collection

Collection接口中常见操作

接口变量或方法	说明
int size();
boolean isEmpty()	判断集合时候有任何元素
boolean contains(Object o);
Iterator iterator()	返回迭代器，用来访问各个元素
boolean add(E e);	在最后增加元素e
boolean remove(Object o);	从当前List中删除第一次出现的元素o
boolean containsAll(Collection c)
boolean addAll(Collection c)
void clear();	删除所有元素
void removeAll(Collection c)
void retainAll(Collection c)	从集合中删除集合c中不包含的元素
boolean equals(Object o);
int hashCode();
Object[] toArray()	返回含集合所有元素的数组
Object[] toArray(Object[] a)	返回含集合所有元素的数组，返回的数组与参数a的类型相同

43. java.util.List

接口变量或方法	说明
E get(int index);	获得指定位置的元素
E set(int index, E element);	将指定位置的元素替换为element
List<E> subList(int fromIndex, int toIndex);	不包括toIndex指定的元素

List有两个实现类，ArrayList和LinkedList，都是线程不安全的。LinkedList使用双向链表实现，保存头结点first和尾结点last。ArrayList使用动态数组实现，默认容量为10，每当容量不够的时候，就要重新申请新的内存，并将之前的内容复制进来。 int newCapacity = oldCapacity + (oldCapacity » 1); 申请的内存是之前的1.5倍。ArrayList可以随机访问，但是增加和删除消耗大，每次这样的操作都要移动其余的元素。而LinkedList按索引访问时要按照指针一次遍历，访问消耗大。然而，如果每次插入和删除都是在队列尾部，ArrayList效率要高，因为不需要移动元素。 Vector同样实现的是List接口，是一个重量级列表，线程安全的。也是采用动态数组实现，每次动态分配的内存和ArrayList不同，默认是2倍。 int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);

43. java.util.Set

Set不存在重复的元素，依靠equals()来检测独一性。与Collection有着完全一样的接口，根据值来确定。

HashSet。实现了SortedSet接口。其对快速查找进行了优化。存入的元素必须定义hashCode()。
TreeSet。底层为树结构。可以从Set中提取有序的序列。元素必须实现Comparable接口。
LinkedHashSet。具有HashSet的查询速度，内部使用链表维护元素的顺序(插入的顺序)，使用迭代器遍历Set时，会按照插入的顺序显示。存入的元素必须实现hashCode()方法。

44. java.util.Iterator

List可以通过get来遍历整个链表，但是对于其他的数据接口，这些遍历方法将不能通用。所以使用Iterator接口来封装遍历操作，使遍历所有的集合，都能有一个共同的接口。

接口变量或方法	说明
boolean hasNext();
E next();	将指定位置的元素替换为element
void remove();	删除上一次iterator返回的元素

45. java.util.Map

Map中不允许有重复的key。

接口变量或方法	说明
Object put(Object key, Object value);
Object remove(Object key);	根据key删除元素
void putAll(Map m);	将m中所有元素存入当前map
void clear();
Object get(Object key);	根据key获得元素
int size();
boolean isEmpty();
boolean containsKey(Object key);	检测是否有指定key的对象
boolean containsValue(Object value);	检测是否有指定value的对象
boolean equals(Object o);
Set<K> keySet();	返回一个Set，里面保存map中所有的key
Collection<V> values();	返回一个Collection，保存map中的所有value
Set<Map.Entry<K, V>> entrySet();	返回一个Set，保存所有mappings
interface Entry<K,V>	存储单个键/值对

HashMap。Java 2.0引入，是非同步的，但是提高了性能。基于散列表实现，解决哈希冲突使用链接法。 HashMap哈希的方法，是将key的hashCode与key的总数求余，得到哈希的索引。如果key是常量，则有可能相同，即使不同，与key的总数求余也有可能有哈希冲突。HashMap使用链接法解决冲突。

int hash = key.hashCode();
int index = hash % Entity[].length;
Entity[index] = value; ![Hash](https://res.cloudinary.com/cyeam/image/upload/v1537933530/cyeam/javacollection_hash.png)

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(hash, key, value, i);
    return null;
} + Hashtable是Dictionary的子类，是同步的。 + TreeMap。采用红黑树实现，可以获得字数subTree()。

47. java.io

Java IO采用Decorator模式，可以动态装配不同功能的Stream。IO体系分Input/Output和Reader/Writer两类，区别在于Reader/Writer读写文本时自动转换内码。 System.out是PrintStream的一个子类，PrintStream继承了FilterOutputStream类，FilterOutputStream类继承了OutputStream类。

48. Servlet生命周期

装载Servlet。
创建Servlet实例。
调用Servlet的init()方法。Servlet只初始化一次。
当一个客户端请求到达后，创建一个request对象和一个response对象。
调用service()方法，处理数据，并将结果返回客户端。
当服务器不再需要Servlet时，调用destroy()方法。

49. Servlet的转发和重定向

javax.servlet.RequestDispatcher的forward方法 javax.servlet.http.HttpServletResponse的sendRedirect(String)方法

电影《色|戒》最后王佳芝为什么没有吃下那颗为特工准备的自杀胶囊？

2013-11-25T00:00:00+00:00

大学互相喜欢的男生，在需要训练房事的时候找一个爱召妓的同学去，训练这个难道一定要有丰富的经验么，向那个人请教一下，自己也可以来的。她恨他的懦弱。
六个大学生，没有什么能耐，居然敢去杀特务头头，她恨他们自己的无知。
她的领导，骗她说做完任务就送她去英国，但是最后又来了句要放长线，而且这期间她也肯定没有联系到父亲，也肯定能猜到她交给领导的信都没寄出去。这明摆着从头到尾骗她们。她恨领导的欺骗。
还有她的父亲，带他弟弟去英国，却不带她，最后还自己成家了，明显怕她过去影响自己今后的家庭。她的姑妈，卖了她最后唯一的房子，仅仅供她去读个大学。
也许就是命运吧，最后差一点就走了，被拦了下来。回想起自己的经历，她就像和这个世界结仇了似的，绝不会轻易的认输。她还想看看她既恨又愧疚的相识多年的同学，所以她没有吃药。

知乎

搜狗2014校园招聘笔试题

2013-11-23T00:00:00+00:00

1. 以下关于JSTL和EL表述正确的有：（CD）

A. JSTL标签<c:if>和<c:when>都拥有test属性
B. 使用JSTL标签<fmt:formatDate format=”yyyy年MM月dd日 HH点mm分ss秒”可以得到”2009年01月05日22点00分23秒”格式的时间值
C. 使用EL表达式可以输出request中的值
D. 使用EL表达式可以输出cookie中的值

2. 一下程序执行后将有（C）个字节被写入到文件afile.txt中。

try {
	FileOutputStream fos = new FileOutputStream(“afile.txt”);
	DataOutputStream dos = new DataOutputStream(fos);
	dos.writeInt(3);
	dos.writeChar(1);
	dos.close();
} catch(IOException e) {}

A. 3
B. 5
C. 6
D. 不确定，与软硬件环境有关

char占两个字节，int占4个。

3. 下面哪些说法是正确的（D）

A. 如果引用x和引用y表示2个不同的对象，那么x.equals(y)始终为false
B. 如果引用x和引用y表示2个不同的对象，那么(x.hashCode()==y.hashCode())始终为false
C. Object的hashCode方法被声明为final
D. 所有数组都有一个clone()方法

4. 哪两个说法是正确的？（）

class A {
	A() {}
} 
class B extends A {
} * A. B类的构造函数应该是public * B. B类的构造器应该是没有参数的 * C. B类的构造器应该调用this() * D. B类的构造器应该调用super()

5. 下面代码的输出为：（C）

String s = “hello world”;
String s1 = “Hello world”;
s.replace(“hello”, “Hello”);
System.out.println((s == s1) + “,” + s.equals(s1)); * A. true, true * B. false, true * C. false, false * D. true, false

String的replace不会改变String的内容，只能返回一个被修改的字符串。

6. 下面那些类，不是实现于Collection接口（C）

A. TreeSet
B. ArrayList
C. HashMap
D. Vector

ABD都是实现的List接口。HashMap实现Map接口。

7. 下列哪些不是JSP中的隐含变量（A）

A. session
B. servletContext
C. config
D. application

8. 以下对Java垃圾收集的描述中正确的是（）

A. 发生垃圾回收时，如果一个对象被垃圾收集器认定为不可达，那么它一定会被垃圾回收器回收
B. 一个对象的finalize()方法可能会被垃圾收集器调用多次
C. 发生垃圾回收时，无论回收之后的内存是否足够，都会回收掉都被SoftReference的内存
D. 一个对象是否被PhantomReference引用完全不会对它的生命周期造成影响

9. 下列Java类中，哪个类不是线程安全的（D）

A. StringBuffer
B. Hashtable
C. Vector

ABC都是线程安全的。

10. 下列Java程序的输出是什么？（C）

public class Test{
	public static String output=””;
	public static void test(int i) {
		try {
			if (i == 0) {
				throw new Exception();
			}
			output += “a”;
		} catch (Exception e) {
			output += “b”;
			return ;
		} finally {
			output += “c”;
		}
		output += “d”;
	}
	public static void main(String args[]) {
		test(3);
		test(0);
		System.out.println(output);
	}
} * A. adb * B. acbc * C. acdbc * D. acdbcd

如果try执行了，finally不论有没有Exception都会被执行，而且即使之前return了还是会执行完再return。

11. 对于变量StringBuilder str = new StringBuilder(“搜狗Sogou”)，下面描述正确的是（C）

A. str.length()的值为11
B. str.capacity()的值为11
C. str.indexOf(“S”)的值为2
D. str.charAt(6)为g

Java中char可以表示中文，且每个char占两个字节。该字符串长度为7个单位。catapcity是字符串长度加16，为23。S的下标为2（从0开始算）。

#####搜狗大厦

#####搜狗的茶水间里等待二面

#####旁边的Google中国

中科曙光2014校园招聘笔试

2013-11-05T00:00:00+00:00

###一、单项选择题

1. 为了区分重载多态中同名不同方法，要求（A）

A. 形式参数个数或者类型不同
B. 返回值类型不同
C. 调用时用类名或对象名做前缀
D. 形式参数名称不同

2. 给定Java代码如下，运行时，会产生（B）

String s = null;
s.concat(“abc”);

A. ArithmeticException
B. NullPointerException
C. IOExcepiton
D. EOFException

3. 给定如下Java代码，编译时会在（C）出现错误。

public class Sugon {
    static int arr[] = new int[10];
    public static void main(String args[]) {
        System.out.println(arr[1]);
    }
}

A. 编译时将产生错误
B. 编译时正确，运行时将产生错误
C. 输出零
D. 输出空

4. 表（TEACHER）包含以下列

ID NUMBER(7) PK
SALARY NUMBER(7, 2)
SUBJECT_ID NUMBER(7)

分别执行以下两个SQL语句：（B）

SELECT ROUND(SUM(salary), -2) FROM teacher;
SELECT subject_id, ROUND(SUM(salary), -2) FROM teacher GROUP BY id 

A. 语句1将返回每个老师一个结果
B. 语句2将返回多个结果
C. 结果相同，显示不同
D. 将有一个句子产生错误

5. 下面哪个是正确的类声明？假设每一段文本都作为一个名称为GPUTest.java的文件的全部内容？（A）

  public class GPUTest {
      public int x = 0;
      public GPUTest(int x) {
          this.x = x;
      }
  } 

  public class gpuTest {
      public int x = 0;
      public gpuTest(int x) {
          this.x = x;
      }
  }

  public class GPUTest extends MyBaseClass, MyOtherBaseClass {
      public int x = 0;
      public GPUTest(int xval) {
          x = xval;
      }
  }

  protected class GPUTest {
      private int x = 0;
      private GPUTest (int xval) {
          x = xval;
      }
  }

首先说明了文件是GPUTest.java，那么，这个名称就要和该文件中public声明的类文件名相同，包括大小写，排除B。Java只有单继承，C错。class只能用public和空修饰，D错。

6. 如果只想得到1000个元素组成的序列中第5个元素之前的部分排列的序列（D）方法最快。

A. 冒泡排序
B. 快速排序
C. Shell排序
D. 堆排序

这个题要求查询序列中最小的5个元素。希尔排序和快速排序，都是在整个序列排序结束之后，才能够实现。冒泡和堆排序能够优先获得最小的5个元素，而堆排序被叫做是高级的冒泡排序，交换次数少于冒泡排序。

7.在Java中下列关于自动类型转换的说法正确的是（A）

A. 基本类型和String类型相加结果一定是字符串类型
B. char类型和int类型相加结果一定是字符
C. double类型可以自动转换为int
D. char + int + double + “”的结果一定是double

8. 以下不属于Thread类提供的线程控制方法是（C）

A. sleep()
B. interrupted
C. init()
D. yield()

9. 执行下面PL/SQL代码块，被插入到表EXAMPLE中的行数为（B）

BEGIN
FOR i IN 1..6 LOOP
IF i=2 OR i=3 THEN null;
ELSE
INSERT INTO example(one) VALUES(i);
END IF;
ROLLBACK;
END LOOP;
COMMIT;
END; + A. 0 + B. 1 + C. 2 + D. 3

###二、填空题

1. 类变量在类中声明，而不是在类的某个方法中声明，它的作用域是（整个当前类）。

2. 一个完整的URL地址由（协议类型）、（主机地址）、端口和文件四部分组成。

3. Java中线程4个状态，初始状态、运行状态、阻塞状态、阻塞状态。

4. 如下第4行执行后foo的值是（basketball）。

String foo = “base”;
foo.substring(0, 3);
foo.concat(“ket”);
foo += “ball”;

5. Throwable类有两个字类：（Error）类和（Exception）类。

6. 用Thread t new Thread(r)创建一个新的线程的时候，表达式r instanceof Thread的值是（false）。

7. 下面选项中有2个可以放在程序中间没有任何问题，请选出来（CE）

A. private synchronized Object o;
B. void go() {synchronized() {}}
C. public synchronized void go() {}
D. private synchronized(this) void go() {}
E. void go() {synchronized(Object.class){}}

synchronized 不能用来修饰成员变量，A错。如果用来修饰代码块，并且要指出修饰的对象时，不能为空，B错。synchronized修饰函数时不需要(this)。C正确，用来修饰函数，并且同步的是this对象。E正确，class literals synchronize，同步类的所有实例。

###三、简答题

1. sleep()和wait()的区别和联系？

sleep()不会将线程控制权交出去，线程会暂停指定时间。wait()会交出去，然后处于就绪状态。

2. 你认为在表上建立索引可以提高数据库系统的效率吗？为什么？

不一定。建立太多的索引将会影响更新和插入的速度，因为插入和更新之后还需要更新每个索引文件。对于一个经常需要更新和插入的表格，就没有必要为一个很少使用的where子句单独建立索引了，对于比较小的表，排序的开销不会很大，也没有必要建立另外的索引。

3. 简述synchronized和java.util.concurrent.locks.Lock的异同？

Lock有比Synchronized更精确的线程域城予以和更好的性能。Synchronized会自动释放锁，但是Lock一定要求程序员手工释放，并且必须在finally从句中释放。

###四、代码题

1. 有一对猫咪，一公一母，从出生后第三年起每年都生一对小猫（假设一公一母），孩子长到第三年后每个月又生一对猫，假如猫都不死，问每年的猫总对数为多少？请使用Java语言编写一个获取每年猫对数的程序方法。

int func(int year) {
    if (year > 0 && year <= 2) {
        return 2;
    }
    return func(year - 1) + func(year - 2);
}

方正国际2014校园招聘笔试

2013-10-30T00:00:00+00:00

###一、选择题

1. 下列表达式正确时（D）？

A. byte b = 128;
B. boolean flag = null;
C. double f = 0.92395917;
D. long a = 9223372036854775808L;

byte范围是-128~127，boolean只有true和false两个值，long范围是-9223372036854775808L~9223372036854775807L，占8个字节。

2. 下列正确的说法有：（C）

A. 声明抽象方法，大括号必须有。
B. 抽象类不能有static方法。
C. 抽象类除了有抽象方法外，还可以有普通方法。
D. static方法可以访问类的所有属性

抽象方法如果有大括号，则表明有实现部分，错误。含有抽象方法的类叫做抽象类，所以可以有普通方法和static方法。static方法可以访问类的静态属性，非静态属性是在创建类的对象时才会初始化，所以没有实例化的对象属性不能被访问。

3. 下列不属于Java标示符的事（B）：

A. _HelloWorld
B. 3HelloWorld
C. $HelloWorld
D. HelloWorld

不光是Java，还包括C语言，标示符都不能以数字开头。
https://www.zhihu.com/question/20150792

4. 属于Java语言中基本数据类型的事（BC）：

A. var
B. char
C. long
D. String

String属于java.lang包。

5. 下列代码运行结果是（C）：

int x = 0;
int i = 1;
do {
    if ((i % 5) == 0) {
        i++;
        continue;
    }
    x += ++i;
} while (x < 100);
System.out.println("x=" + x)

A. x=10
B. x=101
C. x=102
D. x=103
E. x=104
F. x=105

6. 下列代码运行结果是（C）：

public class Parent{
    public int x;
    public int y;
    public Parent(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public void increaseX(int x) {
        this.x = getX() + x;
    }
    public int getX() {
        return x;
    }
    public void increaseY(int y) {
        this.y = getY() + y;
    }
    public int getY() {
        return y;
    }
}
public class Child extends Parent {
    private int x;
    private int y;
    public Child(int x, int y) {
        super(x, y);
        this.y = y + 250;
        this.x = x + 150;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
}
Child child = new new Child(50, 50);
child.increaseX(100);
child.increaseY(100);
System.out.println("x=" + child.getX() + " and y=" + child.getY());

A. x=200 and y=200
B. x=250 and y=350
C. x=200 and y=300
D. 编译错误

重写具体又可以分为隐藏和覆盖，父类实例变量和静态变量能被子类同名变量隐藏，父类静态方法被子类同名静态方法隐藏，父类实例方法被子类同名实例方法覆盖。被隐藏的变量和方法是存在的，可以通过该类实例去访问。此题Child继承Parent，Child类中重写了变量x、y，方法getX()、getY()。所以，Parent的变量x和y会被隐藏，getX()和getY()会被覆盖，increaseX()和increaseY()会被子类继承。此题还要考虑子类和父类构造函数的调用顺序。

Child child = new new Child(50, 50);此行之行时，会先调用父类的super(x, y)，父类的x和y被修改，接着初始化Child的x和y为0。然后，执行this.y = y + 250;this.x = x + 150;修改子类的x和y，此时，child的x和y是200和300。后来的child.increaseX(100);child.increaseY(100);方法都是使用的父类的函数，修改的也是父类的x和y，对于child的不影响。所以结果是C。

7. 下列选项可以在A的子类中使用的是（AC）：

class A {
    protected int method(int a, int b) {
        return 0;
    }
}

A. public int method(int a, int b) {return 0;}
B. private int method(int a, int b) {return 0;}
C. private int method(int a, short b) {return a + b;}
D. public short method(int a, short b) {return a + b;}

A为重写。B为重写，重写的方法不能比原方法有更低的访问权限。C参数表不同，为重载，对于访问修饰符没有要求。D的参数表不同，为重写，但是int a和short b相加，得到的是int，题目中没有进行类型转换，错误。

8. 关于以下代码说明正确的是（C）：

class StaticTest {
    public static int x = 1;
    public void increaseX(int increasement) {
        x += increasement;
    }
    public StaticTest(int original) {
        increaseX(original);
        if (x > 10) {
            x = 1;
        }
    }
}
StaticTest obj1 = new StaticTest(5);
obj1.increaseX(2);
StaticTest obj2 = new StaticTest(3);
obj2.x += 4;
StaticTest obj3 = new StaticTest(1);
StaticTest.x += 3;
System.out.println("x=" + obj1.x);

A. 第5行不能编译通过，因为引用了私有静态变量
B. 第17行不能编译通过，因为x是私有静态变量
C. 能编译通过，结果为9
D. 能编译通过，结果为8

x为static变量，被所有对象所共享。StaticTest obj1 = new StaticTest(5);x加5变为6。obj1.increaseX(2);x加2成为8。StaticTest obj2 = new StaticTest(3);x加3成为11，大于10，重新赋为1。obj2.x += 4;加4成为5。StaticTest obj3 = new StaticTest(1);加1成为6。StaticTest.x += 3;加3成为9。

9. 下列选项中不属于JDBC基本功能的是：

A. 与数据库建立连接
B. 提交sql语句
C. 处理查询结果
D. 执行Oracle存储过程

10. Page指令用于定义JSP文件中的全局属性，下列关于该指令用法的描述不正确的是：

A. <%@ page %>作用于整个JSP页面
B. 可以在一个页面中使用多个<%@ page %>指令
C. 为增强程序的可读性，建议将<%@ page %>指令放在JSP文件的开头，但不是必须的
D. <%@ page %>指令中的属性只能出现一次

11. 关于jQuery，是由哪些语言编写的（A）：

A. JavaScript
B. HTML
C. Java
D. CSS

12. 在CSS样式中以下哪些选项属于选择符的分类（ABD）

A. HTML选择符
B. Class选择符
C. #选择符
D. ID选择符

此外，还包括通用元素选择符*。

###二、填空题

1. Java的基本数据类型中，long类型占用（8）字节空间。对long类型的赋值（不是）线程安全的。

32位或更少位数是原子性的，按32位为基本操作单位。所以Java中long和double不是原子性的。需要使用volatile保证原子性。

2. 请写出Java语言的三个访问权限修饰符，并作简单说明：

private：当前类访问权限，只能被当前类的实例自己内部调用。
protected：继承类修饰，能被子类访问。
friendly：包访问权限。
public：全局访问。

3. 请写出一下代码段的输出结果：（Hello world）

StringBuilder word = new StringBuilder("Hello");
getWho(word);
System.out.println(word.toString());
public static void getWho(StringBuilder word) {
    word = word.append(" word");
} StringBuilder的内容是可以更改的。

4. 请填空列举5个您所知道的struts2（struts-2.2.3之前版本）的Result Type：（dispatcher、redirect、chain、freemarker）。

5. JAXB（Java Architecture for XML Binding）是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。它通过JDK的Annotation在类元素与XML元素之间进行映射。其中，（@XmlRootElement）Annotation用来将Java类型或枚举类型映射到XML元素，（@XmlElement）Annotation用来将Java类的一个属性映射到与属性同名的一个XML元素，（@XmlAttribute）Annotation用来将Java类的一个属性映射到与属性同名的一个XML属性。它通过（@XmlAccessOrder）Annotation来定类属性对应元素在XML节点中的前后顺序关系。

6. ECMAScript的5种原始类型是：（undefined、boolean、number、string、object）。 JavaScript的typeof运算符用来判断一个值是否在某种类型的范围内。

var s1;
var s2 = null;
var type1 = (typeof s1);
var type2 = (typeof s2); 变量type1和type2分别指向（undefined）类型和（object）类型。

7. 请写出3个Hibernate的数据查询方式以及它们的使用场景：

query接口
Criteria接口
SQLQuery接口

###三、简答题

1. Java中String、StringBuffer、StringBuilder中之间的区别是什么？

String是final类，不允许继承。内部使用final数组实现，一经初始化，不能够再修改。如果要修改一个String对象，只能重新创建一个新的String并使其引用这个对象。StringBuffer和StringBuilder是可变的String。通过封装String实现。其中StringBuilder是Java 5.0之后的较新版本，且不支持多线程。

2. Java中为什么需要同步？列出你所知道的几种同步方法。

在多线程环境下，多个线程会并发访问共享的一个内存地址空间。由于多线程切换的不确定性，运行不能保证每次都按相同的顺序执行，所以就要保证这样运行的情况下与单线程执行的结果是一致的。Java可以使用sychronized关键字同步代码块或者函数，volatile关键字保证long和double类型的原子性操作，wait()和notify()方法保证同步执行。

3. 无论系统规模有多大，Web缓存都有助于优化性能和节省带宽。Web缓存主要有哪两种方式？我们常见的MemcachD属于哪一种方式？它能提高系统性能的原因是什么？如果我们要自行设计一个Web缓存系统，需要关注哪些方面？

Web缓存主要包括文件缓存和分布式缓存。MemcacheD是分布式缓存。MemcacheD使用物理内存作为缓存区，还使用了高校的基于key和value的hash算法来设计存储数据结构。淘汰机制基于LRU算法，所以提高了系统性能。

###四、编程题

1. 请使用Java语言定义一个具备insert、remove、find功能的二叉查找树BinarySearchTree摸板类，实现以下接口：

interface BinarySearchTree<T> {
    void add(T value);
    void remove();
    T find(T value);
    int size();
}

为了实现对象之间的比较，在BinarySearchTree类的构造方法中，会传入一个Comparable<T>;的接口实例。Comparable<T>的接口定义如下：

interface Comparable<T> {
    public int compareTo(T o1, T o2);
}

当o1小于o2时，compareTo方法返回-1，如果o1等于o2，compareTo放回0。如果o1大于o2，compareTo方法返回-1。在实现BinarySearchTree类时，不需要考虑实现Comparable方法。可以假定调用者会主动传参。

class Value implements Comparable <Value>{
    private int value;
    
    public Value(int value) {
        this.value = value;
    }
    
    public int compareTo(Value v) {
        return this.value - v.value;  
    }  
}
public class BinarySearchTree<T extends Comparable<? super T>> {
    private static class BinaryNode<T> {
        BinaryNode(T element) {
            this(element, null, null);
        }
        BinaryNode(T element, BinaryNode<T> left, BinaryNode<T> right) {
            this.element = element;
            this.left = left;
            this.right = right;
        }
        T element;
        BinaryNode<T> left;
        BinaryNode<T> right;
    }
    
    private BinaryNode<T> root;
    private int count;
    
    public BinarySearchTree() {
        root = null;
        count = 0;
    }
    public void add(T value) {
        add(value, root);
    }
    public BinaryNode<T> add(T value, BinaryNode<T> t) {
        if (t == null) {
            count++;
            return new BinaryNode<T>(value) ;
        }
        
        int compareResult = value.compareTo(this.root.element);
        if (compareResult > 0) {
            t.right = add(value, t.right);
        }
        else if (compareResult < 0) {
            t.left = add(value, t.left);
        }
        return t;
    }
    public void remove(T value) {
        remove(value, root);
        count--;
    }
    public BinaryNode<T> remove(T value, BinaryNode<T> t) {
        if (t == null) {
            return t;
        }
        
        int compareResult = value.compareTo(this.root.element);
        if (compareResult > 0) {
            t.right = remove(value, t.right);
        }
        else if (compareResult < 0) {
            t.left = remove(value, t.left);
        }
        else if (t.left != null && t.right != null) {
            t.element = findMin(t.right).element;
            remove(t.element, t.right);
        }
        else {
            t = (t.right != null) ? t.left : t.right;
            count--;
        }
        return t;
    }
    public boolean find(T value) {
        return find(value, root);
    }
    public boolean find(T value, BinaryNode<T> t) {
        if (t == null)
            return false;
        
        int compareResult = value.compareTo(this.root.element);
        if (compareResult > 0) {
            return find(value, this.root.right);
        }
        else if (compareResult < 0) {
            return find(value, this.root.left);
        }
        else {
            return true;
        }
    }
    public BinaryNode<T> findMin(BinaryNode<T> t) {
        if (t == null) {
            return null;
        }
        if (t.left == null) {
            return t;
        }
        return findMin(t.left);
    }
    public int size() {
        return count;
    }
    
}

2. 有两个数组int a[], b[]。这两个数组都已经被进行了数据初始化，数据都不重复，且都没有排序。请设计一种算法，利用【问题1】实现的接口，将这两个数组合并，同时合并后的数据也要保证都是按照数值从小到大排列。同时请分析算法中元素之间比较的复杂度。

用两个数组创建一颗二叉查找树即可。比较的复杂度是O(logn)。

神州航天软件2014校园招聘笔试

2013-10-25T00:00:00+00:00

1. String s = new String(“xyz”);创建了几个String Object？

创建了一个String Object。涉及到两个String Object，一个是字符串字面量”xyz”所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与”xyz”相同的实例。

2. 有如下定义：

String str = new String("hello world");
String[] arr = {"hello", "world"}; 请写出如何获取str和arr的长度？

str.length();
arr.length;

3. 你所知道的集合类有哪些？主要方法？

ArrayList、LinkedList、Vector、HashMap、HashSet。主要有size()、add()、insert()、remove()、get()、set()、put()。

4. 运行时异常与一般异常有何异同？

Java提供了两类主要的异常:runtime exception和checked exception。checked 异常也就是我们经常遇到的IO异常，以及SQL异常都是这种异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。但是另外一种异常：runtime exception，也称运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

5. error和exception有什么区别？

都继承自Throwable。Error指出现了错误，且不能恢复，只能在系统级处理。Exception是指出现了异常，有可能能处理，可以在应用程序级处理。

6. 下列异常的含义，并举出合适会产生该异常（异常出现的场景）

NullPointerException; 空指针异常，访问指向null的对象的操作或方法。
IndexOutOfBoundsException; 下标溢出异常，访问的下标超过了范围。
NoSuchElementException; 使用nextElement()访问枚举类型时。
ClassCastException; 类型转换异常，将父类强制转换为子类时会发生。

7. JSP中的静态包含和动态包含有什么区别？

静态包含：<%@ include file="被包含文件" %>；
动态包含：<jsp:include page="被包含文件" />。

8. 在JSP中，Request、Response、Session都有什么功能？什么情况下使用？

Request代表客户端的请求信息，用于接受通过HTTP协议传送到服务器的数据。作用域为一次请求。
Response代表服务器对客户端的相应，只在JSP页面内有效。
Session是指用户打开浏览器连接到服务器，到关闭浏览器离开服务器这段时间，是一个会话。无论用户打开多少个网页，服务器都能知道这是同一个用户。

9. 写出单件模式。

public class Singleton {
    private static volatile Singleton INSTANCE = null;

    public Singleton() {

    }

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    return new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

乐视2014校园招聘笔试

2013-10-24T00:00:00+00:00

###试题一

1. 程序，进程，线程的区别？进程的通信方式有哪些？

程序是用你适当形式描述的算法，是存储在硬盘上的静态的文件。进程是某种类型的一个活动，是动态的，它有程序、输入、输出以及状态，如果一个程序运行了两次，算过两个进程。线程是轻量级进程，进程间可以共享地址空间，可以更容易创建和撤销，如果存在大量计算和大量I/O处理，多线程可以使这些过程重叠进行，加快应用程序执行速度。

2. 删除一个单项链表的最中间的元素，要求时间尽可能短（代码和思路）。

3. 输入一个整形数组，数组有正数也有负数数组中连续的一个或多个整数组组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。例如输入的数组为1，-2，3，10，-4，7，2，-5，和最大的子数组为3，10，-4，7，2，因此输出为该子数组的和18。

###试题二

1. 什么是死锁？产生的原因是什么？必要条件是什么？如何预防和解除？

如果一个进程集合中的每个进程都在等待只能由该进程集合中的其他进程才能引发的事件，那么，该进程集合就是死锁的。

######四个必要条件：

互斥条件。资源每次只能被一个进程访问。
占有和等待条件。已经得到某个资源的进程还可以再请求新资源。
不可抢占条件。已经分配给一个进程的资源不能被强制地抢占。
环路等待条件。每个进程都在等待着下一个进程所占有的资源。

######死锁的预防：

互斥。一切都使用假脱机技术。
占有和等待。在开始就请求全部资源。
不可抢占。抢占资源。
环路等待。对资源按序编号。

2. 假设有一个单向链表，请输出该链表中倒数第n个节点。

3. 给定数组A，大小为n，数组元素为1到n的数字，不过有的数字出现了多次，有的数字没有出现。请给出算法和程序，统计哪些数字没有出现，哪些数字出现了多少次。能够在O(n)的时间复杂度，O(1)的空间复杂度要求下完成么？

趣游2014校园招聘笔试

2013-10-24T00:00:00+00:00

###一、概念题

1. 引用和指针的区别？

int a = 1;
int& b = a;
cout << &a << endl;
cout << &b << endl; // same address

引用访问一个变量是直接访问，而指针是间接访问。
引用是一个变量的别名，本身不单独分配自己的内存空间，而指针有自己的内存空间。 + 不存在空引用，引用必须初始化。
引用在开始的时候就绑定到了一个内存空间(开始必须赋初值)，所以他只能是这个内存空间的名字，而不能改成其他的，当然可以改变这个内存空间的值。

2. new delete与malloc free的联系与区别？

malloc/free是C/C++语言的标准库函数，new/delete是C++的运算符。
maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象消亡之前要自动执行析构函数。
new 内置了sizeof、类型转换和类型安全检查功能。
在用delete 释放对象数组时，留意不要丢了符号‘[]’。

3. struct和class的联系和区别？

struct Shape {
    int id;

    Shape() {
        cout << "Constructor of Shape" << endl;
    }

    ~Shape() {
        cout << "Destructor of Shape" << endl;
    }
};

struct Circle : Shape {

    Circle() {
        cout << "Constructor of Circle" << endl;
    }

    ~Circle() {
        cout << "Destructor of Circle" << endl;
    }
};

访问权限不同。struct 的默认访问权限是public，class 的默认访问权限是private。如果一个类中只有get/set函数，而没有其他处理数据的函数，使用struct就可以了。
struct默认是public继承，class默认是private继承。

4. 什么是面向对象，描述它的基本特征。

封装、继承、多态。

5. 重载（overload）和重写（override）的区别？

6. “线程安全”的含义。

程序中的每一条语句都是原子操作，则是线程安全的。
实例变量是在堆中分配的,并不被属于该实例的所有线程共享，只有一个线程独享，是线程安全的。
局部变量在堆栈中分配,因为每个线程都有它自己的堆栈空间,所以是线程安全的.
静态类不用被实例化,就可直接使用,也不是线程安全的.
单线程方式是线程安全的。

7. 用c socket函数描述C/S架构的程序，两端网络连接建立过程。

###二、程序编写题

1. 写一个在一个字符串（n）中寻找一个子串（m）第一个位置的函数（不能用strlen）。

请描述你解决这个问题的思路；
请给出函数代码，以及算法的复杂度。

解析

2. 链表题：一个链表的节点结构

struct Node
{
    int data;
    Node* next;
}; + a. 已知链表的头结点head，写一个函数把这个链表逆序。 + b. 已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序（保留所有结点，即便大小相同）。 + c. 已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序，这次要用递归的方法。

3. 用数组来实现一个栈，并用面向对象的方法进行封装。

###三、附加题

1. 两个数相乘，位数没有限制，请写一个程序接受键盘输入并输出结果。

解析《大数乘法》。本题目难度就在于先开始不做进位处理，然后还能找出竖式乘法的左移规律。否则写起来会很麻烦。

巨人网络2014校园招聘笔试

2013-10-21T00:00:00+00:00

###一、改错题

1. 下列代码的错误之处

public class Question1 {
    public static boolean isOdd(int i) {
        return i % 2 == 1;
    }
    public static void main(String[] args) {
        for (int i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; ++i) {
            boolean isOdd = isOdd(i);
            System.out.println(String.format("i=%d, isOdd = %b", i, isOdd);
        }
    }
} // 负数求模，取绝对值取模，然后加符号。此处负数的部分，奇数取模之后都是-1，所以返回都是false。检测负数奇偶性时应先判断正负。

2. 下列代码的错误之处

public class Question2 {
    public static void main(String[] args) {
        final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;
        final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;
        System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);
    }
} // long 64位 范围合适 // 右边做乘法时，是int类型数值，int是32位，乘法结束后，才转成long型付给MICROS_PER_DAY // 改成：final long MICROS_PER_DAY = 24l * 60l * 60l * 1000l * 1000l;

3. 下列代码的错误之处

public class Question3 {
    public static void main(String[] args) {
        for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {
            if (b == 0x90)
                System.out.print("Joy!");
        }
    }
} // byte只有8位，0x90是16位，超出范围，永远不会执行到Joy处。

###二、问答题

1. 请解释一下JVM GC的原理

GC garbage coolection，使用一个线程实现，监控内存，如果该块内存没有被对象引用，则会自动释放该内存块。常见的情况下，a = null;后，a原本引用的内存就会被自动释放。程序员也可以通过System.gc()建议JVM去释放内存。

2. 实现一个高并发的聊天服务器需要克服哪些问题？

###三、编程题

1. 请用Java实现冒泡排序算法

class BubbleSort {
    
    public static void BubbleSort(int [] arr) {
        boolean flag;
        for (int i = 0; i < arr.length; i++) {
            flag = false;
            for (int j = i; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    arr[i] ^= arr[j];
                    arr[j] ^= arr[i];
                    arr[i] ^= arr[j];
                    
                    flag = true;
                }
            }
            
            if (!flag) {
                return ;
            }
        }
    }
    
    public static void main(String argv[]) {
        int arr[] = {5, 4, 6, 2, 3, 9};
        BubbleSort(arr);
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

2. 请用Java实现二叉树的（中序）遍历算法。

public void inOrder(Node node) {
    if (node == null) {
        return ;
    }
    
    if (node.left != null) {
        inOrder(node.left);
    }
    
    System.out.println(node.value);
    
    if (node.right != null) {
        inOrder(node.right);
    }
}

去哪网2014校园招聘Java开发面经

2013-10-19T00:00:00+00:00

去哪网待遇非常给力，一个FE都能给到14x16。而且刚刚上市，发展很不错。我的面试官是重庆人，看到我的简历上写着本科是重庆大学的，也很照顾我，可惜我很不给力。一直摊开了问，从基础到Java源码、C++源码都问了一圈，还有C语言小技巧。面试难度符合他们公司的工资水平。

下面是记忆版的面试题目。

1 . ArrayList实现 add方法如何分配内存

ArrayList基于数组实现，封装的数组，但是数组大小是固定了，而ArrayList是动态数组。动态数组是通过ensureCapacity(int minCapacity)实现。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

每次可以扩容1.5倍，将老数组拷贝一份到新数组。

2. HashMap如何实现？

HashMap是基于哈希表的Map接口的非同步实现。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。

Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}

3. C++容器

4. 数据库索引建立

CREATE INDEX idx_test4_name ON   test_tab (name );

索引要建立在经常进行select操作的字段上。这是因为，如果这些列很少用到，那么有无索引并不能明显改变查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。
索引要建立在值比较唯一的字段上。这样做才是发挥索引的最大效果。，比如主键的id字段，唯一的名字name字段等等。如果索引建立在唯一值比较少的字段，比如性别gender字段，寥寥无几的类别字段等，刚索引几乎没有任何意义。
对于那些定义为text、image和bit数据类型的列不应该增加索引。因为这些列的数据量要么相当大，要么取值很少。
当修改性能远远大于检索性能时，不应该创建索引。修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。
在WHERE和JOIN中出现的列需要建立索引。
在以通配符% 和_ 开头作查询时，mysql索引是无效的。但是这样索引是有效的：select * from tbl1 where name like ‘xxx%’，所以mysql正确建立索引是很重要的。

5. 设计模式

6. 如何检测一个数是大端还是小段存储

short x = 0x1234;
char* arr;
arr = reinterpret_cast<char*>(&x);
cout << hex << static_cast<short>(arr[0]) << static_cast<short>(arr[1]) << endl;
char y = x;
cout << "0x" << hex << (short)y << endl;
union endian {
    int i;
    float f;
    char s;
};
endian e;
e.i = 1;
cout << static_cast<int>(e.s) << endl;

7. Json的解析

8. ajax原理

9. 快速排序堆排序哪个快

建立最大堆（堆顶的元素大于其两个儿子，两个儿子又分别大于它们各自下属的两个儿子… 以此类推）
将堆顶的元素和最后一个元素对调（相当于将堆顶元素（最大值）拿走，然后将堆底的那个元素补上它的空缺），然后让那最后一个元素从顶上往下滑到恰当的位置（重新使堆最大化）。
重复第2步。这里的关键问题就在于第2步，堆底的元素肯定很小，将它拿到堆顶和原本属于最大元素的两个子节点比较，它比它们大的可能性是微乎其微的。实际上它肯定小于其中的一个儿子。而大于另一个儿子的可能性非常小。于是，这一次比较的结果就是概率不均等的，根据前面的分析，概率不均等的比较是不明智的，因为它并不能保证在糟糕情况下也能将问题的可能性削减到原本的1/2。可以想像一种极端情况，如果a肯定小于b，那么比较a和b就会什么信息也得不到——原本剩下多少可能性还是剩下多少可能性。在堆排序里面有大量这种近乎无效的比较，因为被拿到堆顶的那个元素几乎肯定是很小的，而靠近堆顶的元素又几乎肯定是很大的，将一个很小的数和一个很大的数比较，结果几乎肯定是“小于”的，这就意味着问题的可能性只被排除掉了很小一部分。这就是为什么堆排序比较慢（堆排序虽然和快速排序一样复杂度都是O(NlogN)但堆排序复杂度的常系数更大）。 MacKay也提供了一个修改版的堆排序：每次不是将堆底的元素拿到上面去，而是直接比较堆顶（最大）元素的两个儿子，即选出次大的元素。由于这两个儿子之间的大小关系是很不确定的，两者都很大，说不好哪个更大哪个更小，所以这次比较的两个结果就是概率均等的了。

10. TCP建立过程，传输过程syn码是否变化

11. Protobuf

12. 单件模式关键点除了线程安全

double check
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
//import javax.ejb.EntityContext;
import org.apache.struts2.dispatcher.StaticContentLoader;
public class ZSingleton<T> {
    
    private static Object instance;
    
    public ZSingleton() {
        Class<T> entityClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
    
    public static <T> T getInstance() {
//      entityClass.cast(instance);
        
        if (instance == null) {
            // Delay load and synchronized load
            synchronized (ZSingleton.class) {
                if (instance == null) {
//                  instance = entityClass.getConstructors();
                }
            }
        }
        return (T)instance;
    }
}

13. Http状态码

2xx成功
3xx重定向
- 301 StatusMovedPermanently。第一次收到301之后，浏览器会进行跳转。但是浏览器认为这个站点已经被永久移动到新的站点了，所以，再访问的话会直接访问新网址，不会发生跳转操作。如果需要进行每次跳转，记录跳转来源或者日志等信息，例如短网址服务区，就需要使用此状态码。
- 302 StatusFound。每次收到这个状态码都会进行跳转操作。
- 304 Not Modified。如果客户端发送了一个带条件的GET请求且该请求已被允许，而文档的内容（自上次访问以来或者根据请求的条件）并没有改变，则服务器应当返回这个状态码。304响应禁止包含消息体，因此始终以消息头后的第一个空行结尾。
4xx请求错误
5xx服务器错误

14. Vector 与普通数组实现区别

void reserve( int newCapacity )  
{  
    Object *oldArray = objects;  
        //1.重设size,capacity  
    int numToCopy = newCapacity < theSize ? newCapacity : theSize;  
    //capacity是在size的基础上加一个常数  
    newCapacity += SPARE_CAPACITY;  
        //2.建立新的数组，并拷贝元素到新数组  
    objects = new Object[ newCapacity ];  
    for( int k = 0; k < numToCopy; k++ )  
        objects[ k ] = oldArray[ k ];  
  
    theSize = numToCopy;  
    theCapacity = newCapacity;  
        //删除原来的数组  
    delete [ ] oldArray;  
}

一面后直接就被委婉的告知没戏了。下午还有完美世界的笔试，走在去清华的路上，拍到的这张北大的博雅塔。

完美世界2014校园招聘笔试

2013-10-19T00:00:00+00:00

###一、单项选择题

1. 某工作站无法访问www.wanmei.com的服务器，使用ping命令对该服务器的IP地址进行测试，响应正常；但是对服务器域名进行测试时出现超时错误，可能出现的问题是（B）

A. 线路故障
B. 路由故障
C. 域名解析故障
D. 服务器网卡故障

如果能ping通，那么说明DNS解析是正常的。就好比去访问facebook，肯定ping不通，因为DNS被污染了。同理，线路故障和网卡故障也会导致ping不通。一般服务器前面还会再增加一层负载均衡服务器，一般是Nginx或者Apache，会在这里做域名正则匹配，如果转发到错误的IP上面，有可能导致超时错误。

2. 小明每次可以上1级、2级或者3级台阶、请问小明上6级台阶总共共有多少种方法（B）

A. 23
B. 24
C. 25
D. 26

3. 师徒四人西天取经，途中必需跨过一座桥、四个人从桥的同一端出发，你得帮助他们到达另一端，天色很暗，而他们只有一只手电筒。一次同时最多可以有两人一起过桥，而过桥的时候必须持有手电筒，所以就得有人把手电筒带来带去、来回桥两端。手电筒不能同丢的方式来传递。四个人的步行速度各不同，若两人同行则以较慢者的速度为准。大师兄需花1分钟过桥，二师兄需花2分钟过桥，三师兄需5分钟过桥，师父需花10分钟过桥，请问他们最短在多少分钟内能过桥？（B）

A. 16
B. 17
C. 18
D. 19

4. 以下说法不正确的是：（A）

A. 死锁的充分条件是互斥、占有且等待、非剥夺、循环等待，且缺一不可。
B. Raid5至少需要3块磁盘。
C. 地址空间和资源（例如打开文件句柄）在进程间相互独立，而同一进程的线程可以共享。
D. 局部性原理主要包括时间局部性和空间局部性。

5. 权值为9，5，2，7的四个叶子构成的哈夫曼树，其带权路径长度是：（B）

A. 23
B. 44
C. 46
D. 50

6. 程序执行后，count的值将会是：（B）

public class CrazyCount {
    private static volatile int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                public void run() {
                    count++;
                }
            }).start();
        }
    }
}

A. 无效值，因为对count的代码修改没有同步
B. 1到1000中的一个值
C. 正好1000
D. 至少1000

// 在JVM中，每个线程都可以有自己的栈空间，volatile的作用是保证栈空间中的值和内存中的一致，并不会保证变量的原子性。保证原子性需要使用synchronized关键字，为cout++保证线程安全。

// 另：虽然1000个线程并行执行，但是保证了count++的线程安全之后，最终结果肯定是1000

7. 各处如下代码：

public class Test {
    public static void main(String[] args) {
        int x = 5;
        boolean b1 = true;
        boolean b2 = false;
        if ((x == 4) && !b2)
            System.out.print("1");
        System.out.print("2");
        if ((b2 = true) && b1)
            System.out.print("3");
    }
}

输出结果是：（D）

A. 2
B. 3
C. 12
D. 23
E. 123
F. 编译出错
G. 运行时程序抛出异常

8. 编译运行下面的代码会出现哪种情况？（C）

public class Test {
    public void myMethod(Object o) {
        System.out.println("My Object");
    }
    public void myMethod(String s) {
        System.out.println("My String");
    }
    public static void main(String args[]) {
        Test t = new Test();
        t.myMethod(null);
    }
}

A. 不能编译通过
B. 编译通过，输出”My Object”
C. 编译通过，输出”My String”
D. 编译通过，但运行时报错

9. 以下代码运行时输出的结果是什么？（B）

class C {
    C() {
        System.out.print("C");
    }
}
class A {
    C c = new C();
    A() {
        this("A");
        System.out.print("A");
    }
    A(String s) {
        System.out.print(s);
    }
}
class B extends A {
    B() {
        super("B");
        System.out.print("B");
    }
    public static void main(String[] args) {
        new B();
    }
}

A. BB
B. CBB
C. BAB
D. 以上都不是

10. 栈是一种：（A）

A. 存取受限的线性结构
B. 存取不受限的线性结构
C. 存取受限的非线性结构
D. 存取不受限的非线性结构

11. java中一个char对象可以表示的数值范围是：（B）

A. 0到255
B. 0到65535
C. -256到255
D. -32768到32767
E. 平台相关

// Java中char为16位，4个字节，使用Unicode编码

12. 以下描述正确的是：（B）

A. Java支持多重继承，一个类可以实现多个接口；
B. Java只支持单重继承，一个类可以实现多个接口；
C. Java只支持单重继承，一个类只可以实现一个接口；
D. Java支持多重继承，但一个类只可以实现一个接口。

13. 下列关于集合类描述错误的包括：（C）

A. ArrayList和LinkedList均实现了List接口
B. ArrayList的访问速度比LinkedList快
C. 添加和删除元素时，ArrayList的表现更佳
D. HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

14. 执行如下程序代码后，c的值是：（A）

a = 0; c = 1;
do {
    --c;
    a = a - 1;
} while (a > 0);

A. 0
B. 1
C. -1
D. 死循环

15. 下列关于修饰符混用的说法，错误的包括：（D）

A. abstract不能与final并列修饰同一个类
B. abstract类中可以有private的成员
C. abstract方法必须在abstract类中
D. static方法中能处理非static的成员变量

###二、填空题

1. 下面二叉树的中序遍历结果是：

2. 请至少列举出5个常用的设计模式：

3. 一个1300字节的IP包，包长度为20字节，进入一个MTU为500的网络中，请问该IP包被拆成（）段，其中每段的长度分别是（）。

4. 完美世界的个性账号注册时要求账号由6-16位小写英文字母及数字组成且首位为字母，请写出验证账号合法的正则表达式（）。

5. 请给出以下程序的输出：

class Value {
    public int i = 15;
}
public class Test {
    public static void main(String argv[]) {
        Test t = new Test();
        t.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

###三、简答题

1. 列举HTTP 1.1所支持的方法。

OPTIONS、HEAD、GET、POST、PUT、DELETE、TRACE、CONNECT

2. 什么是反射？反射的作用是什么？

反射就是可以在程序运行时刻动态获得类的信息，动态调用类的方法。反射的作用是，可以动态的获得对象的内部接口，可以动态对一个对象进行操作。

3. 方法equals()和方法hashCode()有什么联系？它们各自有什么作用？实现这两个方法的时候有些什么要求？

equals()和hashCode()均继承自Object对象。equals()是通过比较两个对象的内存地址来判断时候相等，可以重写这个函数来进行内容判断。hashCode()用来实现Set等，可以简单的认为是使用物理内存地址来实现，这是一个native方法，会因为平台不同而不同。equals()需要自反性、对称性、传递性、一致性、对任何不适null的x，x.equals(null)一定返回false。

###四、编程题

1. 用java实现一个方法，从指定的mymap中删除所有值为value的对象，并返回删除的对象个数

int removeValue(Map<Integer, Integer> mymap, int value);

int removeValue(Map<Integer, Integer> mymap, int value) {
    int count = 0;
    List<Integer> list = new LinkedList<Integer>();
    Iterator<Entry<Integer, Integer>> iter = mymap.entrySet().iterator();
    Entry<Integer, Integer> entry;
    while (iter.hasNext()) {
        entry = iter.next();
        if (entry.getValue() == value) {
            list.add(entry.getKey());
        }
    }
    
    // 
    count = list.size();
    for (int i = 0; i < list.size(); i++) {
        mymap.remove(list.get(i));
    }
    
    return count;
}

清华的一家飞机，也不知道是何来历。

广联达2014校园招聘笔试

2013-10-17T00:00:00+00:00

###卷一

1. 实现一个函数，把一个字符串中的字符从小写转为大写。

解析。

2. 给定一个二叉树的根结点R，写一个函数返回该二叉树是否为平衡二叉树。

二叉树的结点定义如下：

struct node {
    int data;
    struct node* left;
    struct node* right;
}

3. 写一个函数，将两个有序的Key-Value数组按Key累加得到一个新的有序数组。

例：数组 1 1, 400 4, 700 5, 100 数组 2 1, 300 2, 500 3, 400 4, 200 按Key累加之后得到新的数组 1, 700 2, 500 3, 400 4, 900 5, 100 Key-Value定义：

typedef struct keyvalue {
    int key;
    double value;
} 函数接口：

void sumKeyValueArray(const keyvalue aArray1[], int nLen1, const keyvalue aArray2[], int nLen2, keyvalue aResult[], int &nResultLen);

4. 不开辟和用于交换数据的临时空间，如何完成字符串的逆序。

C语言的函数头为：void change(char* str);

不开辟临时空间交换值可以使用异或操作或者加法来实现，可以参考《3种交换值的方法》

Golang实现

5. 一个学生的信息包括：姓名，学号，性别，年龄等信息，用一个链表保存所有学生的信息，给出一个age，在链表中删除学生年龄等于age的学生信息。

typedef struct student {
    char name`[20]`;
    char sex;
    int no;
    int age;
    student* next;
};

###卷六

4. 在字符串中找出第一个只出现一次的字符，如输入”abaccdeff”，则输出’b’。

5. 设计一个算法，把一个含有N个元素的数组循环右移K位，要求时间复杂度为O(N)，空间复杂度为O(1)。

触控科技2014校园招聘笔试题

2013-10-15T00:00:00+00:00

1. 实现运行时多态的机制是（B）

A. 重载函数 // 编译时多态
B. 虚函数 // 运行时多态
C. 静态函数
D. 模板函数

2. fun()函数是一个类的常成员函数，它无返回值，下列表示中，正确的是（A）

A. void fun() const;
B. const void fun();
C. void const fun();
D. void fun(const);

3. 下列说明中 const char* ptr，ptr应该是（A）

A. 指向字符常量的指针
B. 指向字符的常量指针
C. 指向字符串常量的指针 char *p="hello";
D. 指向字符串的常量指针 const char *p="hello";

Bjarne在他的The C++ Programming Language里面给出过一个助记的方法：把一个声明从右向左读。

char  * const cp; ( * 读成 pointer to ) 
cp is a const pointer to char --->cp是一个指向字符char的固定指针
const char * ptr; 
ptr is a pointer to const char; --->ptr是一个指向固定字符char的指针

4. 这段代码执行后，哪项描述是正确的（A）

int a = 5, b = 7, c; c = a+++b;

A. a = 6, b = 7, c = 12
B. a = 5, b = 8, c = 12
C. a = 5, b = 8, c = 13
D. 这段代码不合法

就近原则，先执行a++。a++的话，是先赋值后做加法。

5. 字符串：`”\\0211\”xab”` 的长度为（B）

A. 7
B. 9
C. 10
D. 11

6. expr的值为（3）

int a = 8, b = 4;
int expr = a++ % ++b;

7. expr的值为（8）

int expr = (1 % 3) + (5 | 3);

8. expr的值为（22）

char a[6][8];
int expr = a[2] - &a[4][6];

9. 请简述C++中overload(重载)和override(覆盖)的区别？

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。（1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。
Override(覆盖)：是指派生类函数覆盖基类函数，特征是：（1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。

10. 请简述C++中的4种类型转换方式？

static_cast 静态的_cast
dynamic_cast 动态的_cast
reinterpret_cast 重新解释的_cast
const_cast 常量的_cast

11. 写出几种在不用第三方参数的情况下，交换两个参数的值的方法。

交换值是比较常用的步骤，也比较简单，这里总结了3个方法:

使用临时变量交换。方法很简单，使用临时变量来保存一个值，该值被保存后就可以对其进行赋值操作了;

// 通过临时变量交换值
void swap_temp(int *a, int *b) {    // a = 1, b = 3
    int temp = *a;                  // temp = 1
    *a = *b;                        // a = 3
    *b = temp;                      // b = 1
}

使用异或操作(可参考《位运算符》)。具体原理是：对于任何数,都有A^0=A A^A=0;

// 通过位运算交换值
void swap_bit(int *a, int *b) {     // a = 1, b = 3
    *a = *a ^ *b;                   // a = a ^ b
    *b = *b ^ *a;                   // b = b ^ a = b ^ (a ^ b) = a = 1
    *a = *a ^ *b;                   // a = a ^ b = (a ^ b) ^ a = b = 3
}

使用加法和减法也可以实现数字的交换，原理同第二条异或原理基本一致;

void swap_add_substract(int *a, int *b) {   // a = 1, b = 3
    *a = *a + *b;                           // a = a + b
    *b = *a - *b;                           // b = a - b = (a + b) - b = a = 1
    *a = *a - *b;                           // a = a - b = (a + b) - a = b = 3
}

虽然使用异或操作和加减法运算并没有去声明临时变量，但实际运行过程中，会在临时寄存器中保存临时变量用于计算，所以都是将一个数值保存在了一个临时的场所，只是位置不同而已。

12. 假设我们用16位bit来存储RGB像素数据，存储格式定义为RRRRRGGGGGBBBBBB，接下来，我们为了加入透明色，重新定义格式为AAAARRRRGGGGBBBB，头4个bit用来存储alpha值，请写出实现函数。

short convertRGB2ARGB(short RGB, char alpha) {
	short ARGB = 0;
	short A = alpha & 15;
	short R = (RGB >> 11) & 31;
	short G = (RGB >> 6) & 31;
	short B = RGB & 63;
	ARGB = (A << 12) + (R << 8) + (G << 4) + B;
	return ARGB;
}

13. 翻译(略)。

百度2014校园招聘后台开发笔试

2013-10-13T00:00:00+00:00

###一、简答题

1. 请描述下osi七层模型（开放式系统护栏参考模型）。

2. 请列举下不同进程之间共享数据的方式（至少三种）？

3. 请描述下TCP和UDP的差别，并且各列举一个上层协议？

4. （大数据）列举出至少3中常用的衡量分类特征区分度的计算策略

###二、算法与程序设计题

1. 给出一个数据A=`[a_0, a_1, a_2, ……, a_n]`（其中，n可变）打印出该数值元素的所有组合。

2. 有这样一个数组A，大小为n，相邻元素差的绝对值都是1，如：A=`[4,5,6,5,6,7,8,9,10,9]`。现在，给定A和目标数t，请找到t在A中的位置。

3. 有一颗二叉树，定义树的高度为从根到叶子节点的最长距离，树的宽度为每层结点的最大值，树的面积定义为高度与宽度的乘积。写一个函数计算一个二叉树的面积。

###三、系统设计题

1. （大数据）假设在一个k维空间中，我们有两个向量u和v，其中u

阿里巴巴2014校园招聘面经

2013-09-16T00:00:00+00:00

上周六去中科院参加阿里的笔试，结果阿里那边出了意外，没有打印出题目来。他们应急是去筛选简历，通过的今天直接面试，剩下的下周日笔试。

昨天下午参加July的讲座的时候就接到了电话，跟我约今天来面试。很不巧，今天还是我新实习第一天入职的日子，果断不去入职了。更不巧的是，今天4号线信号故障，等了20分钟都没一辆车，还是坐公交去海淀黄庄倒的10号线。这样明显绕了。等到了大望路的阿里，时间也就刚刚好。

昨天预约面试方向时，我选了Java。一个是因为我最近一直在做Java，这个实习也是面的这个方向的，还有就是C++略难，我怕hold不住。今天去了阿里，发现投Java还是有点取巧的，大家都是投的C++。我因为去的比较晚，阿里是按签到次序叫人的，简历排在后面。但是还是很快的叫到了我，而且据我观察，HR那里Java分类的简历好像都快面完了。
比较好的说一说面试的经过。面试是一对一的，一个阿里的人出来叫人，你跟着进去就可以了。面试我的人很nice，说话很亲切，还一直跟我握手，貌似搞技术的公司的员工都这样，不像那些国企那些，那么有距离感。不过面起来还是很认真的。

先问我学得比较好的一门课，这也是比较常见的开头。我说是数据结构和操作系统。然后叫我讲一个比较印象深刻的自己写过的算法。这个问得我很意外，因为最近除了做了做项目，就是准备了一下面试题，之前些的算法好久不碰，都生疏了。我说我好久没做那些了，有点忘记了，然后就开始扯别的，我扯了一大段自我介绍，然后扯我简历上的项目，因为这个是我准备叫他问我的。
他貌似对我最近做那几个项目兴趣不大，转而开始问我本科毕设怎么做的，让我给他讲具体原理。我本科做的人脸检测，算法还是写过的，多少能扯点。不过没想到他问那么仔细，具体到特征值怎么算都开始问了，我说我也忘记了。
接着他让我说一下我自己的优势，特长。还让我说一个我周围我觉得比较欣赏的人，叫我说一下他那里值得欣赏。其实就是拐着弯让我自我评价一下自己。
他还问我看到Java源代码没有，对Java哪个包比较熟悉。我之前准备了一些Sprindg的面试题，我就想说我知道Spring的一些实现原理，比如利用反射啥的，我自己也用Servlet模拟过Spring的Ioc开发。因为这些我准备过，而且最近我也一直看这些，比较了解，想把他往这边引，结果他不听使唤。。。
后来我往Linux下扯，我说我熟悉Linux下开发，这次他终于为我所动，问我vi一些命令，问我vi下替换字符串的命令，用正则表达式替换的命令是什么，尼玛好久不用，忘记了，唉。
最后他问我你自己是未来想做Java还是C++方向，我当时扯了一大通，说两个都可以。结果出来我就后悔了，其实他是想变着法问你你举得自己Java和C++那个学得好，我自己答都不行。。。这招太狠了，我太嫩了，当时没反映过来。

本来准备先面一些小公司，积累点经验，再去面自己想去的公司的。结果才试了一家，阿里就来面试了。而且我觉得我的水平确实不够阿里的层次。虽然我开发经验比较多一些，但是他们更关注你对底层实现的理解，说来惭愧，一直在做东西，没有时间关注这些。这次面试，就我本人而言，没有任何亮点，没有说出来一个让人觉得还可以的东西，所以没戏。

回来的路上，看到1号线上的一个广告词：我想要怒放的生命。路一直都在，继续努力吧。

2013年9月16日于寝室回来的路上，看到1号线上的一个广告词：我想要怒放的生命。路一直都在，继续努力吧。

2013年9月16日于寝室

神州航天软件发展规划部实习笔试

2013-09-09T00:00:00+00:00

1. 修改bug之后的测试

回归测试（验证修改是否破坏了现有的功能，测试验证修改工作本身）
Beta测试可称为确认测试，在一个真实的环境中以实际的数据来运行测试，以确认性能，系统运行有效率，系统撤消与备份作业正常，通过测试让信息系统日后可以更趋完善。

2. jsp用于输出的内置对象

out 输出流
request 由WEB浏览器或其它客户端生成地HTTP请求的细节
response 此对象封装了返回到HTTP客户端的输出
session 跟踪对话

3. 快速排序

4. 广度优先排序

5. 设有图书管理数据库：

图书(总编号C(6),分类号C(8),书名C(16),作者C(6),出版单位C(20),单价N(6,2)) 读者(借书证号C(4),单位C(8),姓名C(6),性别C(2),职称C(6),地址C(20)) 借阅(借书证号C(4),总编号C(6),借书日期D(8))

a. 对于图书管理数据库，检索藏书中比高等教育出版社的所有图书的书价更高的书。

SELECT * FROM 图书 WHERE 单价>ALL(SELECT 单价 FROM 图书 WHERE 出版单位="高等教育出版社");

b. 对于图书管理数据库，分别求出各个单位当前借阅图书的读者人次。

SELECT 单位,COUNT(借阅.借书证号) FROM 借阅,读者 WHERE 借阅.借书证号=读者.借书证号 GROUP BY 单位;

c. 对于图书管理数据库，检索所有借阅了图书的读者姓名和所在单位。

    SELECT DISTINCT 姓名,单位 FROM 读者,借阅 WHERE 读者.借书证号=借阅.借书证号;

d. 对于图书管理数据库，求电子工业出版社出版图书的最高单价、最低单价和平均单价。

SELECT MAX(单价),MIN(单价),AVG(单价)FROM 图书 WHERE 出版单位="电子工业出版社";

e. 对于图书管理数据库，求CIE单位借阅图书的读者的人数。

SELECT COUNT (DISTINCT 借书证号) FROM 借阅 WHERE 借书证号 IN (SELECT 借书证号 FROM 读者 WHERE 单位="CIE");

f. 重名的人。

select 姓名, count(*) from 读者 group by 姓名having count(*) > 1;

阿里巴巴2013年实习生笔试题

2013-05-23T00:00:00+00:00

一、单项选择题

1.下列说法错误的是：

A.SATA硬盘的速度大约为500Mbps/s

B.读取18XDVD光盘数据的速度为1Gbps

C.千兆以太网的数据读取速度为1Gpbs

D.读取DDR3内存数据的速度为100Gbps

2.（）不能用于Linux中的进程通信

A.共享内存

B.命名管道

C.信号量

D.临界区

3.设在内存中有P1,P2,P3三道程序，并按照P1,P2,P3的优先级次序运行，其中内部计算和IO操作时间由下表给出（CPU计算和IO资源都只能同时由一个程序占用）：

P1:计算60ms—》IO 80ms—》计算20ms

P2:计算120ms—》IO 40ms—》计算40ms

P3:计算40ms—》IO 80ms—》计算40ms

完成三道程序比单道运行节省的时间是（）

A.80ms

B.120ms

C.160ms

D.200ms

4.两个等价线程并发的执行下列程序，a为全局变量，初始为0，假设printf、++、–操作都是原子性的，则输出不可能是（）

void foo() {
    if(a &lt;= 0) {
        a++;
    }
    else{
        a--;
    }
    printf("%d", a);
}

A.01

B.10

C.12

D.22

5.给定fun函数如下，那么fun(10)的输出结果是（）

int fun(intx)
{
    return(x==1)? 1 : (x + fun(x-1));
}

A.0

B.10

C.55

D.3628800

6.在c++程序中，如果一个整型变量频繁使用，最好将他定义为（）

A.auto

B.extern

C.static

D.register

7.长为n的字符串中匹配长度为m的子串的复杂度为（）

A.O(N)

B.O(M+N)

C.O(N+logM)

D.O(M+logN)

8.判断一包含n个整数a[]中是否存在i、j、k满足a[i] + a[j] = a[k]的时间复杂度最小值是（）

A.O(n^2) B. O(n^2*logn) C. O(n^3) D. O(nlogn)

9.下列序排算法中最坏情况下的时间复杂度不是n(n-1)/2的是

A.快速排序 B.冒泡排序 C.直接插入排序 D.堆排序

10.发射三次炮弹，射中目标的概率是0.95，请问发射一次能击中目标的概率是多少？

A.0.63

B.0.50

C.0.32

D.0.86

二、不定向选择题

1.进程状态转换，下列转换会发生的有（） A就绪运行 B运行就绪 C运行阻塞 D阻塞运行

2.一个栈的入栈数列为：1、2、3、4、5、6；下列哪个是可能的出栈顺序。

A 123465 B 154623 C 312546 D 325641

3.下列哪些代码可以使得a和b交换数值

A b=a+b; a=a+b; b=b-a; B a=a|b; b=b+a; a=b-a; C a=a-b; b=a+b; a=b-a; D a=a+b;b=a-b;a=b|a;

4.两人数星星，每回数k个（20<=k<=30），设定数完最后一批的人获胜。当A先数，则星星总数为多少时，A才胜出 A 2013 B 2888 C 3935 D 4026 E 25051

三、填空问答题

1.给你一个整型数组A[N]，完成一个小程序代码（20行之内），使得A[N]逆向，即原数组为1，2，3，4，逆向之后为4，3，2，1

	void revense(int * a,int n) {
        int begin = 0, end = n-1;
        int tmp;
        while(begin &lt; end)
        {
                tmp = a[begin];
                a[begin] = a[end];
                a[end] = tmp;
                ++begin;
                --end;
	}

2.自选调度方面的问题，题目很长，就是给你三个线程，分别采用先来先分配的策略和最短执行之间的调度策略，然后计算每个线程从提交到执行完成的时间。题目实在太长，还有几个表格。考察的是操作系统里面作业调度算法先进先出和最短作业优先。

3.有个苦逼的上班族，他每天忘记定闹钟的概率为0.2，上班堵车的概率为0.5，如果他既没定闹钟上班又堵车那他迟到的概率为1.0，如果他定了闹钟但是上班堵车那他迟到的概率为0.9，如果他没定闹钟但是上班不堵车他迟到的概率为0.8，如果他既定了闹钟上班又不堵车那他迟到的概率为0.0，那么求出他在60天里上班迟到的期望。

4.战报交流：战场上不同的位置有N个战士（n>4），每个战士知道当前的一些战况，现在需要这n个战士通过通话交流，互相传达自己知道的战况信息，每次通话，可以让通话的双方知道对方的所有情报，设计算法，使用最少的通话次数，是的战场上的n个士兵知道所有的战况信息，不需要写程序代码，得出最少的通话次数。

5.有N个人，其中一个明星和n-1个群众，群众都认识明星，明星不认识任何群众，群众和群众之间的认识关系不知道，现在如果你是机器人R2T2，你每次问一个人是否认识另外一个人的代价为O(1)，试设计一种算法找出明星，并给出时间复杂度（没有复杂度不得分）。）

四、综合题

有一个淘宝商户，在某城市有n个仓库，每个仓库的储货量不同，现在要通过货物运输，将每次仓库的储货量变成一致的，n个仓库之间的运输线路围城一个圈，即1->2->3->4->…->n->1->…，货物只能通过连接的仓库运输，设计最小的运送成本（运货量*路程）达到淘宝商户的要求，并写出代码。

微软2012年实习生笔试题

2013-04-20T00:00:00+00:00

1.Suppose that a selection sort of 80 items has completed 32 iterations of the main loop. How many items are now guaranteed to be in their final spot (never to be moved again)? （C）

A、16 B、31 C、32 D、39 E、40

80个元素进行选择排序，进行了32次循环，问有哪些元素已经在最终位置上了。考察选择排序基本原理。每一趟遍历都会从剩余待排元素中选择一个最大(小)的元素放在最终位置上，所以进行32次循环就是有32个元素在最终位置上了，选C。

2.Which synchronization mechanism(s) is/are used to avoid race conditions among processes/threads in operating system?(AC)

A、Mutex B、Mailbox C、Semaphore D、Local procedure call

Mutex,(Mutual exclusion, 互斥锁)，可以通过互斥的方式来保护临界资源。有硬件和软件两种实现方式；
Semaphore，信号量，用户多线程同步。值为2的信号量就是互斥锁；
Local procedure call，本地过程调用。

3.There is a sequence of n numbers 1,2,3,…,n and a stack which can keep m numbers at most. Push the n numbers into the stack following the sequence and pop out randomly . Suppose n is 2 and m is 3,the output sequence may be 1,2 or 2,1,so we get 2 different sequences . Suppose n is 7,and m is 5,please choose the output sequence of the stack. (AC)

A、1,2,3,4,5,6,7
B、7,6,5,4,3,2,1
C、5,6,4,3,7,2,1
D、1,7,6,5,4,3,2
E、3,2,1,7,5,6,4

有一个大小为5的栈，有1～7的5个数，随机的进出栈，判断出栈结果。常见的数据结构栈的题目。

如果每push进去一个数字，立刻pop出来，结果就是A，此时需要栈空间最小为1；
B中第一个pop出来的是7，说明是将这7个数字都push进栈之后才pop，需要栈空间最小为7；
C中第一个pop出来的是5，说明栈中之前有5个元素(1,2,3,4,5)，pop之后，还剩4个(1,2,3,4)。然后push进6，pop出4和3，push 7，pop2和1，此过程中，需要最小的栈空间为5；
D中push 1之后立刻pop，之后pop出来的是7，说明pop 7之前栈中有6个元素，需要最小的栈空间是6；
E中首先pop 3，2，1，此时栈为空，然后将4，5，6，7依次push进栈。此时战中是(4,5,6,7)，pop的话结果只有一种，就是7,6,5,4，此选项的出栈序列是错误的。

4.Which is the result of binary number 01011001 after multiplying by 0111001 and adding 1101110? (A)

A、0001010000111111
B、0101011101110011
C、0011010000110101

如果数字二进制乘法和加法的话可以考虑计算一下，这里是将二进制数字转换成十进制后计算再转成二进制。

题目要计算01011001(89)0111001(57)+1101110(110)，得到5183，转换为二进制为0001010000111111。*

5.What is output if you compile and execute the following c code?(C)

int main() 
{ 
    int i = 11; 
    int const * p = &i; 
    p++; 
    printf("%d", *p); 
    return 0; 
}

此处，第4行声明了指向常量的指针，说明指针p所指向的int类型的变量i不可以更改。接着，第五行执行p++，p指向了后四个字节的内存，由于该内存并没有进行初始化操作，所以此时p的值不确定，为Garbage value，选C。

A、11 B、12 C、Garbage value D、Compile error E、None of above

6.Which of following C++ code is correct ?(C) A.

int f() 
{ 
    int *a = new int(3); 
    return *a; 
} B.

int *f() 
{ 
    int a[3] = {1,2,3}; 
    return a; 
} C.

vector<int> f() 
{ 
    vector<int> v(3); 
    return v; 
} D.

void f(int *ret) 
{ 
    int a[3] = {1,2,3}; 
    ret = a; 
    return ; 
} E. None of above

(A)选项，会动态分配一个指向int类型，值为3的指针，但是这样并不会释放内存，导致内存泄漏；
(B)a[3]是局部变量，会分配在栈中，函数返回后就会释放。这样编译的过程中会有警告；
(C)STL中的ector是动态分配到堆中的，正确；
(D)ret只是赋给了指针a的值，而指针a保存的是指向局部变量的地址，错误同(B)。

7.Given that the 180-degree rotated image of a 5-digit number is another 5-digit number and the difference between the numbers is 78633, what is the original 5-digit number？(D)

A、60918 B、91086 C、18609 D、10968 E、86901

算是一道智力题。五位数旋转180度得到另一个五位数，两个数的差是78633。问原来的那个五位数是多少。10968旋转后是89601，差正好是78633。

8.Which of the following statements are true?(ACD)

A、We can create a binary tree from given inorder and preorder traversal sequences. B、We can create a binary tree from given preorder and postorder traversal sequences. C、For an almost sorted array,Insertion sort can be more effective than Quciksort. D、Suppose T(n) is the runtime of resolving a problem with n elements, T(n)=O(1) if n=1 T(n)=2*T(n/2)+O(n) if n>1; so T(n) is O(nlgn) E、None of above

根据前序和后序序列无法唯一确定一颗二叉树，例如前序为abc，后序为cba，就会有两种结果；必须要有中序遍历；
前序和中序，或者后序和中序，可以确定根结点位置，从而得到二叉树；
对于基本有序的序列，插入排序比快速排序有效。快速排序适于基本无序的情况；
- T(1)=1;T(2)=2T(2)+2=4=22;T(4)=2T(2)+4=12=43=N(k+1)=2^{k}times (k+1);T(N)=Ntimes (log_2 N+1).*

9.Which of the following statements are true?(ABD)

A、Insertion sort and bubble sort are not efficient for large data sets. B、Qucik sort makes O(n^2) comparisons in the worst case. C、There is an array :7,6,5,4,3,2,1. If using selection sort (ascending),the number of swap operations is 6 D、Heap sort uses two heap operations:insertion and root deletion （插入、堆调整） E、None of above

插入排序和冒泡排序时间复杂度都是o(n^{2})，对于大数据集效率很低；
快序排序最差情况，就是序列是倒序的时候，此时快速排序会退化成成冒泡排序，复杂度变为o(n^{2});
7,6,5,4,3,2,1，使用选择排序，首先选到最小的1，与队列头7交换，变成1,6,5,4,3,2,7。然后选到2，与队列头6交换，变成1,2,5,4,3,6,7，选择到3，与队列头5交换，得到1,2,3,4,5,6,7，只交换了3次；
堆排序两个操作是建堆和堆调整。

10.Assume both x and y are integers, which one of the following returns the minimun of the two integers?(A)

A、 y^((x^y) & -(x<y)) B、 y^(x^y) C、 x^(x^y) D、 (x^y)^(y^x) E、 None of the above

据异或操作的自反性，(B)的结果是x，(C)的结果是y，(D)的结果是0。下面来看(A)，如果x<y，(x<y)结果是1，而-1的补码是11111111，所以原式变为：

y^((x^y) & 11111111)

结果是x；如果x>y，(x<y)结果是0，而0的补码是00000000，所以原式化简为

y^((x^y) & 00000000)

结果是y，(A)正确。

11.The Orchid Pavilion(兰亭集序) is well known as the top of “行书”in history of Chinese literature. The most fascinating sentence is “Well I know it is a lie to say that life and death is the same thing, and that longevity and early death make no difference Alas!”(固知一死生为虚诞，齐彭殇为妄作).By counting the characters of the whole content (in Chinese version),the result should be 391(including punctuation). For these characters written to a text file,please select the possible file size without any data corrupt.（ABCD）

A、782 bytes in UTF-16 encoding B、784 bytes in UTF-16 encoding C、1173 bytes in UTF-8 encoding D、1176 bytes in UTF-8 encoding E、None of above

关于编码，最早是ACSII，里面之后256个字符。这只能满足英文编码。我国发展出了GBK、Big5等中文编码，但是问题是，每个国家都定义了自己国家语言的编码，用不同的方式可以解出不同的文字。后来为了统一，出现了Unicode。Unicode的实现有几种方式。常见的就是UTF8、UTF16。UTF8以8位为单位，可以有1字节、2字节、3字节、4字节四种长度。而中文在UTF8编码当中是占3个字节。UTF16是以16位作为单位长度，有2字节和4字节两种。中文在UTF16当中占两个字节。Unicode也可以指是UTF16编码。

Unicode有多种实现方式，所以需要在开头定义出所用的编码形式：

	UTF编码		Byte Order Mark
	UTF-8		EF BB BF
	UTF-16LE		FF FE
	UTF-16BE		FE FF
	UTF-32LE		FF FE 00 00
	UTF-32BE		00 00 FE FF

UTF8的Bom头占3个字节，UTF16的Bom头占2个字节。而Bom头并未规定是必须加的，也可以不加。

下面看这道题，391个字，UTF8将会占1173个字节，加上Bom头占1176个字节。UTF16是782个字节，加上Bom头是784个字节。

12.Fill the blanks inside class definition

class Test 
{ 
public: 
    ____ int a; 
    ____ int b; 
    public: 
    Test::Test(int _a , int _b) : a( _a ) 
    { 
        b = _b; 
    } 
}; 
int Test::b; 

int main(void) 
{ 
    Test t1(0 , 0) , t2(1 , 1); 
    t1.b = 10; 
    t2.b = 20; 
    printf("%u %u %u %u",t1.a , t1.b , t2.a , t2.b); 
    return 0; 
}

Running result : 0 20 1 20

(C)

A、static/const B、const/static C、–/static D、conststatic/static E、None of above

在17、18行，分别修改了对象t1和t2的成员变量b，输出之后，值一样，同为20，说明b为静态变量，可以被所有对象共享，所以b是static静态变量；变量a的值是通过Test类的构造函数的参数表进行初始化的，所以此处可以是空或者是const(const对象可以使用参数表进行初始化)。

13.A 3-order B-tree has 2047 key words,what is the maximum height of the tree?

A、11 B、12 C、13 D、14

14.In C++,which of the following keyword(s) can be used on both a variable and a function?(ACE)

A、static B、virtual C、extern D、inline E、const

static关键字，可以用来声明静态变量或者静态函数。static声明后在全局中唯一存在；
virtual关键字，C++语法，用来声明虚函数。虚函数声明之后，可以在派生类中实现。这与Java中的接口定义类似，可以帮助实现多态；
extern关键字。对于一个全局变量，它既可以在本源文件中被访问到，也可以在同一个工程的其它源文件中被访问，只需用extern进行声明即可。在C语言中，修饰符extern用在变量或者函数的声明前，用来说明此变量/函数是在别处定义的，要在此处引用。在C++中extern还有另外一种作用，用于指示C或者C＋＋函数的调用规范。比如在C++中调用C库函数，就需要在C++程序中用extern “C”声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C＋＋和C程序编译完成后在目标代码中命名规则不同，用此来解决名字匹配的问题；
inline关键字，用来指示内联函数。每一次调用函数，都会使用到内存中的栈，用来保存此函数的地址、参数表、返回值等信息。如果此函数频繁被使用并且函数逻辑简单，就可以使用inline关键字。在C语言中，#define的作用类似于inline关键字。
const关键字，可以用来声明常量，常函数void Func(int a) const。

15.What is the result of the following program?(D)

char* f(char* str, char ch) 
{ 
    char* it1 = str; 
    char* it2 = str; 
    while(*it2 != '\0') 
    { 
        while(*it2 == ch) 
        { 
            it2++; 
        } 
        *it1++ = *it2++; 
    } 
    return str; 
} 
 
int main(int argc, char* argv[]) 
{ 
    char* a = new char[10]; 
    strcpy(a, "abcdcccd"); 
    cout<<f(a, 'c'); 
    return 0;
}

A、abdcccd B、abdd C、abcc D、abddcccd E、Access violation

简单考察了C-style string概念的理解。首先将常量字符串”abcdcccd”赋值给变量a，然后调用函数f。while(it2 != ‘’)用来遍历整个字符串。内存循环*

while(*it2 == ch)  
{  
      it2++;  
}

用来将指定字符去除，这里是要将字符’c’去除，所以去除之后是”abdd”。然而，虽然去除了指定字符，但是并没有在该字符串末尾追加’’，所以”abdd”并不是最终结果，当输出的时候，结果是输出到\n为止，所以输出完”abdd”后还会继续输出。所以原字符串的cccd也会输出。

16.Consider the following definition of a recursive function,power,that will perform exponentiation.

int power(int b , int e) 
{ 
    if(e == 0) 
        return 1; 
    if(e % 2 == 0) 
        return power(b*b , e/2); 
    else 
        return b * power(b*b , e/2); 
}

Asymptotically（渐进地） in terms of the exponent e,the number of calls to power that occur as a result of the call power(b,e) is

A、logarithmic B、linear C、quadratic D、exponential

17.Assume a full deck of cards has 52 cards,2 blacks suits (spade and club) and 2 red suits(diamond and heart). If you are given a full deck,and a half deck(with 1 red suit and 1 black suit),what is the possibility for each one getting 2 red cards if taking 2 cards?(B)

A、1/2 1/2 B、25/102 12/50 C、50/51 24/25 D、25/51 12/25 E、25/51 1/2

一副扑克牌共52张，其中红色花色(红桃、方片)各13张，黑色花色(梅花、黑桃)各13张。现在有一副全套扑克牌，还有一套半套的扑克牌(有13张黑牌和13张红牌)，从这两副牌中抽取不放回两张牌，两次都是红色花色的概率。

第一副全套牌，从54张牌中抽取1张红色的概率是frac{26}{52}，此时还剩51张牌，红色还剩25张，再抽出一张红色的概率是frac{25}{51}，两次都是红色的概率是frac{26}{52}frac{25}{51}=frac{25}{102}；*
第二副牌，计算方法相同，从26张牌中抽取一张红色牌概率是frac{13}{26}，从剩余25张牌中抽取12张红色中的一张的概率是frac{12}{25}，两次都是红色的概率是frac{13}{26}frac{12}{25}=frac{6}{25}。选B。*

18.There is a stack and a sequence of n numbers(i.e. 1,2,3,…,n), Push the n numbers into the stack following the sequence and pop out randomly . How many different sequences of the n numbers we may get? Suppose n is 2 , the output sequence may 1,2 or 2,1, so wo get 2 different sequences .

A、C_2n^n B、C_2n^n - C_2n^(n+1) C、((2n)!)/(n+1)n!n! D、n! E、None of above

19.Longest Increasing Subsequence(LIS) means a sequence containing some elements in another sequence by the same order, and the values of elements keeps increasing. For example, LIS of {2,1,4,2,3,7,4,6} is {1,2,3,4,6}, and its LIS length is 5. Considering an array with N elements , what is the lowest time and space complexity to get the length of LIS？

A、Time : N^2 , Space : N^2 B、Time : N^2 , Space : N C、Time : NlogN , Space : N D、Time : N , Space : N E、Time : N , Space : C

20.What is the output of the following piece of C++ code ？

#include<iostream> 
using namespace std; 

struct Item 
{ 
    char c; 
    Item *next; 
}; 

Item *Routine1(Item *x) 
{ 
    Item *prev = NULL, 
    *curr = x; 
    while(curr) 
    { 
        Item *next = curr->next; 
        curr->next = prev; 
        prev = curr; 
        curr = next; 
    } 
    return prev; 
} 

void Routine2(Item *x) 
{ 
    Item *curr = x; 
    while(curr) 
    { 
        cout<<curr->c<<" "; 
        curr = curr->next; 
    } 
} 

int main(void) 
{ 
    Item *x, 
    d = {'d' , NULL}, 
    c = {'c' , &d}, 
    b = {'b' , &c}, 
    a = {'a' , &b}; 
    x = Routine1( &a ); 
    Routine2( x ); 
    return 0; 
}

A、 c b a d B、 b a d c C、 d b c a D、 a b c d E、 d c b a

快速排序(QUICK SORT)

2013-04-17T00:00:00+00:00

冒泡排序是通过遍历整个链表，进行两两比较、交换操作的排序方法。然而，该方法在每一趟遍历过程中，只是简单的在两个相邻的元素中操作，如果能对每一次的比较结果进行利用，有可能提高排序效率。

快速排序就是这样的一种排序方法。同样是利用比较交换的思想，只是每次比较的元素选取不同：冒泡排序是通过比较相邻的两个元素，而快速排序是列表中元素与枢轴(Pivot)进行比较，大的元素交换到枢轴后面，小的元素交换到枢轴前面。这样就利用到了每一次的比较结果。

如果一个队列中只有三个元素，分别是2、3、1，如果以2为枢轴，3比2大，1比2小，那么只需要将最小的1放在枢轴2的位置上，最大的3放到最小的1的位置上，2放在最大的3的位置上。

快速排序一般步骤：

选取枢轴，一般选取队列的第一个元素作为枢轴pivotkey；
分别从队列的首和尾进行遍历。从首部找到第一个大于枢轴的元素为止，位置记为i，从尾部找到第一个小于枢轴的元素为止，位置记为j；
交换操作是这三个元素进行交换。和前面提到的三个元素交换方法相类似，最小的元素j放在枢轴pivotkey上，最大的元素i放在最小的元素j的位置上，枢轴pivotkey放在最大的位置i上；
从两端想中间遍历，一趟遍历直到交汇为止，即i==j；
每一趟结束后，都会将当前队列分割成两个子队列，对两个子队列分别进行1～4步操作。直到子队列大小为1时，排序结束。

快速排序特性：

快速排序每一趟排序结束，都会有一个元素(即枢轴Pivot)在最终位置上，其前面的元素都比它小，后面的元素都比它大；
一趟排序结束，会产生两个子队列，分别对这两个子队列进行排序。这是分治的思想，分而治之；
如果待排序队列基本有序，例如正序或者逆序，此时枢轴为队列中最大(小)的值，所以从两个开始遍历的操作只能找到一个队列中最小(大)的值来进行交换，此时快速排序变退化成了冒泡排序。例如队列1、2、3和2、3、1，前者虽然不需要交换操作，但是需要两趟遍历，第一趟确定1的位置，第二趟确实2和3的位置，后者只需要一次交换操作就可以完成排序；
排序的效率和初始化队列排序情况与枢轴的选取有关。枢轴越接近队列的中间值越好，队列越混乱越好；
快速排序通过使用分治的思想，减少了排序趟数，冒泡排序数量级是O(n)，而快速排序数量级是O(log_{2} n)，所以时间复杂度是O(nlog_{} n)；
排序的过程中只是交换的时候需要申请临时空间，空间复杂度是O(1)；
快速排序不稳定。

快速排序实例：

{49, 38, 65, 97, 76, 13, 27, 49} 初始序列；
{27, 38, , 97, 76, 13, 65, 49} 将49作为枢轴，并将其保存在临时空间内，从38开始遍历，找到第一个大于49的元素65，然后从49开始遍历，找到第一个小于49的元素27。将这3个元素进行交换，枢轴的位置存放最小的元素27，最小元素13的位置存放最大元素65，最大元素位置存放枢轴49。继续遍历，找到最小元素13，最大元素97。一趟排序结束；
{27, 38, 13}, 49, {76, 97, 65, 49} 一趟排序结果；
{13}, 27, {38}, 49, {49, 65}, 76, {97} 对两个子序列分别进行快速排序；
13, 27, 38, 49, 49, 65, 76, 97 最终结果。

冒泡排序(BUBBLE SORT)

2013-04-16T00:00:00+00:00

如果一个队列只有两个元素且为逆序，只要将这两个元素交换即可。冒泡排序就是一种基于“交换”思想的排序方法，每次比较两个元素，如果为逆序，就将其交换。而这两个元素的选取，就是遍历整个队列来得到。

冒泡排序一般步骤：

第一趟冒泡。遍历整个队列，将当前元素和身后的元素进行比较，逆序的进行交换。这样会进行(n-1)次；
然后再进行遍历冒泡，直到该趟遍历过程中没有发生交换操作为止，此时队列已为正序。

冒泡排序特性：

冒泡的过程中，每一次交换都是大元素向下移动，小元素向上移动，所以整个一趟排序的趋势就是大元素向下移动，小元素想上移动。因为在每一次交换的过程中，大元素都会被交换到下方，所以，一趟排序结束之后，都会有一个当前队列中最大的元素被交换到了队列最后，到达最终位置。
如果该队列为逆序，那就需要遍历(n-1)趟，一共sum_{i=n}^{2}(i-1)比较；如果为正序，那么只需要遍历一趟，进行(n-1)比较即可。平均时间复杂度是O(n^{2})；
该排序方法是就地排序，只是在交换的过程中需要申请一个临时变量，一个变量来记录当前遍历是否发生过交换操作，所以空间复杂度是O(1)；
冒泡排序基于交换的思想，所以可以保证两个相同的元素不会被交换，该算法是稳定的。

冒牌排序实例：

初始序列：{49, 38, 65, 97, 76, 13, 27, 49}
{38, 49, 65, 97, 76, 13, 27, 49} 元素49和38进行比较，逆序，交换；
{38, 49, 65, 76, 97, 13, 27, 49} 元素49行业64进行比较，正序，不交换；
{38, 49, 65, 76, 13, 27, 97, 49} 元素65和76进行比较，正序；
{38, 49, 65, 76, 13, 27, 49, 97} 元素76和13进行比较，逆序，交换；
{38, 49, 65, 13, 76, 27, 49, 97} 元素76和27进行比较，逆序，交换；
{38, 49, 65, 13, 27, 76, 49, 97} 元素76和49进行比较，逆序，交换；
{38, 49, 65, 13, 27, 49, 76}, 97 元素76和97进行比较，正序，不交换。一趟遍历结束，97到达最终位置；
{38, 49, 13, 27, 49, 65}, 76, 97 第二趟排序，76到达最终位置；
{38, 13, 27, 49, 49}, 65, 76, 97 第三趟排序结束，选出了65；
{13, 27, 38, 49}, 49, 65, 76, 97 第四趟排序
{13, 27, 38}, 49, 49, 65, 76, 97 第五趟排序
{13, 27}, 38, 49, 49, 65, 76, 97 第六趟排序
13, 27, 38, 49, 49, 65, 76, 97 最终结果

微软2013年夏季实习生笔试题

2013-04-07T00:00:00+00:00

1. Which of the following convension(s) support(s) support variable length parameter (e.g. printf)? (3 Points)

A. cdecl

B. stdcall

C. pascal

D. fastcall

2.What’s the output of the following code? (3 Points)

class A
{
public:
    virtual void f()
    {
        cout << "A::f()" << endl;
    }
    void f() const
    {
        cout << "A::f() const" << endl;
    }
};

class B: public A
{
public:
    void f()
    {
        cout << "B::f()" << endl;
    }
    
    void f() const
    {
        cout << "B::f() const" << endl;
    }
};

void g(const A *a)
{
    a->f();
}

int main()
{
    A *a = new B();
    a->f();
    g(a);
    delete a;
}

A. B::f() B::f() const

B. B::f() A::f() const

C. A::f() B::f() const

D. A::f() A::f() const

3.What is the difference between a linked list and an array? (3 Points)

A. Search complexity when both are sorted

B. Dynamically add/remove

C. Random access efficiency

D. Data storage type

4.About the Thread and Process in Windows, which description(s) is (are) correct? (3 Points)

A. One application in OS must have one Process, but not a necessary to have one Thread

B. Thre process could have its own Stack but the thread only could share the Stack of its parent Process

C. Thread must belong to a Process

D. Thread could change its belonging Process

5.What is the output of the following code? (3 Points)

{
    int x = 10;
    int y = 10;
    x = x++;
    y = ++y;
    
    printf("%d, %d\n", x, y);
}

A. 10, 10

B. 10, 11

C. 11, 10

D. 11, 11

6.For the following Java or C# code (3 Points)

int[][] myArray3 =
    new int[3][] {
        new int[3]{5, 6, 2},
        new int[5]{6, 9, 7, 8, 3},
        new int[2]{3, 2}
    };

What will myArray3[2][2] return?

A. 9

B. 2

C. 6

D. overflow

7.Please choose the right statement about const usage: (3 Points)

A. const int a; // const integer

B. int const a; // const integer

C. int const *a; // a pointer which point to const integer

D. const int *a; // a const pointer which point to integer

E. int const *a; // a const pointer which point to integer

8.Given the following code: (3 Points)

#include <iostream>
class A
{
public:
    long a;
};

class B: public A
{
public:
    long b;
}

void seta(A *data, int idx)
{
    data[idx].a = 2;
}

int _tmain(int argc, _TCHAR *argv[])
{
    B data[4];
    
    for (int i = 0; i < 4; ++i)
    {
        data[i].a = 1;
        data[i].b = 1;
        seta(data, i);
    }
    
    for (int i = 0; i < 4; ++i)
    {
        std::cout << data[i].a << data[i].b;
    }
    
    return 0;
}

What is the correct result?

A. 11111111

B. 12121212

C. 11112222

D. 21212121

9.1 of 1000 bottles of water is poisoned which will kill a rat in 1 week if the rat drunk any amount of the water. Given the bottles of water have no visual difference, how many rates are needed at least to find the poisoned one in 1 week? (5 Points)

A. 9

B. 10

C. 32

D. 999

E. None of the above

***为每瓶水编号，从1～1000，然后转成二进制，从0000000001~1111100111，找十只老鼠，按照二进制位对应得给老鼠喝水。最后查看死掉的老鼠编号，就能对应找到水的二进制编码。

10.Which of following statement(s) eaual(s) value 1 in C programming language? (5 Points)

A. the return value of main function if program ends normally

B. return (7 & 1);

C. char *str = “microsoft”; return str == “microsoft”;

D. return “microsoft” == “microsoft”;

E. None of the above

11.If you computed 32 bit signed integers F and G from 32 bit signed integer X using F = X/2 and G = (X » 1), and if you found F != G, this implies that (5 Points)

A. There’s a compiler error

B. x is odd

C. X is negative

D. F - G = 1

E. G - F = 1

12.How many rectangles you can find from 3 * 4 grid?D (5 Points)

A. 18

B. 20

C. 40

D. 60

E. None of the above is correct

34的网格，内部包含多少个矩形。长度取值有三种情况（1、2、3），宽度取值有四种情况（1、2、3、4），一共是C_{3}^{1}times C_{4}^{1}=12次。按照长宽的不同取值去计算，这样就不会少了。*

11：12个； 12：9个； 13：4个； 21：8个； 22：6个； 23：3个； 31：6个； 32：4个； 33：2个； 41：3个； 42：2个； 43：1个。一共60个。

13.One line can split of a surface to 2 parts, 2 lines can split a surface to 4 parts. Given 100 lines, no two parallel lines, no three lines join at same point, how many parts can 100 lines split? (5 Points)

A. 5051

B. 5053

C. 5510

D. 5511

14.Which of the following sorting algorithm(s) is(are) stabe sorting? (5 Points)

A. bubble sort

B. quicksort

C. heap sort

D. merge sort

E. Selection sort

15.Model-View-Contrller (MVC) is an architectural pattern that is frequently used in web applications. Which of the following statement(s) is(are) correct? (5 Points)

A. Models often represent data and the business logics needed to manipulate the data in the application

B. A View is a (visual) representation of its model. It renders the model into a form suitable for interaction, typically a user interface element

C. A controller is the linke between a user and the system. It accepts input from the user and instructs the model and a view to perform actions based on that input

D. The common practice of MVC in web applications is, the model receives GET or POST input from user and decides what to do with it, handing over to controller and which hand control to views (HTML-generating components)

16.We can recover the binary tree if given the output of (5 Points)

A. Preorder traversal and inorder traversal

B. Preorder traversal and postorder traversal

C. Inorder traversal and postorder traversal

D. Postorder traversal

17.Given a string with n characters, suppose all the characters are different from each other, how many substrings do we have? (5 Points)C

A. n + 1

B. n^2

C. n(n+1)/2

D. 2^n-1

E. n!

首先想到的是，定位一个开头，一个结束位置。开头位置好定义，是n，结束位置要受开头位置影响，因为必须要在它后面。如果定义在最前面，那么结束位置有n-1个选择；如果是第二个，那么是n-2。依次类推，如果开头定位在最后一位，那么结束也只能是最后一位，为1。是一个等差数列相加。

还有一种解法，按照长度计算。如果长为1，有n中情况，长为2，有n-1中情况……长为n，只有一种情况。结果就是1+2+…n=n(n+1)/2

18.Given the following database table, how many rows will the following SQL statement update? (5 Points)

update Books set NumberofCopies = NumberOfCopies + 1 Where AuthorID
in
Select AutorID from Books
group by AuthorID
having sum(NumberOfCopies) <= 8

BookID	Title	Category	NumberOfCopies	AuthorID
1	SQL Server 2008	MS	3	1
2	SharePoint 2007	MS	2	2
3	SharePoint 2010	MS	4	2
5	DB2	IBM	10	3
7	SQL Server 2012	MS	6	1

A. 1

B. 2

C. 3

D. 4

E. 5

19.What is the sortest path between S and node T, given the graph below? Note: the numbers represent the lengths of the connected nodes (13 Points)

20.Given a set of N balls and one of which is defective (weighs less than others), you are allowed to weigh with a balance 3 times to find the defective. Which of the following are possible N? (13 Points)

A. 12

B. 16

C. 20

D. 24

E. 28

堆排序(HEAP SORT)

2013-04-06T00:00:00+00:00

堆排序是简单选择排序的进化版本，也是使用了选择的思想。简单选择排序是每趟进行顺序遍历选择出最大(小)的元素。而堆排序是通过使用数据结构堆进行选择最大(小)的元素。这两个排序算法唯一的区别也只有这个地方。

下面先介绍数据结构堆的定义：

小顶堆 left { frac{k_{i}leqslant k_{2i+1}}{k_{i}leqslant k_{2i+2}}；
大顶堆 left { frac{k_{i}geqslant k_{2i+1}}{k_{i}geqslant k_{2i+2}}；
其中，i=0,1,…,left lfloor frac{n}{2} right rfloor。

堆排序的一般步骤(以小顶堆为例)：

从最后一个非终端结点left lfloor frac{n}{2} right rfloor开始遍历；
对于每一个遍历到的根结点，比较其左右孩子，选择出最小的结点值，与根结点交换值；
为了保证交换后堆的特性，堆子结点与根节点交换时，如果该子结点还有孩子结点，还要向下进行交换建堆；
堆建成后，删除根结点，用最后一个结点n代替(此操作与简单选择排序操作相似)；
继续执行这4步，直到排序完成。

堆的定义类似于完全二叉树，可以理解为完全二叉树所有非终端结点的值不大于(小于)其左、右孩子结点的值。依此规则建堆的话，我们遍历寻找最大(小)结点的步骤就得以简化，堆顶就是我们需要找的值。之前简单选择排序是逐个顺序比较，一趟遍历要执行(n-i+1)次，堆排序是从最后一个非终端结点left lfloor frac{n}{2} right rfloor开始建堆，所以只执行left lfloor frac{n-i+1}{2} right rfloor次。效率增强显而易见。

堆排序使用就地排序，只是删除结点时需要一个临时空间存储变量，其余操作不需要额外的空间，空间复杂度是O(n);
在建堆的比较过程中，从最后一个非空结点开始，所以最多是left lfloor log_{2}n right rfloor+1次，需要执行(n-1)次，所以时间复杂度是Oleft ( nlog n right )；
在建堆交换的过程中，只是子结点和双亲比较，所以不稳定。

堆排序实例(以小顶堆为例)：

初始序列为：{49,38,65,97,76,13,27,49}；
开始建堆，从left lfloor frac{n}{2} right rfloor开始，本例中是第四个结点97，和子结点49比较，子结点较小，进行交换；第三结点65，和子结点13和27进行比较，与较小的13进行交换；第二结点38，与子结点49和76比较，不需要交换；根结点49，与子结点38和13进行比较，与较小的13进行交换。此时第三个结点发生了变动，为了保证堆的特性，还要将该结点与子结点进行比较，使用较小的右子结点27与第三结点49进行交换。{13,38,27,49,76,65,49,97}；
删除根结点13，使用最后一个结点97代替；{97,38,27,49,76,65,49},13；
重复建堆，直到所有结点都已排序完成。下面只附上结果，不再复述重复的步骤；调整堆：{27,38,49,49,76,65,97},13；
删除根结点：{97,38,49,49,76,65},27,13；
调整堆：{38,49,49,97,76,65},27,13；
删除根结点：{65,49,49,97,76},38,27,13；
调整堆：{49,65,49,97,76},38,27,13；
删除根结点：{76,65,49,97},49,38,27,13；
调整堆：{49,65,76,97},49,38,27,13；
删除根结点：{97,65,76},49,49,38,27,13；
调整堆：{65,97,76},49,49,38,27,13；
删除根结点：{76,97},65,49,49,38,27,13；
调整堆：{76,97},65,49,49,38,27,13；
删除根结点：97,76,65,49,49,38,27,13。排序结束，这样建立排序的结果是倒序的，建立小顶堆，结果是递减的序列，建立大顶堆，得到的递增的序列。

3种交换值的方法

2013-04-02T00:00:00+00:00

交换值是比较常用的步骤，也比较简单，这里总结了3个方法:

使用临时变量交换。方法很简单，使用临时变量来保存一个值，该值被保存后就可以对其进行赋值操作了;

  // 通过临时变量交换值
  void swap_temp(int *a, int *b) {	// a = 1, b = 3
      int temp = *a;					// temp = 1
      *a = *b;						// a = 3
      *b = temp;						// b = 1
  }

使用异或操作(可参考《位运算符》)。具体原理是：对于任何数,都有A^0=A A^A=0;

  // 通过位运算交换值
  void swap_bit(int *a, int *b) {		// a = 1, b = 3
      *a = *a ^ *b;					// a = a ^ b
      *b = *b ^ *a;					// b = b ^ a = b ^ (a ^ b) = a = 1
      *a = *a ^ *b;					// a = a ^ b = (a ^ b) ^ a = b = 3
  }

使用加法和减法也可以实现数字的交换，原理同第二条异或原理基本一致;

  void swap_add_substract(int *a, int *b) {	// a = 1, b = 3
      *a = *a + *b;							// a = a + b
      *b = *a - *b;							// b = a - b = (a + b) - b = a = 1
      *a = *a - *b;							// a = a - b = (a + b) - a = b = 3
  }

我大Golang在语言级别支持了多重赋值，所以值的交换异常简单a, b = b, a。

简单选择排序(SELECT SORT)

2013-04-02T00:00:00+00:00

简单选择排序的原理比较简单：

遍历整个待排序序列，选择出最小(大)的值，并与待排序序列的第一个元素进行交换；
每一选择，都会选择出一个剩余元素中最小(大)的元素，放在最终的位置上;

选择排序的一些特征总结：

第i回合的剩余元素是(n-i+1)个，其中第一次是n个。
排序要进(n-1)次(最后一趟只剩一个元素，元素合适的最后一位置上)；
每一趟要在(n-i+1)个元素中选择一个最小(大)的元素，要进行(n-i)次比较，一共要进行比较(n-1)趟，所以比较次数是：(n-1)+(n-2)+…+(1)=frac{n(n-1)}{2}。时间复杂度为：O(n^{2});
最好情况为有序递增，不需要交换，只进行遍历；最差情况为每次都进行交换；
每一次交换操作(可参考《3种交换值的方法》)要使用临时变量来保存，需要进行3次移动操作，最差进行3(n-1)次移动；
就地排序，空间复杂度为O(1)；
每次交换是选择出的元素与剩余序列中第一个序列进行交换，这个操作可能会导致排序结果不稳定。

简单选择排序演示

初始序列：{49,38,65,97,76,13,27,49}；
第一趟遍历选出最小的数字13，与49交换：13 {38,65,97,76,49,27,49}；
选出最小的27，13,27 {65,97,76,49,38,49}；
选出38，13,27,38 {97,76,49,65,49}；
这次选出的是靠左的49，默认选出最先遍历到的最小的元素，13,27,38,49 {76,97,65,49}；
选出49，13,27,38,49,49, {97,65,76}；
选择65，13,27,38,49,49,65, {97,76}；
选择76，13,27,38,49,49,65,76,97。

构造函数成员初始化列表

2013-03-31T00:00:00+00:00

我们平时习惯于在C++构造函数体中使用赋值操作符来初始化数据成员，其实这并不是真正的初始化过程。初始化是指使用参数表初始化。初始化列表位于构造函数参数表之后。

class A{
private:
	A m_a;
	A() : m_a(a);
}

这样，初始化就在类的代码被执行之前调用，由编译器来实现。

派生类可以在参数表中直接调用基类的构造函数；

class A { public: A(int x); }; class B : public A { private: B(int x, int y); }; B::B(int x, int y) : A(y) { // 在初始化列表内调用A的初始化函数 }
非静态const成员只能在参数表中初始化；
如果采用赋值操作符初始化，具体是先调用构造函数创建一个变量，然后在调用赋值函数进行赋值，效率较低；
使用参数表来初始化数据成员时，初始化顺序并不一定是初始化列表的顺序，而且按照在类中声明的次序来初始化。

蒙特卡洛求圆周率

2013-03-27T00:00:00+00:00

使用蒙特卡洛方法求圆周率的方法比较简单。其原理是：在一个边长为l的正方形中有一个半径也为l的四分之一圆，如图所示。在这个正方形中仍石子，统计命中园的次数S1和一共仍的次数S2。假设半径足够大，仍的次数足够多。那么，S1和S2便可以代表四分之一园的面积和正方形的面积。所以工具如下公式，可以得到圆周率的计算方法。这个过程与半径无关。

实现的过程中，需要使用随机数来模拟扔石子的过程。在(0,l)的范围内随机出一对横坐标x和纵坐标y，计算这个点到原点(0,0)的距离来判断是否仍到了圆内。在理论上，圆周率的计算和半径无关，但是在实际计算过程中，因为半径会影响仍石子随机坐标的范围，所以还是会影响到精确度，半径越大越好。产生随机数试用stdlib库中的rand和srand分别来产生随机数和随机种子。随机种子调用时间来生成。具体实现如下：

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cmath>
using namespace std;
int main(int argc, char *argv[]) {
	int times = atoi(argv[1]); // 获得用户输入的模拟次数

	const int R = 1000; // 半径
	int count = 0;

	srand((unsigned)time(0)); // 通过获得时间来产生随机数种子
	int i;
	for (i = 0; i < times; i++)
	{
		int x = rand() % (R + 1); // 生成随机横坐标和纵坐标
		int y = rand() % (R + 1);
		if (x * x + y * y <= R * R) // 判断是否在圆内
		{
			count++;
		}
	}
	float pi = count * 4.0f / times; // 根据统计结果计算出圆周率
	cout << pi << endl;

	return 0;
}

STATIC数据成员

2013-03-21T00:00:00+00:00

如果要在程序任意点统计已创建特定类型的数量，就需要一个全局变量。但是全局变量会破坏封装。static数据成员可以解决这个问题，并且可以通过将该成员定义成private来实现封装。

static是存储说明符，其具有唯一性。static数据成员对全体对象共享，全体对象共享一个static数据成员。
static数据成员可以声明为任意类型，常量、引用、数组、类类型。
静态数据成员实际上是类域中的全局变量，static并不能通过类构造函数来进行初始化。所以，静态数据成员的定义(初始化)不应该被放在头文件中。必须在类定义体外部定义一次。static 成员变量在类内部声明，在类外部定义，定义的时候才真正分配空间。
static成员不是类对象的组成部分。

#include using namespace std;

class Test { public: static int counter; // counter被所有对象共享 Test() { counter++; // 每调用一次构造函数，counter加1 } };

int Test::counter; // static变量定义和初始化

int main() { Test a; // 自动调用构造函数 Test b; // 第二次调用构造函数 cout « Test::counter « endl; return 0; }
const static。static定义的类成员变量不能在类中初始化，使用const static来实现类中初始化。但是在类外部仍然需要进行定义。不过由于const的作用，该变量只能共享使用不能修改其值。

字符数组、字符指针、字符串

2013-03-20T00:00:00+00:00

字符数组，就是元素是字符的数组。
字符串(C-Sytle String)，是字符变量的数组，以’’结尾。可见，字符串是特殊的字符数组。
字符指针，即char *a。

字符串操作函数strlen、strcpy、strlen定义在string.h中。
如果用字符串字面常量初始化一个字符数组，数组长度会加1，因为要保存\n。
调用字符串操作函数只能使用字符指针作为参数，所以传递的既可以是字符数组，也可以是字符串。如果传递的是字符数组，而且没有加入\n的话，遍历的时候会因为找不到结束符而持续遍历，可能出现内存访问错误或结果不正确的情况。

char arrChar3[3]; arrChar3[0] = ‘a’; arrChar3[1] = ‘b’; arrChar3[2] = ‘c’; printf(“%dn”, strlen(arrChar3)); // 7。结果明显错误
字符数组、字符指针、字符串实例：

#include #include

main() { char arrChar1[] = {‘a’, ‘b’, ‘’, ‘d’, ‘e’}; char arrChar2[] = “hello”; char *p = “hello”; printf(“%dn”, sizeof(arrChar1)); // 5 返回数组大小 printf(“%dn”, strlen(arrChar1)); // 2 提前遇到了字符串结束符’’ printf(“%dn”, sizeof(arrChar2)); // 6 数组长度加1 printf(“%dn”, strlen(arrChar2)); // 5 printf(“%dn”, sizeof(p)); // 4 结果指的是指针大小 printf(“%dn”, strlen(p)); // 5 }

SIZEOF操作符

2013-03-20T00:00:00+00:00

sizeof是C/C++中的单目操作符，在编译期间计算，测量这个变量占用的内存大小，它并不是函数。返回值是size_t(无符号整数)。可以求出数据类型、函数、变量，表达式的大小。

数据类型sizeof(type)。可以求出指定数据类型的大小，单位是字节。注意：指向任何数据类型的指针通过sizeof运算都是4。
```
  printf("%dn", sizeof(int*)); // 4
```

变量sizeof a。计算变量大小时并不需要加括号。

  char a[] = "hello";
  printf("%dn", sizeof(a));  // 6。字符串赋给数组时，还要考虑末尾的''

表达式。这里的表达式求值不是在求表达式结果，而是得到表达式结果的占用内存大小。编译器在编译的时候判断表达式结果类型，求得结果。
```
  printf("%dn", sizeof(1 + 1)); // 4
```

函数。计算函数返回值大小，并不会执行函数。

  int getArrChar() {
      printf("hello");
      return 3;
  }
  main() {
      printf("%dn", sizeof(getArrChar())); // 4
  }

内存分配方式

2013-03-20T00:00:00+00:00

全局变量和static变量从静态存储区(static)分配。内存在编译阶段就已经分配好了。其中，初始化过的全局变量和static变量存放在.data区；未初始化的全局变量和static变量存放在.bss区，该区的变量值均为0。在程序整个生命周期中都会存在。
局部变量、形参在堆栈(stack)上分配。在函数调用过程中进行分配，函数返回后自动释放。其生命周期在其作用域内。
通过new、delete、malloc、free动态分配到堆(heap)。由程序员来管理其生命周期。C++STL中的vector是动态分配内存，所以分配在堆中。如果分配内存之后并没有进行释放，改内存会一直被占用，知道程序结束，导致内存泄漏。

CONST关键字

2013-03-14T00:00:00+00:00

常变量 const修饰的变量不可以修改该变量的值。
常引用在函数void Func(A a)中，传递了一个临时对象a，该对象要进行构造、拷贝、析构这些过程，运行效率会大大降低。由于该函数是按值传递，所以使用void Func(const A &a)，这样不会重新创建临时变量，只是常引用原始变量，不会进行构造、析构等过程，可以提高执行效率。
const修饰函数返回值 const修饰过的函数返回值是常量，形如const getA()，这样，可以避免如下代码错误：
```
  A a;
  getA() = a;
```
常函数形如void Func(int a) const，在该函数体内，变量a的值不可以更改，包含该函数的类的其他成员变量的值，不会更改。同时，也会通知使用该方法的程序员：这个函数是常函数，不会改变任何值，放心使用。
指向const对象的指针
```
  const double *ptr;
```
把*放在离变量近的位置比较方便理解。ptr是一个指针，指向double类型，ptr指向的值(*ptr)是常量，不可以更改。同时，const对象指针也只能赋值给const对象指针，因为如果可以赋值，之前的const限定也就无效了。也可以像下面这样定义，含义是一样的。
```
  double const *ptr;
```
const指针
```
  int * const a;
```
表明该指针是常量，不可以更改。

位运算符(Bitwise Operators)

2013-03-11T00:00:00+00:00

按位与&(bitwise AND)

两个都是1时结果才为1
e.g. 1&0=0, 0&1=0, 0&0=0, 1&1=1
任意一位，和0与操作，结果都为0；和1与操作，结果不变
经常用来屏蔽某些二进制位

按位或|(bitwise inclusive OR)

两个有一个是1结果就为1
e.g. 1|1=1, 1|0=1, 0|0=0, 0|1=1
任意一位，与0或操作，结果不变；与1或操作，变为1
经常用来将某些二进制位设为1

按位异或^(bitwise exclusive OR)

当两位相异时，结果为1
e.g. 1^1=0, 1^0=1, 0^1=1, 0^0=0
可以简单的理解为不进位加法,1+1=0, 0+0=0, 1+0=1, 0+1=1
任意一位，和0异或操作不变，和自身异或操作为0
对于任何数,都有A^0=A A^A=0
自反性：A^B^A=B^0=B

左移运算符«(left shift)

高位左移后溢出,右边用0补
左右移位比乘除法效率高。左移用来计算乘法，n«2等效于n*2

右移运算符»(right shift)

由于数字采用补码表示，右移时，正数低位右移溢出，左边用0补；负数右移溢出后用1补
e.g. 00001010>>2 = 00000010 10001010>>3 = 11110001
右移用来计算正数的除法(向下取整)

取反操作符~(one’s complement)

求该数反码，该数二进制位上1变为0，0变为1

常见面试题：

设置一个数的某一位为1
```
  n |= 1 << x;
```
清除一个数的某一位
```
  if (n & (1 << x))
```
开关某一位
```
  n &= ~(1 << x);
```
检查某一位状态
```
  n ^= 1 << x;
```

实例代码：

int n = 5; // 101(binary)
int x = 1;

// 设置一个数的某一位(x)为1
n |= 1 << x;
// x = 00000000000000000000000000000111(binary)
printf("n=%dn", n);

// 检查某一位状态
if (n & (1 << x))
printf("onn");
else
printf("offn");

// 清除一个数的某一位
n &= ~(1 << x);
// x = 00000000000000000000000000000101(binary)
printf("n=%dn", n);

// 开关某一位(如果打开，则关闭；反之，则打开)
n ^= 1 << x;
// x = 00000000000000000000000000000111(binary)
printf("n=%dn", n);

//使用异或交换两个整数
//a' = a ^ b
//b' = b ^ a' = b ^ a ^ b = a
//a' = a' ^ b = a ^ b ^ b = b
//00000000000000000000000000001011 ^ 00000000000000000000000000101101 = 0000000000000000000
//00000000000000000000000000101101 ^ 00000000000000000000000000100110 = 0000000000000000000
//00000000000000000000000000001011 ^ 00000000000000000000000000100110 = 0000000000000000000
int a = 11;
int b = 45;
a = a ^ b;
b = b ^ a;
a = a ^ b;
printf("使用异或交换11和45: %d %dn", a, b);

计算一个正数的二进制数中1的个数。

可以借鉴上面的题目2，逐位判断是否为1。从最低位开始判断，下次判断倒数第二位，以此类推，但是不能进行通过右移操作来实现(因为右移涉及到正负数问题，会引入新的1进来)。可以移动用来判断的位。

int NumberOfOne(int n) {
	int on = 0;
	unsigned int flat = 1;
	while (flag)
	{
		if (n & flag)
		on++;
		flag = flag << 1;
	}
	return on;
}

一个数组中有多个整数，其中只有一个没有重复过，求出该数。

考虑使用异或操作帮助实现。

int AppearOnce(int data[], int length)
{
	int i;
	int once = 0;
	for (i = 0; i < length; i++)
	{
		once ^= data[i];
	}
	return once;
}

不用+、-、*、/四则运算计算处两个数的和。

异或操作可以理解为不进位加法，所以先将两个数异或，然后再加入进位来实现。进位只要在1+1的时候才会出现，所以可以使用1&1来代替，如果两个数都是1，与操作得到1，然后左移1位得到10，实现了进位。

int add(int a, int b) {
	int sum, carry;
	do {
		sum = a ^ b;
		carry = (a & b) << 1;
		
		a = sum; 
		b = carry;
	} while (b != 0);
	
	return a;
}

又一年

2013-03-05T00:00:00+00:00

一年前的今天，我来北京复查考研成绩，蛋疼的政治44。孤身一人第一次出门，就想着说历练一下吧。来北京查了查分，顺便见了几个同学，一个人绕着西单啥的逛了逛。

感觉一切都是新的，都没见过，当时很屌丝的去了商场跟服务员都不怎么敢说话。呵呵。四月份又来了一趟，考研复试。那时对北京已经比较熟了，趁着蛋疼复试的时候又到处走了走，很多地方都混熟了。

现在已经在北理读研一个多学期了，基本混熟了，正好一年。

从上个学期开始找实习，面了两次，挺伤心的，面得特别差，第一次面没办法，真是艰辛。这个学期提前几天过来，玩了几天，就开始准备。面的第三个，就录了。之前压力是多么的大，生怕找不到，准备还那么认真，结果就是第三个就录了嘛，哈哈，得瑟一下。IBM是我一直比较喜欢的公司，能去这里实习结果算很好的了，而且是研发岗位。

最近还在和大牛搞网站的事情，应该就要上线了。一直觉得当时的想法太草率，现在就硬着头皮上吧，做技术博客，写个半年，我应该也会有点竞争力了。

这一年，对我来说，是成长的一年，我确确实实感觉到自己成熟了好多，面试会去争取主动权了，融入这个城市了，懂得理解父母了，前天睡觉想起来家里的事情，就觉得好幸福啊。

你永远都不知道自己有多傻逼

2013-01-23T00:00:00+00:00

最近的一些小感慨。乱七八糟。

编码也有很多了，但是一直没有特别好的编码感觉。也不知道感觉对不对，自从复读以来，做事情就没有特别得意的时候。自己变得很教条，一切都是按着规定好的东西在做。这本来也无可厚非，但是自己在一中时期灵活聪明的一面，貌似已经失去了。其实周围的人大多也都是这样，都很教条，这可能也是我们教育的悲哀吧。我需要接触一些新的人，多学习一下新思路。

自己一心想成为一个高富帅，却发现自己做的事情从来都是这么傻逼，离那个还有很远的距离。自己的定位很矛盾。除了装逼，我基本啥都没干好。怎么才能成为一个内心强大的人，这是一个问题。

自己有一堆一堆的想法，而且我觉得如果都能实现的话，在应用方面应该会有很大的前景。但是再盘算一下，根本没有时间来实现，我可能也没有那个能力搞定。唉，这是我唯一引以为豪的东西了。

写这个东西，自己都不知道想说什么。我很迷茫。现在社会上有各种励志大师，我也读了一些，都是扯淡的。到底要怎么变牛逼，对我来说还是一个问题。不过当下，我需要改变思路，我要灵活起来，找回当年那个傻逼、快乐、自信的我。

Connect the dots

2013-01-23T00:00:00+00:00

转眼就要过年了，半年的研究生生活还差两天就结束了。2012年，对于我来说，是不平凡的一年，这一整年的经历，让我突然明白了许多，慢慢得有了目标，有了规划。

上半年的复试，让我第一次感受到了帝都的生活，我是多么的渺小，我甚至很自卑，一个山西屌丝从重庆跑到北京来参加复试，没技术没GPA。复试过了之后，我又是多么的屌丝，忘记了复试时候的冷嘲热讽，各种冷眼，突然觉得自己多么的了不起，尤其是刚开始读研的时候，觉得终于来到了大城市了。当然，在帝都这种城市，有这种想法是难免的，不过好在我现在已经看得很淡了。

从4月份开始，我在汉奸的推荐下开始阅读。从《南方周末》开始，后来是《看天下》，接着读了一些书。我和汉奸真是屌丝中的绝配，如果我俩是gay，绝对可以一见钟情，因为我俩的想法总是如此的相似。其实从大一开始就有计划去读一些书，但只是计划，到大四毕业才真正开始，输在起跑线上了，呵呵，扯远了。后来我也不怎么去看报纸了，我去读了一些书，《世界因你不同》、《我的奋斗》，这些在我看来的文化鸡肋，当时居然会选择去读，没文化真可怕。现在阅读算是步入正轨了。

那天在豆瓣写书评，突然认识到我为什么要读书了，之前确实有些盲目，看别人推荐的，但是后来也知道根据自己喜好来了，慢慢发现，其实我读书，一直在寻找一个答案：我的青春要怎么过？我的路要怎么走？我要坚持怎么样的价值观？我的理想是什么？

还有一次打击，是后半年的实习生面试。当我信心满满的跑去面后，幼小的心灵再一次受挫。但是IBM的那次面试，让我真正做了一次自己，做了一次男人。我有勇气去跟面试官去说我想说的话，去展示我自己，这很好。他也鼓励我去坚持梦想。

之后才意识到，天天放在嘴边的“follow my heart”放在我这，是多么的扯淡，因为我倒那时，才想到我真正想做什么。

这几天终于读了几本像样的书了，读完这基本之后，我应该又能上一个台阶，找实习应该不愁了，完成我台湾游的梦想也不难了，哈哈。台北、东京、纽约、拉萨，等我。

尽瞎扯了，写得好乱。

码农人生，游戏人生～

2012读书总结

2013-01-13T00:00:00+00:00

《正说清朝十二帝》研究生复试的时候，问我清朝有多少个皇帝，我说10个，老师都笑了。回去找了这本书读了读。这也是我读历史的起点。《世界因你不同》开复老师讲了不少，但是回头想想，其实也没啥，都是虚的。微博也是，都是炒自己，没劲。《青春》都一次读韩寒的东西，他很有自己的想法，敢作敢当。但是从中没有找到我想要的答案。《历史是个什么玩意儿1》“读史以明智”。《我的奋斗》老罗主要强调了要坚持原则，多读书，还是挺好的，不过自传那部分写得不怎么样。《乡关何处》现在回想，其实内容大都忘掉了，但是还是让我坚定了我的理想。

头一次一年读了这么多所谓的课外书，好友成就感。有人说，一年读4本，我一下完整的读完了6本，还有基本在读，没读完就没写了。就可以成为一个牛逼人，我一下读了这么多，就当为以前补补课吧。话说之前读的几本书，好烂啊，没读过书，不会挑，就喜欢读《世界因你不同》、《我的奋斗》这种，还读过《说话之道》，我都没坚持读完。所谓的励志书，不适合我。今天找我读过的书，发现其实我一直在找我自己的影子，我想更好的理解我自己。

请求网页所需协议

2012-11-02T00:00:00+00:00

请求页面http://www.bit.edu.cn/index.htm后，首先在本地查找DNS缓存。本机已有缓冲，故不再向DNS服务器请求DNS解析。

www.bit.edu.cn
----------------------------------------
Record Name . . . . . : www.bit.edu.cn
Record Type . . . . . : 1
Time To Live  . . . . : 84020
Data Length . . . . . : 4
Section . . . . . . . : Answer
A (Host) Record . . . : 10.0.6.30

清空本机的DNS缓存后，重新请求该页面。访问本地DNS服务器10.0.0.10，DNS服务器返回该域名的地址10.0.6.30。这个获得的是IPv4的地址，随后还执行了一次请求，请求IPv6的地址。
随后与10.0.6.30建立TCP连接，请求index.htm页面。使用了基于TCP的HTTP协议，所以基于80端口。建立TCP连接的过程使用了3次握手。第一次握手，Flags: 0x002 (SYN) Sequence number: 0 (relative sequence number)；第二次握手，Sequence number: 0 (relative sequence number) Acknowledgment number: 1 (relative ack number) Flags: 0x012 (SYN, ACK)；第三次握手，Sequence number: 1 (relative sequence number) Acknowledgment number: 1 (relative ack number) Flags: 0x010 (ACK)。

服务器成功响应，发送过来index.htm文件。其中，Server: Apache/2.2.6 (Unix) mod_jk/1.2.27\r\n可以知道北京理工大学使用的服务器是Unix版本的Apache服务器2.2.6版。部分HTML代码如下。

 <html xmlns="https://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title></title>
     <SCRIPT type=text/javascript src="js/common.js" ></SCRIPT>
     <link href="https://www.bit.edu.cn/css/newcss1.css" rel="stylesheet" type="text/css" />
     <link href="https://www.bit.edu.cn/css/style.css" rel="stylesheet" type="text/css" />
     <link href="https://www.bit.edu.cn/favicon.ico" rel="shortcut icon" type="image/x-icon" />
     <link href="https://www.bit.edu.cn/favicon.ico" rel="icon" type="image/x-icon" />
 </head>
 </html>

获取到index.htm之后，根据HTML代码下载Javascript脚本、CSS文件、显示用的图片。每一次获取，都要建立TCP连接。这是请求资源的过程。登陆126.com与之前描述相当，只是在登陆时需要提交表单。其中，用户名和密码已经经过加密。
```
 var=%3C%3Fxml%20version%3D%221.0%22%3F%3E%3Cobject%3E%3Cobject%20name%3D%22attrs%22%3E%3Cstring%20name%3D%22helptips%22%3E0000000300000085%3C%2Fstring%3E%3C%2Fobject%3E%3C%2Fobject%3E
```

沉淀心情

2012-05-23T00:00:00+00:00

我从小到大都是一个听话的孩子，我家里人也一直以此为傲，因为我读了一个还算名牌的大学，一个名牌的研究生。我可以没人任何杂念的去准备高考，准备考研，完全不会有其他杂念：谈恋爱、玩……

自从考研结束后，接二连三发生了一些事情，我也开始意识到自己的问题：我是个优柔寡断的人，不太会选择。尤其是在研究生复试和之前的找工作的事情上表现的非常明显，一些不大不小的事情被我扩大化了。随之而来的就是焦虑，再者就是找人倾诉。本来也不是什么大事，我自己其实也没啥好说的，姚宁一和孙黎就这么每天听我罗嗦。他们也都知道我是怎么回事，还有心情搭理我，真心感谢你们~

我是一个胸有大志的人，有各种理想、各种报复，可能因为我的性格的原因，至今还是一菜鸟。我感觉很多时候不是我自己的能力问题，而我一直最需要的是一个能指引我的人，告诉我接下来该怎么做。可能我从小听命令听习惯了，也可能我缺少机遇，我大学四年的状态就是有劲没处使。

一直很羡慕老姚，他经历了我认为的比较困难的阶段，没有因为抉择而过于苦恼，反正没有找我倾诉过。之前看蓝昊的视频，很多时候必须忍受寂寞，而我们去找人寻求帮助，其实是想要一个自己心里已经设定好的回复。

是时候尝试去改变一下了，果断一些，多出去接触一下社会，我不能再是小孩子了。

在main函数中创建2个线程，一个运行冒泡排序算法，另一个运行选择排序算法，分别对两个一样的数组进行

2011-01-11T00:00:00+00:00

#include<Windows.h>
#include<iostream>
#include<stdlib.h>
#include<strsafe.h>
#include<time.h>
 
#defineMAX_THREADS 2
#defineDATASIZE 100000
usingnamespacestd;
 
voidErrorHandler(LPTSTRlpszFunction);
DWORDWINAPIBubble( LPVOIDlpParam);
DWORDWINAPISelectSort(LPVOIDlpParam); 
 
DWORDtime1 = 0, time2= 0;
 
typedefstructMyData {
        intvar[DATASIZE];
} MYDATA,*PMYDATA;
 
int main()
{
    DWORD   dwThreadIdArray[MAX_THREADS];
    HANDLE  hThreadArray[MAX_THREADS];
    PMYDATApDataArray[MAX_THREADS];

    for (inti = 0; i < MAX_THREADS; i++)
    {
            pDataArray[i] =(PMYDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                    sizeof(MYDATA));

            if( pDataArray[i] == NULL )
            {
                    ExitProcess(2);
            }
    }
    srand((unsignedint)time(NULL));
    for (intj = 0; j < DATASIZE; j++)
    {
            pDataArray[0]->var[j] = pDataArray[1]->var[j] = rand();
    }

    hThreadArray[0] = CreateThread(
            NULL,
            0,
            Bubble,
            pDataArray[0],
            0,
            &dwThreadIdArray[0]);

    if (hThreadArray[0]== NULL) 
    {
            ErrorHandler(TEXT("CreateThread"));
            ExitProcess(3);
    }

    hThreadArray[1] = CreateThread(
            NULL,
            0,
            SelectSort,
            pDataArray[1],
            0,
            &dwThreadIdArray[1]);

    if (hThreadArray[1]== NULL) 
    {
            ErrorHandler(TEXT("CreateThread"));
            ExitProcess(3);
    }
    
    WaitForMultipleObjects(MAX_THREADS,hThreadArray, TRUE,INFINITE);

    for(inti=0; i<MAX_THREADS; i++)
    {
            CloseHandle(hThreadArray[i]);
    }

    return 0;
}
 
voidErrorHandler(LPTSTRlpszFunction) 
{ 
    // Retrieve the system error message for the last-errorcode.

    LPVOIDlpMsgBuf;
    LPVOIDlpDisplayBuf;
    DWORDdw = GetLastError(); 

    FormatMessage(
            FORMAT_MESSAGE_ALLOCATE_BUFFER | 
            FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL,
            dw,
            MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
            (LPTSTR) &lpMsgBuf,
            0,NULL );

    // Display the error message.

    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
            (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
            LocalSize(lpDisplayBuf)/ sizeof(TCHAR),
            TEXT("%s failedwith error %d: %s"), 
            lpszFunction, dw,lpMsgBuf); 
    MessageBox(NULL,(LPCTSTR)lpDisplayBuf,TEXT("Error"),MB_OK); 

    // Free the error-handling buffer allocations.

    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
}
 
DWORDWINAPIBubble( LPVOIDlpParam) 
{
    time1 = GetTickCount();
    int *p = (int*)lpParam;
    inttemp;
    for(inti=DATASIZE - 1;i > 0; i--)
    {
            for(intj = 0; j < i; j++)
            {
                    if(p[j] > p[j + 1])
                    {
                            temp=p[j];
                            p[j]=p[j + 1];
                            p[j + 1]=temp;
                    }
            }
    }
    time2 = GetTickCount();
    cout << "Timeof Bubble:" << time2 - time1 << "ms"<< endl;
    return 0;
}
 
DWORDWINAPISelectSort(LPVOIDlpParam) 
{
    time1 = GetTickCount();
    int *p = (int*)lpParam;
    intpos;
    inttemp;
    for (inti = 0; i < DATASIZE; i++)
    {
            pos = i;
            for (intj = i; j < DATASIZE;j++)
            {
                    if (p[pos] > p[j])
                    {
                            pos = j;
                    }
            }
            temp = p[pos];
            p[pos] = p[i];
            p[i] = temp;
    }
    time2 = GetTickCount();
    cout << "Timeof SelectSort:" << time2 -time1 << "ms"<< endl;
    return 0;
}

计算结果：

在main函数中加入

SetThreadPriority(hThreadArray[0], THREAD_PRIORITY_HIGHEST);
SetThreadPriority(hThreadArray[1], THREAD_PRIORITY_LOWEST);

修改两个线程的优先级，得到的结果：

用CreateProcess创建线程，指定运行QQ.EXE

2011-01-11T00:00:00+00:00

STARTUPINFOsi;
PROCESS_INFORMATIONpi;

ZeroMemory( &si,sizeof(si));
si.cb = sizeof(si);
ZeroMemory( &pi,sizeof(pi));


if (!CreateProcess(NULL,
        "D:\\Program Files\\Tencent\\QQ\\Bin\\QQ.exe",
        NULL,
        NULL,
        FALSE,
        0,
        NULL,
        NULL,
        &si,
        &pi)
        )
{
        cout << "CreateProcessfailed:" << GetLastError()<< endl;
}
cout << "CreateProcesssuccess" << endl;
return 0;

用SPY++查看

DX基础知识

2011-01-09T00:00:00+00:00

D3D中任何复杂的图形由什么图元组成：三角形
向量的属性包括：长度和方向
三维空间的变换：（3种）平移、放缩、旋转
像素的格式: ARGB 和 XRGB （常用）
如果贴上图片，顶点格式必须有D3DFVF_TEX1，取值范围[0,1] 。
最基础的对象是 D3D对象，由它创建 Device ，再由Device创建索引、顶点等。
创建和释放应符合栈（先进后出）的顺序。
D3D在设备创建时选择两种方式，用硬件是 HAL ，用软件是 REF 。
表示纯红颜色的颜色的常量是： 0xFFFF0000
在D3D中，本地空间指局部坐标系，世界空间指世界坐标系。
使用索引缓冲区相对于顶点缓冲区的优点：对于可重用的点，用索引代替，省去重复空间。
D3D中，绘制基本图元的函数是： DrawPrimitive（）。
实现光照的效果需要通过光照和模型的法线来实现。法线分为顶点法线和面法线。
D3D中，顶点是程序员的定义格式，叫做：灵活顶点格式（FVF），FVF的值必须与顶点结构体一一对应。
处理纹理坐标的值在（0,1）边界外，纹理坐标的方式叫纹理寻址。三种纹理寻址的方式：包装、边框、镜面、夹取。
D3D中，模型表面的材质是指物体表明对光的反射能力，也包括 α通道。
在DX中，渲染需要占用大量的CPU时间，要想获得稳定的帧速率，调用 PeekMessage()。
只要不去修改，就会一直保持状态，则这些状态叫做开关量。
设置渲染状态的函数是SetRenderState()。
纹理尺寸最好符合什么标准？长宽最好是2的n次幂，矩形也行。
DX最多支持同时 8 个光源， 8 层纹理。
DX中正确体系物体遮挡关系，使用 Z-Buffer(深度缓冲)。
为了增加场景的真实感，通常添加雾效。
DX中，专门封装了一个处理2D图形的接口：D3DXSprite

DX图形库的开发方式，使用这种机制有什么好处？ DX图形库的开发方式是基于Windows的COM机制（ComponentObject Model组件对象模型）。COM对象是对一组特定功能的抽象集合，应用程序不能直接访问COM对象，而是必须通过COM对象接口（Interface）的指针执行COM对象的功能。使用这种机制的好处是：
- COM接口永远不会改变
- COM是独立于语言的（language-independent）
- COM只能通过方法来访问，而不能直接访问数据成员。
DX程序运行的基本流程是什么？
1. 创建窗口
2. 创建D3D对象
3. 创建图形
4. 载入资源
5. 设置变换
6. 设置状态
7. 在BeginScene()和EndScene()之间绘制
8. 创建图元
9. 销毁图元
10. 销毁窗口
简述光的类型以及特性。

光的类型有：环境光、漫反射光、镜面反射光环境光：是经其他表面反射到达物体表面，并照亮整个场景。这时物体并不处于光源的直接照射下，照亮物体的光是其他物体反射到该物体上的光线。光线经过多次折射后看起来就像是来自四面八方一样，这种光不依赖于光源的位置。漫反射光：有特定的传播方向，但当它到达某一表面时，将沿着各个方向均匀反射。这种光无论从哪个方位观察，表面亮度均相同，所以无须考虑观察者的位置，仅需考虑光传播的方向以及表面的朝向。从一个光源发出的光一般都是这种类型的。镜面反射光：用于显示物体表面（光滑和光泽表面）的高光效果，有特定的传播方向。但当它到达一个表面时，将严格的沿着另一个方向反射。是只能在一定的角度范围内才能观察到的高亮度照射。因为光照均沿着同一个方向反射，所以不仅要考虑光的入射方向和表面的朝向，还需要考虑观察者的位置。
简述α混合和α测试的原理，相同点和不同点。

α通道就是记录像素的透明度。 α混合：先绘制目标颜色，再绘制源颜色，用两个颜色值分别乘以各自的α系数再相加，即得到最后的颜色。所以，最终颜色里既包含了源颜色又包含的目标颜色。 α测试：设置一个测试函数，把参考值和将要测试按照比较函数来运算，通过测试的颜色显示出来，未通过测试的颜色不显示出来。

按照“Alpha”混合向量的值来混合源像素和目标像素。是一种让3D物件产生透明感的技术。若3D环境中像素拥有一个α通道，记载像素的透明度。就是处理两个物件在萤幕画面上叠加的时候，还会将α值列入考虑，使其呈现接近真实物件的效果。

具体就是：第一步，先把源像素和目标像素的RGB 三个颜色分量分离，然后把源像素的三个颜色分量分别乘上Alpha 的值，并把目标像素的三个颜色分量分别乘上Alpha 的反值，接下来把结果按对应颜色分量相加，再对最后求得的每个分量结果除以Alpha 的最大值，最后把三个颜色分量重新合成为一个像素输出。透过那些透明度非常高的物体看其他物体，例如透过几乎完全透明的玻璃看其他物体，会感到玻璃好像不存在，在三维图形程序中渲染时就可以不渲染这些透明度非常高的物体，从而可以提高渲染速度，这可以通过alpha测试来实现。

alpha测试根据当前像素是否满足alpha测试条件（即是否达到一定的透明度）来控制是否绘制该像素，图形程序应用alpha测试可以有效地屏蔽某些像素颜色。与alpha混合相比，alpha测试不将当前像素的颜色与颜色缓冲区中像素的颜色混合，像素要么完全不透明，要么完全透明。由于无需进行颜色缓冲区的读操作和颜色混合，因此alpha测试在速度上要优于alpha混合。相同：都要使用到Alpha通道不同：Alpha混合中，无论无题Alpha值的大小，只要》0，就会保留附体的像素值，使它能在屏幕上显示 Alpha测试则是一种非此即彼的选择，设置一个参考值，给出一个测试方法，对每一个物体进行测试。当物体Alpha值>参考值,保留其在屏幕上的显示，反之则不显示。
简述基本图元的类型和使用方法。
- 点列（D3DPT_POINTLIST）：点列由一系列的顶点组成。按照在顶点结构体数组的标识的点的位置画出单个点。
- 线列（D3DPT_LINELIST）：线列由一系列的线段组成。D3D依次读取两个点来构成一个图元，即一条线段。
- 线带（D3DPT_LINESTRIP）：线带由一系列的线段组成，前一个线段的终点是下一条线段的起点。D3D依次读取一组（2个）顶点画出一条线段，上一组的最后一个顶点是下一组的第一个顶点。
- 三角形列（D3DPT_TRIANGLELIST）：三角系列由一系列的三角形组成。D3D依次读取一组（3个）顶点画出一个三角形，只要顶点声明的不一样，各组中就没有任何一个顶点相同，但是当D3D读取的三个构成三角形的三个点是逆时针时，在默认情况下就不绘制该三角形。
- 三角形带（D3DPT_TRIANGLESTRIP）：三角形带又一系列的三角形组成，除了第一个三角形，其他的三角形只需要输入第三个顶点，其他两个顶点与前一个三角形重合。D3D依次读取一组（3个）顶点来构造一个三角形，后一组和前两个顶点时前一组的后两个顶点，在这种模式下，D3D保证在默认情况下以顺时针来画三角形。
- 三角形扇（D3DPT_TRANGLEFAN）：三角形扇也是由一系列的三角形组成，每两个三角形有两个顶点重合。D3D读取顶点数组中的第一个顶点作为三角扇的顶点，然后依次读取一组（2个顶点），前一组的第二个顶点是后一组的第一个顶点，若顶点顺序为逆时针时，在默认情况下仍然不画出。
绘制函数
```
 HRESULT DrawPrimitive(          
 D3DPRIMITIVETYPE PrimitiveType,                              //基本图元类型
     UINT StartVertex,                                                      //起始顶点
     UINTPrimitiveCount                                     //绘制的图元的数量
 );
	 
 g_pDevice->DrawPrimitive(type,startvertex,vertexnumber);
```
DX中非其次坐标顶点同三维空间坐标通过变换显示到2D上，经历了那几个变换？摄像机有几大要素，每个要素的含义。
- 对每个物体建立局部坐标系
- 将每个物体铜鼓偶世界变换的运算变换到世界坐标系。
- 几何体和摄像机都是嫌贵世界坐标系定义的，将摄像机变换至世界坐标系的原点，并将其旋转，使摄像机的光轴与世界坐标系Z轴正方向一致。
- 通过投影将3D场景用2D表示
- 用视口变换把投影窗口转换到屏幕的一个矩形区域中。
三大要素：视点、焦点、正方向
介绍DX渲染管线的流程。
- 建立局部坐标系：用于定义构成物体的三角形单元列表的坐标系。此时，构建模型时无需考虑位置、大小、或相对于场景中其他物体的朝向。
- 建立世界坐标系：将位于自身局部坐标系中的物体组织在一起构成世界坐标系中的场景。通过平移、旋转以及比例运算，分别设定该物体在世界坐标系中的位置、方向以及模型的大小。
- 观察坐标系：我们将摄像机变换至世界坐标系的原点，并将其旋转，使摄像机的光轴与世界坐标系z轴正方向一致。同时，世界空间中的所有几何体都随着摄像机一同进行变换，以保证摄像机的现场恒定。
- 背面消隐：多边形都有两个侧面，一个侧面标记机为正面，另一个侧面标记为背面。通常，多边形的背面是不可见的。利用正面朝向多边形遮挡位于其后的背面朝向的多边形，将背面朝向多边形加以剔除。
- 光照：光源定义在世界坐标系中，必须经过取经变换至观察坐标系方可使用。光源照亮了场景中的物体，从而可以获得较为逼真的显示效果。
- 裁剪：将位于视域体外的几何体剔除掉。
- 投影：获取3D场景的2D表示。定义了视域体，并负责将视域体中的几何体投影到投影窗口中。
- 视口变换：将顶点坐标从投影窗口转换到屏幕的一个矩形区域中，该矩形区域成为视口。
- 光栅化：计算构成三角形单元的每个像素的颜色值，以绘制每个三角形单元。其最终结果是显示在屏幕上一副2D图像。

动画与游戏设计基础

2010-12-29T00:00:00+00:00

面向对象的四大特征：抽象、封装、继承、多态。
C++全局函数重载的语法特点：（重载是什么？）函数声明的参数列表不同。
Int function （int， int）是函数原型，那么怎么样定义函数指针：int(*f)(intx, int y)
常用的数据结构有哪些：（3个）堆栈、队列、堆
在游戏开发中，都有哪些分工：（3种）美术、程序、策划。
在C++种将一个概念封装成类，类的数据成员的类型都是确定的，那么有一种高级的抽象叫做什么：模板。
在编译中，C++代码如果出现无法解析的外部符号说明：已声明未定义
C++中虚函数的关键字是：virtual
一个子类继承了带有纯虚函数的父类，怎样才能被实例化：实现父类中的所有虚函数
Windows程序驱动的机制是：消息机制
Windows编程中的窗口句柄：HWND
什么代表现实的屏幕：HDC
用某种变量代表某种资源：句柄
Windows中获取现实设备的函数是GetDC()，释放资源的函数是：ReleaseDC()。
在Windows中，只有一个地方的消息机制会被执行一次：WM_CREATE：
Windows中用什么机制来消除闪烁：双缓冲。
在游戏程序中，要把绘制和逻辑分开写，以免造成代码混乱。
响应键盘按下的消息是：WM_KEYDOWN，鼠标移动的消息是：WM_MOUSEMOVE
实现镂空的方法是：TransparentBlt()
需要链接的库函数：msimg32(msimg.lib)
场景调度分为：角色调度、场景调度、镜头调度
从三维动画工程角度看，角色的设定要考虑：造型和工程难度
运动的规律分为：起始、预备、过级、复位
基本的三维除了前期：模型制作、材质贴图、绑定蒙皮、动画渲染、后期合成（题目不清楚）
影视语言中的运动分为：画面内部运动、画面外部运动。
影视语言中的声音主要有：音乐、音效、对白。

广角镜头的特点是什么？
- 拍摄范围广
- 透视角度大
- 画面易于变形
- 适合表现大场面，小环境拍摄和处理特殊的艺术效果
摄像机的运动方式有哪些？

推、拉、摇、移、跟、甩、综合运动镜头
谈谈对轴线的认识：

轴线是指根据物体的运动方向或朝向假定的一条虚线；在拍摄当中应该在轴线一侧180度安排机位；如果摄像机超过这范围就叫做越轴；为了合理的越轴，主要有以下几种处理方式：1、空镜头2、齐轴镜头3、跟随运动镜头4、主观视角镜头5、特写镜头

有时候根据影片的具体情节，艺术效果的需求，也可以有意越轴。
解释缩略词：

SDK：（SoftwareDevelopment Kit）软件开发工具包 MSDN：(MicrosoftDeveloper Network) GDI：(Graphic DeviceInterface)图形装置界面 STL：(StandardTemplate Library)标准模板库
简要描述一个游戏引擎在游戏开发中的作用。

游戏引擎指挥控制着游戏中各种资源，包含：渲染器、物理引擎、碰撞检测系统、音效、脚本引擎、电脑动画、人工智能、网络引擎以及场景管理。游戏引擎提供了以上种种功能的实现，并把底层的细节封装，提供给用户接口，提供开发工具，它大大提高开发速度，降低开发难度，让用户可以直接使用已经实现过的功能，不必再做别的程序员做过的事情，帮助用户实现一些很难的效果，是游戏开发的必然趋势。
是否存在指针的引用，是否存在指向引用的指针？为什么？

不存在指向引用的指针，引用是对象的一个别名，引用不被分配存储空间，而指针是指向一个内存地址的，所以没有能指向引用的指针

指针的引用指针的引用是利用指针变量，提供对变量的一种间接访问形式。对指针变量的引用形式为：*指针变量

其含义是指针变量所指向的值。
PC游戏的开发为什么首选C++，而非C#或Java

C++是一种高级语言同时也是一种编译性语言，他具有高级语言的特性，同时也具有低级语言的特性，可以直接操作硬件，效率很高。而像C#或Java这些解释性语言必然会有一个虚拟机，降低了效率；

pc游戏它通常会有非常巨大的绘制图形，玩家频繁的输入操作，在输入输出的时候对响应速度要求非常高，并且网络通信的负荷大，要求通信量大，速度快。所以PC游戏的开发首选C++，而非C#或Java。
如何检查单向链表是否存在封闭环？

方法思想：例如两个人在环状操场赛跑,一名快者，一名慢者，一直跑下去，总有一个时刻，两人会相遇。但是如果赛跑场地是一条无限延伸的直路，则快者将一直领先，不会与慢者相遇。

例如检查下面链表是否存在封闭环：

检测方法如下：

定义两个指针P1（每次移动一格）： 1,2,3,4,5

P2（每次移动两个格）：1,3,5,3,5 此时相遇，则证明该单向链表存在封闭环。

3Q大战

2010-11-03T00:00:00+00:00

360老总周鸿炜以前在雅虎工作时，带队研发了3721恶意插件，在我记忆中能算是中国恶意软件的鼻祖了吧。后来周鸿炜出走，创建了奇虎网，带队研发了360安全卫士，主要就是针对3721恶意软件（后来更名为雅虎助手），结果是如果安装了360，他会提示删除雅虎助手，而雅虎助手会提示删除360。

周鸿炜对他自己这个矛盾的行为的解释是：他打开了这个潘多拉盒子，他要亲手消灭它。

今年，360又推出一个隐私保护器，跟上次一样，两家打起来了，又是一场闹剧。

我们就当看笑话吧，反正我个人觉得这两个公司都不怎么样，一个免费杀毒，也杀不了什么厉害的病毒，到现在为止也不能把一个U盘病毒彻底杀掉吧；一个各种山寨，如果不是里面好友多，我才懒得用。

又要走了，可是不怎么想走啊

2009-02-16T00:00:00+00:00

又要开学了，我也要离开阳泉了。

有一万分不愿，但还是得走啊。

前两天送了几个哥们，就有点伤感了，一年也就见两次，以后毕业了估计最多也就每年一次了。他们走的时候不怎么高兴，搞得我这几天也不怎么舒服啊。

要走了，奶奶天天看着日历算日子，算还能和我呆几天。每天想着法给我做我喜欢的吃的，每次我说有事不去吃时，她总是很伤心的，可又不好说什么。每次我吃了饭要走了，她总是要送我，直到我在她的视野里消失。每次给我做饭都忙到很晚的，走得时候还硬要我带东西走。记得刚回来的时候回去看她，她哭了，说快想死了。暑假去学校的时候她病了，很厉害，可担心孙子，一夜一夜的睡不着，电话里总骗我说病好了，其实我走了两个月才好的。这次又走，不知道她会哭成什么样了，也不知道她会几个晚上睡不着。

也总想和父母谈些什么，可代沟太深了，实在没什么能说的，我爱玩电脑，他们不懂什么，他们看电视，我也不怎么喜欢看啊，也就吃饭能坐到一起，可又说不了什么。他们总想和我说些什么，可又开不了口，我也一样，我恨代沟啊，也不知道怎么会有啊。这几天也是一样，每天给我吃饺子，忙活一阵子，我说在重庆也能吃得到，可他们还是要做。说白了，就是有点不想我走啊。

重庆什么时候变天，我家人比我还清楚啊，每天看天气预报，真是儿行千里母担忧啊！

真是后悔考这么远啊，去个北京什么的，周末还能回去！

回想回来的几天啊，每天就周末玩游戏，哎，虚度啊！

真想早点毕业，让他们和我一起住，就不用和家人分开了！

下学期，我要继续努力啊，争取奖学金，不是为了我，让家人欣慰啊！我能做的也就这么多了。

又过了一年

2008-12-31T00:00:00+00:00

今年发生了好多事啊，接触了一生中好多没见过的。

前半年，在艰苦的环境中挣扎。补习好难啊，压力大，条件差，老师素质不高，好郁闷啊。当时没什么感觉，现在觉得好苦啊，好在挺过来了，考上了。真不知道如果没考上的话会怎么样。从去年高考成绩出来后，就郁闷到了今年分数出来，父母跟我承受着压力，虽然嘴上没说，可看得出来啊。我也是啊，面对同样的东西，一遍一遍的看，厌倦了，又没办法，逼着自己去看，就这么过着。每天12点睡，早上6点起，重复着，根本来不及想该休息了，没从没想过如果考上了会怎么去玩，不敢想啊。从考完那天起，我感觉我疯了，那是第一年没有的感觉，尤其是填了志愿后。我没白天没黑夜的玩，到处跑。父母也终于放下了包袱，开心了。呵呵，我妈也舍得让我花钱了，那是最美好的一段日子了。

后来就来了重大。当初也没想很多，就是根据分报的。来了感觉也不错，呵呵，相当不错。我适应能力不错，我很快爱上这里了。在这里认识了很多朋友，好开心的。

我报了软件工程（含数字媒体方向），我热爱这个专业，不管他将来就业怎么样。我一开始也是在努力的学的，而且相当不错，可后来，尤其是最近，堕落了，呵呵。

来了这也遇到过以前没遇到的问题。忘了银行卡密码，帮人打架……

总之，还有不到15分，今年就这么过去了。呵呵，心情好复杂啊。

2008，就这么过去了，我还要加油啊。努力吧，Superman.

Cyeam Go学习优化沉淀 架构设计分享

LLM不能做什么？解析大模型的能力边界与适用场景

Harness Engineering深度解析：AI时代的系统控制新范式

AI工程化三阶段

Code Harness Engineering架构

第一阶段：系统启动与加载（构建底座）

1. 实时代码仓库上下文 (Live Repo Context)

2. 提示词形态与缓存复用 (Prompt Shape And Cache Reuse)

Stable Prompt Prefix（稳定提示词前缀）——CLAUDE.md

Rules

第二阶段：对话运行与组装（核心循环）

5. 结构化的会话记忆 (Structured Session Memory)

记忆系统Memory:

会话Transcript：

第三阶段：工具执行与安全管控（驾驭核心）

3. 工具的接入与调用 (Tool Access and Use)

低幻觉

强力提示词

第四阶段：上下文瘦身（防爆炸与优化）

4. 给上下文瘦身，防止撑爆 (Minimizing Context Bloat)

压缩时机

压缩方式

第五阶段：任务委派与复杂场景

6. 任务委派与受限子智能体 (Delegation With (Bounded) Subagents)

配置方式

调用方式

完整架构图

更多阅读

Claude Code安装与使用完全指南：从OpenRouter到黄大善人模型

准备

安装使用OpenRouter模型

配置环境变量

启动

使用黄大善人模型

接入LangSmith

安装插件

配置Token

模型选择

增加提示音

Shortcuts

配置文件

大语言模型选型指南：从架构到场景的全方位对比分析

发展史

模型指标

模型体量 Parameters

架构 Architecture

Embedding 模型

蒸馏&RAG

模型选择参考

AGENTS.md与SKILL.md：为AI智能体赋能的标准格式详解

AGENTS.md

跟README.md的区别

兼容性

如何使用

例子

SKILL.md

Skill的结构

如何工作

例子

渐进式拉取skill

OpenClaw深度解析：模型选择、Skill系统与Heartbeat机制

准备工作

全链路数据流转总流程

源码目录

四层调用链

模型选择规则

实际案例

选择规则&优先级

SKILL

执行过程

计算执行方式activeRunQueueAction

LLM交互案例

INPUT

SYSTEM

HUMAN&AI

OUTPUT（输出）

HEARTBEAT

CLI

开启心跳

飞书场景配置

Cyeam Go学习优化沉淀架构设计分享

Geek新闻每日AI热点新闻