Spring Boot基于 JWT 优化 Spring Security 无状态登录实战指南

更新时间：2025年11月27日 11:26:51 作者：Java天梯之路

本文介绍如何使用JWT优化SpringSecurity实现无状态登录,提高接口安全性,并通过实际操作步骤展示了如何配置JWT参数、实现JWT登录接口、认证过滤器等,感兴趣的朋友跟随小编一起看看吧

Spring Boot 实战：基于 JWT 优化 Spring Security 无状态登录

在上一篇文章中，我们通过 Spring Security 实现了基础的接口权限控制，但采用的 HTTP Basic 登录存在明显缺陷：安全性，用户名和密码只是简单的通过 Base64 编码之后就开始传送了，很容易被破解，进而暴露用户信息。

本文将引入 JWT（JSON Web Token） 技术，重构登录流程，让接口即安全又贴合企业级项目需求。

一、先搞懂：为什么需要 JWT？

Jwt的核心优势是 无状态：

登录成功后，服务器生成一个包含用户信息和权限的加密 Token，直接返回给客户端；
客户端后续请求时，只需在请求头携带 Token，服务器无需存储任何状态，直接通过 Token 验证身份和权限；
多台服务器共用一套 Token 验证逻辑，无需同步状态，完美适配分布式部署。

二、准备工作：添加 JWT 依赖

在 pom.xml 的 <dependencies> 标签中，新增 JWT 相关依赖（基于 JJWT 框架，Spring 官方推荐）：

        <!-- JWT 核心依赖（JJWT） -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.11.5</version>
        </dependency>
        <!-- JWT 实现依赖 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>
        <!-- JWT 加密算法依赖 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.11.5</version>
            <scope>runtime</scope>
        </dependency>

添加后点击 IDEA 右上角的 “Load Maven Changes” 刷新依赖，确保无红色报错。

三、第一步：实现 JWT 工具类（核心）

JWT 的核心操作包括 生成 Token、验证 Token、解析 Token 中的用户信息，我们创建一个工具类封装这些逻辑，方便后续调用。

在 com.example.firstspringbootproject.utils 包下创建 JwtUtil 类：

package com.example.firstspringbootproject.utils;
import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
@Component
public class JwtUtil {
    // 1. 从配置文件读取 JWT 关键参数（避免硬编码）
    @Value("${jwt.secret}") // 密钥（必须保密，建议在生产环境用环境变量配置）
    private String secret;
    @Value("${jwt.expiration}") // Token 过期时间（单位：毫秒，这里配置 2 小时）
    private long expiration;
    @Value("${jwt.header}") // 请求头中携带 Token 的字段名（如 Authorization）
    private String tokenHeader;
    @Value("${jwt.prefix}") // Token 前缀（如 Bearer，规范要求加空格）
    private String tokenPrefix;
    // 2. 生成 Token：基于用户信息（用户名、角色）
    public String generateToken(UserDetails userDetails) {
        // 存储 Token 中的自定义信息（Payload）
        Map<String, Object> claims = new HashMap<>();
        // 将用户角色存入 Token（后续验证权限用）
        claims.put("roles", userDetails.getAuthorities().stream()
                .map(authority -> authority.getAuthority())
                .toList());
        // 构建 Token 并返回
        return Jwts.builder()
                .setClaims(claims) // 自定义信息
                .setSubject(userDetails.getUsername()) // 用户名（唯一标识）
                .setIssuedAt(new Date()) // 签发时间
                .setExpiration(new Date(System.currentTimeMillis() + expiration)) // 过期时间
                .signWith(SignatureAlgorithm.HS512, secret) // 加密算法（HS512）+ 密钥
                .compact();
    }
    // 3. 从 Token 中获取用户名
    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }
    // 4. 验证 Token 是否有效（未过期 + 用户名匹配）
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUsernameFromToken(token);
        // 验证逻辑：用户名一致 + Token 未过期 + Token 未被篡改
        return username.equals(userDetails.getUsername())
                && !isTokenExpired(token);
    }
    // 5. 从 Token 中获取自定义角色信息
    public String getRoleFromToken(String token) {
        Claims claims = getAllClaimsFromToken(token);
        // 从自定义信息中获取角色列表（这里简化为单个角色，多角色可返回 List）
        return ((List<String>) claims.get("roles")).get(0);
    }
    // ------------------------------
    // 以下是内部工具方法（无需外部调用）
    // ------------------------------
    // 解析 Token，获取所有自定义信息（Payload）
    private Claims getAllClaimsFromToken(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(secret) // 用密钥解密
                    .parseClaimsJws(token)
                    .getBody();
        } catch (ExpiredJwtException | MalformedJwtException | SignatureException
                 | IllegalArgumentException | UnsupportedJwtException e) {
            // 捕获 Token 异常（过期、格式错误、签名错误等）
            throw new RuntimeException("无效的 Token：" + e.getMessage());
        }
    }
    // 从 Token 中获取指定信息（通用方法）
    private <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }
    // 判断 Token 是否过期
    private boolean isTokenExpired(String token) {
        final Date expirationDate = getClaimFromToken(token, Claims::getExpiration);
        return expirationDate.before(new Date());
    }
    // 6. 辅助方法：从请求头中提取 Token（去除前缀）
    public String extractTokenFromHeader(String header) {
        if (header != null && header.startsWith(tokenPrefix)) {
            // 例如：header = "Bearer eyJhbGciOiJIUzI1NiJ9..."，返回后面的 Token 部分
            return header.substring(tokenPrefix.length()).trim();
        }
        return null;
    }
    // Getter 方法（供外部获取配置参数）
    public String getTokenHeader() {
        return tokenHeader;
    }
    public String getTokenPrefix() {
        return tokenPrefix;
    }
}

四、第二步：配置 JWT 参数（避免硬编码）

在 src/main/resources/application.yml（或 application.properties）中，添加 JWT 相关配置（替换硬编码，方便后续修改）：

# JWT 配置
jwt:
  secret: firstspringbootproject2025secretkeyfirstspringbootproject2025secretkeyfirstspringbootproject2025secretkey # 密钥（生产环境建议用 64 位以上随机字符串）
#  expiration: 7200000 # Token 过期时间（7200000 毫秒 = 2 小时）
  expiration: 1000 # Token 过期时间（1000 毫秒 = 1 秒）
  header: Authorization # 请求头字段名
  prefix: Bearer  # Token 前缀（注意末尾有空格）

五、第三步：实现 JWT 登录接口（替换 HTTP Basic）

HTTP Basic 登录是通过浏览器弹窗输入账号密码，体验较差；我们需要自定义一个 登录接口（如 /api/login），客户端通过 JSON 提交账号密码，服务器验证通过后返回 JWT Token。

1. 创建登录请求参数实体类

在 com.example.firstspringbootproject.dto 包下创建 LoginRequestDTO（接收客户端提交的账号密码）：

package com.example.firstspringbootproject.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
@Schema(name = "LoginRequestDTO", description = "登录请求参数")
public class LoginRequestDTO {
    @NotBlank(message = "用户名不能为空")
    @Schema(description = "用户名", example = "admin")
    private String username;
    @NotBlank(message = "密码不能为空")
    @Schema(description = "密码", example = "123456")
    private String password;
}

2. 创建登录控制器

在 com.example.firstspringbootproject.controller 包下创建 AuthController，实现登录接口：

package com.example.firstspringbootproject.controller;
import com.example.firstspringbootproject.dto.LoginRequestDTO;
import com.example.firstspringbootproject.common.Result;
import com.example.firstspringbootproject.utils.JwtUtil;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;
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 java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/api")
@Tag(name = "认证接口", description = "登录、Token 相关接口")
public class AuthController {
    @Autowired
    private AuthenticationManager authenticationManager; // Spring Security 认证管理器
    @Autowired
    private JwtUtil jwtUtil; // 自定义 JWT 工具类
    /**
     * 登录接口：接收账号密码，验证通过后返回 JWT Token
     */
    @PostMapping("/login")
    @Operation(summary = "用户登录", description = "提交用户名和密码，获取 JWT Token")
    public Result<Map<String, String>> login(@Valid @RequestBody LoginRequestDTO loginRequest) {
        // 1. 调用 Spring Security 认证管理器，验证账号密码
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequest.getUsername(),
                        loginRequest.getPassword()
                )
        );
        // 2. 认证通过：从认证结果中获取用户信息
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        // 3. 生成 JWT Token
        String token = jwtUtil.generateToken(userDetails);
        // 4. 构建返回结果（包含 Token 和过期提示）
        Map<String, String> resultMap = new HashMap<>();
        resultMap.put("token", token);
        resultMap.put("expiration", "Token 有效期 2 小时，请及时刷新");
        resultMap.put("role", jwtUtil.getRoleFromToken(token)); // 返回用户角色，方便前端处理
        return Result.success(resultMap);
    }
}

六、第四步：实现 JWT 认证过滤器（核心拦截逻辑）

客户端登录成功后，后续请求会在 Authorization 头中携带 Token（格式：Bearer eyJhbGciOiJIUzI1NiJ9...）。我们需要自定义一个 过滤器，在请求到达接口前拦截 Token，完成以下操作：

从请求头中提取 Token；
验证 Token 有效性；
从 Token 中解析用户信息和角色；
将用户信息存入 Spring Security 上下文，让后续权限校验生效。

在 com.example.firstspringbootproject.filter 包下创建 JwtAuthenticationFilter 类：

package com.example.firstspringbootproject.filter;
import com.example.firstspringbootproject.utils.JwtUtil;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
// 自定义 JWT 认证过滤器：每次请求都会执行（OncePerRequestFilter 确保一次请求只执行一次）
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private JwtUtil jwtUtil;
    @Autowired
    private UserDetailsService userDetailsService; // 之前实现的用户查询服务
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain
    ) throws ServletException, IOException {
        try {
            // 1. 从请求头中提取 Token
            String token = jwtUtil.extractTokenFromHeader(
                    request.getHeader(jwtUtil.getTokenHeader())
            );
            // 2. 验证 Token：非空 + 有效
            if (token != null) {
                // 2.1 从 Token 中获取用户名
                String username = jwtUtil.getUsernameFromToken(token);
                // 2.2 若用户名存在，且 Spring Security 上下文未存储用户信息（未登录）
                if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                    // 2.3 从数据库查询用户完整信息（UserDetails）
                    UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                    // 2.4 验证 Token 有效性（未过期 + 用户名匹配）
                    if (jwtUtil.validateToken(token, userDetails)) {
                        // 3. 构建认证对象，存入 Spring Security 上下文
                        UsernamePasswordAuthenticationToken authentication =
                                new UsernamePasswordAuthenticationToken(
                                        userDetails, // 用户信息
                                        null, // 密码（已验证，无需存储）
                                        userDetails.getAuthorities() // 用户权限（角色）
                                );
                        // 设置请求详情（如 IP、会话 ID）
                        authentication.setDetails(
                                new WebAuthenticationDetailsSource().buildDetails(request)
                        );
                        // 将认证对象存入上下文：后续接口权限校验会从这里获取用户信息
                        SecurityContextHolder.getContext().setAuthentication(authentication);
                    }
                }
            }
        } catch (Exception e) {
            // Token 验证失败（如过期、篡改），打印日志但不阻断请求（后续会返回 401）
            logger.error("JWT Token 验证失败：" + e.getMessage());
        }
        // 4. 继续执行过滤器链（让请求到达后续接口或过滤器）
        filterChain.doFilter(request, response);
    }
}

七、第五步：重构 SecurityConfig（适配 JWT）

之前的 SecurityConfig 基于 HTTP Basic 登录，现在需要修改为 JWT 无状态登录，核心调整点：

关闭 Session（无状态登录不需要 Session）；
放行登录接口（/api/login）；
将 JWT 过滤器加入过滤器链；
移除 HTTP Basic 配置，保留统一异常处理。

修改 com.example.firstspringbootproject.config.SecurityConfig 类：

package com.example.firstspringbootproject.config;
import com.example.firstspringbootproject.common.Result;
import com.example.firstspringbootproject.entity.SysUser;
import com.example.firstspringbootproject.filter.JwtAuthenticationFilter;
import com.example.firstspringbootproject.mapper.SysUserMapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableWebSecurity
@EnableMethodSecurity // 启用方法级权限控制（如 @PreAuthorize("hasRole('ADMIN')")）
public class SecurityConfig {
    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter; // 自定义 JWT 过滤器
    // 1. 密码编码器（不变）
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    // 2. 用户详情服务（不变）
    @Bean
    public UserDetailsService userDetailsService() {
        return username -> {
            SysUser sysUser = sysUserMapper.findByUsername(username);
            if (sysUser == null) {
                throw new UsernameNotFoundException("用户不存在: " + username);
            }
            return sysUser;
        };
    }
    // 3. 认证提供者（不变）
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setUserDetailsService(userDetailsService());
        provider.setPasswordEncoder(passwordEncoder());
        return provider;
    }
    // 4. 认证管理器（不变）
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
    // 5. 核心规则配置（重点修改：适配 JWT）
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                // 1. 关闭 CSRF（前后端分离必须关）
                .csrf(csrf -> csrf.disable())
                // 2. 关闭 Session（无状态登录核心：不创建和使用 Session）
                .sessionManagement(session -> session
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                )
                // 3. 配置接口访问规则（调整放行接口）
                .authorizeHttpRequests(auth -> auth
                        // ① 放行：接口文档（Knife4j）、登录接口
                        .requestMatchers("/doc.html", "/webjars/**", "/v3/api-docs/**", "/api/login").permitAll()
                        // ② 管理员接口：仅 ADMIN 可访问
                        .requestMatchers("/api/user/all").hasRole("ADMIN")
                        // ③ 普通用户接口：USER/ADMIN 可访问
                        .requestMatchers("/api/user/**", "/api/product/**").hasAnyRole("USER", "ADMIN")
                        // ④ 其他接口：必须登录（Token 有效）
                        .anyRequest().authenticated()
                )
                // 4. 加入 JWT 过滤器：在 UsernamePasswordAuthenticationFilter 之前执行
                // （先验证 Token，再执行后续认证逻辑）
                .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class)
                // 5. 统一异常处理（不变：未登录返回 401，权限不足返回 403）
                .exceptionHandling(ex -> ex
                        .authenticationEntryPoint((request, response, authException) -> {
                            response.setContentType("application/json;charset=UTF-8");
                            Result<Void> result = Result.error(401, "未登录或 Token 已过期，请重新登录");
                            response.getWriter().write(objectMapper.writeValueAsString(result));
                        })
                        .accessDeniedHandler((request, response, accessDeniedException) -> {
                            response.setContentType("application/json;charset=UTF-8");
                            Result<Void> result = Result.error(403, "权限不足，无法访问");
                            response.getWriter().write(objectMapper.writeValueAsString(result));
                        })
                );
        // 关联认证提供者
        http.authenticationProvider(authenticationProvider());
        return http.build();
    }
}

八、第六步：测试 JWT 无状态登录流程

启动项目，用 Apifox 测试完整流程，验证无状态登录和权限控制是否生效：

1. 测试 1：调用登录接口，获取 Token

请求地址：http://localhost:8080/api/login
请求方法：POST
请求体（JSON）：

{
    "username": "admin",
    "password": "123456"
}

响应结果（成功）：

{
    "code": 200,
    "msg": "success",
    "data": {
        "role": "ROLE_ADMIN",
        "expiration": "Token 有效期 2 小时，请及时刷新",
        "token": "eyJhbGciOiJIUzUxMiJ9.eyJyb2xlcyI6WyJST0xFX0FETUlOIl0sInN1YiI6ImFkbWluIiwiaWF0IjoxNzYzNDgxMDk0LCJleHAiOjE3NjM0ODgyOTR9.hSxBCTlQo5tUai-knfM2Sh4nVmehizOslcHkvG86jdC-U7-EztskPkF0r4G0DcaTMV3eFcJUu4pCewDdnniq2A"
    }
}

复制返回的 token，后续请求会用到。

2. 测试 2：携带 Token 访问管理员接口

请求地址：http://localhost:8080/api/user/all（需 ADMIN 角色）
请求方法：GET
请求头：添加 Authorization: Bearer eyJhbGciOiJIUzUxMiJ9.eyJyb2xlcyI6WyJST0xFX0FETUlOIl0sInN1YiI6ImFkbWluIiwiaWF0IjoxNzYzNDgxMDk0LCJleHAiOjE3NjM0ODgyOTR9.hSxBCTlQo5tUai-knfM2Sh4nVmehizOslcHkvG86jdC-U7-EztskPkF0r4G0DcaTMV3eFcJUu4pCewDdnniq2A（注意 Bearer 后有空格）
响应结果（成功）：

{
    "code": 200,
    "msg": "success",
    "data": [
        {
            "id": 1,
            "name": "小明",
            "age": 20,
            "phone": "13800138000"
        },
        {
            "id": 2,
            "name": "小红",
            "age": 19,
            "phone": "13900139000"
        },
        {
            "id": 3,
            "name": "小李",
            "age": 22,
            "phone": "13700137000"
        }
    ]
}

3. 测试 3：普通用户 Token 访问管理员接口（权限不足）

先用 zhangsan（密码 123456）调用登录接口，获取普通用户 Token；
携带普通用户 Token 访问 http://localhost:8080/api/user/all；
响应结果（失败）：

{
    "code": 403,
    "msg": "权限不足，无法访问",
    "data": null
}

4. 测试 4：Token 过期（模拟）

修改 application.yml 中 jwt.expiration 为 1000（1 秒过期）；
重新登录获取 Token，1 秒后携带 Token 访问接口；
响应结果（失败）：

{
    "code": 401,
    "msg": "未登录或 Token 已过期，请重新登录",
    "data": null
}

九、常见问题与优化建议

1. 问题：Token 被盗用怎么办？

原因：JWT Token 一旦生成，在过期前无法主动作废；
解决方案：

缩短 Token 过期时间（如 30 分钟），同时实现 Token 刷新接口（用旧 Token 换取新 Token，避免频繁登录）；
维护一个 黑名单（如 Redis），用户登出或 Token 被盗时，将 Token 加入黑名单，验证时先检查是否在黑名单中。

2. 问题：密钥（secret）泄露怎么办？

原因：密钥是 JWT 安全的核心，泄露后攻击者可伪造 Token；
解决方案：

生产环境中，密钥通过 环境变量 或 配置中心 注入，不写入代码或配置文件；
使用 非对称加密算法（如 RS256），用私钥生成 Token，公钥验证 Token，私钥严格保密。

## 十、总结：JWT 无状态登录的核心价值

通过本文的改造，我们实现了 Spring Boot + Spring Security + JWT 的无状态登录，核心优势总结如下：

分布式友好：服务器无需存储 Session，多台服务器可直接共用 Token 验证逻辑；
前后端分离适配：通过请求头携带 Token，无需依赖 Cookie，适配移动端、小程序等多端场景；
安全性提升：Token 包含过期时间和加密签名，避免身份信息被篡改；
扩展性强：Token 可自定义存储用户角色、权限等信息，减少数据库查询次数。

至此，恭喜你已具备初级程序员开发水平，可以试着投简历找工作啦。

到此这篇关于Spring Boot基于 JWT 优化 Spring Security 无状态登录实战指南的文章就介绍到这了,更多相关Spring Boot JWT Spring Security 无状态登录内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

SpringMVC对日期类型的转换示例
本篇文章主要介绍了SpringMVC对日期类型的转换示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-02-02
Java ASM使用logback日志级别动态切换方案展示
这篇文章主要介绍了Java ASM使用logback日志级别动态切换方案展示，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪
2022-04-04
MybatisX快速生成增删改查的方法示例
MybatisX是基于IDEA的MyBatis/MyBatis-Plus开发插件,本文主要介绍了MybatisX快速生成增删改查的方法示例,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来一起学习学习吧
2025-05-05
关于Spring中@Transactional事务回滚的注意事项
这篇文章主要介绍了关于Spring中@Transactional事务回滚的注意事项,回滚（Rollback）指的是程序或数据处理错误，将程序或数据恢复到上一次正确状态的行为。回滚包括程序回滚和数据回滚等类型,需要的朋友可以参考下
2023-05-05
Spring Boot如何在加载bean时优先选择我
这篇文章主要介绍了Spring Boot如何在加载bean时优先选择我,在 Spring Boot 应用程序中，我们可以采取三种方式实现自己的 bean 优先加载，本文通过实例代码给大家详细讲解，需要的朋友可以参考下
2023-03-03
Spring Java-based容器配置详解
这篇文章主要介绍了Spring Java-based容器配置详解，涉及注解和@Configuration类以及@Beans的相关知识，具有一定参考价值，需要的朋友可以了解。
2017-10-10
Java的Spring框架中DAO数据访问对象的使用示例
这篇文章主要介绍了Java的Spring框架中DAO数据访问对象的使用示例,分为在Spring中DOA与JDBC以及与Hibernate的配合使用两种情况来进行演示,需要的朋友可以参考下
2016-03-03
springboot-dubbo cannot be cast to问题及解决
这篇文章主要介绍了springboot-dubbo cannot be cast to问题及解决方案，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-04-04
SpringBoot中@ConditionalOnBean实现原理解读
这篇文章主要介绍了SpringBoot中@ConditionalOnBean实现原理，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-02-02
SpringBoot拦截器实现API安全验证的示例详解
在开放平台和第三方集成的项目中,如何确保 API 调用的安全性和可靠性是一个重要课题,本文将详细介绍如何基于 Spring Boot 拦截器和 HMAC-SHA256 算法,构建一套轻量级但足够安全的 API 验签机制,希望对大家有所帮助
2025-11-11