Spring Security 6 【1-快速入门指南】

原创 于 2025-06-29 08:41:40 发布 · 1k 阅读 · 25 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #security

Spring Security 6 快速入门指南

下面是一个完整的 Spring Security 6 快速入门实现，包含用户认证、授权、自定义登录页和API保护等核心功能。

项目结构

src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── example/
│   │           └── security/
│   │               ├── SecurityConfig.java
│   │               ├── WebController.java
│   │               ├── CustomUserDetailsService.java
│   │               └── SecurityApplication.java
│   └── resources/
│       ├── static/
│       │   ├── css/
│       │   │   └── style.css
│       │   └── js/
│       │       └── script.js
│       ├── templates/
│       │   ├── home.html
│       │   ├── login.html
│       │   ├── admin.html
│       │   └── user.html
│       └── application.properties

核心代码实现

1. Spring Security 配置类

package com.example.security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/home", "/public/**", "/css/**", "/js/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard", true)
                .permitAll()
            )
            .logout(logout -> logout
                .logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
                .logoutSuccessUrl("/login?logout")
                .invalidateHttpSession(true)
                .deleteCookies("JSESSIONID")
                .permitAll()
            )
            .exceptionHandling(exception -> exception
                .accessDeniedPage("/access-denied")
            )
            .csrf(csrf -> csrf
                .ignoringRequestMatchers("/api/**") // API端点禁用CSRF
            );
        
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.builder()
            .username("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER")
            .build();
        
        UserDetails admin = User.builder()
            .username("admin")
            .password(passwordEncoder().encode("admin"))
            .roles("ADMIN", "USER")
            .build();
        
        return new InMemoryUserDetailsManager(user, admin);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

2. 控制器类

package com.example.security;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class WebController {

    @GetMapping("/")
    public String home() {
        return "home";
    }

    @GetMapping("/dashboard")
    public String dashboard(Model model) {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        model.addAttribute("username", auth.getName());
        model.addAttribute("roles", auth.getAuthorities());
        return "dashboard";
    }

    @GetMapping("/admin/dashboard")
    public String adminDashboard() {
        return "admin";
    }

    @GetMapping("/user/dashboard")
    public String userDashboard() {
        return "user";
    }

    @GetMapping("/access-denied")
    public String accessDenied() {
        return "access-denied";
    }
    
    // 受保护的API端点
    @GetMapping("/api/greet")
    @ResponseBody
    public String apiGreet() {
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        return "Hello, " + auth.getName() + "! You have roles: " + auth.getAuthorities();
    }
    
    // 公共API端点
    @GetMapping("/api/public")
    @ResponseBody
    public String publicApi() {
        return "This is a public API endpoint";
    }
}

3. 自定义登录页面 (login.html)

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
    <link rel="stylesheet" href="/css/style.css">
</head>
<body>
    <div class="login-container">
        <h2>Spring Security 6 Login</h2>
        
        <!-- 错误消息显示 -->
        <div th:if="${param.error}" class="error">
            Invalid username or password
        </div>
        
        <!-- 登出成功消息 -->
        <div th:if="${param.logout}" class="success">
            You have been logged out
        </div>
        
        <form th:action="@{/login}" method="post">
            <div class="form-group">
                <label for="username">Username</label>
                <input type="text" id="username" name="username" required autofocus>
            </div>
            
            <div class="form-group">
                <label for="password">Password</label>
                <input type="password" id="password" name="password" required>
            </div>
            
            <div class="form-group remember">
                <label>
                    <input type="checkbox" name="remember-me"> Remember me
                </label>
            </div>
            
            <button type="submit">Login</button>
        </form>
        
        <div class="footer">
            <p>Demo Accounts:</p>
            <ul>
                <li>User: user/password</li>
                <li>Admin: admin/admin</li>
            </ul>
        </div>
    </div>
</body>
</html>

4. 仪表盘页面 (dashboard.html)

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Dashboard</title>
    <link rel="stylesheet" href="/css/style.css">
</head>
<body>
    <div class="container">
        <header>
            <h1>Welcome, <span th:text="${username}">User</span>!</h1>
            <form th:action="@{/logout}" method="post">
                <button type="submit">Logout</button>
            </form>
        </header>
        
        <section class="user-info">
            <h2>Your Information</h2>
            <p><strong>Username:</strong> <span th:text="${username}"></span></p>
            <p><strong>Roles:</strong> <span th:text="${roles}"></span></p>
        </section>
        
        <section class="navigation">
            <h2>Navigation</h2>
            <ul>
                <li><a href="/">Home</a></li>
                <li><a href="/user/dashboard">User Dashboard</a></li>
                <li sec:authorize="hasRole('ADMIN')">
                    <a href="/admin/dashboard">Admin Dashboard</a>
                </li>
                <li><a href="/api/greet">API Greeting</a></li>
                <li><a href="/api/public">Public API</a></li>
            </ul>
        </section>
    </div>
</body>
</html>

5. 基本样式 (style.css)

/* 基础样式 */
body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    line-height: 1.6;
    color: #333;
    background-color: #f4f4f4;
    margin: 0;
    padding: 0;
}

.container {
    width: 80%;
    max-width: 1200px;
    margin: 20px auto;
    padding: 20px;
    background: #fff;
    box-shadow: 0 0 10px rgba(0,0,0,0.1);
}

.login-container {
    width: 400px;
    margin: 50px auto;
    padding: 30px;
    background: #fff;
    border-radius: 8px;
    box-shadow: 0 0 15px rgba(0,0,0,0.1);
}

header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 30px;
    padding-bottom: 15px;
    border-bottom: 1px solid #eee;
}

.form-group {
    margin-bottom: 20px;
}

label {
    display: block;
    margin-bottom: 5px;
    font-weight: bold;
}

input[type="text"],
input[type="password"] {
    width: 100%;
    padding: 10px;
    border: 1px solid #ddd;
    border-radius: 4px;
    box-sizing: border-box;
}

button {
    background: #007bff;
    color: white;
    border: none;
    padding: 10px 20px;
    border-radius: 4px;
    cursor: pointer;
    font-size: 16px;
}

button:hover {
    background: #0056b3;
}

.error {
    background: #ffdddd;
    color: #d8000c;
    padding: 10px;
    margin-bottom: 20px;
    border-radius: 4px;
}

.success {
    background: #ddffdd;
    color: #4f8a10;
    padding: 10px;
    margin-bottom: 20px;
    border-radius: 4px;
}

.footer {
    margin-top: 20px;
    padding-top: 10px;
    border-top: 1px solid #eee;
    font-size: 0.9em;
    color: #666;
}

.navigation ul {
    list-style: none;
    padding: 0;
}

.navigation li {
    margin-bottom: 10px;
}

.navigation a {
    text-decoration: none;
    color: #007bff;
}

.navigation a:hover {
    text-decoration: underline;
}

关键功能说明

1. 安全配置解析

  1. 请求授权：

    .authorizeHttpRequests(auth -> auth
    .requestMatchers("/", "/home", "/public/**", "/css/**", "/js/**").permitAll()
    .requestMatchers("/admin/**").hasRole("ADMIN")
    .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
    .anyRequest().authenticated()
)

  2. 表单登录：

    .formLogin(form -> form
    .loginPage("/login")
    .defaultSuccessUrl("/dashboard", true)
    .permitAll()
)

  3. 登出功能：

    .logout(logout -> logout
    .logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
    .logoutSuccessUrl("/login?logout")
    .invalidateHttpSession(true)
    .deleteCookies("JSESSIONID")
    .permitAll()
)

  4. 异常处理：

    .exceptionHandling(exception -> exception
    .accessDeniedPage("/access-denied")
)

2. 用户管理

Spring Security 6 提供多种用户存储方式：

  1. 内存用户存储：

    @Bean
public UserDetailsService userDetailsService() {
    UserDetails user = User.builder()
        .username("user")
        .password(passwordEncoder().encode("password"))
        .roles("USER")
        .build();
    
    UserDetails admin = User.builder()
        .username("admin")
        .password(passwordEncoder().encode("admin"))
        .roles("ADMIN", "USER")
        .build();
    
    return new InMemoryUserDetailsManager(user, admin);
}

  2. JDBC用户存储：

    @Bean
public UserDetailsService jdbcUserDetailsService(DataSource dataSource) {
    return new JdbcUserDetailsManager(dataSource);
}

  3. 自定义用户服务：

    @Service
public class CustomUserDetailsService implements UserDetailsService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) 
        throws UsernameNotFoundException {
        
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException("User not found"));
        
        return org.springframework.security.core.userdetails.User
            .withUsername(user.getUsername())
            .password(user.getPassword())
            .authorities(user.getAuthorities())
            .build();
    }
}

3. 密码加密

使用 BCrypt 密码编码器：

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

进阶功能

1. 方法级安全控制

在配置类上添加 @EnableMethodSecurity 注解：

@Configuration
@EnableWebSecurity
@EnableMethodSecurity
public class SecurityConfig {
    // ...
}

在服务方法上使用安全注解：

@Service
public class ProductService {

    @PreAuthorize("hasRole('ADMIN')")
    public void deleteProduct(Long id) {
        // 只有管理员可以删除产品
    }

    @PreAuthorize("hasRole('USER')")
    @PostAuthorize("returnObject.owner == authentication.name")
    public Product getProduct(Long id) {
        // 用户只能访问自己的产品
    }
}

2. OAuth2 登录集成

添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

配置 OAuth2 登录：

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(auth -> auth
            .anyRequest().authenticated()
        )
        .oauth2Login(oauth -> oauth
            .loginPage("/login")
            .defaultSuccessUrl("/dashboard", true)
        );
    
    return http.build();
}

在 application.properties 中配置客户端：

# Google OAuth2 配置
spring.security.oauth2.client.registration.google.client-id=your-client-id
spring.security.oauth2.client.registration.google.client-secret=your-client-secret

3. JWT 认证

添加 JWT 依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

创建 JWT 工具类：

public class JwtUtil {
    
    private static final String SECRET_KEY = "your-secret-key";
    private static final long EXPIRATION_TIME = 864_000_000; // 10 days

    public static String generateToken(UserDetails userDetails) {
        return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
            .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
            .compact();
    }

    public static String extractUsername(String token) {
        return Jwts.parser()
            .setSigningKey(SECRET_KEY)
            .parseClaimsJws(token)
            .getBody()
            .getSubject();
    }

    public static boolean validateToken(String token, UserDetails userDetails) {
        final String username = extractUsername(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }

    private static boolean isTokenExpired(String token) {
        return Jwts.parser()
            .setSigningKey(SECRET_KEY)
            .parseClaimsJws(token)
            .getBody()
            .getExpiration()
            .before(new Date());
    }
}

配置 JWT 过滤器：

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 {
        
        final String authorizationHeader = request.getHeader("Authorization");
        
        String username = null;
        String jwt = null;
        
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
        
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            
            if (jwtUtil.validateToken(jwt, userDetails)) {
                UsernamePasswordAuthenticationToken authentication = 
                    new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

在安全配置中添加过滤器：

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/authenticate").permitAll()
            .anyRequest().authenticated()
        )
        .sessionManagement(session -> session
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        )
        .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    
    return http.build();
}

运行和测试

  1. 启动应用程序：

    ./mvnw spring-boot:run

  2. 访问以下端点：

    • http://localhost:8080 - 公共主页
    • http://localhost:8080/login - 登录页面
    • http://localhost:8080/dashboard - 用户仪表盘（需要登录）
    • http://localhost:8080/admin/dashboard - 管理员仪表盘
    • http://localhost:8080/api/public - 公共API
    • http://localhost:8080/api/greet - 受保护API

  3. 测试用户：

    • 普通用户：user/password
    • 管理员：admin/admin

最佳实践

  1. 生产环境建议：

    • 使用数据库存储用户凭据
    • 配置 HTTPS
    • 设置强密码策略
    • 实施多因素认证

  2. 安全加固：

    .headers(headers -> headers
    .contentSecurityPolicy(csp -> csp.policyDirectives("default-src 'self'"))
    .frameOptions(frame -> frame.sameOrigin())
    .httpStrictTransportSecurity(hsts -> hsts
        .includeSubDomains(true)
        .maxAgeInSeconds(31536000) // 1年
    )
)
.sessionManagement(session -> session
    .maximumSessions(1) // 单会话限制
    .sessionFixation().migrateSession()
)

  3. 审计日志：

    @Bean
public AuditorAware<String> auditorAware() {
    return () -> Optional.ofNullable(SecurityContextHolder.getContext())
        .map(SecurityContext::getAuthentication)
        .filter(Authentication::isAuthenticated)
        .map(Authentication::getName);
}

Spring Security 6 提供了强大而灵活的安全解决方案，通过这个快速入门指南，您可以

SpringBoot集成Spring Security全解：从入门到精通实战指南（亲测可用）
本博客聚焦 YOLOv11 全流程落地，涵盖架构优化、数据集处理、训练技巧与多场景部署，兼及国产数据库、Java 开发与 AI 模型应用，内容兼顾理论与工程实践，为开发者提供系统干货，助力高效提升技术能力。
06-10 2288
1.3 Spring Boot的“魔法”：让安全配置“开箱即用” 如果说Spring Security是功能强大的“瑞士军刀”，那么Spring Boot就是那位能帮你把刀用得行云流水的“魔术师”。在没有Spring Boot的时代，配置Spring Security是一件相当繁琐的事情，你需要编写大量的XML或Java配置代码，来定义各种过滤器、处理器和提供者。 Spring Boot的出现彻底改变了这一切。它遵循“约定优于配置”的原则，通过spring-boot-starter-security这个启
上古掌控安全的神-零:Spring Security5.x到Spring Security6.x的迁移
Xayla的博客
04-20 2294
之前有写过一篇关于的文章，但那已经是相对比较旧的版本了，就目前来说，这其中出现了不少的变动和更新，很多API的使用也是有不小的变化，所以我觉得有必要再写几篇文章学习一下，是的，不是一篇，是几篇，下面是初步的写作计划。《上古掌控安全的神-壹:Spring Security6.0+版本初探》《上古掌控安全的神-贰:Spring Security6.0+版本再探》《上古掌控安全的神-叁:Spring Security6.0+版本认证实践》
SpringSecurity6（认证-前后端分离）
最新发布
Linging_24的博客
06-23 469
本文介绍了基于SpringBoot 3.2.8和Spring Security 6.1.11的认证系统设计方案。系统使用JDK17开发，包含验证码过滤、密码加密认证、记住我功能、并发会话控制、Redis会话存储、CSRF防护等安全特性。配置文件中详细设置了数据库连接池、Redis会话存储等参数。通过自定义PasswordEncoder支持多种加密算法（如MD5、BCrypt等），并使用@EnableRedisIndexedHttpSession实现Redis持久化会话管理。系统整合了MybatisPlus、
Spring Security（6）
分享专业、有用、有趣的技术、产品、运营和管理知识。
11-28 662
MySQL保存cookie记录虽然方便，但是目前主流应用都是用NoSQL的。之前SpringSecurity并不支持NoSQL，但这个问题对于一个爱钻研的码农来说应该只是个小CASE——毕竟只要有代码，就没有搞不定的问题。
SpringSecurity 6 快速入门
qq_46216299的博客
02-02 2595
SpringSecurity 6 是 Spring 全家桶中属于安全权限的一类框架产品，同时它对于 Spring 框架的兼容性以及高定制性以及开源等优点，使得有些企业或个人开发者都会使用该框架
Spring Security 6
追逐自己的目标，感受生活的乐趣。Elcker
07-21 882
Spring Security6
SpringSecurity6
zhuge_long的专栏
08-20 1140
​是一个能够为基于 Spring 的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在 Spring 应用上下文中配置的 Bean，充分利用了 Spring IoC（Inversion of Control 控制反转），DI（Dependency Injection 依赖注入）和 AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。对身份验证和授权的全面且可扩展的支持防御会话固定、点击劫持，跨站请求伪造等攻击。
Spring Security 6 with SpringBoot
2301_81071716的博客
11-11 1982
首先登陆网站start.spring.io,添加web,devtool,security依赖编写完controller代码后进入网址会发现需要填表单,用户默认是user,密码在后端的控制台.springsecurity会有很多过滤器,如图中的f1,f2等request经过filter进入front controller(这个是在controller之前的控制器),且注意这里的后端都是在Servlet Container(即Tomcat)中运行的,关于Servlet:Servlet是Java EE（Java
SpringSecurity6的WebFlux安全配置指南.pdf
04-21
文档支持目录章节跳转同时还支持阅读器左侧大纲显示和章节快速定位，文档内容完整、条理清晰。文档内所有文字、图表、函数、目录等元素均显示正常，无任何异常情况，敬请您放心查阅与使用。文档仅供学习参考，请勿...
Spring Security基础教程：快速入门指南
由于提供的文件信息中，压缩包的文件名称列表只有一个“springSecurity”，说明这个压缩包内可能只包含了一个文件，可能是关于Spring Security的入门教程、配置文档或示例代码。在处理这类文件时，可以通过编写...
Spring Security 教程：从入门到精通（含 OAuth2 接入）
kalle2021的博客
03-17 1536
本文全面深入地介绍了Spring Security相关知识。首先阐述其基础概念，包括认证与授权等关键要点。接着讲述从入门到进阶的实践过程，如创建Spring Boot项目并引入依赖，进行内存用户认证、基于数据库的用户认证配置，还涉及授权管理的多种方式。随后说明CSRF防护机制及其配置要点。重点讲解了OAuth2接入方法，涵盖客户端与资源服务器的配置及自定义流程。最后提及一些高级特性与优化方向，助力开发者构建安全可靠的Web应用 。
SpringSecurity6.x
qq_45726327的博客
03-23 2449
Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架。它是保护基于 Spring 的应用程序的事实上的标准。Spring Security 是一个专注于为 Java 应用程序提供身份验证和授权的框架。与所有 Spring 项目一样，Spring Security 的真正强大之处在于它可以轻松扩展以满足自定义需求。实际开发的过程中，我们需要应用程序更加灵活，可以在SpringSecurity中创建自定义配置文件。Java自定义配置用来管理用户信息，
SpringSecurity6（安全框架知识初步了解）
2401_86329916的博客
10-30 700
SpringSecurtiy初步认识
Spring Security 6 学习-1
一根火柴博客
01-23 2123
Spring Security文档Spring Security中文文档Spring Security 是 Spring 家族中的安全型开发框架，主要解决三大方面问题：认证（你是谁）、授权（你能干什么）、常见攻击保护（CSRF、HTTP安全响应头设置、Http防火墙）。它常用于 Spring Boot 及 Spring Cloud 框架中。
springsecurity 6.0学习
热门推荐
.
05-13 1万+
小伙伴们，你们好呀！我是老寇！ 曾几何时，我想一直用jdk8开发项目，不料，随着spring版本的迭代，jdk8也成为了过去，因此，有必要学习新的技术，然而，学习新的技术必然离不了官网文档，所以，老寇决定开个新坑，用来记录新版本的springsecurity与微服务的整合
认证 (authentication) 和授权 (authorization) 的区别
全栈空间
09-14 3304
  以前一直傻傻分不清各种网际应用中 authentication 和 authorization, 其实很简单:   这两个术语通常在安全性方面相互结合使用，尤其是在获得对系统的访问权限时。两者都是非常重要的主题，通常与网络相关联，作为其服务基础架构的关键部分。然而，这两个术语在完全不同的概念上是非常不同的。虽然它们通常使用相同的工具在相同的上下文中使用，但它们彼此完全不同。 身份验...
SpringSecurity6 学习
screamn的博客
05-03 1520
SpringSecurity6介绍，讲解基本的配置过滤链 和 对应的用户配置，流程讲解。
SpringSecurity6从入门到实战之SpringSecurity整合自动装配详解(源码级讲解,耐心看完)
helloworld工程师的博客
06-03 1969
这里我先引出问题然后再来一步步进行剖析,SpringSecurity到底是如何实现引入依赖后所有请求都需要进行认证并且会弹出login登录表单页面.接下来会对SpringBoot的自动装配进行详解,SpringSecurity也是通过自动装配实现以上一系列操作的。
SpringSecurity-6-基于Filter实现图形验证码
zhoubangbang1的博客
03-25 999
SpringSecurity-6-基于Filter实现图形验证码SpringSecurity中有多种方式实现图像验证码，使用自定义过滤器去处理验证码逻辑是最简单的方式，只要将过滤器添加到合适的位置，当登录的时候，对验证码进行校验，成功就放行，失败则抛出异常。图形验证流程 流程图如下使用kaptcha生成图形验证码 kaptcha是谷歌提供的一款开源验证码jar包，只需简单配置就可以生成图片，源码地址：https://github.com/penggle/kaptcha添加kaptcha依赖在项目的pom.x
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值