后端进阶之路——综述Spring Security认证，授权（一）

╰半橙微兮° 2023-10-14 11:45 12阅读 0赞

# 前言 #

![在这里插入图片描述][0422b4369a3549b3a39da19588ab88f4.png]  
「作者主页」：[雪碧有白泡泡][Link 1]  
「个人网站」：[雪碧的个人网站][Link 2]  
「推荐专栏」：

> ★[java一站式服务][java] ★  
> ★[前端炫酷代码分享][Link 3]  
> ★ ★ [uniapp-从构建到提升][uniapp-]★  
> ★ [从0到英雄，vue成神之路][0_vue]★  
> ★ [解决算法，一个专栏就够了][Link 4]★  
> ★ [架构咱们从0说][0]★  
> ★ [数据流通的精妙之道][Link 5]★  
> ★[后端进阶之路][Link 6]★

![请添加图片描述][c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]

### 文章目录 ###

*  前言
 *  ✍1. 引言
 *   *  ✌ 背景介绍：网络安全的重要性
     *  ✌ Spring Security简介：什么是Spring Security，它的作用和优势
 *  ✍2. Spring Security基本概念
 *   *   *  ✌认证(Authentication)：验证用户身份
         *   *   *  代码演示
             *  1. 创建一个自定义的 \`UserDetailsService\` 实现来加载用户信息：
             *  2. 配置 Spring Security 来使用上述的 \`UserDetailsService\` 实现：
             *  3. 在控制器中处理登录请求：
         *  ✌授权(Authorization)：授予用户访问权限
         *   *   *  代码演示
             *  1. 基于角色（Role）的授权：
             *  2. 基于权限（Permission）的授权：
         *  ✌安全上下文(Security Context)：保存已认证的用户信息
         *   *   *  代码演示
             *  一旦你在认证过程中验证了用户的凭据，你可以创建 \`CustomUserDetails\` 实例，并将其放入安全上下文中：
         *  ✌过滤器链(Filter Chain)：处理请求的过程
 *  ✍小结

以下是在每个标题前添加\#符号后的文本：

# ✍1. 引言 #

## ✌ 背景介绍：网络安全的重要性 ##

**网络安全的重要性无法被低估。随着我们越来越依赖互联网和数字技术，网络安全问题变得愈发严峻。以下是网络安全的几个重要方面：**

> 1.  防止数据泄露：网络安全确保我们的个人信息、敏感数据和商业机密不会落入未授权的人手中。这包括银行账户信息、社交媒体账号、医疗记录等。
> 2.  防范黑客攻击：黑客可以通过各种方式入侵网络系统，窃取信息、破坏系统或勒索金钱。网络安全措施有助于防止这些攻击，并保护我们的计算机、移动设备和网络连接。
> 3.  维护企业安全：对于企业而言，网络安全至关重要。保护公司的数据和机密信息，防止竞争对手或恶意行为者获取敏感信息，确保业务的连续性和声誉。
> 4.  保护个人隐私：在数字时代，我们的个人隐私面临威胁。网络安全可以帮助我们保护个人身份和隐私，避免成为身份盗窃、网络欺诈或网络骚扰的受害者。
> 5.  防止网络犯罪：网络安全对于打击网络犯罪至关重要。网络犯罪包括电信诈骗、网络钓鱼、恶意软件传播等。通过加强网络安全，可以降低这些犯罪行为的发生率，并维护社会的安全和秩序。

## ✌ Spring Security简介：什么是Spring Security，它的作用和优势 ##

**Spring Security**是一个用于在Java应用程序中实现身份验证和授权的框架。它对应用程序进行保护，以防止未经授权的访问，并确保只有经过身份验证的用户可以执行特定操作。

**Spring Security**的主要作用是提供全面的安全性解决方案，包括用户认证、授权、会话管理和密码加密等功能。它可以轻松集成到Spring应用程序中，并通过配置和自定义来满足各种安全需求。

**以下是Spring Security的几个优点：**

> 1.  统一的安全管控：**Spring Security提供了一套完善的安全管理框架，使得开发者可以方便地集中管理应用程序的安全性，而无需重复编写安全相关的代码。**
> 2.  灵活的身份验证和授权机制：**Spring Security支持多种身份验证方式，如基于表单的身份验证、HTTP Basic和Digest身份验证、LDAP身份验证等。它还提供了细粒度的授权机制，可以通过注解或配置的方式定义权限规则。**
> 3.  安全性扩展性：**Spring Security具有良好的扩展性，可以与其他框架和技术无缝集成，例如Spring框架、OAuth、OpenID等。这使得开发人员可以根据项目需求选择合适的安全性解决方案。**
> 4.  内置防护措施：**Spring Security提供了对常见安全威胁的内置防护机制，如跨站点请求伪造（CSRF）保护、点击劫持保护、会话管理等。这些功能可以有效地提高应用程序的安全性。**

![在这里插入图片描述][a890fe72274c4a2aa4f2af513ddef7b1.png]

# ✍2. Spring Security基本概念 #

**Spring Security是一个基于Java的身份验证和访问控制框架，用于保护Web应用程序和服务。它提供了一套功能强大的安全性特性，帮助开发人员在应用程序中实现各种身份验证和授权方案。**

![在这里插入图片描述][119aecdb3197468f8e8927662f5fb340.png]

### ✌认证(Authentication)：验证用户身份 ###

认证是**确认用户身份**的过程。当用户尝试登录系统时，Spring Security会验证用户提供的凭据是否有效，并根据验证结果构建一个代表用户身份的对象，称为Authentication对象。

##### 代码演示 #####

当使用Spring Security进行身份验证时，可以通过以下代码片段来理解认证过程：

#### 1. 创建一个自定义的 `UserDetailsService` 实现来加载用户信息： ####

@Service
    public class UserDetailsServiceImpl implements UserDetailsService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            User user = userRepository.findByUsername(username);
            if (user == null) {
        
                throw new UsernameNotFoundException("User not found with username: " + username);
            }
            return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(),
                    getAuthorities(user.getRoles()));
        }
    
        private Collection<? extends GrantedAuthority> getAuthorities(Set<Role> roles) {
        
            return roles.stream()
                    .map(role -> new SimpleGrantedAuthority(role.getName()))
                    .collect(Collectors.toList());
        }
    }

#### 2. 配置 Spring Security 来使用上述的 `UserDetailsService` 实现： ####

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
        }
    
        // 密码加密器
        @Bean
        public PasswordEncoder passwordEncoder() {
        
            return new BCryptPasswordEncoder();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .antMatchers("/admin/**").hasRole("ADMIN")
                    .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                    .anyRequest().authenticated()
                    .and()
                    .formLogin().permitAll()
                    .and()
                    .logout().permitAll();
        }
    }

#### 3. 在控制器中处理登录请求： ####

@Controller
    public class LoginController {
        
    
        @GetMapping("/login")
        public String login() {
        
            return "login";
        }
    
        @GetMapping("/")
        public String home() {
        
            return "home";
        }
    }

![在这里插入图片描述][f7c074a14a084323bc4dbc76800bd236.png]

> 以上代码演示了一个基本的Spring  
> Security身份验证过程。当用户尝试访问受保护的资源时，会被重定向到登录页面（`/login`）。用户输入用户名和密码后，Spring  
> Security将通过 `UserDetailsService` 加载用户信息，并使用提供的凭据进行验证。如果验证成功，将创建一个  
> `Authentication` 对象表示用户身份，并允许用户访问受保护的资源。

### ✌授权(Authorization)：授予用户访问权限 ###

授权是确定**用户是否有权限执行某个操作或访问某个资源的过程**。Spring Security提供了丰富的授权机制，包括基于角色（Role）和权限（Permission）的授权方式。

##### 代码演示 #####

当涉及到授权时，Spring Security提供了几种常见的授权方式。下面是一些代码片段来帮助理解这些授权机制。

#### 1. 基于角色（Role）的授权： ####

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin();
        }
    
        @Autowired
        public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.inMemoryAuthentication()
                .withUser("user").password("{noop}password").roles("USER")
                .and()
                .withUser("admin").password("{noop}password").roles("ADMIN");
        }
    }

> 在上面的示例中，我们使用了基于角色的授权方式。通过`hasRole()`和`hasAnyRole()`方法，我们可以指定哪些角色有访问权限。在`configureGlobal()`方法中，我们使用了一个简单的内存身份验证，其中包含了具有不同角色的两个用户。

#### 2. 基于权限（Permission）的授权： ####

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                .antMatchers("/admin/**").hasAuthority("ADMIN")
                .antMatchers("/user/**").hasAnyAuthority("USER", "ADMIN")
                .anyRequest().authenticated()
                .and()
                .formLogin();
        }
    
        @Autowired
        public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.inMemoryAuthentication()
                .withUser("user").password("{noop}password").authorities("USER")
                .and()
                .withUser("admin").password("{noop}password").authorities("ADMIN");
        }
    }

> 在上面的示例中，我们使用了基于权限的授权方式。通过`hasAuthority()`和`hasAnyAuthority()`方法，我们可以指定哪些权限有访问权限。在`configureGlobal()`方法中，我们使用了相同的内存身份验证，但是这次我们分配了不同的权限。

### ✌安全上下文(Security Context)：保存已认证的用户信息 ###

用户详情（User Details）：用户详情是**Spring Security中表示用户信息的接口**，通常由开发人员实现以提供自定义用户信息。它包含用户的用户名、密码、角色等属性。

##### 代码演示 #####

以下是自定义用户详情（User Details）并在安全上下文（Security Context）中保存已认证的用户信息。

import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.userdetails.UserDetails;
    
    import java.util.Collection;
    
    public class CustomUserDetails implements UserDetails {
        
        private String username;
        private String password;
        private Collection<? extends GrantedAuthority> authorities;
    
        public CustomUserDetails(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        
            this.username = username;
            this.password = password;
            this.authorities = authorities;
        }
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
        
            return authorities;
        }
    
        @Override
        public String getPassword() {
        
            return password;
        }
    
        @Override
        public String getUsername() {
        
            return username;
        }
    
        // 下面的方法可以根据实际需求进行实现
    
        @Override
        public boolean isAccountNonExpired() {
        
            return true;
        }
    
        @Override
        public boolean isAccountNonLocked() {
        
            return true;
        }
    
        @Override
        public boolean isCredentialsNonExpired() {
        
            return true;
        }
    
        @Override
        public boolean isEnabled() {
        
            return true;
        }
    }

> 在上述代码中，`CustomUserDetails` 类实现了 `UserDetails`  
> 接口，并提供了必要的方法来获取用户名、密码和用户角色等属性。这个类是开发人员自定义的用户详情实现。

#### 一旦你在认证过程中验证了用户的凭据，你可以创建 `CustomUserDetails` 实例，并将其放入安全上下文中： ####

import org.springframework.security.core.Authentication;
    import org.springframework.security.core.context.SecurityContextHolder;
    
    public class AuthenticationService {
        
        public void authenticateUser(String username, String password) {
        
            // 通过验证用户名和密码
    
            // 创建用户详情
            UserDetails userDetails = new CustomUserDetails(username, password, authorities);
    
            // 创建认证对象
            Authentication authentication = new UsernamePasswordAuthenticationToken(userDetails, password, authorities);
    
            // 将认证对象放入安全上下文
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
    }

> 在上述代码中，`authenticateUser` 方法创建了一个 `CustomUserDetails` 实例，并使用该实例创建了一个  
> `UsernamePasswordAuthenticationToken`  
> 对象。然后，它将认证对象放入安全上下文中，以便后续可以访问已认证的用户信息。

### ✌过滤器链(Filter Chain)：处理请求的过程 ###

过滤器链（Filter Chain）：过滤器链是**Spring Security的核心组件之一**，负责处理请求的安全性。它由多个过滤器组成，每个过滤器负责执行特定的安全操作，例如身份验证、授权检查等。

下面是一个基本的Spring Security过滤器链配置

@Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http
                .authorizeRequests()
                    .antMatchers("/public/**").permitAll()
                    .anyRequest().authenticated()
                    .and()
                .formLogin()
                    .and()
                .logout();
        }
    }

> 在上面的示例中，`SecurityConfig`类继承了`WebSecurityConfigurerAdapter`，这是一个方便的基类，用于配置Spring  
> Security。
> 
> `configure()`方法用于配置`HttpSecurity`对象，它定义了过滤器链的行为。在该示例中，过滤器链执行以下操作：
> 
> 1.  `authorizeRequests()`：配置请求授权规则。
> 2.  `.antMatchers("/public/**").permitAll()`：允许所有用户访问以`/public/`开头的URL。
> 3.  `.anyRequest().authenticated()`：对于其他所有请求，要求用户进行身份验证。
> 4.  `.formLogin()`：启用基于表单的身份验证。
> 5.  `.logout()`：启用退出功能。

# ✍小结 #

Spring Security是一个功能强大的Java框架，用于在应用程序中实现认证（Authentication）和授权（Authorization）功能。它提供了一套细粒度的安全性控制机制，帮助保护应用程序免受恶意攻击和未经授权的访问。  
![在这里插入图片描述][8607597ddb66429e9d8dd5ea61097d18.png]  
**下一篇我们会详细讲述Spring Security配置问题**

[0422b4369a3549b3a39da19588ab88f4.png]: https://img-blog.csdnimg.cn/0422b4369a3549b3a39da19588ab88f4.png
[Link 1]: https://blog.csdn.net/Why_does_it_work?spm=1011.2415.3001.5343
[Link 2]: https://sprite.inscode.cc/
[java]: https://blog.csdn.net/why_does_it_work/category_12379581.html
[Link 3]: https://blog.csdn.net/why_does_it_work/category_12378617.html
[uniapp-]: https://blog.csdn.net/why_does_it_work/category_12363697.html
[0_vue]: https://blog.csdn.net/why_does_it_work/category_12376654.html
[Link 4]: https://blog.csdn.net/why_does_it_work/category_12381051.html
[0]: https://blog.csdn.net/why_does_it_work/category_12381055.html
[Link 5]: https://blog.csdn.net/why_does_it_work/category_12381058.html
[Link 6]: https://blog.csdn.net/why_does_it_work/category_12397959.html?spm=1001.2014.3001.5482
[c7f3e6b8a7624a9eabbea77dbcbca119.jpeg]: https://img-blog.csdnimg.cn/c7f3e6b8a7624a9eabbea77dbcbca119.jpeg
[a890fe72274c4a2aa4f2af513ddef7b1.png]: https://img-blog.csdnimg.cn/a890fe72274c4a2aa4f2af513ddef7b1.png
[119aecdb3197468f8e8927662f5fb340.png]: https://img-blog.csdnimg.cn/119aecdb3197468f8e8927662f5fb340.png
[f7c074a14a084323bc4dbc76800bd236.png]: https://img-blog.csdnimg.cn/f7c074a14a084323bc4dbc76800bd236.png
[8607597ddb66429e9d8dd5ea61097d18.png]: https://img-blog.csdnimg.cn/8607597ddb66429e9d8dd5ea61097d18.png