Java代码规范案例

本文目录导读：

1. 命名规范
2. 类设计规范
3. 方法编写规范
4. 常用注解规范
5. 异常处理规范
6. 代码书写规范
7. 日志规范
8. 示例DTO
9. 关键规范要点总结

我来提供一个全面的Java代码规范案例,包含正反示例对比：

命名规范

❌ 错误示例

public class user_info {
    private String user_name;
    private String u_pwd;
    public void getinfo() {
        // ...
    }
    public String getU() {
        return user_name;
    }
}

✅ 正确示例

public class UserInfo {
    // 常量：全大写+下划线
    private static final int MAX_LOGIN_ATTEMPTS = 5;
    // 变量：驼峰命名
    private String userName;
    private String userPassword;
    private Integer loginCount;
    // 方法：动词+名词，驼峰命名
    public void getUserInfo() {
        // ...
    }
    public String getUserName() {
        return userName;
    }
    // 布尔类型：is/has/can前缀
    public boolean isActive() {
        return loginCount > 0;
    }
}

类设计规范

/**
 * 用户管理服务类
 * 
 * @author 张三
 * @version 1.0
 * @since 2024-01-01
 */
@Service
public class UserServiceImpl implements UserService {
    // 常量放在类最前面
    private static final Logger LOGGER = LoggerFactory.getLogger(UserServiceImpl.class);
    private static final String DEFAULT_ROLE = "USER";
    // 依赖注入
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private PasswordEncoder passwordEncoder;
    // 构造方法
    public UserServiceImpl() {
        // 初始化
    }
    // 公共方法：提供对外服务
    @Override
    @Transactional
    public User createUser(UserCreateRequest request) {
        LOGGER.info("Creating user with username: {}", request.getUsername());
        // 参数校验
        validateCreateRequest(request);
        // 业务逻辑
        User user = new User();
        user.setUsername(request.getUsername());
        user.setPassword(passwordEncoder.encode(request.getPassword()));
        user.setRole(DEFAULT_ROLE);
        // 持久化
        User savedUser = userRepository.save(user);
        LOGGER.info("User created successfully with id: {}", savedUser.getId());
        return savedUser;
    }
    // 私有方法：辅助功能
    private void validateCreateRequest(UserCreateRequest request) {
        if (StringUtils.isBlank(request.getUsername())) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        if (request.getPassword().length() < 8) {
            throw new IllegalArgumentException("密码长度不能少于8位");
        }
    }
}

方法编写规范

❌ 过长方法示例

public void processOrder(Order order) {
    // 50行代码检查库存
    // 30行代码计算价格
    // 40行代码生成订单
    // 20行代码发送邮件
    // ...
}

✅ 方法拆分示例

public class OrderService {
    /**
     * 处理订单主方法
     *
     * @param order 订单信息
     * @return 处理结果
     */
    public OrderResult processOrder(Order order) {
        // 1. 校验订单
        validateOrder(order);
        // 2. 检查库存
        checkInventory(order);
        // 3. 计算价格
        BigDecimal totalPrice = calculatePrice(order);
        // 4. 创建订单
        Order savedOrder = createOrder(order, totalPrice);
        // 5. 发送通知
        sendOrderNotification(savedOrder);
        return buildResult(savedOrder);
    }
    // 每个子方法只做一件事
    private void validateOrder(Order order) {
        // 订单校验逻辑
    }
    private void checkInventory(Order order) {
        // 库存检查逻辑
    }
    private BigDecimal calculatePrice(Order order) {
        // 价格计算逻辑
        return BigDecimal.ZERO;
    }
    private Order createOrder(Order order, BigDecimal totalPrice) {
        // 订单创建逻辑
        return order;
    }
    private void sendOrderNotification(Order order) {
        // 通知发送逻辑
    }
}

常用注解规范

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    /**
     * 获取用户列表
     *
     * @param page 页码
     * @param size 每页大小
     * @return 用户列表
     */
    @GetMapping
    public Result<List<User>> listUsers(
            @RequestParam(value = "page", defaultValue = "1") int page,
            @RequestParam(value = "size", defaultValue = "10") int size) {
        List<User> users = userService.listUsers(page, size);
        return Result.success(users);
    }
    /**
     * 获取用户详情
     *
     * @param id 用户ID
     * @return 用户信息
     */
    @GetMapping("/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        User user = userService.getUser(id);
        return Result.success(user);
    }
}

异常处理规范

public class BusinessException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    private final ErrorCode errorCode;
    public BusinessException(ErrorCode errorCode) {
        super(errorCode.getMessage());
        this.errorCode = errorCode;
    }
    public BusinessException(ErrorCode errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
    public ErrorCode getErrorCode() {
        return errorCode;
    }
}
// 统一异常处理
@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    @ExceptionHandler(BusinessException.class)
    @ResponseBody
    public Result<Void> handleBusinessException(BusinessException e) {
        LOGGER.warn("Business exception: {}", e.getMessage());
        return Result.fail(e.getErrorCode().getCode(), e.getMessage());
    }
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Result<Void> handleException(Exception e) {
        LOGGER.error("System error", e);
        return Result.fail(500, "系统内部错误");
    }
}

代码书写规范

public class CodingStandards {
    /**
     * 演示代码书写规范
     * 
     * 1. 使用4个空格缩进
     * 2. 运算符两侧加空格
     * 3. 大括号的用法
     * 4. 空行分隔逻辑块
     * 5. 合理添加注释
     */
    public void demonstrateCodingStandards(int[] numbers) {
        // 变量声明
        int sum = 0;
        int max = Integer.MIN_VALUE;
        // 循环处理
        for (int number : numbers) {
            sum += number;
            if (number > max) {
                max = number;
            }
        }
        // 条件判断
        if (sum > 0 && max > 0) {
            System.out.println("Positive sum: " + sum);
        } else {
            System.out.println("Non-positive sum");
        }
        // 空行分隔不同逻辑块
        StringBuilder result = new StringBuilder();
        result.append("Sum: ").append(sum);
        result.append(", Max: ").append(max);
        System.out.println(result.toString());
    }
}

日志规范

@Service
public class PaymentService {
    private static final Logger LOGGER = LoggerFactory.getLogger(PaymentService.class);
    public PaymentResult processPayment(PaymentRequest request) {
        // 记录传入参数（注意脱敏）
        LOGGER.info("Processing payment. OrderId={}, Amount={}",
                request.getOrderId(), request.getAmount());
        try {
            // 业务逻辑
            PaymentResult result = doPayment(request);
            // 记录成功日志
            LOGGER.info("Payment processed successfully. OrderId={}, PaymentId={}",
                    request.getOrderId(), result.getPaymentId());
            return result;
        } catch (Exception e) {
            // 记录错误日志，包含堆栈
            LOGGER.error("Payment processing failed. OrderId={}", 
                    request.getOrderId(), e);
            throw e;
        }
    }
    private PaymentResult doPayment(PaymentRequest request) {
        // 模拟支付处理
        return new PaymentResult();
    }
}

示例DTO

/**
 * 用户创建请求DTO
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserCreateRequest {
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 50, message = "用户名长度必须在3-50个字符之间")
    private String username;
    @NotBlank(message = "密码不能为空")
    @Size(min = 8, max = 100, message = "密码长度必须在8-100个字符之间")
    private String password;
    @Email(message = "邮箱格式不正确")
    private String email;
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    private String phone;
    private String nickname;
}

关键规范要点总结

1. 命名规范

   • 类名：PascalCase（首字母大写）
   • 方法/变量：camelCase（首字母小写）
   • 常量：UPPER_CASE_WITH_UNDERSCORES
   • 包名：小写+域名倒置

2. 代码结构

   • 一个类只做一件事（单一职责）
   • 方法长度控制（不超过50行）
   • 合理的注释
   • 统一的导入顺序

3. 异常处理

   • 使用自定义异常
   • 全局异常处理
   • 不要捕获Throwable
   • 对异常进行记录

4. 日志规范

   • 使用参数化日志
   • 记录关键信息
   • 敏感信息脱敏
   • 避免记录不必要的数据

5. 其他

   • 使用Lombok简化代码
   • 合理使用设计模式
   • 编写单元测试
   • 及时清理代码
   • 使用SonarQube等工具检查代码质量