SpringBoot安全認證Security

一、基本環境搭建

父pom依賴

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.3.RELEASE</version>
</parent>

1. 添加pom依賴：

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

2. 創建測試用Controller

@RestController
public class TestController {

    @GetMapping("getData")
    public String getData() {
        return "date";
    }

}

3. 創建SpringBoot啟動類並run

@SpringBootApplication
public class SpringBootTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootTestApplication.class, args);
    }

}

4. 測試

訪問http://127.0.0.1:8080/getData，由於我們開啟了SpringSecurity且當前是未登錄狀態，頁面會被302重定向到http://127.0.0.1:8080/login，頁面如下：

用戶名：user，密碼可以在控制台輸出中找到：

輸入正確的用戶名和密碼后點擊Login按鈕即被重新302到http://127.0.0.1:8080/getData並顯示查詢數據：

這表示我們的接口已經被spring保護了。

那么肯定會有小伙伴吐槽了，這么復雜的密碼，鬼才及得住，所以...

二、為Spring Security設定用戶名和密碼

為了解決復雜密碼的問題，我們可以在application.yml中做如下設定：

spring:
  security:
    user:
      name: user
      password: 123

這樣我們就可以通過用戶名user密碼123來訪問http://127.0.0.1:8080/getData接口了。

然后肯定又有小伙伴吐槽了，整個系統就一個用戶么？有哪個系統是只有一個用戶的？所以...

三、為Spring Security設定多個用戶

如果想要給Spring Security設定多個用戶可用，則新建一個class：

@Configuration
@EnableWebSecurity
public class WebSecurityConfig {

    @Bean
    public UserDetailsService userDetailsService() {
        PasswordEncoder encoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User
                .withUsername("admin")
                .password("admin")
                .passwordEncoder(encoder::encode)
                .roles("")
                .build()
        );
        manager.createUser(User
                .withUsername("guest")
                .password("guest")
                .passwordEncoder(encoder::encode)
                .roles("")
                .build()
        );
        return manager;
    }
}

1. 注意需要注解@EnableWebSecurity
2. InMemoryUserDetailsManager：顧名思義，將用戶名密碼存儲在內存中的用戶管理器。我們通過這個管理器增加了兩個用戶，分別是：用戶名admin密碼admin，用戶名guest密碼guest。

做完如上更改后重啟應用，再次訪問http://127.0.0.1:8080/getData，輸入admin/admin或guest/guest即可通過身份驗證並正常使用接口了。

看到這肯定又有小伙伴要吐槽了：用戶數據直接硬編碼到代碼里是什么鬼！我要把用戶放在數據庫！所以...

四、SpringSecurity+Mysql

想要使用數據庫，那么我們可以

1. 增加如下依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2. 配置數據庫連接

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.2.12:3306/test?characterEncoding=utf8
    username: root
    password: onceas

3. 創建測試用表結構及數據

drop table if exists test.user;
create table test.user (
  id int auto_increment primary key,
  username varchar(50),
  password varchar(50)
);

insert into test.user(id, username, password) values (1, 'admin', 'admin');
insert into test.user(id, username, password) values (2, 'guest', 'guest');

我們創建了用戶信息表，並插入兩個用戶信息，用戶名/密碼依然是admin/admin、guest/guest

4. entity、dao、service

public class User {

    private int id;
    private String username;
    private String password;

    // get set ...
}

@Repository
public class LoginDao {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public LoginDao(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List<User> getUserByUsername(String username) {
        String sql = "select id, username, password from user where username = ?";
        return jdbcTemplate.query(sql, new String[]{username}, new BeanPropertyRowMapper<>(User.class));
    }
}

@Service
public class LoginService {

    private final LoginDao loginDao;

    @Autowired
    public LoginService(LoginDao loginDao) {
        this.loginDao = loginDao;
    }

    public List<User> getUserByUsername(String username) {
        return loginDao.getUserByUsername(username);
    }

}

5. 調整WebSecurityConfig

@Bean
public UserDetailsService userDetailsService() {
    return username -> {
        List<UserEntity> users = loginService.getUserByUsername(username);
        if (users == null || users.size() == 0) {
            throw new UsernameNotFoundException("用戶名未找到");
        }
        String password = users.get(0).getPassword();
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        String passwordAfterEncoder = passwordEncoder.encode(password);
        return User.withUsername(username).password(passwordAfterEncoder).roles("").build();
    };
}

做完如上更改后重啟應用，再次訪問http://127.0.0.1:8080/getData，輸入admin/admin或guest/guest即可通過身份驗證並正常使用接口了。

關於UserDetailsService，有些東西要說明下：

PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
String passwordAfterEncoder = passwordEncoder.encode(password);

上面這兩句代碼是在對用戶密碼進行加密。為什么要這樣子呢？看到這肯定又有小伙伴會吐槽：數據庫存儲銘文密碼是什么鬼！對，Spring也是盡量在幫助開發者避免這個事情。所以SpringSecurity在進行密碼比對的時候需要開發者提供加密后的密碼。我們上面的寫法其實是不合理的，實際情況應該是數據庫中存儲密文密碼，然后將數據庫中的密碼直接傳給User.password()就可以了。

6. 關於SpringSecurity加密后的密文格式

我們可以通過打斷點的方式或者增加

System.out.println(username + "---->>>" + passwordAfterEncoder);

來查看下，如果admin/admin被登錄時候，passwordAfterEncoder的值是什么？輸出結果：

admin---->>>{bcrypt}$2a$10$d4VkiIfP7MyNSipjLtQ0Keva4ST6U6Fnw77iiv39IGnGswptqWRG.
guest---->>>{bcrypt}$2a$10$8jRMbiGzFIS4GU3SWAm83eWgFO29EEb5QhXOEkPEaabw5Oiy/jxUC

可以看出加密后的密碼可以分為兩部分

1. {}內描述了加密算法，這里為bcrypt算法。
2. {}后面即為密文密碼，這里是包含鹽的。

所以SpringSecurity的工作原理就是：當用戶輸入用戶名和密碼點擊Login以后，SpringSecurity先通過調用我們自定義的UserDetailsService獲取到加密后密碼，然后根據{}里的內容獲知加密算法，再將用戶輸入的密碼按照該算法進行加密，最后再與{}后的密文密碼比對即可獲知用戶憑據是否有效。

通過查看PasswordEncoderFactories的源碼，我們可以知道SpringEncoder工具可以提供哪些加密算法：

public static PasswordEncoder createDelegatingPasswordEncoder() {
        String encodingId = "bcrypt";
        Map<String, PasswordEncoder> encoders = new HashMap<>();
        encoders.put(encodingId, new BCryptPasswordEncoder());
        encoders.put("ldap", new LdapShaPasswordEncoder());
        encoders.put("MD4", new Md4PasswordEncoder());
        encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
        encoders.put("noop", NoOpPasswordEncoder.getInstance());
        encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
        encoders.put("scrypt", new SCryptPasswordEncoder());
        encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
        encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
        encoders.put("sha256", new StandardPasswordEncoder());
        return new DelegatingPasswordEncoder(encodingId, encoders);
    }

其中LdapShaPasswordEncoder、Md4PasswordEncoder、MessageDigestPasswordEncoder、NoOpPasswordEncoder、StandardPasswordEncoder已經不建議使用了。SpringSecurity認為：

Digest based password encoding is not considered secure.  //基於摘要的密碼編碼被認為是不安全的

五 、權限控制

以上內容我們只解決了用戶登錄問題，但是實際開發中僅僅完成用戶登錄是不夠的，我們還需要用戶授權及授權驗證。由於我們已經將用戶信息存儲到數據庫里了，那么姑且我們也將權限信息存儲在數據庫吧。

1. 准備數據庫表及測試數據

drop table if exists test.role;
create table test.role (
  id int auto_increment primary key,
  role varchar(50)
);

drop table if exists test.permission;
create table test.permission (
  id int auto_increment primary key,
  permission varchar(50)
);

drop table if exists test.user_r_role;
create table test.user_r_role (
  userid int,
  roleid int
);

drop table if exists test.role_r_permission;
create table test.role_r_permission (
  roleid int,
  permissionid int
);

drop table if exists test.user_r_permission;
create table test.user_r_permission (
  userid int,
  permissionid int
);

insert into test.role(id, role) values (1, 'adminRole');
insert into test.role(id, role) values (2, 'guestRole');

insert into test.permission(id, permission) values (1, 'permission1');
insert into test.permission(id, permission) values (2, 'permission2');
insert into test.permission(id, permission) values (3, 'permission3');
insert into test.permission(id, permission) values (4, 'permission4');

insert into test.user_r_role(userid, roleid) values (1, 1);
insert into test.user_r_role(userid, roleid) values (2, 2);

insert into test.role_r_permission(roleid, permissionid) values (1, 1);
insert into test.role_r_permission(roleid, permissionid) values (1, 2);

insert into test.user_r_permission(userid, permissionid) values (1, 3);
insert into test.user_r_permission(userid, permissionid) values (1, 4);
insert into test.user_r_permission(userid, permissionid) values (2, 3);
insert into test.user_r_permission(userid, permissionid) values (2, 4);

1. role：角色信息表，permission權限信息表，user_r_role用戶所屬角色表，role_r_permission角色擁有權限表，user_r_permission用戶擁有權限表。
2. 由於用戶有所屬角色且角色是有權限的，用戶同時又單獨擁有權限，所以用戶最終擁有的權限取並集。
3. 用戶admin最終擁有角色adminRole以及權限：permission1、permission2、permission3、permission4
4. 用戶guest最終擁有角色guestRole以及權限：permission3、permission4

2. Dao、Service

public List<String> getPermissionsByUsername(String username) {
    String sql =
            "select d.permission\n" +
            "from user a\n" +
            "       join user_r_role b on a.id = b.userid\n" +
            "       join role_r_permission c on b.roleid = c.roleid\n" +
            "       join permission d on c.permissionid = d.id\n" +
            "where a.username = ?\n" +
            "union\n" +
            "select c.permission\n" +
            "from user a\n" +
            "       join user_r_permission b on a.id = b.userid\n" +
            "       join permission c on b.permissionid = c.id\n" +
            "where a.username = ?";
    return jdbcTemplate.queryForList(sql, new String[]{username, username}, String.class);
}

public List<String> getRoleByUsername(String username) {
    String sql =
            "select c.role\n" +
            "from user a\n" +
            "       join user_r_role b on a.id = b.userid\n" +
            "       join role c on b.roleid = c.id\n" +
            "where a.username = ?";
    return jdbcTemplate.queryForList(sql, new String[]{username}, String.class);
}

public List<String> getPermissionsByUsername(String username) {
    return loginDao.getPermissionsByUsername(username);
}

public List<String> getRoleByUsername(String username) {
    return loginDao.getRoleByUsername(username);
}

3. WebSecurityConfig

（1）調整public UserDetailsService userDetailsService()方法，在構建用戶信息的時候把用戶所屬角色和用戶所擁有的權限也填充上（最后return的時候）。

@Bean
public UserDetailsService userDetailsService() {
    return username -> {
        List<UserEntity> users = loginService.getUserByUsername(username);
        if (users == null || users.size() == 0) {
            throw new UsernameNotFoundException("用戶名未找到");
        }
        String password = users.get(0).getPassword();
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        String passwordAfterEncoder = passwordEncoder.encode(password);
        System.out.println(username + "/" + passwordAfterEncoder);

        List<String> roles = loginService.getRoleByUsername(username);
        List<String> permissions = loginService.getPermissionsByUsername(username);

        String[] roleArr = new String[roles.size()];
        String[] permissionArr = new String[permissions.size()];

        return User.withUsername(username).password(passwordAfterEncoder).
                roles(roles.toArray(roleArr)).authorities(permissions.toArray(permissionArr)).
                build();
    };
}

這里面有個坑，就是紅色代碼部分。具體可查看org.springframework.security.core.userdetails.User.UserBuilder。roles()方法和authorities()方法實際上都是在針對UserBuilder的authorities屬性進行set操作，執行roles("roleName")和執行authorities("ROLE_roleName")是等價的。所以上例代碼中roles(roles.toArray(roleArr))起不到任何作用，直接被后面的authorities(permissions.toArray(permissionArr))覆蓋掉了。

所以正確的寫法可參考：

@Bean
public UserDetailsService userDetailsService() {
    return username -> {
        List<UserEntity> users = loginService.getUserByUsername(username);
        if (users == null || users.size() == 0) {
            throw new UsernameNotFoundException("用戶名未找到");
        }
        String password = users.get(0).getPassword();
        PasswordEncoder passwordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
        String passwordAfterEncoder = passwordEncoder.encode(password);
        System.out.println(username + "/" + passwordAfterEncoder);

        List<String> roles = loginService.getRoleByUsername(username);
        List<String> permissions = loginService.getPermissionsByUsername(username);

        String[] permissionArr = new String[roles.size() + permissions.size()];
        int permissionArrIndex = 0;
        for (String role : roles) {
            permissionArr[permissionArrIndex] = "ROLE_" + role;
            permissionArrIndex++;
        }
        for (String permission : permissions) {
            permissionArr[permissionArrIndex] = permission;
            permissionArrIndex++;
        }
        return User.withUsername(username).password(passwordAfterEncoder).authorities(permissionArr).build();
    };
}

（2）增加新的bean，為我們需要的保護的接口設定需要權限驗證：

@Bean
public WebSecurityConfigurerAdapter webSecurityConfigurerAdapter() {
    return new WebSecurityConfigurerAdapter() {
        @Override
        public void configure(HttpSecurity httpSecurity) throws Exception {
            httpSecurity.
                    authorizeRequests().antMatchers("/guest/**").permitAll().
                    and().authorizeRequests().antMatchers("/admin/**").hasRole("admin").
                    and().authorizeRequests().antMatchers("/authenticated/**").authenticated().
                    and().authorizeRequests().antMatchers("/permission1/**").hasAuthority("permission1").
                    and().authorizeRequests().antMatchers("/permission2/**").hasAuthority("permission2").
                    and().authorizeRequests().antMatchers("/permission3/**").hasAuthority("permission3").
                    and().authorizeRequests().antMatchers("/permission4/**").hasAuthority("permission4").
                    and().formLogin().
                    and().authorizeRequests().anyRequest().permitAll();
        }
    };
}

1. /guest/**的接口會被允許所有人訪問，包括未登錄的人。
2. /admin/**的接口只能被擁有admin角色的用戶訪問。
3. /authenticated/**的接口可以被所有已經登錄的用戶訪問。
4. /permission1/**的接口可以被擁有permission1權限的用戶訪問。/permission2/**、/permission3/**、/permission4/**同理

4. TestController

最后我們調整下TestContrller，增加幾個接口以便測試：

@RestController
public class TestController {

    @GetMapping("getData")
    public String getData() {
        return "date";
    }

    @GetMapping("authenticated/getData")
    public String getAuthenticatedData() {
        return "authenticatedData";
    }

    @GetMapping("admin/getData")
    public String getAdminData() {
        return "adminData";
    }

    @GetMapping("guest/getData")
    public String getGuestData() {
        return "guestData";
    }

    @GetMapping("permission1/getData")
    public String getPermission1Data() {
        return "permission1Data";
    }

    @GetMapping("permission2/getData")
    public String getPermission2Data() {
        return "permission2Data";
    }

    @GetMapping("permission3/getData")
    public String getPermission3Data() {
        return "permission3Data";
    }

    @GetMapping("permission4/getData")
    public String getPermission4Data() {
        return "permission4Data";
    }

}

5. 測試

• 訪問/guest/getData無需登錄即可訪問成功。
• 訪問/authenticated/getData，會彈出用戶登錄頁面。登錄任何一個用戶都可訪問成功。
• 訪問/admin/getData，會彈出用戶登錄頁面。登錄admin用戶訪問成功，登錄guest用戶會發生錯誤，403未授權。
• 其他的就不再贅述了。

六、自定義登錄頁面

是不是覺得SpringScurity的登錄頁面丑爆了？是不是想老子還能做一個更丑的登錄頁面你信不信？接下來我們來弄一個更丑的登錄頁面。

1. 增加pom依賴

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

2. 編寫自己的登錄頁面

thymeleaf默認的頁面放置位置為：classpath:templates/ 目錄下，所以在編寫代碼的時候我們可以將頁面放在resources/templates目錄下，名稱為：login.html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>一個更丑的登錄頁面</title>
</head>
<body>
    <form method="post" action="/login">
        用戶名：<input name="username" placeholder="請輸入用戶名" type="text">
        密碼：<input name="password" placeholder="請輸入密碼" type="password">
        <input value="登錄" type="submit">
    </form>
</body>
</html>

3. 將SpringSecurity指向自定義的登錄頁面

（1）調整WebSecurityConfig注入的WebSecurityConfigurerAdapter，在and().formLogin()后面增加loginPage("/login")以指定登錄頁面的uri地址，同時關閉csrf安全保護。

@Bean
public WebSecurityConfigurerAdapter webSecurityConfigurerAdapter() {
    return new WebSecurityConfigurerAdapter() {
        @Override
        public void configure(HttpSecurity httpSecurity) throws Exception {
            httpSecurity.
                    authorizeRequests().antMatchers("/guest/**").permitAll().
 ...省略部分代碼...
                    and().formLogin().loginPage("/login").
                    and().authorizeRequests().anyRequest().permitAll().
                    and().csrf().disable();
        }
    };
}

（2）TestController增加login方法（注意我們之前在TestController類上注解了@RestController，這里要記得改成@Controller，否則訪問/login的時候會直接返回字符串而不是返回html頁面。另外除了下面新增的/login方法其他方法要增加注解@ResponseBody）

@GetMapping("login")
public String login() {
    return "login";
}

4. 測試及其他

測試過程就略吧。還有一些要囑咐的東西給小白們：

• 我們通過loginPage("/login")來告知SpringSecurity自定義登錄頁面的uri路徑，同時這個設定也告知了用戶點擊登錄按鈕的時候form表單post的uri路徑。即：如果SpringSecurity判定需要用戶登錄，會將302到/login （get請求），用戶輸入用戶名和密碼點擊登錄按鈕后，也需要我們自定義頁面post到/login才能讓SpringSecurity完成用戶認證過程。
• 關於html中輸入用戶名的input的name屬性值本例為username、輸入密碼的input的name屬性值本例為password，這是因為SpringSecurity在接收用戶登錄請求時候默認的參數名就是username和password、如果想更改這兩個參數名，可以這樣設定：and().formLogin().loginPage("/login").usernameParameter("username").passwordParameter("password")
• 測試過程中我們可以試着輸錯用戶名和密碼點擊登錄，會發現頁面又重新跳轉到 http://127.0.0.1:8080/login?error ，只不過后面增加了參數error且沒有參數值。所以需要我們再login.html中處理相應的邏輯。當然你也可以指定用戶認證失敗時候的跳轉地址，可以這樣設定：and().formLogin().loginPage("/login").failureForwardUrl("/login/error")
• 測試過程中，如果我們直接訪問http://127.0.0.1:8080/login，輸入正確的用戶名和密碼后跳轉到http://127.0.0.1:8080即網站根目錄。如果你想指定用戶登錄成功后的默認跳轉地址，可以這樣設定：and().formLogin().loginPage("/login").successForwardUrl("/login/success")

七、登出

登出呢？有登錄了，怎么能沒有登出呢？其實SpringSecurity已經早早的為我們默認了一個登出功能，你訪問：http://127.0.0.1:8080/logout 試試看？

如果想做我們自己的個性化登出，可以繼續調整WebSecurityConfig注入的WebSecurityConfigurerAdapter

@Bean
public WebSecurityConfigurerAdapter webSecurityConfigurerAdapter() {
    return new WebSecurityConfigurerAdapter() {
        @Override
        public void configure(HttpSecurity httpSecurity) throws Exception {
            httpSecurity.
                    authorizeRequests().antMatchers("/guest/**").permitAll().
                    and().authorizeRequests().antMatchers("/admin/**").hasRole("admin").
                    and().authorizeRequests().antMatchers("/authenticated/**").authenticated().
                    and().authorizeRequests().antMatchers("/permission1/**").hasAuthority("permission1").
                    and().authorizeRequests().antMatchers("/permission2/**").hasAuthority("permission2").
                    and().authorizeRequests().antMatchers("/permission3/**").hasAuthority("permission3").
                    and().authorizeRequests().antMatchers("/permission4/**").hasAuthority("permission4").
                    and().formLogin().loginPage("/login").
                    and().logout().logoutUrl("/logout").logoutSuccessUrl("/logoutSuccess").
 invalidateHttpSession(true).deleteCookies("cookiename").
 addLogoutHandler(new MyLogoutHandle()).logoutSuccessHandler(new MyLogoutSuccessHandle()).
                    and().authorizeRequests().anyRequest().permitAll().
                    and().csrf().disable();
        }
    };
}

• MyLogoutHandle實現了LogoutHandler接口：

  public class MyLogoutHandle implements LogoutHandler {
  
      @Override
      public void logout(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) {
          System.out.println("==================>>>> LogoutHandler Begin");
          System.out.println(authentication.getPrincipal());
          System.out.println("==================>>>> LogoutHandler End");
      }
  }

• MyLogoutSuccessHandle實現了LogoutSuccessHandler接口：

  public class MyLogoutSuccessHandle implements LogoutSuccessHandler {
  
      @Override
      public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
          System.out.println("==================>>>> LogoutSuccessHandler Begin");
          System.out.println(authentication.getPrincipal());
          System.out.println("==================>>>> LogoutSuccessHandler End");
      }
  }

• logoutUrl()：告訴SpringSecurity用戶登出的接口uri地址是什么
• logoutSuccessUrl()：告訴SpringSecurity完成用戶登出后要跳轉到哪個地址。如果設定了LogoutSuccessHandler則logoutSuccessUrl設定無效
• invalidateHttpSession：執行登出的同時是否清空session
• deleteCookies：執行登出的同時刪除那些cookie
• addLogoutHandler：執行登出的同時執行那些代碼

八、SpringSecurity在Restfull中的變通使用

當前環境前后盾分離已經是大趨勢了吧，除非那些很小很小的項目。所以SpringBoot項目更多的時候為前端提供接口，而並不提供前端頁面路由的功能。所以，當SpringSecurity在Restfull開發中還需要變通一下：

1. 首先我們通過and().formLogin().loginPage("/login")設定的跳轉到登錄頁面的GET請求不再指向html，而是直接返回json數據告知前端需要用戶登錄。
2. 用戶執行登錄的時候，前端執行post請求到/login進行用戶身份校驗。
3. 然后我們通過and().formLogin().failureForwardUrl("/login/error")和and().formLogin().successForwardUrl("/login/error")設定的登錄成功和失敗跳轉來地址來返回json數據給前端告知其用戶認證結果。
4. 最后我們通過and().logout().logoutSuccessHandler(new MyLogoutSuccessHandle())來返回json數據給前端告知用戶已經完成登出。

九、SpringSecurity+SpringSession+Redis

接下來還有一個問題要處理。在上面的案例中，session都是存儲在servlet容器中的，如果我們需要多點部署負載均衡的話，就會出現問題。比如：我們部署了兩個服務並做了負載均衡，用戶登錄時調用其中一台服務進行身份認證通過並將用戶登錄信息存儲在了這台服務器的session里，接下來用戶訪問其他接口，由於負載均衡的存在用戶請求被分配到了另一個服務上，該服務檢測用戶session不存在啊，於是就拒絕訪問。

在SpringBoot環境下解決這個問題也很簡答，很容易就想到SpringSession。所以我們嘗試用SpringSession+Redis解決此問題

1. 增加pom依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

2. 修改application.yml

spring:
  redis:
    host: 192.168.2.12
    port: 6379
    password: 123456

  session:
    store-type: redis

3. 修改主啟動類，增加@EnableRedisHttpSession注解，開啟SpringSession

十、通過注解的方式實現權限控制

首先要在主啟動類上增加@EnableGlobalMethodSecurity注解，具體參數如下：

1. @EnableGlobalMethodSecurity(securedEnabled=true)

支持@Secured注解，例如

@Secured("ROLE_adminRole")

2. @EnableGlobalMethodSecurity(jsr250Enabled=true)

支持@RolesAllowed、@DenyAll、@PermitAll 注解，例如：

@RolesAllowed("ROLE_guestRole")

3. @EnableGlobalMethodSecurity(prePostEnabled=true)

支持@PreAuthorize、@PostAuthorize、@PreFilter、@PostFilter注解，它們使用SpEL能夠在方法調用上實現更有意思的安全性約束

• @PreAuthorize :在方法調用之前，基於表達式的計算結果來限制對方法的訪問，只有表達式計算結果為true才允許執行方法
• @PostAuthorize 在方法調用之后，允許方法調用，但是如果表達式計算結果為false，將拋出一個安全性異常
• @PostFilter 允許方法調用，但必須按照表達式來過濾方法的結果
• @PreFilter 允許方法調用，但必須在進入方法之前過濾輸入值

由於這里涉及到SpEL表達式，所以本文就不詳細說了。

十一、在Controller中獲取當前登錄用戶

public String getAuthenticatedData(HttpSession session) {
        //SecurityContext securityContext = SecurityContextHolder.getContext();
        SecurityContext securityContext = (SecurityContext) session.getAttribute("SPRING_SECURITY_CONTEXT");
        // 以上獲取securityContext的兩種方法二選一
        WebAuthenticationDetails userDetailsService = (WebAuthenticationDetails) securityContext.getAuthentication().getDetails();
        UserDetails userDetails = (UserDetails) securityContext.getAuthentication().getPrincipal();

        System.out.println("===userDetailsService.getRemoteAddress()===>>" + userDetailsService.getRemoteAddress());
        System.out.println("===userDetailsService.getSessionId()===>>" + userDetailsService.getSessionId());
        System.out.println("===userDetails.getRemoteAddress()===>>" + userDetails.getUsername());
        System.out.println("===userDetails.getPassword()===>>" + userDetails.getPassword());
        System.out.println("===userDetails.getAuthorities()===>>" + userDetails.getAuthorities());
        return "authenticatedData";
    }

十二、總結

SpringSecurity的使用基本就上面這些。就業務邏輯來說，SpringSecurity中所謂的role概念嚴格意義並不能稱之為“角色”。理由是：如果我們的權限控制比較簡單，整個系統中的角色以及角色所擁有的權限是固定的，那么我們可以將SpringSecurity的role概念拿來即用。但是如果我們的權限控制是可配置，用戶和角色是多對多關系、角色和權限也是多對多關系，那么我們只能講SpringSecurity的role當做“權限”來使用。