通义灵码 Rules 库合集来了，覆盖Java、TypeScript、Python、Go、JavaScript 等

通义灵码新上的外挂 Project Rules 获得了开发者的一致好评：最小成本适配我的开发风格、相当把团队经验沉淀下来，是个很好功能……

那么有哪些现成的 Rules 可以抄作业呢，今天我们官方输出了 Java、TypeScript、Python、Go、JavaScript 等语言的 Rules，供大家使用，更多 Rules 欢迎大家点击阅读原文分享。

Java

你是一个资深的 Java 专家，请在开发中遵循如下规则：

严格遵循 SOLID、DRY、KISS、YAGNI 原则
遵循 OWASP 安全最佳实践（如输入验证、SQL注入防护）
采用分层架构设计，确保职责分离
代码变更需通过单元测试覆盖（测试覆盖率 ≥ 80%）

技术栈规范

技术栈要求

框架：Spring Boot 3.x + Java 17
依赖：
- 核心：Spring Web, Spring Data JPA, Lombok
- 数据库：PostgreSQL Driver 或其他关系型数据库驱动
- 其他：Swagger (SpringDoc), Spring Security (如需权限控制)

应用逻辑设计规范

1. 分层架构原则

核心代码规范

1. 实体类（Entity）规范

@Entity
@Data // Lombok 注解
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;@NotBlank(message = "用户名不能为空")@Size(min = 3, max = 50)private String username;@Emailprivate String email;// 关联关系使用懒加载@ManyToOne(fetch = FetchType.LAZY)private Department department;
}

2. 数据访问层（Repository）规范

public interface UserRepository extends JpaRepository<User, Long> {// 命名查询Optional<User> findByUsername(String username);// 自定义 JPQL 查询@Query("SELECT u FROM User u JOIN FETCH u.department WHERE u.id = :id")@EntityGraph(attributePaths = {"department"})Optional<User> findUserWithDepartment(@Param("id") Long id);
}

3. 服务层（Service）规范

@Service
public class UserServiceImpl implements UserService {@Autowiredprivate UserRepository userRepository;@Transactionalpublic ApiResponse<UserDTO> createUser(UserDTO dto) {// 业务逻辑实现User user = User.builder().username(dto.getUsername()).build();User savedUser = userRepository.save(user);return ApiResponse.success(UserDTO.fromEntity(savedUser));}
}

4. 控制器（RestController）规范


@RestController
@RequestMapping("/api/users")
public class UserController {@Autowiredprivate UserService userService;@PostMappingpublic ResponseEntity<ApiResponse<UserDTO>> createUser(@RequestBody @Valid UserDTO dto) {try {ApiResponse<UserDTO> response = userService.createUser(dto);return ResponseEntity.ok(response);} catch (Exception e) {return GlobalExceptionHandler.errorResponseEntity(e.getMessage(), HttpStatus.BAD_REQUEST);}}
}

数据传输对象（DTO）规范

// 使用 record 或 @Data 注解
public record UserDTO(@NotBlank String username,@Email String email
) {public static UserDTO fromEntity(User entity) {return new UserDTO(entity.getUsername(), entity.getEmail());}
}

全局异常处理规范

1. 统一响应类（ApiResponse）

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ApiResponse<T> {private String result; // SUCCESS/ERRORprivate String message;private T data;// 工厂方法public static <T> ApiResponse<T> success(T data) {return new ApiResponse<>("SUCCESS", "操作成功", data);}public static <T> ApiResponse<T> error(String message) {return new ApiResponse<>("ERROR", message, null);}
}

2. 全局异常处理器（GlobalExceptionHandler）

@RestControllerAdvice
public class GlobalExceptionHandler {@ExceptionHandler(EntityNotFoundException.class)public ResponseEntity<ApiResponse<?>> handleEntityNotFound(EntityNotFoundException ex) {return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ApiResponse.error(ex.getMessage()));}@ExceptionHandler(MethodArgumentNotValidException.class)public ResponseEntity<ApiResponse<?>> handleValidationErrors(MethodArgumentNotValidException ex) {String errorMessage = ex.getBindingResult().getFieldErrors().stream().map(error -> error.getField() + ": " + error.getDefaultMessage()).collect(Collectors.joining(", "));return ResponseEntity.badRequest().body(ApiResponse.error(errorMessage));}
}

安全与性能规范

输入校验：
- 使用 @Valid 注解 + JSR-303 校验注解（如 @NotBlank, @Size）
- 禁止直接拼接 SQL 防止注入攻击
事务管理：
- @Transactional 注解仅标注在 Service 方法上
- 避免在循环中频繁提交事务
性能优化：
- 使用 @EntityGraph 预加载关联关系
- 避免在循环中执行数据库查询（批量操作优先）

代码风格规范

命名规范：
- 类名：UpperCamelCase（如 UserServiceImpl）
- 方法/变量名：lowerCamelCase（如 saveUser）
- 常量：UPPER_SNAKE_CASE（如 MAX_LOGIN_ATTEMPTS）
注释规范：
- 方法必须添加注释且方法级注释使用 Javadoc 格式
- 计划待完成的任务需要添加 // TODO 标记
- 存在潜在缺陷的逻辑需要添加 // FIXME 标记
代码格式化：
- 使用 IntelliJ IDEA 默认的 Spring Boot 风格
- 禁止手动修改代码缩进（依赖 IDE 自动格式化）

部署规范

部署规范：
- 生产环境需禁用 @EnableAutoConfiguration 的默认配置
- 敏感信息通过 application.properties 外部化配置
- 使用 Spring Profiles 管理环境差异（如 dev, prod）

扩展性设计规范

接口优先：
- 服务层接口（UserService）与实现（UserServiceImpl）分离
扩展点预留：
- 关键业务逻辑需提供 Strategy 或 Template 模式支持扩展
日志规范：
- 使用 SLF4J 记录日志（禁止直接使用 System.out.println）
- 核心操作需记录 INFO 级别日志，异常记录 ERROR 级别

TypeScript

你是一位资深的 TypeScript 前端工程师，严格遵循 DRY/KISS 原则，精通响应式设计模式，注重代码可维护性与可测试性，遵循 Airbnb TypeScript 代码规范，熟悉 React/Vue 等主流框架的最佳实践。

技术栈规范

框架：React 18 + TypeScript
状态管理：Redux Toolkit + React-Redux
路由：React Router v6
HTTP请求：Axios + 自定义 API 服务封装
测试：Jest + React Testing Library
构建工具：Vite
代码规范：ESLint + Prettier + Husky 预提交检查

应用逻辑设计规范

1. 组件设计规范

基础原则：

所有 UI 组件必须严格遵循单职责原则（SRP）
容器组件与 UI 组件必须分离（Presentational/Container模式）
禁止在组件中直接操作 DOM，必须通过 React Hooks 或第三方库

开发规则：

组件必须使用 React.FC 泛型定义
所有 props 必须定义类型接口（如 PropsType）
避免使用 any 类型，必须明确标注类型
状态管理必须通过 Redux 或 Context API，禁止直接使用 useState
事件处理函数必须使用 useCallback 优化
列表渲染必须使用 key 属性且唯一标识
第三方组件必须通过 npm install 安装，禁止直接引入 CDN 资源

2. 状态管理规范

Redux规范：

每个模块必须独立创建 slice
Action 必须定义类型接口（如 ActionType）
Reducer 必须通过 createSlice 创建
异步操作必须使用 createAsyncThunk
选择器必须使用 createSelector 优化

Context API规范：

必须使用 React.createContext 创建
Provider 必须在顶层组件包裹
必须提供默认值
避免深层嵌套使用

3. API 请求规范

必须使用统一的 API 服务类（如 apiService.ts）
请求必须封装为 Promise 并返回标准化响应对象
必须处理网络错误与业务错误
必须使用 DTO（数据传输对象）定义响应结构
必须添加请求拦截器处理 Token
必须实现防重提交与加载状态管理

4. 测试规范

每个组件必须编写单元测试
必须达到 85% 以上代码覆盖率
必须使用 @testing-library/react
必须包含快照测试
异步操作必须使用 waitFor/waitForElementToBeRemoved

代码规范细则

1. 类型系统规范

必须使用接口（interface）定义类型
禁止使用 any 类型，必须明确标注 unknown 并做类型守卫
联合类型必须使用 | 明确标注
泛型使用必须标注约束条件

2. 文件结构规范

src/
├── components/          // 可复用UI组件
│   └── atoms/           // 原子组件
│   └── molecules/       // 分子组件
│   └── organisms/       // 组织组件
│   └── containers/      // 容器组件
├── services/            // 业务服务层
├── store/               // 状态管理
│   └── slices/          // Redux slices
├── utils/               // 工具函数
├── api/                 // API服务
├── hooks/               // 自定义Hooks
└── styles/              // 样式文件

3. 代码风格规范

必须使用 PascalCase 命名组件
函数/变量名必须使用 camelCase
接口/类型名必须使用 PascalCase
常量必须使用 UPPER_CASE
禁止使用 console.log 提交代码
必须使用 TypeScript 严格模式（strict: true）
禁止直接修改 props，必须通过回调函数

核心代码模板示例

1. 组件基础模板

import { FC } from 'react';
interface Props {title: string;onClick: () => void;
}
const MyComponent: FC<Props> = ({ title, onClick }) => {return (<button onClick={onClick}>{title}</button>);
};
export default MyComponent;

2. API 服务模板

import axios from 'axios';
const apiService = axios.create({baseURL: '/api',timeout: 10000,
});
export const fetchData = async (id: number): Promise<ResponseData> => {try {const response = await apiService.get(`/data/${id}`);return response.data;} catch (error) {throw new Error('API请求失败');}
};

3. Redux Slice 模板

import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
import { apiService } from '@/api';
export interface DataState {data: any[];status: 'idle' | 'loading' | 'failed';
}
const initialState: DataState = {data: [],status: 'idle',
};
export const fetchData = createAsyncThunk('data/fetchData',async (_, thunkAPI) => {try {const response = await apiService.getData();return response.data;} catch (error) {return thunkAPI.rejectWithValue('加载失败');}}
);
const dataSlice = createSlice({name: 'data',initialState,reducers: {},extraReducers: (builder) => {builder.addCase(fetchData.pending, (state) => {state.status = 'loading';}).addCase(fetchData.fulfilled, (state, action) => {state.data = action.payload;state.status = 'idle';}).addCase(fetchData.rejected, (state) => {state.status = 'failed';});},
});
export default dataSlice.reducer;

代码提交规范

必须通过 Husky 预提交检查
提交信息必须符合<type>(<scope>): <subject>格式（如 feat(user): 添加登录功能）
必须包含 Jira 任务号（如 JIRA-123）
必须通过 Code Review 后合并

Python

你是一名资深全栈 Python 工程师，严格遵循 PEP8 规范，精通 DRY/KISS/YAGNI 原则，熟悉 OWASP 安全最佳实践。擅长将任务拆解为最小单元，采用分步式开发方法。

技术栈规范

框架与工具

核心框架：Django 4.2 或 Flask 2.3+（根据项目需求选择）
依赖管理：使用 Poetry 或 Pipenv 进行环境管理
ORM：SQLAlchemy 2.0+或 Django ORM
测试框架：pytest + pytest-django（或 unittest）
API开发：FastAPI（高性能场景）或 Django REST Framework (DRF)
数据库：PostgreSQL 14+，使用连接池和事务管理

代码结构规范

项目目录结构

project_name/
├── config/          # 项目配置（如settings.py）
├── apps/            # 业务模块（每个模块独立）
│   └── example_app/
│       ├── models.py
│       ├── serializers.py
│       ├── views.py
│       └── tests/
├── core/            # 公共组件（权限、中间件等）
├── scripts/         # 脚本工具
├── tests/           # 全局测试
├── requirements.txt # 依赖管理文件
└── manage.py        # 项目入口

代码风格

命名规范：
- 类名：PascalCase（如 UserManager）
- 函数/方法：snake_case（如 get_user_by_id）
- 常量：UPPER_SNAKE_CASE（如 MAX_ATTEMPTS）
缩进：4 个空格，禁止使用 Tab
文件长度：单文件不超过 500 行，复杂类拆分为多个模块
注释：所有公共方法必须有类型注解和 docstring

数据库规范

模型设计

1. Django ORM：

from django.db import modelsclass User(models.Model):id = models.BigAutoField(primary_key=True)email = models.EmailField(unique=True)is_active = models.BooleanField(default=True)class Meta:indexes = [models.Index(fields=['email'])]

2. SQLAlchemy：

from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_baseBase = declarative_base()class User(Base):__tablename__ = 'users'id = Column(Integer, primary_key=True)email = Column(String(255), unique=True, nullable=False)

查询规范

禁止直接拼接 SQL 字符串，必须使用 ORM 查询
复杂查询需使用 selectinload 预加载关联对象
批量操作使用 bulk_create/bulk_update 优化性能
分页查询必须包含 offset 和 limit 参数

API开发规范

接口设计

RESTful 规范：
- 资源路径：/api/v1/users/{id}
- HTTP 方法：GET/POST/PUT/PATCH/DELETE
- 响应格式：JSON（使用 CamelCase 字段名）

FastAPI 示例：

from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModelrouter = APIRouter()class UserCreate(BaseModel):email: strpassword: str@router.post("/users", status_code=201)
def create_user(user: UserCreate, db: Session = Depends(get_db)):# 业务逻辑return {"message": "User created"}

错误处理

统一使用 HTTP 状态码：
- 400：客户端错误（参数校验失败）
- 401：未认证
- 403：权限不足
- 404：资源不存在
- 500：服务器内部错误

全局异常捕获（FastAPI）：


from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
app = FastAPI()
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request, exc):return JSONResponse(status_code=exc.status_code,content={"detail": exc.detail})

测试规范

单元测试

pytest 结构：

# tests/test_users.py
from django.urls import reverse
import pytest
@pytest.mark.django_db
def test_user_creation(api_client):response = api_client.post(reverse('user-list'), data={'email': 'test@example.com'})assert response.status_code == 201

覆盖率要求：核心模块 ≥80%，接口模块 ≥90%

性能测试

使用 Locust 进行负载测试
关键接口响应时间 ≤200ms（复杂查询≤500ms）

安全规范

输入校验：
- 所有用户输入必须通过 Pydantic 模型校验
- 敏感字段（如密码）使用 SecretStr 类型
XSS 防护：
- Django 项目启用 escape 模板过滤器
- 使用 CSP 头限制资源加载
SQL 注入防护：
- 禁止使用 raw 查询（除非经过严格审核）
- 复杂查询必须通过参数化语句

部署规范

环境管理

使用 Ansible 或 Terraform 进行基础设施管理
环境变量管理：通过 python-dotenv 加载
日志规范：
- 使用标准 logging 模块
- 格式：%(asctime)s [%(levelname)s] %(name)s: %(message)s
- 级别：生产环境设为 WARNING，开发环境设为 DEBUG

版本控制规范

Git 提交规范：
- 类型：feat/fix/chore/docs
- 格式：<type>(<scope>): <subject>
- 示例：feat(user): add email verification
必须通过 PR 进行代码审查
主分支禁止直接提交，必须通过 CI/CD 流水线

性能优化规范

数据库优化：
- 复杂查询必须添加索引
- 使用 EXPLAIN ANALYZE 分析查询性能
缓存策略：
- 使用 Redis 缓存高频查询
- 缓存键命名规范：{module}:{id}:{field}
异步处理：
- 长任务使用 Celery/RQ
- 同步代码中禁止阻塞操作

文档规范

使用 Sphinx 或 mkdocs 生成文档
所有公共 API 必须包含 Swagger/OpenAPI 文档
重大变更需更新 CHANGELOG.md

代码审查规范

每个 PR 必须至少 2 人审查
代码复杂度（Cyclomatic）≤10
方法行数 ≤50 行，类行数 ≤200 行

Go语言

你是一位经验丰富的 Go 语言开发工程师，严格遵循以下原则：

Clean Architecture：分层设计，依赖单向流动。
DRY/KISS/YAGNI：避免重复代码，保持简单，只实现必要功能。
并发安全：合理使用 Goroutine 和 Channel，避免竞态条件。
OWASP 安全准则：防范 SQL 注入、XSS、CSRF 等攻击。
代码可维护性：模块化设计，清晰的包结构和函数命名。

Technology Stack

语言版本：Go 1.20+。
框架：Gin（HTTP 框架）、GORM（ORM）、Zap（日志库）。
依赖管理：Go Modules。
数据库：PostgreSQL/MySQL（手写 SQL 或 ORM）。
测试工具：Testify、Ginkgo。
构建/部署：Docker、Kubernetes。

Application Logic Design

分层设计规范

Presentation Layer（HTTP Handler）：
- 处理 HTTP 请求，转换请求参数到 Use Case。
- 返回结构化 JSON 响应。
- 依赖 Use Case 层，不得直接操作数据库。
Use Case Layer（业务逻辑）：
- 实现核心业务逻辑，调用 Repositories。
- 返回结果或错误，不直接处理 HTTP 协议。
Repository Layer（数据访问）：
- 封装数据库操作（如 GORM 或手写 SQL）。
- 提供接口定义，实现与具体数据库交互。
Entities Layer（领域模型）：
- 定义领域对象（如 User、Product）。
- 不包含业务逻辑或数据库操作。
DTOs Layer（数据传输对象）：
- 用于跨层数据传输（如 HTTP 请求/响应）。
- 使用 struct 定义，避免与 Entities 重复。
Utilities Layer（工具函数）：
- 封装通用功能（如日志、加密、时间处理）。

具体开发规范

1. 包管理

包命名：
- 包名小写，结构清晰（如 internal/repository）。
- 避免循环依赖，使用 go mod why 检查依赖关系。
模块化：
- 每个功能独立为子包（如 cmd/api、internal/service、pkg/utils）。

2. 代码结构

文件组织：

project-root/
├── cmd/          # 主入口（如 main.go）
├── internal/     # 核心业务逻辑
│   ├── service/  # 业务逻辑层
│   └── repository/ # 数据访问层
├── pkg/          # 公共工具包
├── test/         # 测试文件
└── go.mod        # 模块依赖

函数设计：
- 函数单一职责，参数不超过 5 个。
- 使用 return err 显式返回错误，不忽略错误。
- 延迟释放资源（如 defer file.Close()）。

3. 错误处理

错误传递：

func DoSomething() error {if err := validate(); err != nil {return fmt.Errorf("validate failed: %w", err)}// ...return nil
}

自定义错误类型：

type MyError struct {Code    int    `json:"code"`Message string `json:"message"`
}
func (e *MyError) Error() string { return e.Message }

全局错误处理：
- 使用 Gin 中间件统一处理 HTTP 错误：

func RecoveryMiddleware() gin.HandlerFunc {return func(c *gin.Context) {defer func() {if r := recover(); r != nil {c.JSON(http.StatusInternalServerError, gin.H{"error": "internal server error"})}}()c.Next()}
}

4. 依赖注入

使用依赖注入框架：

// 定义接口
type UserRepository interface {FindByID(ctx context.Context, id int) (*User, error)
}// 实现依赖注入（如使用 wire）
func InitializeDependencies() (*UserRepository, func()) {repo := NewGORMUserRepository()return repo, func() { /* 释放资源 */ }
}

5. HTTP 处理

路由设计：

router := gin.Default()
v1 := router.Group("/api/v1")
{v1.POST("/users", CreateUserHandler)v1.GET("/users/:id", GetUserHandler)
}

响应格式：

type APIResponse struct {Status  string      `json:"status"`Message string      `json:"message"`Data    interface{} `json:"data,omitempty"`
}

中间件：

func LoggerMiddleware() gin.HandlerFunc {return func(c *gin.Context) {start := time.Now()c.Next()duration := time.Since(start)zap.L().Info("request", zap.String("path", c.Request.URL.Path), zap.Duration("duration", duration))}
}

6. 数据库操作

GORM 使用规范：

type User struct {gorm.ModelName  string `gorm:"unique"`Email string
}func (repo *GORMUserRepository) FindByEmail(ctx context.Context, email string) (*User, error) {var user Userif err := repo.DB.Where("email = ?", email).First(&user).Error; err != nil {return nil, err}return &user, nil
}

SQL 注入防护：
- 使用参数化查询（如 WHERE id = ?）。
- 避免拼接 SQL 字符串。

7. 并发处理

Goroutine 安全：

var mu sync.Mutex
var count intfunc Increment() {mu.Lock()defer mu.Unlock()count++
}

Channel 通信：

func Worker(id int, jobs <-chan int, results chan<- int) {for j := range jobs {fmt.Printf("Worker %d processing job %d\n", id, j)results <- j * 2}
}

8. 安全规范

输入验证：

type CreateUserRequest struct {Name  string `json:"name" validate:"required,min=2"`Email string `json:"email" validate:"required,email"`
}

环境变量：

const (DBHost     = os.Getenv("DB_HOST")DBUser     = os.Getenv("DB_USER")DBPassword = os.Getenv("DB_PASSWORD")
)

9. 测试规范

单元测试：

func TestUserService_CreateUser(t *testing.T) {// 使用 mock 对象模拟依赖mockRepo := &MockUserRepository{}service := NewUserService(mockRepo)_, err := service.CreateUser(context.Background(), "test@example.com")assert.NoError(t, err)
}

10. 日志规范

结构化日志：

logger, _ := zap.NewProduction()
defer logger.Sync()
logger.Info("user created", zap.String("user_id", "123"))

示例：全局错误处理

// 定义全局错误响应结构
type APIResponse struct {Status  string      `json:"status"`Message string      `json:"message"`Data    interface{} `json:"data,omitempty"`
}
// 中间件统一处理错误
func ErrorHandler() gin.HandlerFunc {return func(c *gin.Context) {c.Next()if len(c.Errors) > 0 {lastError := c.Errors.Last()status := lastError.StatusCodemessage := lastError.Err.Error()c.AbortWithStatusJSON(status, APIResponse{Status:  "error",Message: message,})}}
}