Java 后端实习复盘：企业级项目实战与核心代码解析

这里利用 Spring AOP 的 @Pointcut 定义切点，拦截所有标注了 @Auth 的方法。通知方法中获取当前登录用户信息，比对角色权限，不匹配则抛出异常。这种设计将权限逻辑与业务代码解耦，维护起来更清晰。

2. Token 管理与认证

Token 是连接客户端与服务端的桥梁。我们的实现结合了 JWT 签名与 Redis 存储，兼顾无状态校验与动态失效能力。

过滤器流程

请求进入系统时，LoginFilter 作为第一道关卡处理认证：

@Component
@WebFilter(urlPatterns = "/*")
public class LoginFilter implements Filter {
    // ... 省略部分配置 ...
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
        
        // 白名单直接放行
        PathContainer pathContainer = PathContainer.parsePath(httpRequest.getRequestURI());
        if (ignorePatterns.stream().anyMatch(p -> p.matches(pathContainer))) {
            filterChain.doFilter(servletRequest, servletResponse);
            return;
        }
        
        // 执行认证处理
        if (handle(httpRequest, httpResponse)) {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }
    
    private boolean handle(HttpServletRequest request, HttpServletResponse response) {
        // 区分 OpenAPI 和普通用户认证
        if (openApiAuthHandler.isOpenApiRequest(request)) {
            return handleOpenApiAuth(request, response);
        }
        return handleUserAuth(request, response);
    }
}

关键点在于 finally 块中的上下文清理，无论认证成功与否，都要移除 LoginUserHandler 中的上下文，防止内存泄漏。

Token 服务

TokenService 负责 Token 的生成、解析和刷新。核心逻辑如下：

public String createToken(LoginUser loginUser) {
    String uuid = UUID.randomUUID().toString();
    Map<String, Object> claims = new HashMap<>();
    claims.put(TOKEN, uuid);
    claims.put(USERNAME, loginUser.getUsername());
    
    String token = Jwts.builder()
        .claims(claims)
        .expiration(new Date(System.currentTimeMillis() + expirationHours * 3600 * 1000))
        .signWith(Keys.hmacShaKeyFor(secretKey), Jwts.SIG.HS512)
        .compact();
    
    loginUser.setToken(token);
    refreshToken(loginUser, uuid); // 同步存入 Redis
    return token;
}

创建 Token 后，立即将用户信息存入 Redis 并设置过期时间。这样即使 JWT 未过期，若 Redis 中数据被删除（如登出），也能实现即时失效。

3. 企业管理模块

针对高频查询的场景，我们采用了全量缓存策略来优化性能。

public List<Company> cacheAll() {
    final String cacheKey = "company:all";
    List<Company> cachedList = redisService.get(cacheKey, List.class);
    if (cachedList != null) {
        return cachedList;
    }
    synchronized (cacheLock) {
        cachedList = redisService.get(cacheKey, List.class);
        if (cachedList != null) {
            return cachedList;
        }
        List<Company> list = list();
        redisService.set(cacheKey, list, 3600); // 设置 1 小时过期
        return list;
    }
}

这段代码实现了经典的「双重检查加锁」模式。第一层检查避免不必要的锁竞争，第二层检查防止缓存击穿。同时设置了合理的过期时间，保证数据最终一致性。

对于下拉列表查询，复用 cacheAll() 的结果进行过滤，避免了重复查库：

public List<CompanyDropDown> getCompanyDropDownList(Long companyId, LoginUser loginUser) {
    return cacheAll().stream()
        .filter(c -> companyId == null || c.getId().equals(companyId))
        .filter(c -> !loginUser.isEnterprise() || c.getId().equals(loginUser.getAuthCompanyId()))
        .sorted(Comparator.comparing(Company::getName))
        .map(CompanyDropDown::from)
        .collect(Collectors.toList());
}

4. 第三方系统访问模块

开放平台（OpenAPI）的 Token 生成逻辑需要严格管控。一个 API Key 同一时间只能有一个有效 Token，旧 Token 需强制撤销。

public TokenInfo generateToken(String apiKey, String secret) {
    // 验证 API 密钥和秘钥
    ApiKey entity = apiKeyRepository.findByApiKey(apiKey);
    if (entity == null || !entity.getEnabled() || !SecretEncoder.matches(secret, entity.getSecret())) {
        throw new BusinessException(ResponseCode.FAIL, "认证失败");
    }
    
    // 撤销现有 Token，保证唯一性
    tokenRepository.revokeTokensByApiKey(apiKey);
    
    // 生成新 Token 并保存至 Redis
    String token = ApiKeyGenerator.generateToken();
    // ... 省略部分逻辑 ...
    tokenRepository.saveToken(tokenInfo, DEFAULT_TOKEN_EXPIRE_HOURS);
    return tokenInfo;
}

四、工程化规范总结

1. 判空工具类

业务中大量涉及判空，推荐使用 Hutool 的 ObjectUtil 和 StringUtils，覆盖 99% 的场景。

• 字符串：isBlank(str) 判断是否为 null、空串或仅空格。
• 包装类：isEmpty(num) 判断 Integer 是否为 null 或默认值 0。
• 集合：isEmpty(list) 判断引用是否为 null 或集合为空。

2. 日志配置

生产环境建议使用异步日志输出，避免 IO 阻塞主线程。Logback 配置中开启了 ASYNC_FILE 和 ASYNC_STDOUT，并设置了队列大小和丢弃阈值，平衡性能与安全性。

3. 分布式锁

使用 @Lock4j 注解封装 Redisson 分布式锁，支持 SpEL 表达式动态指定 Key。注意切面优先级，确保锁逻辑在事务之前执行。

@Lock4j(lockType = "addCompany", key = "#dto.name")
@Transactional(rollbackFor = Exception.class)
public Long addCompany(AddCompanyDTO dto, LoginUser loginUser) {
    // 业务逻辑
}

4. 异步任务处理

对于非核心链路（如记录日志、发送消息），使用 CompletableFuture 配合自定义线程池执行，避免阻塞主线程。

private void saveLogAsync(OperationLog operationLog) {
    CompletableUtil.run(() -> {
        try {
            SpringUtil.getBean(OperationLogMapper.class).insert(operationLog);
        } catch (Exception exception) {
            log.error("操作日志异常", exception);
        }
    });
}

五、常见问题处理

1. 缓存失效问题

初期发现 removeCache() 方法调用后缓存并未真正失效，原因是部分业务逻辑未接入缓存读取，导致缓存键从未被实际使用。后续统一了缓存读写入口，确保增删改操作后及时清理对应缓存。

2. Token 续期后旧 Token 未失效

在 Token 刷新逻辑中，如果只生成新 Token 而不删除 Redis 中的旧 Token，会导致同一账号多个 Token 同时有效。解决方案是在刷新成功后，显式调用 invalidateOldToken 删除旧 Key，确保单点登录安全。

public String refreshToken(HttpServletRequest request) {
    Long expireTime = tokenService.getExpireTime(request);
    if (expireTime < 30 * 60) {
        String oldToken = tokenService.getToken(request);
        LoginUser loginUser = tokenService.getLoginUser(request);
        if (loginUser == null) {
            throw new BusinessException(ResponseCode.AUTHENTICATION_FAIL);
        }
        String newToken = tokenService.createToken(loginUser);
        tokenService.invalidateOldToken(oldToken); // 关键步骤
        return newToken;
    }
    return tokenService.getToken(request);
}

这次实习让我深刻体会到企业级开发不仅仅是写功能，更重要的是稳定性、可维护性和规范性的平衡。希望这些经验能对即将步入职场的同学有所帮助。