如何理解java編程SpringSecurity

本篇內容主要講解“如何理解java編程SpringSecurity”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“如何理解java編程SpringSecurity”吧!

目錄

• 1. SpringSecurity 框架簡介

• 1.1 概要

• 1.2 組成以及同款產品（shiro）對比

• 1.2.1 Spring Security

• 1.2.2 Shiro

• 1.3 模塊劃分

• 1.4 SpringSecurity 基本原理

• 1.5.UserDetailsService 接口講解
  

• 2.SpringSecurity Web 權限方案

• 2.1設置登錄系統的賬號密碼（三種方式）
  

• 設計數據庫表

• 建立springboot項目，勾選相應依賴

• 完整pom.xml

• 數據庫配置

• 創建對應的實體類

• 創建service層

• 配置spring security

• security配置類說明

• 3.security-記住我-的實現
  

• 4.用戶注銷功能實現
  

• 5.關于CSRF

• 6.spring security原理總結

1. SpringSecurity 框架簡介

1.1 概要

正如你可能知道的關于安全方面的兩個主要區域是“認證”和“授權”（或者訪問控制），一般來說，Web 應用的安全性包括用戶認證（Authentication）和用戶授權（Authorization）兩個部分，這兩點也是 Spring Security 重要核心功能。

（1） 用戶認證指的是：驗證某個用戶是否為系統中的合法主體，也就是說用戶能否訪問該系統。用戶認證一般要求用戶提供用戶名和密碼。系統通過校驗用戶名和密碼來完成認證過程。通俗點說就是系統認為用戶是否能登錄

（2） 用戶授權指的是驗證某個用戶是否有權限執行某個操作。在一個系統中，不同用戶所具有的權限是不同的。比如對一個文件來說，有的用戶只能進行讀取，而有的用戶可以進行修改。一般來說，系統會為不同的用戶分配不同的角色，而每個角色則對應一系列的權限。通俗點講就是系統判斷用戶是否有權限去做某些事情。

1.2 組成以及同款產品（shiro）對比

1.2.1 Spring Security

SpringSecurity 特點：

• 和 Spring 無縫整合。

•  全面的權限控制。

•  專門為Web 開發而設計。

• 舊版本不能脫離Web 環境使用。

• 新版本對整個框架進行了分層抽取，分成了核心模塊和Web 模塊。單獨引入核心模塊就可以脫離Web 環境。

•  重量級。

1.2.2 Shiro

Apache 旗下的輕量級權限控制框架。

特點：

• 輕量級。Shiro 主張的理念是把復雜的事情變簡單。針對對性能有更高要求的互聯網應用有更好表現。

• 通用性。
  

好處：不局限于Web 環境，可以脫離Web 環境使用。
缺陷：在Web 環境下一些特定的需求需要手動編寫代碼定制。

Spring Security 是 Spring 家族中的一個安全管理框架，實際上，在 Spring Boot 出現之前，Spring Security 就已經發展了多年了，但是使用的并不多，安全管理這個領域，一直是 Shiro 的天下。

相對于 Shiro，在 SSM 中整合 Spring Security 都是比較麻煩的操作，所以，SpringSecurity 雖然功能比 Shiro 強大，但是使用反而沒有 Shiro 多（Shiro 雖然功能沒有Spring Security 多，但是對于大部分項目而言，Shiro 也夠用了）。

自從有了 Spring Boot 之后，Spring Boot 對于 Spring Security 提供了自動化配置方案，可以使用更少的配置來使用 Spring Security。

因此，一般來說，常見的安全管理技術棧的組合是這樣的：

SSM + Shiro
Spring Boot/Spring Cloud + Spring Security

以上只是一個推薦的組合而已，如果單純從技術上來說，無論怎么組合，都是可以運行的。

1.3 模塊劃分

1.4 SpringSecurity 基本原理

SpringSecurity 本質是一個過濾器鏈： 從啟動是可以獲取到過濾器鏈：

代碼底層流程：重點看三個過濾器：
FilterSecurityInterceptor：是一個方法級的權限過濾器, 基本位于過濾鏈的最底部。

1.5.UserDetailsService 接口講解

當什么也沒有配置的時候，賬號和密碼是由 Spring Security 定義生成的。而在實際項目中
賬號和密碼都是從數據庫中查詢出來的。 所以我們要通過自定義邏輯控制認證邏輯。
如果需要自定義邏輯時，只需要實現userDetailsService接口即可，定義如下：

2.SpringSecurity Web 權限方案

2.1設置登錄系統的賬號密碼（三種方式）

一：在application.xml中自行配置

spring.security.user.name = xxx
spring.security.user.password = xxx

二：編寫類實現接口

三：實現數據庫認證來完成用戶登錄
這里就拿一個例子來完成認證和授權

設計數據庫表

建立springboot項目，勾選相應依賴

完整pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

數據庫配置

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: xxxxxx
    url: jdbc:mysql://xxxxxxxxxx //根據自己情況填寫

創建對應的實體類

package com.example.demo.domain;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class User implements UserDetails {
    private Integer id;
    private String username;
    private String password;
    private Boolean enabled;
    private Boolean locked;
    private List<Role> roles;
    @Override
    // 實體類和SpringSecurity轉換
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> authorities = new ArrayList<>();
        for (Role role : roles) {
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }
        return authorities;
    }
    @Override
    public String getPassword() {
        return null;
    }
    @Override
    public String getUsername() {
        return null;
    }
    @Override
    public boolean isAccountNonExpired() {
        return false;
    }
    @Override
    public boolean isAccountNonLocked() {
        return false;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return false;
    }
    @Override
    public boolean isEnabled() {
        return false;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Boolean getEnabled() {
        return enabled;
    }
    public void setEnabled(Boolean enabled) {
        this.enabled = enabled;
    }
    public Boolean getLocked() {
        return locked;
    }
    public void setLocked(Boolean locked) {
        this.locked = locked;
    }
    public List<Role> getRoles() {
        return roles;
    }
    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }
}

package com.example.demo.domain;
public class Role {
    private Integer id;
    private String name;
    private String nameZh;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getNameZh() {
        return nameZh;
    }
    public void setNameZh(String nameZh) {
        this.nameZh = nameZh;
    }
}

創建service層

package com.example.demo.mapper;
import com.example.demo.domain.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.graalvm.compiler.nodeinfo.StructuralInput;
import org.springframework.security.core.userdetails.User;
import java.util.List;
@Mapper
public interface UserMapper {
    @Select("select * from user where username=#{username}")
    public User loadUserByUsername(String username);
    @Select("select * from role r, user_role ur where r.id = ur.rid and ur.uid = #{id}")
    public List<Role> getUserRoleByUid(Integer id);
}

配置spring security

package com.example.demo.config;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configurable
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserService userService;
    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .loginProcessingUrl("/login").permitAll()
                .and()
                .csrf().disable();
    }
}

security配置類說明

3.security-記住我-的實現

在security配置類中開啟remember me功能，并設置有效期。默認時間為兩周。

4.用戶注銷功能實現

通過退出按鈕找到映射地址，在配置類中添加退出映射地址

5.關于CSRF

跨站請求偽造（英語：Cross-site request forgery），也被稱為 one-click
attack 或者 session riding，通常縮寫為 CSRF 或者 XSRF， 是一種挾制用戶在當前已登錄的 Web 應用程序上執行非本意的操作的攻擊方法。跟跨網站腳本（XSS）相比，XSS 利用的是用戶對指定網站的信任，CSRF 利用的是網站對用戶網頁瀏覽器的信任。

跨站請求攻擊，簡單地說，是攻擊者通過一些技術手段欺騙用戶的瀏覽器去訪問一個自己曾經認證過的網站并運行一些操作（如發郵件，發消息，甚至財產操作如轉賬和購買商品）。由于瀏覽器曾經認證過，所以被訪問的網站會認為是真正的用戶操作而去運行。這利用了web 中用戶身份驗證的一個漏洞：簡單的身份驗證只能保證請求發自某個用戶的瀏覽器，卻不能保證請求本身是用戶自愿發出的。

從 Spring Security 4.0 開始，默認情況下會啟用CSRF 保護，以防止CSRF 攻擊應用程序，Spring Security CSRF 會針對 PATCH，POST，PUT 和DELETE 方法進行防護。

6.spring security原理總結

SpringSecurity 采用的是責任鏈的設計模式，它有一條很長的過濾器鏈。

現在對這條過濾器鏈的 15 個過濾器進行說明:

（1） WebAsyncManagerIntegrationFilter：將 Security 上下文與 Spring Web 中用于處理異步請求映射的 WebAsyncManager 進行集成。

（2） SecurityContextPersistenceFilter：在每次請求處理之前將該請求相關的安全上下文信息加載到 SecurityContextHolder 中，然后在該次請求處理完成之后，將
SecurityContextHolder 中關于這次請求的信息存儲到一個“倉儲”中，然后將
SecurityContextHolder 中的信息清除，例如在 Session 中維護一個用戶的安全信息就是這個過濾器處理的。

（3） HeaderWriterFilter：用于將頭信息加入響應中。

（4） CsrfFilter：用于處理跨站請求偽造。

（5） LogoutFilter：用于處理退出登錄。

（6） UsernamePasswordAuthenticationFilter：用于處理基于表單的登錄請求，從表單中獲取用戶名和密碼。默認情況下處理來自 /login 的請求。從表單中獲取用戶名和密碼時，默認使用的表單 name 值為 username 和 password，這兩個值可以通過設置這個過濾器的 usernameParameter 和 passwordParameter 兩個參數的值進行修改。

（7） DefaultLoginPageGeneratingFilter：如果沒有配置登錄頁面，那系統初始化時就會配置這個過濾器，并且用于在需要進行登錄時生成一個登錄表單頁面。

（8） BasicAuthenticationFilter：檢測和處理 http basic 認證。

（9） RequestCacheAwareFilter：用來處理請求的緩存。

（10） SecurityContextHolderAwareRequestFilter：主要是包裝請求對象 request。

（11） AnonymousAuthenticationFilter：檢測 SecurityContextHolder 中是否存在
Authentication 對象，如果不存在為其提供一個匿名 Authentication。

（12） SessionManagementFilter：管理 session 的過濾器

（13） ExceptionTranslationFilter：處理 AccessDeniedException 和
AuthenticationException 異常。

（14） FilterSecurityInterceptor：可以看做過濾器鏈的出口。

（15） RememberMeAuthenticationFilter：當用戶沒有登錄而直接訪問資源時, 從 cookie 里找出用戶的信息, 如果 Spring Security 能夠識別出用戶提供的 remember me cookie, 用戶將不必填寫用戶名和密碼, 而是直接登錄進入系統，該過濾器默認不開啟。

到此，相信大家對“如何理解java編程SpringSecurity”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！