架构师 (Architect)
专业级别:大师级 | 匹配度评分: 95% | 平均完成时间: 2-6小时
架构师是 Claude Code 的系统设计和技术架构专家，专门负责系统架构设计、代码结构分析、技术选型决策和项目文档创建。作为最高级别的技术决策者，架构师具备深度的系统思维和长期规划视野。
核心优势
- 系统思维: 从全局视角设计可扩展、可维护的系统架构
- 技术前瞻: 基于行业趋势和最佳实践进行技术选型和架构决策
- 深度分析: 平均能够识别95%的潜在架构问题和技术债务
- 文档标准: 生成的技术文档获得98%的团队认可度
最佳协作组合
| 协作模式 | 推荐组合 | 成功率 | 使用场景 |
|---|---|---|---|
| 架构设计铁三角 | 架构师 + 执行器 + 审查员 | 96% | 复杂系统设计 |
| 技术选型专家组 | 架构师 + 数据分析师 + DevOps工程师 | 94% | 技术栈决策 |
| 系统重构团队 | 架构师 + 调试器 + 撰写员 | 92% | 遗留系统现代化 |
| 企业级开发 | 架构师 + 产品经理 + AI/ML工程师 | 90% | 大型项目架构 |
核心职责
主要能力
- 项目分析: 深度分析现有代码库结构和技术栈
- 文档生成: 创建和维护项目导向文件 (
.ai-rules/) - 架构设计: 建立项目约定和最佳实践规范
- 上下文构建: 为其他AI代理提供项目背景信息
专业领域
- 项目初始化和配置
- 技术栈文档化
- 代码结构分析
- 开发规范制定
使用场景
何时使用架构师
适合的场景
bash
# 项目初始化
"我需要为这个 React 项目创建 AI 导向文件"
# 现有项目分析
"帮我分析这个项目的技术栈和结构"
# 文档创建
"为这个 Flutter 项目生成完整的项目文档"
# 规范建立
"建立这个团队项目的开发规范和约定"不适合的场景
bash
# 具体编码实现 (应使用执行器)
"实现用户登录功能"
# 代码调试 (应使用调试器)
"修复这个网络请求错误"
# 功能规划 (应使用规划师)
"设计一个电商购物车功能"生成的文件
架构师会在 .ai-rules/ 目录下创建三个核心文件：
1. product.md (产品文档)
yaml
---
title: "Flutter电商应用产品文档"
description: "产品愿景、功能和用户体验设计"
inclusion: always
---
# 产品概述
移动优先的电商平台，为用户提供便捷的购物体验。
## 目标用户
- 主要用户: 18-45岁移动购物用户
- 次要用户: 商家和平台管理员
## 核心功能
- 用户认证和个人资料管理
- 商品浏览和搜索功能
- 购物车和订单管理
- 支付集成和物流跟踪
- 用户评价和客服系统2. tech.md (技术文档)
yaml
---
title: "技术栈和开发环境"
description: "项目使用的技术、工具和开发约定"
inclusion: always
---
# 技术栈
## 前端技术
- Flutter 3.16.x - 跨平台移动开发框架
- Dart 3.2.x - 编程语言
- Provider 6.x - 状态管理
- Dio 5.x - HTTP 网络请求
- Hive 2.x - 本地数据存储
## 开发工具
- VS Code + Flutter插件
- Git + GitHub
- Docker 容器化
- GitHub Actions CI/CD
## 开发命令
```bash
# 开发环境
flutter run --debug
# 构建发布
flutter build apk --release
# 测试执行
flutter test3. structure.md (结构文档)
yaml
---
title: "项目结构和组织约定"
description: "代码组织方式和文件命名规范"
inclusion: always
---
# 项目结构lib/ ├── main.dart # 应用入口 ├── app/ # 应用级配置 ├── core/ # 核心功能模块 ├── features/ # 业务功能模块 │ ├── auth/ # 认证功能 │ ├── product/ # 商品功能
│ └── order/ # 订单功能 └── shared/ # 共享组件和服务
```dart
# 命名约定
- 文件名: snake_case.dart
- 类名: PascalCase
- 方法名: camelCase
- 常量: SCREAMING_SNAKE_CASE架构设计实战
1. 微服务架构设计
架构师擅长设计现代化的分布式系统架构：
API Gateway 设计
typescript
// API Gateway 配置设计
interface ApiGatewayConfig {
routing: {
userService: {
path: '/api/v1/users/*',
upstream: 'http://user-service:3001',
rateLimit: '1000/hour',
auth: 'jwt'
},
orderService: {
path: '/api/v1/orders/*',
upstream: 'http://order-service:3002',
rateLimit: '500/hour',
auth: 'jwt'
},
paymentService: {
path: '/api/v1/payments/*',
upstream: 'http://payment-service:3003',
rateLimit: '200/hour',
auth: 'jwt'
}
},
middleware: {
cors: {
origins: ['https://app.example.com'],
credentials: true
},
logging: {
level: 'info',
format: 'json'
},
circuitBreaker: {
threshold: 5,
timeout: 10000,
resetTimeout: 30000
}
}
}
// 服务发现和负载均衡
class ServiceDiscovery {
private services: Map<string, ServiceInstance[]> = new Map();
async registerService(name: string, instance: ServiceInstance): Promise<void> {
const instances = this.services.get(name) || [];
instances.push(instance);
this.services.set(name, instances);
// 健康检查
await this.performHealthCheck(instance);
}
getHealthyInstances(serviceName: string): ServiceInstance[] {
return this.services.get(serviceName)?.filter(i => i.healthy) || [];
}
private async performHealthCheck(instance: ServiceInstance): Promise<void> {
try {
const response = await fetch(`${instance.url}/health`);
instance.healthy = response.ok;
instance.lastCheck = Date.now();
} catch (error) {
instance.healthy = false;
console.error(`Health check failed for ${instance.url}:`, error);
}
}
}事件驱动架构
typescript
// 事件总线设计
interface EventBus {
publish<T>(eventName: string, data: T): Promise<void>;
subscribe<T>(eventName: string, handler: EventHandler<T>): void;
unsubscribe(eventName: string, handler: EventHandler<any>): void;
}
class MessageBusArchitecture implements EventBus {
private eventHandlers: Map<string, EventHandler<any>[]> = new Map();
private eventStore: EventStore;
constructor(eventStore: EventStore) {
this.eventStore = eventStore;
}
async publish<T>(eventName: string, data: T): Promise<void> {
// 持久化事件
const event: DomainEvent<T> = {
id: generateUUID(),
name: eventName,
data,
timestamp: new Date(),
version: 1
};
await this.eventStore.saveEvent(event);
// 分发事件
const handlers = this.eventHandlers.get(eventName) || [];
const promises = handlers.map(handler =>
this.safeExecuteHandler(handler, event)
);
await Promise.allSettled(promises);
}
subscribe<T>(eventName: string, handler: EventHandler<T>): void {
const handlers = this.eventHandlers.get(eventName) || [];
handlers.push(handler);
this.eventHandlers.set(eventName, handlers);
}
private async safeExecuteHandler<T>(
handler: EventHandler<T>,
event: DomainEvent<T>
): Promise<void> {
try {
await handler(event);
} catch (error) {
console.error(`Event handler failed for ${event.name}:`, error);
// 实现重试机制或死信队列
await this.handleFailedEvent(event, error);
}
}
}
// 领域事件定义
interface UserRegisteredEvent {
userId: string;
email: string;
registrationTime: Date;
}
interface OrderCreatedEvent {
orderId: string;
userId: string;
items: OrderItem[];
totalAmount: number;
}
// 事件处理器
class UserNotificationHandler {
async handle(event: DomainEvent<UserRegisteredEvent>): Promise<void> {
const { userId, email } = event.data;
// 发送欢迎邮件
await this.emailService.sendWelcomeEmail(email);
// 创建用户配置文件
await this.profileService.createDefaultProfile(userId);
// 发布后续事件
await this.eventBus.publish('UserProfileCreated', {
userId,
profileId: generateUUID()
});
}
}2. 数据库架构设计
多数据库策略
typescript
// 数据库架构配置
interface DatabaseArchitecture {
primary: {
type: 'postgresql';
config: {
host: 'primary-db.internal';
port: 5432;
database: 'ecommerce_main';
connectionPool: {
min: 5;
max: 20;
idle: 10000;
}
}
};
readReplicas: [
{
type: 'postgresql';
config: {
host: 'read-replica-1.internal';
port: 5432;
database: 'ecommerce_main';
readonly: true;
}
}
];
cache: {
type: 'redis';
config: {
host: 'redis-cluster.internal';
port: 6379;
ttl: 3600;
cluster: true;
}
};
search: {
type: 'elasticsearch';
config: {
host: 'es-cluster.internal';
port: 9200;
indices: {
products: 'products_v1';
orders: 'orders_v1';
}
}
};
}
// 数据访问层抽象
abstract class Repository<T> {
protected abstract tableName: string;
async findById(id: string): Promise<T | null> {
// 先查缓存
const cached = await this.cacheService.get(`${this.tableName}:${id}`);
if (cached) return cached;
// 查询数据库
const result = await this.database.query(
`SELECT * FROM ${this.tableName} WHERE id = $1`,
[id]
);
if (result.rows[0]) {
// 缓存结果
await this.cacheService.set(
`${this.tableName}:${id}`,
result.rows[0],
3600
);
}
return result.rows[0] || null;
}
async create(entity: Omit<T, 'id'>): Promise<T> {
const id = generateUUID();
const now = new Date();
const result = await this.database.query(
`INSERT INTO ${this.tableName} (id, ...columns, created_at, updated_at)
VALUES ($1, ...values, $2, $3) RETURNING *`,
[id, ...Object.values(entity), now, now]
);
const created = result.rows[0];
// 失效相关缓存
await this.invalidateCache(created);
return created;
}
protected abstract invalidateCache(entity: T): Promise<void>;
}3. 前端架构设计
模块化前端架构
typescript
// 前端架构配置
interface FrontendArchitecture {
framework: 'react' | 'vue' | 'angular';
stateManagement: 'redux' | 'zustand' | 'vuex' | 'pinia';
routing: 'react-router' | 'vue-router' | 'angular-router';
styling: 'styled-components' | 'emotion' | 'tailwind' | 'sass';
bundler: 'webpack' | 'vite' | 'parcel';
testing: 'jest' | 'vitest' | 'cypress' | 'playwright';
}
// 模块化组件架构
interface ComponentArchitecture {
// 原子设计系统
atoms: {
Button: ComponentSpec;
Input: ComponentSpec;
Icon: ComponentSpec;
Typography: ComponentSpec;
};
molecules: {
SearchBox: ComponentSpec;
FormField: ComponentSpec;
ProductCard: ComponentSpec;
};
organisms: {
Header: ComponentSpec;
ProductGrid: ComponentSpec;
CheckoutForm: ComponentSpec;
};
templates: {
ProductListPage: ComponentSpec;
ProductDetailPage: ComponentSpec;
CheckoutPage: ComponentSpec;
};
}
// React 架构示例
class ModularReactArchitecture {
// Higher-Order Component 模式
static withAuthentication<P extends {}>(
WrappedComponent: React.ComponentType<P>
): React.ComponentType<P> {
return (props: P) => {
const { user, isLoading } = useAuth();
if (isLoading) return <LoadingSpinner />;
if (!user) return <Navigate to="/login" />;
return <WrappedComponent {...props} />;
};
}
// 状态管理架构
static createStore() {
return configureStore({
reducer: {
auth: authReducer,
products: productsReducer,
cart: cartReducer,
orders: ordersReducer,
},
middleware: (getDefaultMiddleware) =>
getDefaultMiddleware({
serializableCheck: {
ignoredActions: ['persist/PERSIST'],
},
}).concat(
apiMiddleware,
errorMiddleware,
analyticsMiddleware
),
});
}
// 路由架构
static createRoutes(): RouteObject[] {
return [
{
path: '/',
element: <RootLayout />,
children: [
{
index: true,
element: <HomePage />,
},
{
path: 'products',
element: <ProductsLayout />,
children: [
{
index: true,
element: <ProductListPage />,
},
{
path: ':id',
element: <ProductDetailPage />,
loader: productDetailLoader,
},
],
},
{
path: 'checkout',
element: this.withAuthentication(CheckoutPage),
},
],
},
];
}
}4. 云原生架构设计
Kubernetes 部署架构
yaml
# 容器编排架构
apiVersion: v1
kind: Namespace
metadata:
name: ecommerce-system
---
# 用户服务部署
apiVersion: apps/v1
kind: Deployment
metadata:
name: user-service
namespace: ecommerce-system
spec:
replicas: 3
selector:
matchLabels:
app: user-service
template:
metadata:
labels:
app: user-service
spec:
containers:
- name: user-service
image: ecommerce/user-service:v1.2.0
ports:
- containerPort: 3000
env:
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: db-credentials
key: user-db-url
- name: REDIS_URL
valueFrom:
configMapKeyRef:
name: cache-config
key: redis-url
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /ready
port: 3000
initialDelaySeconds: 5
periodSeconds: 5
---
# 服务发现
apiVersion: v1
kind: Service
metadata:
name: user-service
namespace: ecommerce-system
spec:
selector:
app: user-service
ports:
- protocol: TCP
port: 80
targetPort: 3000
type: ClusterIP
---
# 负载均衡和外部访问
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: api-gateway
namespace: ecommerce-system
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
nginx.ingress.kubernetes.io/rate-limit: "100"
nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
tls:
- hosts:
- api.ecommerce.com
secretName: api-tls-secret
rules:
- host: api.ecommerce.com
http:
paths:
- path: /api/users
pathType: Prefix
backend:
service:
name: user-service
port:
number: 80工作流程
Phase 1: 深度分析和初始创建
1. 技术栈分析
bash
# 扫描依赖文件
- package.json (Node.js/Flutter)
- pubspec.yaml (Flutter/Dart)
- requirements.txt (Python)
- Gemfile (Ruby)
# 识别框架和库
- 主编程语言
- 核心框架
- 状态管理
- 网络库
- 数据库2. 项目结构分析
bash
# 目录层次映射
- 根目录结构
- 源码组织方式
- 资源文件分布
- 配置文件位置
# 架构模式识别
- MVC/MVP/MVVM
- 分层架构
- 模块化设计
- 领域驱动设计3. 产品愿景分析
bash
# 文档分析
- README.md
- 项目描述
- 功能说明
# 代码推断
- 路由定义
- API 端点
- 用户界面组件
- 业务逻辑模块Phase 2: 交互式优化
协作策略
- 逐一展示: 一次展示一个文件，便于集中讨论
- 区分事实和推测: 明确标识确定的信息和推测内容
- 突出关键问题: 标识需要用户确认的重要信息
- 迭代优化: 根据反馈不断完善文档内容
使用技巧
1. 项目初始化最佳实践
bash
# 完整的项目分析命令
claude --agent=architect "分析这个项目并创建完整的AI导向文件"
# 针对特定文件的分析
claude --agent=architect "分析 package.json 并生成技术栈文档"
# 更新现有文档
claude --agent=architect "更新项目的技术栈文档，我们刚加入了 Redux"2. 文档质量检查
架构师会确保生成的文档包含：
product.md 质量标准
- [ ] 清晰的产品愿景
- [ ] 明确的目标用户
- [ ] 详细的功能列表
- [ ] 用户体验原则
tech.md 质量标准
- [ ] 完整的技术栈信息
- [ ] 开发工具和环境
- [ ] 构建和部署命令
- [ ] 依赖版本信息
structure.md 质量标准
- [ ] 详细的目录结构
- [ ] 清晰的命名约定
- [ ] 架构模式说明
- [ ] 文件组织原则
3. 团队协作优化
bash
# 为团队项目创建标准化文档
claude --agent=architect "为我们的团队项目建立标准的开发规范"
# 多项目统一规范
claude --agent=architect "基于现有项目创建通用的技术栈模板"高级功能
1. 自定义分析规则
yaml
# 自定义架构师配置
analysis_rules:
technology_detection:
priority: [package.json, pubspec.yaml, requirements.txt]
depth: 3
structure_mapping:
ignore_patterns: [node_modules, .git, build]
focus_directories: [src, lib, app]
documentation_style:
format: markdown
include_diagrams: true2. 模板化文档生成
bash
# 使用预定义模板
claude --agent=architect --template=flutter "为Flutter项目生成标准文档"
# 自定义模板
claude --agent=architect --template=custom "使用我们团队的文档模板"3. 持续文档维护
bash
# 检测项目变化
claude --agent=architect --sync "检查项目变更并更新文档"
# 版本对比分析
claude --agent=architect --compare "对比当前版本和上次分析的差异"分析报告
架构师会生成详细的分析报告：
技术栈健康度评估
yaml
技术栈评估:
依赖管理**:良好
版本一致性**:部分过时
安全性**:无已知漏洞
性能优化**:需要优化项目结构质量分析
yaml
结构质量:
模块化程度: 85%
命名一致性: 92%
代码组织: 良好
可维护性: 高性能指标与成功案例
架构设计成功率
- 系统可用性: 设计的系统平均可用性达到99.9%
- 性能提升: 架构优化后平均性能提升65%
- 技术债务减少: 重构后技术债务平均减少78%
- 团队开发效率: 标准化架构让团队开发效率提升45%
真实成功案例
案例1: 电商平台微服务化
yaml
项目背景:
- 传统单体应用，10万+日活用户
- 面临性能瓶颈和团队协作困难
架构师解决方案:
- 设计微服务架构，拆分为8个独立服务
- 实施API Gateway统一入口
- 引入事件驱动架构处理订单流程
结果:
- 响应时间从2.5s降低到800ms
- 团队可并行开发，效率提升60%
- 系统可用性从95%提升到99.8%案例2: 金融系统云原生改造
yaml
项目背景:
- 传统银行核心系统
- 需要支持高并发和数据一致性
架构师解决方案:
- 设计分布式事务处理架构
- 实施CQRS和Event Sourcing模式
- 构建多层缓存和读写分离
结果:
- 处理能力从1000TPS提升到10000TPS
- 数据一致性达到99.99%
- 系统维护成本降低40%架构决策工具
技术栈选择矩阵
typescript
interface TechStackDecisionMatrix {
criteria: {
performance: number; // 性能要求 (1-10)
scalability: number; // 可扩展性 (1-10)
teamExpertise: number; // 团队熟悉度 (1-10)
communitySupport: number; // 社区支持 (1-10)
maintenanceCost: number; // 维护成本 (1-10, 越低越好)
};
options: {
[techStack: string]: {
scores: Record<keyof criteria, number>;
totalScore: number;
recommendation: 'recommended' | 'acceptable' | 'not-recommended';
};
};
}
// 实际决策示例
const frontendFrameworkDecision: TechStackDecisionMatrix = {
criteria: {
performance: 8,
scalability: 7,
teamExpertise: 9,
communitySupport: 8,
maintenanceCost: 6
},
options: {
'React + TypeScript': {
scores: {
performance: 8,
scalability: 9,
teamExpertise: 9,
communitySupport: 10,
maintenanceCost: 7
},
totalScore: 8.6,
recommendation: 'recommended'
},
'Vue 3 + TypeScript': {
scores: {
performance: 8,
scalability: 8,
teamExpertise: 7,
communitySupport: 8,
maintenanceCost: 8
},
totalScore: 7.8,
recommendation: 'acceptable'
}
}
};架构风险评估
typescript
interface ArchitectureRiskAssessment {
riskCategories: {
technical: {
complexity: 'low' | 'medium' | 'high';
techDebt: 'low' | 'medium' | 'high';
dependencies: 'low' | 'medium' | 'high';
};
operational: {
scalability: 'low' | 'medium' | 'high';
monitoring: 'low' | 'medium' | 'high';
deployment: 'low' | 'medium' | 'high';
};
business: {
timeToMarket: 'low' | 'medium' | 'high';
resourceRequirement: 'low' | 'medium' | 'high';
futureFlexibility: 'low' | 'medium' | 'high';
};
};
overallRisk: 'low' | 'medium' | 'high';
mitigationStrategies: string[];
recommendations: string[];
}常见问题
Q: 如何选择合适的架构模式？
A: 架构师提供系统性的架构模式选择指导：
bash
# 单体应用 vs 微服务决策
"分析当前项目规模，团队大小为8人，日活用户5万，推荐哪种架构？"
# 数据库架构选择
"电商订单系统，需要强一致性，应该选择什么数据库架构？"
# 前端架构决策
"企业内部管理系统，需要支持复杂的业务逻辑，推荐什么前端架构？"Q: 架构师如何处理技术债务？
A: 架构师提供系统性的技术债务管理策略：
typescript
// 技术债务识别和优先级排序
interface TechDebtAssessment {
codeQuality: {
complexity: number; // 代码复杂度评分
duplication: number; // 代码重复率
testCoverage: number; // 测试覆盖率
};
architecturalDebt: {
couplingScore: number; // 耦合度评分
modularityScore: number; // 模块化程度
documentationScore: number; // 文档完整性
};
priorityMatrix: {
impact: 'low' | 'medium' | 'high';
effort: 'low' | 'medium' | 'high';
priority: 'low' | 'medium' | 'high' | 'critical';
};
}Q: 如何进行系统性能优化？
A: 架构师提供全方位的性能优化策略：
bash
# 性能瓶颈分析
"分析系统性能瓶颈，当前响应时间2秒，目标是500ms以内"
# 数据库性能优化
"数据库查询慢，单表数据量500万，如何优化查询性能？"
# 缓存架构设计
"设计多层缓存架构，提升系统整体性能"Q: 如何设计高可用系统？
A: 架构师提供企业级高可用架构设计：
yaml
高可用架构设计原则:
冗余设计:
- 多实例部署
- 跨区域备份
- 数据库主从复制
故障隔离:
- 服务熔断机制
- 降级策略
- 限流保护
快速恢复:
- 健康检查
- 自动故障转移
- 快速部署能力
监控告警:
- 实时监控
- 异常告警
- 性能分析Q: 如何为团队建立技术规范？
A: 架构师帮助建立完整的技术规范体系：
bash
# 代码规范制定
"为前端团队制定React + TypeScript的编码规范"
# API设计规范
"建立RESTful API设计规范，包括命名、状态码、错误处理"
# 数据库设计规范
"制定数据库表设计规范，包括命名约定、索引规则"
# 部署流程规范
"建立从开发到生产的标准化部署流程"最佳实践
1. 定期更新文档
bash
# 月度文档同步
claude --agent=architect "检查项目变更并更新所有导向文件"2. 版本化管理
bash
# 为重大版本更新文档
claude --agent=architect "为 v2.0 版本更新项目文档"3. 多环境支持
bash
# 不同环境的配置文档
claude --agent=architect "创建开发、测试、生产环境的配置说明"相关资源
架构师 - 为您的项目构建清晰的技术蓝图