Java 后端实习复盘：企业级开发流程与核心模块解析

这里要注意，@Pointcut 表达式 @annotation(auth) 会拦截所有标注了指定注解的方法，并将注解实例注入参数中，方便后续获取权限信息。

登录过滤器则负责请求入口的统一认证，区分普通用户和 OpenAPI 请求：

@Component
@WebFilter(urlPatterns = "/*")
@Slf4j
public class LoginFilter implements Filter {
    private final TokenService tokenService;
    // ... 其他依赖

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
        httpResponse.setContentType("application/json;charset=utf-8");
        
        try {
            // 判断是否白名单
            String url = httpRequest.getRequestURI();
            if (isWhiteList(url)) {
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
            // 处理认证
            if (handle(httpRequest, httpResponse)) {
                filterChain.doFilter(servletRequest, servletResponse);
            }
        } finally {
            // 清理上下文
            LoginUserHandler.removeLoginUser();
        }
    }
    
    // ... handle 方法实现略
}

白名单配置通过 Spring Boot 的配置绑定类管理，例如 Swagger 文档路径通常不需要认证：

secure.ignored.urls[0]=/swagger-ui.html
secure.ignored.urls[5]=/web/sys/login
# ... 其他白名单

Token 管理模块

Token 是用户身份的核心凭证。我们采用 JWT + Redis 的组合方案，既保证了无状态性，又支持了主动失效。

创建 Token 时，生成 UUID 作为唯一标识，构建 JWT 载荷并签名，同时将用户信息存入 Redis：

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 中获取完整的用户信息，这样即使 Token 未过期，如果 Redis 中被删除（如登出），也能立即失效。

企业管理模块

这是最典型的 CRUD 业务，但其中包含了缓存优化和数据权限控制的细节。

全量数据缓存加载

对于下拉列表等高频查询，我们采用了双重校验加锁的策略来防止缓存击穿：

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);
        return list;
    }
}

这里第一层检查是为了减少锁竞争，第二层检查是在持有锁之后再次确认，避免重复查询数据库。

分页列表查询

使用 PageHelper 或类似的分页插件，配合 DTO 参数校验，可以简化 Controller 层的代码：

@PostMapping("/list")
public CommonResult<SimplePage<CompanyListVO>> getCompanyList(
        @RequestBody @Validated CompanyListDTO dto) {
    return CommonResult.success(companyService.getCompanyList(dto, U.get()));
}

DTO 中使用 @Size 等注解自动校验入参，避免手动写大量的 if-else。

新增与更新

新增和更新操作需要注意唯一性校验和事务控制。特别是并发场景下，建议使用分布式锁防止重复提交：

@Lock4j(lockType = "addCompany", key = "#dto.name")
@Transactional(rollbackFor = Exception.class)
public Long addCompany(AddCompanyDTO dto, LoginUser loginUser) {
    long count = companyRepository.countByName(dto.getName());
    if (count > 0) {
        throw new BusinessException(ResponseCode.MERCHANT_EXISTS);
    }
    // ... 保存逻辑
    companyRepository.removeCache(); // 删除缓存保证一致性
    return company.getId();
}

企业用户账号管理

用户管理模块涉及密码加密和权限隔离。重置密码时，除了更新数据库，还需要强制用户下线，即删除 Redis 中的 Token 缓存：

@Transactional(rollbackFor = Exception.class)
@Lock4j(lockType = "SYS_USER_RESET_PWD", key = "#dto.getUserId()")
public Boolean sysUserRestPwd(SysUserRestPwdDTO dto, LoginUser loginUser) {
    User user = userRepository.getById(dto.getUserId());
    if (user == null) {
        throw new BusinessException(ResponseCode.GET_USER_ERROR);
    }
    // 密码加密存储
    userRepository.sysUserRestPwd(dto);
    tokenService.logout(user.getUsername()); // 强制下线
    return true;
}

编码规范与工具类

判空处理

推荐使用 Hutool 的 ObjectUtil 覆盖大部分场景，比原生判空更健壮：

• 字符串判空：StringUtils.isEmpty(str) 或 StringUtils.isBlank(str)。
• 基本类型：直接比较默认值，如 num == 0。
• 集合判空：ObjectUtil.isEmpty(list)。

日志配置

Logback 配置中，我们开启了异步输出以避免 IO 阻塞主线程，同时设置了文件滚动策略，保留最近 30 天的日志：

<appender name="ASYNC_FILE">
    <discardingThreshold>0</discardingThreshold>
    <queueSize>512</queueSize>
    <appender-ref ref="FILE"/>
</appender>

异步任务封装

使用 CompletableFuture 封装异步执行逻辑，支持线程池定制和虚拟线程：

public class CompletableUtil {
    public static <U> CompletableFuture<U> supply(Supplier<U> supplier) {
        return CompletableFuture.supplyAsync(supplier, CustomThreadPool.getEXECUTOR());
    }
    
    public static <U> CompletableFuture<U> supplyVirtual(Supplier<U> supplier) {
        return CompletableFuture.supplyAsync(supplier, CustomThreadPool.getVIRTUAL_EXECUTOR());
    }
}

常见问题与解决

缓存失效问题

曾遇到缓存逻辑形同虚设的情况。原因是核心业务方法直接操作数据库，既不读取也不写入缓存，导致 removeCache() 方法虽然被调用，但目标缓存键从未被实际使用。解决方案是将缓存逻辑真正接入业务流程，确保读写一致。

续期后旧 Token 未失效

在 Token 刷新逻辑中，发现生成新 Token 后，旧 Token 依然有效。这是因为只更新了 Redis 中的新 Key，未删除旧 Key。修复方案是在刷新成功后，显式调用 invalidateOldToken 删除旧 Token 对应的 Redis 记录，确保单点登录的安全性。

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);
}

通过这次实习，不仅掌握了企业级开发的技术栈，更重要的是理解了如何在高并发、高可用场景下设计系统。希望这些经验能对即将步入职场的同学有所帮助。