Java 登录注册系统构建指南：核心代码与配置

设计要点：

• 密码使用 BCrypt 或 SHA-256 + 盐值加密存储
• 增加登录失败次数控制，防止暴力破解
• 记录最后登录时间，便于安全审计
• 支持账户锁定机制

3. 核心实体类

User 实体类

import java.io.Serializable;
import java.util.Date;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 用户实体类
 */
@Data
@NoArgsConstructor
public class User implements Serializable {
    // 序列化版本号
    private static final long serialVersionUID = 1L;

    private Long id;
    private String username;
    private String email;
    private String password;
    private String salt;
    private Integer status;
    private Date createTime;
    private Date updateTime;
    private Date lastLoginTime;
    private Integer loginAttempts;
    private Date lockedUntil;

    // 业务方法
    /**
     * 判断账户是否被锁定
     * @return 锁定状态（true：已锁定，false：未锁定）
     */
    public boolean isAccountLocked() {
        return lockedUntil != null && lockedUntil.after(new Date());
    }

    /**
     * 判断账户是否启用
     * @return 启用状态（true：启用，false：禁用）
     */
    public boolean isEnabled() {
        return status == 1;
    }

    @Override
    public String toString() {
        return "User{id=" + id + ", username='" + username + "'}";
    }
}

4. 安全工具类

密码加密与验证

import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * 安全工具类
 * 提供密码加密、盐值生成、密码验证和 Token 生成等安全相关操作
 */
public class SecurityUtil {
    /**
     * 生成随机盐值（16 字节）
     * @return Base64 编码的盐值字符串
     */
    public static String generateSalt() {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[16];
        random.nextBytes(salt);
        return Base64.getEncoder().encodeToString(salt);
    }

    /**
     * 使用 SHA-256 算法加密密码
     * @param password 原始密码
     * @param salt 盐值
     * @return 加密后的密码（Base64 编码）
     */
    public static String hashPassword(String password, String salt) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(salt.getBytes());
            byte[] hashedPassword = md.digest(password.getBytes());
            return Base64.getEncoder().encodeToString(hashedPassword);
        } catch (Exception e) {
            throw new RuntimeException("密码加密失败", e);
        }
    }

    /**
     * 验证密码是否匹配
     * @param inputPassword 输入的原始密码
     * @param storedPassword 存储的加密后密码
     * @param salt 盐值
     * @return 密码是否匹配（true:匹配，false:不匹配）
     */
    public static boolean verifyPassword(String inputPassword, String storedPassword, String salt) {
        String hashedInput = hashPassword(inputPassword, salt);
        return hashedInput.equals(storedPassword);
    }

    /**
     * 生成随机 Token（32 字节）
     * 用于会话管理、身份验证等场景
     * @return Base64 编码的 Token 字符串
     */
    public static String generateToken() {
        SecureRandom random = new SecureRandom();
        byte[] token = new byte[32];
        random.nextBytes(token);
        return Base64.getEncoder().encodeToString(token);
    }
}

安全提示：

• 永远不要明文存储密码
• 每个密码使用独立的盐值
• 考虑使用更强的加密算法如 BCrypt
• 实施密码强度策略

5. 数据访问层 (DAO)

UserDAO 接口与实现

UserDAO.java

import java.util.Date;

/**
 * 用户数据访问接口
 * 定义用户相关的数据库操作方法
 */
public interface UserDAO {
    /**
     * 根据用户名查询用户
     * @param username 用户名
     * @return 用户实体，不存在则返回 null
     */
    User findByUsername(String username);

    /**
     * 根据邮箱查询用户
     * @param email 邮箱地址
     * @return 用户实体，不存在则返回 null
     */
    User findByEmail(String email);

    /**
     * 保存新用户
     * @param user 用户实体
     * @return 保存成功返回 true，否则返回 false
     */
    boolean save(User user);

    /**
     * 更新用户最后登录时间
     * @param userId 用户 ID
     * @return 更新成功返回 true，否则返回 false
     */
    boolean updateLastLoginTime(Long userId);

    /**
     * 更新登录失败次数
     * @param userId 用户 ID
     * @param attempts 失败次数
     * @return 更新成功返回 true，否则返回 false
     */
    boolean updateLoginAttempts(Long userId, int attempts);

    /**
     * 锁定用户账户
     * @param userId 用户 ID
     * @param lockUntil 锁定截止时间
     * @return 操作成功返回 true，否则返回 false
     */
    boolean lockAccount(Long userId, Date lockUntil);
}

UserDAOImpl.java

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.Date;

/**
 * 用户数据访问实现类
 * 实现用户相关的数据库操作
 */
public class UserDAOImpl implements UserDAO {
    private final Connection connection;

    /**
     * 构造方法，注入数据库连接
     * @param connection 数据库连接对象
     */
    public UserDAOImpl(Connection connection) {
        this.connection = connection;
    }

    @Override
    public User findByUsername(String username) {
        String sql = "SELECT * FROM users WHERE username = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, username);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                return mapResultSetToUser(rs);
            }
        } catch (SQLException e) {
            throw new RuntimeException("根据用户名查询用户失败：" + username, e);
        }
        return null;
    }

    @Override
    public User findByEmail(String email) {
        String sql = "SELECT * FROM users WHERE email = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, email);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                return mapResultSetToUser(rs);
            }
        } catch (SQLException e) {
            throw new RuntimeException("根据邮箱查询用户失败：" + email, e);
        }
        return null;
    }

    @Override
    public boolean save(User user) {
        String sql = "INSERT INTO users (username, email, password, salt) VALUES (?, ?, ?, ?)";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, user.getUsername());
            stmt.setString(2, user.getEmail());
            stmt.setString(3, user.getPassword());
            stmt.setString(4, user.getSalt());
            return stmt.executeUpdate() > 0;
        } catch (SQLException e) {
            throw new RuntimeException("保存用户失败：" + user.getUsername(), e);
        }
    }

    @Override
    public boolean updateLastLoginTime(Long userId) {
        String sql = "UPDATE users SET last_login_time = CURRENT_TIMESTAMP WHERE id = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setLong(1, userId);
            return stmt.executeUpdate() > 0;
        } catch (SQLException e) {
            throw new RuntimeException("更新用户最后登录时间失败：" + userId, e);
        }
    }

    @Override
    public boolean updateLoginAttempts(Long userId, int attempts) {
        String sql = "UPDATE users SET login_attempts = ?, update_time = CURRENT_TIMESTAMP WHERE id = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setInt(1, attempts);
            stmt.setLong(2, userId);
            return stmt.executeUpdate() > 0;
        } catch (SQLException e) {
            throw new RuntimeException("更新用户登录失败次数失败：" + userId, e);
        }
    }

    @Override
    public boolean lockAccount(Long userId, Date lockUntil) {
        String sql = "UPDATE users SET locked_until = ?, update_time = CURRENT_TIMESTAMP WHERE id = ?";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setTimestamp(1, new Timestamp(lockUntil.getTime()));
            stmt.setLong(2, userId);
            return stmt.executeUpdate() > 0;
        } catch (SQLException e) {
            throw new RuntimeException("锁定用户账户失败：" + userId, e);
        }
    }

    /**
     * 结果集映射为 User 实体
     * @param rs 数据库结果集
     * @return User 实体对象
     * @throws SQLException SQL 异常
     */
    private User mapResultSetToUser(ResultSet rs) throws SQLException {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setUsername(rs.getString("username"));
        user.setEmail(rs.getString("email"));
        user.setPassword(rs.getString("password"));
        user.setSalt(rs.getString("salt"));
        user.setStatus(rs.getInt("status"));
        user.setCreateTime(rs.getTimestamp("create_time"));
        user.setUpdateTime(rs.getTimestamp("update_time"));
        user.setLastLoginTime(rs.getTimestamp("last_login_time"));
        user.setLoginAttempts(rs.getInt("login_attempts"));
        user.setLockedUntil(rs.getTimestamp("locked_until"));
        return user;
    }
}

6. 业务逻辑层 (Service)

UserService 核心业务逻辑

import java.util.Date;

/**
 * 用户服务类
 * 处理用户注册、登录等核心业务逻辑
 */
public class UserService {
    private final UserDAO userDAO;
    // 最大登录失败次数
    private static final int MAX_LOGIN_ATTEMPTS = 5;
    // 账户锁定时长（30 分钟，单位：毫秒）
    private static final long LOCK_DURATION = 30 * 60 * 1000;

    /**
     * 构造方法，注入用户数据访问对象
     * @param userDAO 用户数据访问接口实现
     */
    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    /**
     * 用户注册
     * @param username 用户名
     * @param email 邮箱地址
     * @param password 原始密码
     * @return 注册是否成功
     */
    public boolean register(String username, String email, String password) {
        // 1. 参数合法性校验
        if (!isValidUsername(username) || !isValidEmail(email) || !isValidPassword(password)) {
            throw new IllegalArgumentException("参数格式不正确：用户名 3-50 位，邮箱格式正确，密码至少 6 位");
        }
        // 2. 检查用户名和邮箱是否已存在
        if (userDAO.findByUsername(username) != null) {
            throw new RuntimeException("用户名已存在");
        }
        if (userDAO.findByEmail(email) != null) {
            throw new RuntimeException("邮箱已存在");
        }
        // 3. 密码加密处理
        String salt = SecurityUtil.generateSalt();
        String hashedPassword = SecurityUtil.hashPassword(password, salt);
        // 4. 创建用户对象并保存
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setPassword(hashedPassword);
        user.setSalt(salt);
        return userDAO.save(user);
    }

    /**
     * 用户登录
     * @param username 用户名
     * @param password 原始密码
     * @return 登录成功的用户对象
     */
    public User login(String username, String password) {
        // 1. 根据用户名查询用户
        User user = userDAO.findByUsername(username);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }
        // 2. 检查账户状态
        if (!user.isEnabled()) {
            throw new RuntimeException("账户已被禁用");
        }
        if (user.isAccountLocked()) {
            throw new RuntimeException("账户已被锁定，请稍后再试");
        }
        // 3. 验证密码
        if (!SecurityUtil.verifyPassword(password, user.getPassword(), user.getSalt())) {
            handleLoginFailure(user);
        }
        // 4. 登录成功处理
        handleLoginSuccess(user);
        return user;
    }

    /**
     * 处理登录失败逻辑
     * @param user 当前登录用户
     */
    private void handleLoginFailure(User user) {
        int attempts = user.getLoginAttempts() + 1;
        userDAO.updateLoginAttempts(user.getId(), attempts);
        // 达到最大失败次数，锁定账户
        if (attempts >= MAX_LOGIN_ATTEMPTS) {
            Date lockUntil = new Date(System.currentTimeMillis() + LOCK_DURATION);
            userDAO.lockAccount(user.getId(), lockUntil);
            throw new RuntimeException("登录失败次数过多，账户已被锁定 30 分钟");
        }
        throw new RuntimeException("密码错误，还可尝试 " + (MAX_LOGIN_ATTEMPTS - attempts) + " 次");
    }

    /**
     * 处理登录成功逻辑
     * @param user 当前登录用户
     */
    private void handleLoginSuccess(User user) {
        // 重置登录失败次数
        userDAO.updateLoginAttempts(user.getId(), 0);
        // 更新最后登录时间
        userDAO.updateLastLoginTime(user.getId());
    }

    /**
     * 校验用户名格式
     * @param username 用户名
     * @return 格式是否有效
     */
    private boolean isValidUsername(String username) {
        return username != null && username.length() >= 3 && username.length() <= 50;
    }

    /**
     * 校验邮箱格式
     * @param email 邮箱地址
     * @return 格式是否有效
     */
    private boolean isValidEmail(String email) {
        if (email == null) {
            return false;
        }
        // 简单邮箱格式正则校验
        return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }

    /**
     * 校验密码格式
     * @param password 密码
     * @return 格式是否有效
     */
    private boolean isValidPassword(String password) {
        return password != null && password.length() >= 6;
    }
}

7. 控制器层 (Controller)

UserController - Web 层处理

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

/**
 * 用户控制器
 * 处理用户注册、登录、登出等 HTTP 请求
 */
@RestController
@RequestMapping("/api/user")
public class UserController {
    private final UserService userService;

    /**
     * 构造方法注入用户服务
     * @param userService 用户服务对象
     */
    public UserController(UserService userService) {
        this.userService = userService;
    }

    /**
     * 用户注册接口
     * @param request 注册请求参数
     * @param httpRequest HTTP 请求对象
     * @return 注册结果响应
     */
    @PostMapping("/register")
    public ResponseEntity<Map<String, Object>> register(@RequestBody RegisterRequest request, HttpServletRequest httpRequest) {
        Map<String, Object> response = new HashMap<>();
        try {
            // 参数验证
            if (request.getUsername() == null || request.getPassword() == null || request.getEmail() == null) {
                response.put("success", false);
                response.put("message", "必填参数不能为空");
                return ResponseEntity.badRequest().body(response);
            }
            // 调用服务层执行注册
            boolean success = userService.register(request.getUsername(), request.getEmail(), request.getPassword());
            response.put("success", success);
            response.put("message", success ? "注册成功" : "注册失败");
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            response.put("success", false);
            response.put("message", e.getMessage());
            return ResponseEntity.badRequest().body(response);
        }
    }

    /**
     * 用户登录接口
     * @param request 登录请求参数
     * @param httpRequest HTTP 请求对象
     * @param httpResponse HTTP 响应对象
     * @return 登录结果响应
     */
    @PostMapping("/login")
    public ResponseEntity<Map<String, Object>> login(@RequestBody LoginRequest request, HttpServletRequest httpRequest, HttpServletResponse httpResponse) {
        Map<String, Object> response = new HashMap<>();
        try {
            // 调用服务层执行登录
            User user = userService.login(request.getUsername(), request.getPassword());
            // 生成会话 token
            String token = SecurityUtil.generateToken();
            // 设置认证 Cookie
            Cookie cookie = new Cookie("auth_token", token);
            cookie.setHttpOnly(true);
            cookie.setSecure(true);
            // 生产环境使用 HTTPS 时启用
            cookie.setMaxAge(24 * 60 * 60); // 24 小时有效期
            cookie.setPath("/"); // 设置 Cookie 路径
            httpResponse.addCookie(cookie);
            // 将用户信息存储到 session
            HttpSession session = httpRequest.getSession();
            session.setAttribute("user_id", user.getId());
            session.setAttribute("username", user.getUsername());
            // 构建响应数据
            response.put("success", true);
            response.put("message", "登录成功");
            response.put("user", Map.of("id", user.getId(), "username", user.getUsername(), "email", user.getEmail()));
            return ResponseEntity.ok(response);
        } catch (Exception e) {
            response.put("success", false);
            response.put("message", e.getMessage());
            return ResponseEntity.badRequest().body(response);
        }
    }

    /**
     * 用户登出接口
     * @param request HTTP 请求对象
     * @param response HTTP 响应对象
     * @return 登出结果响应
     */
    @PostMapping("/logout")
    public ResponseEntity<Map<String, Object>> logout(HttpServletRequest request, HttpServletResponse response) {
        // 清除 session
        HttpSession session = request.getSession(false);
        if (session != null) {
            session.invalidate();
        }
        // 清除认证 Cookie
        Cookie cookie = new Cookie("auth_token", null);
        cookie.setMaxAge(0);
        cookie.setPath("/");
        response.addCookie(cookie);
        Map<String, Object> result = new HashMap<>();
        result.put("success", true);
        result.put("message", "退出成功");
        return ResponseEntity.ok(result);
    }
}

/**
 * 注册请求 DTO
 * 接收注册接口的请求参数
 */
class RegisterRequest {
    private String username;
    private String email;
    private String password;

    // Getter 和 Setter 方法
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
}

/**
 * 登录请求 DTO
 * 接收登录接口的请求参数
 */
class LoginRequest {
    private String username;
    private String password;

    // Getter 和 Setter 方法
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
}

配置文件

# Spring Boot 主配置文件
spring:
  # 应用基本信息
  application:
    name: bushuo-users # 应用名称
  # 环境配置 (dev/test/prod，当前激活开发环境)
  profiles:
    active: dev
  # 数据源配置（MySQL）
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver # MySQL 8.x 驱动类
    url: jdbc:mysql://localhost:3306/bushuo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root # 数据库用户名
    password: 123456 # 数据库密码
  # Hikari 连接池配置（Spring Boot 默认连接池）
  hikari:
    minimum-idle: 5 # 最小空闲连接数
    maximum-pool-size: 20 # 最大连接数
    auto-commit: true # 自动提交事务
    idle-timeout: 30000 # 空闲连接超时时间（30 秒）
    pool-name: UserAuthHikariCP # 连接池名称
    max-lifetime: 1800000 # 连接最大生命周期（30 分钟）
    connection-timeout: 30000 # 连接获取超时时间（30 秒）
  # JPA/Hibernate 配置（ORM 框架）
  jpa:
    hibernate:
      ddl-auto: update # 表结构自动更新（开发环境用，生产环境建议改为 validate）
      show-sql: true # 控制台打印 SQL 语句
      properties:
        hibernate:
          dialect: org.hibernate.dialect.MySQL8Dialect # MySQL 8.x 方言
          format_sql: true # 格式化 SQL 语句（便于调试）
  # Redis 配置（用于会话存储、缓存）
  redis:
    host: localhost # Redis 服务地址
    port: 6379 # Redis 端口
    database: 0 # Redis 数据库索引（默认 0）
    timeout: 2000ms # 连接超时时间（2 秒）
  # Jedis 连接池配置
  jedis:
    pool:
      max-active: 20 # 最大活跃连接数
      max-idle: 10 # 最大空闲连接数
      min-idle: 5 # 最小空闲连接数
      max-wait: 2000ms # 连接获取最大等待时间（2 秒）
  # 会话配置（基于 Redis 存储会话）
  session:
    store-type: redis # 会话存储类型（redis/memory/jdbc）
    timeout: 1800s # 会话超时时间（30 分钟）
    redis:
      namespace: "user:session" # Redis 会话键前缀（避免键冲突）
  # Web 配置
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher # 路径匹配策略（兼容老版本 Ant 风格）
  web:
    resources:
      static-locations: classpath:/static/ # 静态资源路径（CSS/JS/图片等）
      cache-period: 3600 # 静态资源缓存时间（1 小时）
  # 邮件配置（用于注册验证、密码找回）
  mail:
    # host: smtp.qq.com # 邮件服务器地址（QQ 邮箱示例）
    # port: 587 # 邮件服务器端口（TLS 协议默认 587）
    # username: ${MAIL_USERNAME:[email protected]} # 发件人邮箱（支持环境变量注入）
    # password: ${MAIL_PASSWORD:your-auth-code} # 邮箱授权码（非登录密码，支持环境变量注入）
    # properties:
    #   mail:
    #     smtp:
    #       auth: true # 启用 SMTP 认证
    #       starttls:
    #         enable: true # 启用 STARTTLS 加密（安全传输）
  # 服务器配置
  server:
    port: 8080 # 应用端口
    servlet:
      context-path: / # 应用上下文路径（默认 /，如需前缀可改为 /api 等）
    session:
      timeout: 30m # 服务器会话超时时间（与 Spring 会话超时保持一致）
      cookie:
        http-only: true # 启用 HttpOnly（防止 JS 读取 Cookie，提升安全性）
        secure: false # 启用 Secure（仅 HTTPS 传输 Cookie，生产环境建议设为 true）
        max-age: 1800 # Cookie 最大存活时间（30 分钟，与会话超时保持一致）
  # 错误页面配置
  error:
    whitelabel:
      enabled: false # 禁用默认错误页面（自定义错误页面时需关闭）
    include-message: always # 错误响应中包含错误信息
    include-binding-errors: always # 错误响应中包含参数绑定错误
  # 日志配置
  logging:
    level:
      # 日志级别（DEBUG < INFO < WARN < ERROR）
      com.example.demo: DEBUG # 自定义包日志级别（调试用）
      org.springframework.security: DEBUG # Spring Security 日志级别（调试权限问题用）
      org.springframework.web: INFO # Spring Web 日志级别
      org.hibernate.SQL: DEBUG # Hibernate SQL 日志级别（打印执行的 SQL）
      org.hibernate.type.descriptor.sql.BasicBinder: TRACE # 打印 SQL 参数（调试参数绑定用）
    pattern:
      console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n" # 控制台日志格式（简洁版）
      file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" # 日志文件格式（含线程、日志器）
    file:
      name: logs/user-auth.log # 日志文件路径及名称（项目根目录下 logs 文件夹）
      max-size: 10MB # 单个日志文件最大大小（超过后切割）
      max-history: 30 # 日志文件保留历史天数（30 天）

controller → service → mapper → 数据库 （前端请求） （业务处理） （数据访问） model 贯穿各层，用于数据传递；utils 为各层提供通用支持。