所有图片来自网络，侵权联系删除。
本文内容经 AI 辅助整理。
前言
在软件开发过程中，代码质量是决定项目成败的关键因素之一。代码质量不仅包括功能性代码质量，也涵盖非功能性代码质量。功能性代码质量大多可以通过测试发现问题，而非功能性代码质量则往往难以被用户直接感知。然而，代码质量的好坏直接影响软件的可维护性成本，最终影响开发者或组织自身的利益。因此，代码质量的保障至关重要，而代码评审（Code Review）则是其中不可或缺的一环。
一、代码评审的重要性
代码评审是保证代码质量的重要手段。通过建立良好的代码评审规范与习惯，技术团队能够有效提升代码质量，降低维护成本。没有代码评审的团队，往往难以在长期发展中保持代码的健康状态，甚至可能面临技术债务不断累积的风险。因此，代码评审不仅是技术团队的核心实践，更是保障项目可持续发展的关键。
二、代码评审的重点内容
（一）代码功能确认
代码的核心是实现产品需求，因此代码功能的确认是评审的首要任务。代码逻辑的严谨性和合理性是基本要求，同时需要考虑适当的扩展性。在代码的可扩展性和过度设计之间做出合理权衡，避免编写无用逻辑和与功能无关的附加代码。遵循“YAGNI”原则（You Aren’t Gonna Need It，你不需要它），即在真正需要某些功能时再去实现，而不是基于预判进行设计。
// 不好的示例：过度设计，包含了未来可能需要但当前不需要的功能
public class OrderProcessor {
// 当前只需要处理普通订单，但却设计了复杂的抽象和扩展点
public abstract class OrderHandler {
public abstract void process(Order order);
}
public class NormalOrderHandler extends OrderHandler {
@Override
public void process(Order order) {
// 处理普通订单逻辑
}
}
// 以下是当前不需要的功能
public class PremiumOrderHandler extends OrderHandler {
@Override
public void process(Order order) {
// 处理高级订单逻辑（当前未使用）
}
}
public class InternationalOrderHandler extends OrderHandler {
@Override
public void process(Order order) {
// 处理国际订单逻辑（当前未使用）
}
}
// ...
}
// 好的示例：只实现当前需要的功能，保持简洁
public class OrderProcessor {
public void processNormalOrder(Order order) {
// 只实现当前需要的普通订单处理逻辑
validateOrder(order);
calculatePrice(order);
saveOrder(order);
}
private void validateOrder(Order order) {
// 验证订单
}
private void calculatePrice(Order order) {
// 计算价格
}
private void saveOrder(Order order) {
// 保存订单
}
}
（二）编码规范检查
编码规范是代码质量的重要保障。以集团开发规约和静态代码规约为基础，确保代码遵循最佳实践。其中，命名规范尤为重要，良好的命名能够显著提高代码的可读性，降低维护成本。例如，变量名和函数名应清晰地表达其用途和功能，避免使用模糊或过于简短的命名。
// 不好的示例：命名不规范，难以理解
public class OPr {
// 变量名模糊不清
private int a;
private String s;
// 方法名不能表达功能
public void m1() {
// ...
}
// 常量命名不符合规范
public static final String pi = "3.14159";
}
// 好的示例：遵循编码规范，命名清晰
public class OrderProcessor {
// 变量名清晰表达用途
private int orderCount;
private String customerName;
// 方法名准确描述功能
public void calculateTotalPrice() {
// ...
}
// 常量命名规范
public static final String PI_VALUE = "3.14159";
// 缩进和格式规范
public void processOrder(Order order) {
if (order != null && order.isValid()) {
validateCustomer(order.getCustomer());
calculatePrice(order);
saveOrder(order);
} else {
log.error("Invalid order: {}", order);
}
}
}
（三）潜在的 BUG挖掘
代码中潜在的 BUG 是评审的重点之一。需要关注可能在最坏情况下出现问题的代码，包括线程安全、业务逻辑准确性、系统边界范围、参数校验，以及是否存在安全漏洞（如业务鉴权漏洞、灰产可利用漏洞）。通过代码评审，提前发现并修复这些问题，能够有效降低系统运行的风险。
// 不好的示例：存在潜在BUG
public class UserService {
// 1. 缺少参数校验
public User getUserById(Long id) {
return userDao.findById(id); // 如果id为null可能导致异常
}
// 2. 线程不安全
private int loginCount = 0;
public void login(User user) {
loginCount++; // 非线程安全的自增操作
// ...
}
// 3. 缺少权限校验
public void deleteUser(Long userId) {
userDao.delete(userId); // 任何人都能删除用户，存在安全漏洞
}
// 4. 边界条件处理不当
public List<User> getUsers(int page, int size) {
return userDao.find(page, size); // 未处理page或size为负数的情况
}
}
// 好的示例：修复潜在BUG
public class UserService {
// 1. 增加参数校验
public User getUserById(Long id) {
if (id == null || id <= 0) {
throw new IllegalArgumentException("Invalid user id: " + id);
}
return userDao.findById(id);
}
// 2. 保证线程安全
private AtomicInteger loginCount = new AtomicInteger(0);
public void login(User user) {
loginCount.incrementAndGet(); // 线程安全的自增操作
// ...
}
// 3. 增加权限校验
public void deleteUser(Long userId, User operator) {
// 检查操作者是否有权限
if (!permissionService.hasDeletePermission(operator)) {
throw new SecurityException("No permission to delete user");
}
userDao.delete(userId);
}
// 4. 正确处理边界条件
public List<User> getUsers(int page, int size) {
if (page < 1) {
page = 1;
}
if (size < 1 || size > 100) { // 限制最大每页条数
size = 20;
}
return userDao.find(page, size);
}
}
（四）文档和注释
文档和注释是代码的重要组成部分。文档和注释应与时俱进，与最新代码保持同步。避免出现过少（缺少必要信息）、过多（没有信息量）或过时的文档和注释。良好的变量和函数命名是最好的注释，清晰的代码结构往往比冗长的注释更具价值。例如，一个清晰命名的函数 calculateTotalPrice() 比一个模糊命名的函数 func1() 更容易理解。
// 不好的示例：注释不当
public class OrderUtil {
// 计算
public double m1(List<Product> p) {
double s = 0;
// 循环
for (int i = 0; i < p.size(); i++) {
// 累加
s += p.get(i).getPrice();
}
// 返回
return s;
}
/**
* 处理订单
* @param o 订单
* @return 结果
*/
// 这个方法现在不使用优惠券了，改用积分抵扣
public boolean process(Order o) {
o.setTotal(o.getSubtotal() - o.getCouponAmount());
return true;
}
}
// 好的示例：适当的注释和文档
/**
* 订单工具类，提供订单计算和处理相关方法
*/
public class OrderUtil {
/**
* 计算商品列表的总价格
*
* @param products 商品列表，不能为null
* @return 商品总价
*/
public double calculateTotalPrice(List<Product> products) {
double total = 0;
for (Product product : products) {
// 跳过赠品（价格为0的商品）
if (product.getPrice() > 0) {
total += product.getPrice();
}
}
return total;
}
/**
* 处理订单，应用积分抵扣
*
* @param order 待处理订单，不能为null
* @return 处理是否成功
*/
public boolean processOrder(Order order) {
// 积分抵扣不超过订单金额的30%
double maxDeduct = order.getSubtotal() * 0.3;
double actualDeduct = Math.min(order.getUserPoints(), maxDeduct);
order.setTotal(order.getSubtotal() - actualDeduct);
return true;
}
}
（五）重复代码
在项目不断开发迭代的过程中，重复代码的出现几乎是不可避免的。通过工具（如 PMD）可以检测重复代码。对于类型体系之外的重复代码，可以通过封装到对应的 Util 类或 Helper 类中解决；对于类体系之内的重复代码，可以通过继承、模板模式等设计模式来优化。减少重复代码不仅能够提高代码的可维护性，还能降低后续开发的复杂度。
// 不好的示例：存在重复代码
public class OrderService {
public void createOrder(Order order) {
// 重复的日期格式化代码
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String createTime = sdf.format(new Date());
order.setCreateTime(createTime);
// 重复的日志记录代码
log.info("Creating order: {}", order.getId());
// 业务逻辑
// ...
}
public void updateOrder(Order order) {
// 重复的日期格式化代码
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String updateTime = sdf.format(new Date());
order.setUpdateTime(updateTime);
// 重复的日志记录代码
log.info("Updating order: {}", order.getId());
// 业务逻辑
// ...
}
}
// 好的示例：消除重复代码
// 1. 创建工具类封装通用功能
public class DateUtil {
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static String getCurrentTime() {
return DATE_FORMAT.format(new Date());
}
}
// 2. 使用AOP或基类处理横切关注点
public abstract class BaseService {
protected void logOperation(String operation, String entityId) {
log.info("{} {}: {}", operation, getEntityName(), entityId);
}
protected abstract String getEntityName();
}
// 3. 重构后的服务类
public class OrderService extends BaseService {
public void createOrder(Order order) {
order.setCreateTime(DateUtil.getCurrentTime());
logOperation("Creating", order.getId());
// 业务逻辑
// ...
}
public void updateOrder(Order order) {
order.setUpdateTime(DateUtil.getCurrentTime());
logOperation("Updating", order.getId());
// 业务逻辑
// ...
}
@Override
protected String getEntityName() {
return "order";
}
}
（六）代码复杂度
代码结构的复杂度直接影响其可理解性、可测试性和可维护性。高圈复杂度的代码往往难以理解和维护。在代码评审过程中，应重点关注代码结构是否过于复杂，是否存在可以通过重构优化的部分。例如，将复杂的条件判断拆分为多个小函数，能够显著降低代码的复杂度。
// 不好的示例：高复杂度代码
public class OrderDiscountCalculator {
public double calculateDiscount(Order order) {
double discount = 0;
// 高圈复杂度：多重嵌套条件判断
if (order.getCustomer() != null) {
if (order.getCustomer().getLevel() == CustomerLevel.VIP) {
discount = 0.2;
if (order.getTotalAmount() > 1000) {
discount += 0.1;
if (order.getItems().size() > 10) {
discount += 0.05;
}
}
} else if (order.getCustomer().getLevel() == CustomerLevel.GOLD) {
discount = 0.15;
if (order.getTotalAmount() > 2000) {
discount += 0.05;
}
} else {
if (order.getTotalAmount() > 3000) {
discount = 0.1;
} else {
discount = 0;
}
}
// 更多条件判断...
if (order.getCreateTime().after(getPromotionStartTime()) &&
order.getCreateTime().before(getPromotionEndTime())) {
discount += 0.05;
}
}
return Math.min(discount, 0.5); // 最大折扣不超过50%
}
// ...
}
// 好的示例：降低复杂度
public class OrderDiscountCalculator {
private static final double MAX_DISCOUNT = 0.5;
public double calculateDiscount(Order order) {
if (order.getCustomer() == null) {
return 0;
}
double discount = 0;
// 将不同逻辑拆分为独立方法
discount += getCustomerLevelDiscount(order);
discount += getTotalAmountDiscount(order);
discount += getPromotionDiscount(order);
return Math.min(discount, MAX_DISCOUNT);
}
private double getCustomerLevelDiscount(Order order) {
switch (order.getCustomer().getLevel()) {
case VIP:
return 0.2;
case GOLD:
return 0.15;
default:
return 0;
}
}
private double getTotalAmountDiscount(Order order) {
double amount = order.getTotalAmount();
if (order.getCustomer().getLevel() == CustomerLevel.VIP) {
if (amount > 1000) {
double additional = order.getItems().size() > 10 ? 0.05 : 0;
return 0.1 + additional;
}
} else if (order.getCustomer().getLevel() == CustomerLevel.GOLD) {
if (amount > 2000) {
return 0.05;
}
} else {
if (amount > 3000) {
return 0.1;
}
}
return 0;
}
private double getPromotionDiscount(Order order) {
Date createTime = order.getCreateTime();
if (createTime.after(getPromotionStartTime()) &&
createTime.before(getPromotionEndTime())) {
return 0.05;
}
return 0;
}
// ...
}
（七）监控与报警
基于产品的需求逻辑，需要设置监控和报警指标来证明业务的正常运行。如果发生异常，及时的监控和报警能够通知研发人员迅速处理。因此，代码评审中也应重点关注业务需求对应的监控与报警指标是否合理、是否能够及时发现和处理异常。
// 不好的示例：缺乏监控和报警
public class PaymentService {
public PaymentResult processPayment(PaymentRequest request) {
try {
// 处理支付逻辑
PaymentResult result = paymentGateway.process(request);
return result;
} catch (Exception e) {
// 只记录了异常，没有监控和报警机制
log.error("Payment processing failed", e);
return PaymentResult.failed(e.getMessage());
}
}
}
// 好的示例：添加监控和报警
public class PaymentService {
// 引入监控工具
private final MetricsCollector metricsCollector;
private final AlertService alertService;
// 构造函数注入
public PaymentService(MetricsCollector metricsCollector, AlertService alertService) {
this.metricsCollector = metricsCollector;
this.alertService = alertService;
}
public PaymentResult processPayment(PaymentRequest request) {
// 记录支付请求量
metricsCollector.incrementCounter("payment.requests.total");
long startTime = System.currentTimeMillis();
try {
// 处理支付逻辑
PaymentResult result = paymentGateway.process(request);
// 记录成功支付
if (result.isSuccess()) {
metricsCollector.incrementCounter("payment.successes.total");
metricsCollector.recordGauge("payment.amount", result.getAmount());
} else {
// 记录失败支付
metricsCollector.incrementCounter("payment.failures.total");
metricsCollector.incrementCounter("payment.failures." + result.getErrorCode());
}
return result;
} catch (ConnectionException e) {
// 对特定异常增加监控和报警
metricsCollector.incrementCounter("payment.exceptions.connection");
alertService.sendAlert("Payment gateway connection issues", e.getMessage());
log.error("Payment gateway connection failed", e);
return PaymentResult.failed("Connection error");
} catch (Exception e) {
// 记录异常并报警
metricsCollector.incrementCounter("payment.exceptions.total");
log.error("Payment processing failed", e);
// 严重错误触发报警
alertService.sendAlert("Payment processing error", e.getMessage());
return PaymentResult.failed(e.getMessage());
} finally {
// 记录处理时间
long duration = System.currentTimeMillis() - startTime;
metricsCollector.recordTimer("payment.processing.time", duration);
// 处理时间过长报警
if (duration > 5000) { // 超过5秒
alertService.sendAlert("Slow payment processing",
"Took " + duration + "ms for order " + request.getOrderId());
}
}
}
}
（八）测试覆盖率
单元测试是代码质量的重要保障。代码评审应关注测试覆盖率是否足够，特别是针对复杂代码的测试是否充分。虽然维护单元测试的成本较高，但其对于保障代码质量的作用不容忽视。团队应重视单元测试的编写和维护，确保代码的可靠性和稳定性。
// 业务代码：Calculator.java
public class Calculator {
/**
* 计算两个数的商
* @param dividend 被除数
* @param divisor 除数，不能为0
* @return 商
* @throws ArithmeticException 如果除数为0
*/
public double divide(double dividend, double divisor) {
if (divisor == 0) {
throw new ArithmeticException("Divisor cannot be zero");
}
return dividend / divisor;
}
/**
* 计算多个数的总和
* @param numbers 数字列表，null或空列表返回0
* @return 总和
*/
public double sum(List<Double> numbers) {
if (numbers == null || numbers.isEmpty()) {
return 0;
}
double total = 0;
for (double num : numbers) {
total += num;
}
return total;
}
}
// 不好的示例：测试覆盖率不足的单元测试
import org.junit.Test;
import static org.junit.Assert.*;
public class CalculatorTest {
// 只测试了正常情况，没有测试边界条件和异常情况
@Test
public void testDivide() {
Calculator calculator = new Calculator();
assertEquals(2.0, calculator.divide(4, 2), 0.001);
}
@Test
public void testSum() {
Calculator calculator = new Calculator();
List<Double> numbers = Arrays.asList(1.0, 2.0, 3.0);
assertEquals(6.0, calculator.sum(numbers), 0.001);
}
}
// 好的示例：高覆盖率的单元测试
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.*;
@RunWith(Parameterized.class)
public class CalculatorTest {
private final Calculator calculator = new Calculator();
// 测试除法的多种情况
@Test
public void testDivideWithPositiveNumbers() {
assertEquals(2.0, calculator.divide(4, 2), 0.001);
}
@Test
public void testDivideWithNegativeNumbers() {
assertEquals(-2.0, calculator.divide(4, -2), 0.001);
assertEquals(2.0, calculator.divide(-4, -2), 0.001);
}
@Test
public void testDivideWithZeroDividend() {
assertEquals(0.0, calculator.divide(0, 5), 0.001);
}
@Test(expected = ArithmeticException.class)
public void testDivideByZero() {
calculator.divide(5, 0);
}
// 测试求和的多种情况
@Test
public void testSumWithPositiveNumbers() {
List<Double> numbers = Arrays.asList(1.0, 2.0, 3.0);
assertEquals(6.0, calculator.sum(numbers), 0.001);
}
@Test
public void testSumWithMixedSignNumbers() {
List<Double> numbers = Arrays.asList(1.0, -2.0, 3.0);
assertEquals(2.0, calculator.sum(numbers), 0.001);
}
@Test
public void testSumWithEmptyList() {
List<Double> numbers = Collections.emptyList();
assertEquals(0.0, calculator.sum(numbers), 0.001);
}
@Test
public void testSumWithNull() {
assertNull("测试传入null的情况", calculator.sum(null), 0.001);
}
@Test
public void testSumWithSingleElement() {
List<Double> numbers = Collections.singletonList(5.0);
assertEquals(5.0, calculator.sum(numbers), 0.001);
}
}
总结
代码评审是技术团队保障代码质量的核心实践。通过重点关注代码功能、编码规范、潜在 BUG、文档和注释、重复代码、复杂度、监控与报警以及测试覆盖率等方面，团队能够有效提升代码质量，降低维护成本。同时，将每次代码评审中发现的经典案例整理成文档，供团队成员共同学习，能够避免重复编写低质量代码，提升团队整体的技术水平。
在实际工作中，代码评审不应仅仅是一个形式化的流程，而应成为团队文化的一部分。通过持续的代码评审实践，团队能够不断优化代码质量，提升开发效率，为项目的长期稳定发展奠定坚实的基础。
扫一扫
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
