Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架

專案背景

公司在幾年前就採用了前後端分離的開發模式，前端所有請求都使用ajax。這樣的專案結構在與CAS單點登入等許可權管理框架整合時遇到了很多問題，使得許可權部分的程式碼冗長醜陋，CAS的各種重定向也使得使用者體驗很差，在前端使用vue-router管理頁面跳轉時，問題更加尖銳。於是我就在尋找一個解決方案，這個方案應該對程式碼的侵入較少，開發速度快，實現優雅。最近無意中看到springboot與shiro框架整合的文章，在瞭解了springboot以及shiro的發展狀況，並學習了使用方法後，開始在網上搜索前後端分離模式下這兩個框架的適應性，在經過測試後發現可行，完全符合個人預期。

解決方案

本文中專案核心包為SpringBoot1.5.9.RELEASE以及shiro-spring 1.4.0，為了加快開發效率，持久化框架使用hibernate-JPA，為增加可靠性，sessionId的管理使用了shiro-redis開源外掛，避免sessionId斷電丟失，同時使得多端可共享session，專案結構為多模組專案，詳見下圖。

其中spring-boot-shiro模組為本文重點，該模組包含shiro核心配置，shiro資料來源配置以及各種自定義實現，登入相關服務等。該模組在專案中使用時可直接在pom中引用，並在spring-boot-main入口模組中配置相應資料庫連線資訊即可，且該模組可以在多個專案中複用，避免重複開發。spring-boot-module1為模擬真實專案中的業務模組，可能會有多個。spring-boot-common中包含通用工具類，常量，異常等等。多模組專案的搭建在本文中不作贅述。

母模組pom.xml程式碼如下

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5. <modelVersion
   >4.0.0</modelVersion>
6. <groupId>com.xxx</groupId>
7. <artifactId>spring-boot-parent</artifactId>
8. <packaging>pom</packaging>
9. <version>1.0-SNAPSHOT</version>
10. <modules>
11. <module>spring-boot-main</module>
12. <module>spring-boot-module1</module>
13. <module>spring-boot-shiro</module>
14. <module>spring-boot-common</module>
15. </modules>
17. <properties>
18. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
19. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
20. <java.version>1.8</java.version>
21. <spring-boot.version>1.5.9.RELEASE</spring-boot.version>
22. <shiro.version>1.4.0</shiro.version>
23. </properties>
25. <dependencies>
26. <dependency>
27. <groupId>org.springframework.boot</groupId>
28. <artifactId>spring-boot-starter-web</artifactId>
29. <version>${spring-boot.version}</version>
30. </dependency>
31. <!--在外部tomcat中釋出故移除內建包-->
32. <dependency>
33. <groupId>org.springframework.boot</groupId>
34. <artifactId>spring-boot-starter-tomcat</artifactId>
35. <version>${spring-boot.version}</version>
36. <scope>provided</scope>
37. </dependency>
38. <dependency>
39. <groupId>org.springframework.boot</groupId>
40. <artifactId>spring-boot-starter-test</artifactId>
41. <version>${spring-boot.version}</version>
42. <scope>test</scope>
43. </dependency>
44. <dependency>
45. <groupId>org.springframework.boot</groupId>
46. <artifactId>spring-boot-devtools</artifactId>
47. <version>${spring-boot.version}</version>
48. <optional>true</optional>
49. </dependency>
50. <dependency>
51. <groupId>org.springframework.boot</groupId>
52. <artifactId>spring-boot-starter-data-jpa</artifactId>
53. <version>${spring-boot.version}</version>
54. </dependency>
55. <dependency>
56. <groupId>org.apache.shiro</groupId>
57. <artifactId>shiro-spring</artifactId>
58. <version>${shiro.version}</version>
59. </dependency>
60. <dependency>
61. <groupId>com.alibaba</groupId>
62. <artifactId>fastjson</artifactId>
63. <version>1.2.8</version>
64. </dependency>
65. <dependency>
66. <groupId>com.alibaba</groupId>
67. <artifactId>druid</artifactId>
68. <version>1.0.28</version>
69. </dependency>
70. <dependency>
71. <groupId>mysql</groupId>
72. <artifactId>mysql-connector-java</artifactId>
73. <version>5.1.39</version>
74. <scope>runtime</scope>
75. </dependency>
76. <!--<dependency>-->
77. <!--<groupId>org.springframework.boot</groupId>-->
78. <!--<artifactId>spring-boot-starter-thymeleaf</artifactId>-->
79. <!--<version>${spring-boot.version}</version>-->
80. <!--</dependency>-->
81. <!--<dependency>-->
82. <!--<groupId>net.sourceforge.nekohtml</groupId>-->
83. <!--<artifactId>nekohtml</artifactId>-->
84. <!--<version>1.9.22</version>-->
85. <!--</dependency>-->
86. </dependencies>
87. </project>

spring-boot-shiro模組介面如下圖

傳統結構專案中，shiro從cookie中讀取sessionId以此來維持會話，在前後端分離的專案中（也可在移動APP專案使用），我們選擇在ajax的請求頭中傳遞sessionId，因此需要重寫shiro獲取sessionId的方式。自定義MySessionManager類繼承DefaultWebSessionManager類，重寫getSessionId方法，程式碼如下

1. import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
2. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
3. import org.apache.shiro.web.util.WebUtils;
4. import org.springframework.util.StringUtils;
5. import javax.servlet.ServletRequest;
6. import javax.servlet.ServletResponse;
7. import java.io.Serializable;
9. /**
10. * Created by Administrator on 2017/12/11.
11. * 自定義sessionId獲取
12. */
13. public class MySessionManager extends DefaultWebSessionManager {
15. private static final String AUTHORIZATION = "Authorization";
17. private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";
19. public MySessionManager() {
20. super();
21. }
23. @Override
24. protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
25. String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
26. //如果請求頭中有 Authorization 則其值為sessionId
27. if (!StringUtils.isEmpty(id)) {
28. request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
29. request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
30. request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
31. return id;
32. } else {
33. //否則按預設規則從cookie取sessionId
34. return super.getSessionId(request, response);
35. }
36. }
37. }

如何配置讓shiro執行我們的自定義sessionManager呢？下面看ShiroConfig類。

1. package com.xxx.shiro.config;
3. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
4. import org.apache.shiro.mgt.SecurityManager;
5. import org.apache.shiro.session.mgt.SessionManager;
6. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
7. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
8. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
9. import org.crazycake.shiro.RedisCacheManager;
10. import org.crazycake.shiro.RedisManager;
11. import org.crazycake.shiro.RedisSessionDAO;
12. import org.springframework.beans.factory.annotation.Value;
13. import org.springframework.context.annotation.Bean;
14. import org.springframework.context.annotation.Configuration;
15. import org.springframework.web.servlet.HandlerExceptionResolver;
16. import java.util.LinkedHashMap;
17. import java.util.Map;
19. /**
20. * Created by Administrator on 2017/12/11.
21. */
22. @Configuration
23. public class ShiroConfig {
25. @Value("${spring.redis.shiro.host}")
26. private String host;
27. @Value("${spring.redis.shiro.port}")
28. private int port;
29. @Value("${spring.redis.shiro.timeout}")
30. private int timeout;
31. @Value("${spring.redis.shiro.password}")
32. private String password;
34. @Bean
35. public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
36. System.out.println("ShiroConfiguration.shirFilter()");
37. ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
38. shiroFilterFactoryBean.setSecurityManager(securityManager);
40. Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
41. //注意過濾器配置順序 不能顛倒
42. //配置退出 過濾器,其中的具體的退出程式碼Shiro已經替我們實現了，登出後跳轉配置的loginUrl
43. filterChainDefinitionMap.put("/logout", "logout");
44. // 配置不會被攔截的連結 順序判斷
45. filterChainDefinitionMap.put("/static/**", "anon");
46. filterChainDefinitionMap.put("/ajaxLogin", "anon");
47. filterChainDefinitionMap.put("/login", "anon");
48. filterChainDefinitionMap.put("/**", "authc");
49. //配置shiro預設登入介面地址，前後端分離中登入介面跳轉應由前端路由控制，後臺僅返回json資料
50. shiroFilterFactoryBean.setLoginUrl("/unauth");
51. // 登入成功後要跳轉的連結
52. // shiroFilterFactoryBean.setSuccessUrl("/index");
53. //未授權介面;
54. // shiroFilterFactoryBean.setUnauthorizedUrl("/403");
55. shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
56. return shiroFilterFactoryBean;
57. }
59. /**
60. * 憑證匹配器
61. * （由於我們的密碼校驗交給Shiro的SimpleAuthenticationInfo進行處理了
62. * ）
63. *
64. * @return
65. */
66. @Bean
67. public HashedCredentialsMatcher hashedCredentialsMatcher() {
68. HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
69. hashedCredentialsMatcher.setHashAlgorithmName("md5");//雜湊演算法:這裡使用MD5演算法;
70. hashedCredentialsMatcher.setHashIterations(2);//雜湊的次數，比如雜湊兩次，相當於 md5(md5(""));
71. return hashedCredentialsMatcher;
72. }
74. @Bean
75. public MyShiroRealm myShiroRealm() {
76. MyShiroRealm myShiroRealm = new MyShiroRealm();
77. myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
78. return myShiroRealm;
79. }
82. @Bean
83. public SecurityManager securityManager() {
84. DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
85. securityManager.setRealm(myShiroRealm());
86. // 自定義session管理 使用redis
87. securityManager.setSessionManager(sessionManager());
88. // 自定義快取實現 使用redis
89. securityManager.setCacheManager(cacheManager());
90. return securityManager;
91. }
93. //自定義sessionManager
94. @Bean
95. public SessionManager sessionManager() {
96. MySessionManager mySessionManager = new MySessionManager();
97. mySessionManager.setSessionDAO(redisSessionDAO());
98. return mySessionManager;
99. }
101. /**
102. * 配置shiro redisManager
103. * <p>
104. * 使用的是shiro-redis開源外掛
105. *
106. * @return
107. */
108. public RedisManager redisManager() {
109. RedisManager redisManager = new RedisManager();
110. redisManager.setHost(host);
111. redisManager.setPort(port);
112. redisManager.setExpire(1800);// 配置快取過期時間
113. redisManager.setTimeout(timeout);
114. redisManager.setPassword(password);
115. return redisManager;
116. }
118. /**
119. * cacheManager 快取 redis實現
120. * <p>
121. * 使用的是shiro-redis開源外掛
122. *
123. * @return
124. */
125. @Bean
126. public RedisCacheManager cacheManager() {
127. RedisCacheManager redisCacheManager = new RedisCacheManager();
128. redisCacheManager.setRedisManager(redisManager());
129. return redisCacheManager;
130. }
132. /**
133. * RedisSessionDAO shiro sessionDao層的實現 通過redis
134. * <p>
135. * 使用的是shiro-redis開源外掛
136. */
137. @Bean
138. public RedisSessionDAO redisSessionDAO() {
139. RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
140. redisSessionDAO.setRedisManager(redisManager());
141. return redisSessionDAO;
142. }
144. /**
145. * 開啟shiro aop註解支援.
146. * 使用代理方式;所以需要開啟程式碼支援;
147. *
148. * @param securityManager
149. * @return
150. */
151. @Bean
152. public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
153. AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
154. authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
155. return authorizationAttributeSourceAdvisor;
156. }
158. /**
159. * 註冊全域性異常處理
160. * @return
161. */
162. @Bean(name = "exceptionHandler")
163. public HandlerExceptionResolver handlerExceptionResolver() {
164. return new MyExceptionHandler();
165. }
166. }

在定義的SessionManager的Bean中返回我們的MySessionManager，然後在SecurityManager的Bean中呼叫setSessionManager(SessionManager sessionManager)方法載入我們的自定義SessionManager。

附上
MyShiroRealm的程式碼

1. package com.xxx.shiro.config;
3. import com.xxx.shiro.entity.SysPermission;
4. import com.xxx.shiro.entity.SysRole;
5. import com.xxx.shiro.entity.UserInfo;
6. import com.xxx.shiro.service.UserInfoService;
7. import org.apache.shiro.authc.*;
8. import org.apache.shiro.authz.AuthorizationInfo;
9. import org.apache.shiro.authz.SimpleAuthorizationInfo;
10. import org.apache.shiro.realm.AuthorizingRealm;
11. import org.apache.shiro.subject.PrincipalCollection;
12. import org.apache.shiro.util.ByteSource;
14. import javax.annotation.Resource;
16. /**
17. * Created by Administrator on 2017/12/11.
18. * 自定義許可權匹配和賬號密碼匹配
19. */
20. public class MyShiroRealm extends AuthorizingRealm {
21. @Resource
22. private UserInfoService userInfoService;
24. @Override
25. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
26. // System.out.println("許可權配置-->MyShiroRealm.doGetAuthorizationInfo()");
27. SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
28. UserInfo userInfo = (UserInfo) principals.getPrimaryPrincipal();
29. for (SysRole role : userInfo.getRoleList()) {
30. authorizationInfo.addRole(role.getRole());
31. for (SysPermission p : role.getPermissions()) {
32. authorizationInfo.addStringPermission(p.getPermission());
33. }
34. }
35. return authorizationInfo;
36. }
38. /*主要是用來進行身份認證的，也就是說驗證使用者輸入的賬號和密碼是否正確。*/
39. @Override
40. protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
41. throws AuthenticationException {
42. // System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
43. //獲取使用者的輸入的賬號.
44. String username = (String) token.getPrincipal();
45. // System.out.println(token.getCredentials());
46. //通過username從資料庫中查詢 User物件，如果找到，沒找到.
47. //實際專案中，這裡可以根據實際情況做快取，如果不做，Shiro自己也是有時間間隔機制，2分鐘內不會重複執行該方法
48. UserInfo userInfo = userInfoService.findByUsername(username);
49. // System.out.println("----->>userInfo="+userInfo);
50. if (userInfo == null) {
51. return null;
52. }
53. if (userInfo.getState() == 1) { //賬戶凍結
54. throw new LockedAccountException();
55. }
56. SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
57. userInfo, //使用者名稱
58. userInfo.getPassword(), //密碼
59. ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt
60. getName() //realm name
61. );
62. return authenticationInfo;
63. }
65. }

傳統專案中，登入成功後應該重定向請求，但在前後端分離專案中，通過ajax登入後應該返回登入狀態標誌以及相關資訊。Web層登入方法程式碼如下

1. /**
2. * 登入方法
3. * @param userInfo
4. * @return
5. */
6. @RequestMapping(value = "/ajaxLogin", method = RequestMethod.POST)
7. @ResponseBody
8. public String ajaxLogin(UserInfo userInfo) {
9. JSONObject jsonObject = new JSONObject();
10. Subject subject = SecurityUtils.getSubject();
11. UsernamePasswordToken token = new UsernamePasswordToken(userInfo.getUsername(), userInfo.getPassword());
12. try {
13. subject.login(token);
14. jsonObject.put("token", subject.getSession().getId());
15. jsonObject.put("msg", "登入成功");
16. } catch (IncorrectCredentialsException e) {
17. jsonObject.put("msg", "密碼錯誤");
18. } catch (LockedAccountException e) {
19. jsonObject.put("msg", "登入失敗，該使用者已被凍結");
20. } catch (AuthenticationException e) {
21. jsonObject.put("msg", "該使用者不存在");
22. } catch (Exception e) {
23. e.printStackTrace();
24. }
25. return jsonObject.toString();
26. }

本專案使用SpringMVC框架，可以自行修改使用其他MVC框架。登入成功則返回sessionId作為token給前端儲存，前端請求時將該token放入請求頭，以Authorization為key，以此來鑑權。如果出現賬號或密碼錯誤等異常則返回錯誤資訊。

傳統專案中，登出後應重定向請求，到登入介面或其他指定介面，在前後端分離的專案中，我們應該返回json資訊。在上面提到的ShiroConfig中配置了預設登入路由

在Web層加入方法

1. /**
2. * 未登入，shiro應重定向到登入介面，此處返回未登入狀態資訊由前端控制跳轉頁面
3. * @return
4. */
5. @RequestMapping(value = "/unauth")
6. @ResponseBody
7. public Object unauth() {
8. Map<String, Object> map = new HashMap<String, Object>();
9. map.put("code", "1000000");
10. map.put("msg", "未登入");
11. return map;
12. }

此處簡單提示未登入返回狀態碼，也可自行定義資訊。

在專案中，許可權相關表可能不在業務庫中，因此有必要單獨配置許可權相關表的資料來源。詳細配置可以參見《Spring Boot多資料來源配置與使用》一文。

Shiro資料來源配置程式碼

1. package com.xxx.shiro.datasource;
3. import java.util.Map;
4. import javax.persistence.EntityManager;
5. import javax.sql.DataSource;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.beans.factory.annotation.Qualifier;
8. import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
9. import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
10. import org.springframework.context.annotation.Bean;
11. import org.springframework.context.annotation.Configuration;
12. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
13. import org.springframework.orm.jpa.JpaTransactionManager;
14. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
15. import org.springframework.transaction.PlatformTransactionManager;
16. import org.springframework.transaction.annotation.EnableTransactionManagement;
18. /**
19. * Created by Administrator on 2017/12/11.
20. */
21. @Configuration
22. @EnableTransactionManagement
23. @EnableJpaRepositories(
24. entityManagerFactoryRef="shiroEntityManagerFactory",
25. transactionManagerRef="shiroTransactionManager",
26. basePackages= { "com.xxx.shiro.dao" })
27. public class ShiroDataSourceConfig {
28. @Autowired
29. private JpaProperties jpaProperties;
31. @Autowired
32. @Qualifier("shiroDataSource")
33. private DataSource shiroDataSource;
35. @Bean(name = "shiroEntityManager")
36. public EntityManager shiroEntityManager(EntityManagerFactoryBuilder builder) {
37. return shiroEntityManagerFactory(builder).getObject().createEntityManager();
38. }
40. @Bean(name = "shiroEntityManagerFactory")
41. public LocalContainerEntityManagerFactoryBean shiroEntityManagerFactory (EntityManagerFactoryBuilder builder) {
42. return builder
43. .dataSource(shiroDataSource)
44. .properties(getVendorProperties(shiroDataSource))
45. .packages("com.xxx.shiro.entity")
46. .persistenceUnit("shiroPersistenceUnit")
47. .build();
48. }
50. private Map<String, String> getVendorProperties(DataSource dataSource) {
51. return jpaProperties.getHibernateProperties(dataSource);
52. }
54. @Bean(name = "shiroTransactionManager")
55. PlatformTransactionManager shiroTransactionManager(EntityManagerFactoryBuilder builder) {
56. return new JpaTransactionManager(shiroEntityManagerFactory(builder).getObject());
57. }
58. }

IDEA下JpaProperties可能會報錯，可以忽略。

入口模組結構如下圖

DataSourceConfig中配置了多個數據源的Bean，其中shiro資料來源Bean程式碼

1. /**
2. * shiro資料來源
3. * @return
4. */
5. @Bean(name = "shiroDataSource")
6. @Qualifier("shiroDataSource")
7. @ConfigurationProperties(prefix="spring.datasource.shiro")
8. public DataSource shiroDataSource() {
9. return DataSourceBuilder.create().build();
10. }

ServletInitializer和StartApp為SpringBoot在外部tomcat啟動配置，不贅述。

SpringBoot的相關配置在application.yml中，shiro配置程式碼如下圖

Primary為主庫配置。當在某個專案中引入spring-boot-shiro模組時，只需要在配置檔案中加入shiro資料來源及redis的相關配置，並在DataSourceConfig加入shiro資料來源Bean即可。

Shiro框架會根據使用者登入及許可權狀態丟擲異常，建議使用SpringMVC的全域性異常捕獲來處理異常，避免重複程式碼。該專案中程式碼如下

1. package com.xxx.shiro.config;
3. import com.alibaba.fastjson.support.spring.FastJsonJsonView;
4. import org.apache.shiro.authz.UnauthenticatedException;
5. import org.apache.shiro.authz.UnauthorizedException;
6. import org.springframework.web.servlet.HandlerExceptionResolver;
7. import org.springframework.web.servlet.ModelAndView;
8. import javax.servlet.http.HttpServletRequest;
9. import javax.servlet.http.HttpServletResponse;
10. import java.util.HashMap;
11. import java.util.Map;
13. /**
14. * Created by Administrator on 2017/12/11.
15. * 全域性異常處理
16. */
17. public class MyExceptionHandler implements HandlerExceptionResolver {
19. public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) {
20. ModelAndView mv = new ModelAndView();
21. FastJsonJsonView view = new FastJsonJsonView();
22. Map<String, Object> attributes = new HashMap<String, Object>();
23. if (ex instanceof UnauthenticatedException) {
24. attributes.put("code", "1000001");
25. attributes.put("msg", "token錯誤");
26. } else if (ex instanceof UnauthorizedException) {
27. attributes.put("code", "1000002");
28. attributes.put("msg", "使用者無許可權");
29. } else {
30. attributes.put("code", "1000003");
31. attributes.put("msg", ex.getMessage());
32. }
34. view.setAttributesMap(attributes);
35. mv.setView(view);
36. return mv;
37. }
38. }

該Bean在ShiroConfig中已有註冊程式碼。

至此，shiro框架的整合就結束了。至於shiro框架的使用細節，可以自行查閱相關資料。專案程式碼本人測試可正常工作，未應用到生產環境，僅供學習交流使用。

參考文章

1.《在前後端分離的專案中，後臺使用shiro框架時，怎樣使用它的會話管理系統(session)，從而實現許可權控制》

2.《Spring Boot多資料來源配置與使用》

3.《springboot整合shiro-登入認證和許可權管理》

需要原始碼的朋友可以看看我的另一篇博文《SpringBoot+Shiro+MyBatisPlus搭建前後端分離的多模組專案》

更優雅的原始碼，更新的springboot版本，熱點問題解答，可以看看最新博文《SpringBoot2.0，Thymeleaf與Shiro整合》

Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架Spring Boot整合Shiro 許可權管理 在前後端分離的SpringBoot專案中整合Shiro許可權框架