用過Spring Security的朋友應該比較熟悉對URL進行全域性的許可權控制，即訪問URL時進行許可權匹配；如果沒有許可權直接跳到相應的錯誤頁面。Shiro也支援類似的機制，不過需要稍微改造下來滿足實際需求。不過在Shiro中，更多的是通過AOP進行分散的許可權控制，即方法級別的；而通過URL進行許可權控制是一種集中的許可權控制。本章將介紹如何在Shiro中完成動態URL許可權控制。

本章程式碼基於《第十六章 綜合例項》，請先了解相關資料模型及基本流程後再學習本章。

表及資料SQL

請執行shiro-example-chapter19/sql/ shiro-schema.sql 表結構

請執行shiro-example-chapter19/sql/ shiro-schema.sql 資料

實體

具體請參考com.github.zhangkaitao.shiro.chapter19包下的實體。 

1. public class UrlFilter implements Serializable {  
2.     private Long id;  
3.     private String name; //url名稱/描述  
4.     private String url; //地址  
5.     private String roles; //所需要的角色，可省略  
6.     private String permissions; //所需要的許可權，可省略  
7. }   

表示攔截的URL和角色/許可權之間的關係，多個角色/許可權之間通過逗號分隔，此處還可以擴充套件其他的關係，另外可以加如available屬性表示是否開啟該攔截。

DAO

具體請參考com.github.zhangkaitao.shiro.chapter19.dao包下的DAO介面及實現。

Service

具體請參考com.github.zhangkaitao.shiro.chapter19.service包下的Service介面及實現。  

1. public interface UrlFilterService {  
2.     public UrlFilter createUrlFilter(UrlFilter urlFilter);  
3.     public UrlFilter updateUrlFilter(UrlFilter urlFilter);  
4.     public void deleteUrlFilter(Long urlFilterId);  
5.     public UrlFilter findOne(Long urlFilterId);  
6.     public List<UrlFilter> findAll();  
7. }  

基本的URL攔截的增刪改查實現。 

1. @Service  
2. public class UrlFilterServiceImpl implements UrlFilterService {  
3.     @Autowired  
4. private ShiroFilerChainManager shiroFilerChainManager;  
5.     @Override  
6.     public UrlFilter createUrlFilter(UrlFilter urlFilter) {  
7.         urlFilterDao.createUrlFilter(urlFilter);  
8.         initFilterChain();  
9.         return urlFilter;  
10.     }  
11.     //其他方法請參考原始碼  
12.     @PostConstruct  
13.     public void initFilterChain() {  
14.         shiroFilerChainManager.initFilterChains(findAll());  
15.     }  
16. }   

UrlFilterServiceImpl在進行新增、修改、刪除時會呼叫initFilterChain來重新初始化Shiro的URL攔截器鏈，即同步資料庫中的URL攔截器定義到Shiro中。此處也要注意如果直接修改資料庫是不會起作用的，因為只要呼叫這幾個Service方法時才同步。另外當容器啟動時會自動回撥initFilterChain來完成容器啟動後的URL攔截器的註冊。

ShiroFilerChainManager 

1. @Service  
2. public class ShiroFilerChainManager {  
3.     @Autowired private DefaultFilterChainManager filterChainManager;  
4.     private Map<String, NamedFilterList> defaultFilterChains;  
5.     @PostConstruct  
6.     public void init() {  
7.         defaultFilterChains =   
8.           new HashMap<String, NamedFilterList>(filterChainManager.getFilterChains());  
9.     }  
10.     public void initFilterChains(List<UrlFilter> urlFilters) {  
11.         //1、首先刪除以前老的filter chain並註冊預設的  
12.         filterChainManager.getFilterChains().clear();  
13.         if(defaultFilterChains != null) {  
14.             filterChainManager.getFilterChains().putAll(defaultFilterChains);  
15.         }  
16.         //2、迴圈URL Filter 註冊filter chain  
17.         for (UrlFilter urlFilter : urlFilters) {  
18.             String url = urlFilter.getUrl();  
19.             //註冊roles filter  
20.             if (!StringUtils.isEmpty(urlFilter.getRoles())) {  
21.                 filterChainManager.addToChain(url, "roles", urlFilter.getRoles());  
22.             }  
23.             //註冊perms filter  
24.             if (!StringUtils.isEmpty(urlFilter.getPermissions())) {  
25.                 filterChainManager.addToChain(url, "perms", urlFilter.getPermissions());  
26.             }  
27.         }  
28.     }  
29. }   

1、init：Spring容器啟動時會呼叫init方法把在spring配置檔案中配置的預設攔截器儲存下來，之後會自動與資料庫中的配置進行合併。

2、initFilterChains：UrlFilterServiceImpl會在Spring容器啟動或進行增刪改UrlFilter時進行註冊URL攔截器到Shiro。

攔截器及攔截器鏈知識請參考《第八章 攔截器機制》，此處再介紹下Shiro攔截器的流程：

AbstractShiroFilter //如ShiroFilter/ SpringShiroFilter都繼承該Filter

   doFilter //Filter的doFilter

     doFilterInternal //轉調doFilterInternal

       executeChain(request, response, chain) //執行攔截器鏈

         FilterChain chain = getExecutionChain(request, response, origChain) //使用原始攔截器鏈獲取新的攔截器鏈

           chain.doFilter(request, response) //執行新組裝的攔截器鏈

getExecutionChain(request, response, origChain) //獲取攔截器鏈流程

       FilterChainResolver resolver = getFilterChainResolver(); //獲取相應的FilterChainResolver

       FilterChain resolved = resolver.getChain(request, response, origChain); //通過FilterChainResolver根據當前請求解析到新的FilterChain攔截器鏈

預設情況下如使用ShiroFilterFactoryBean建立shiroFilter時，預設使用PathMatchingFilterChainResolver進行解析，而它預設是根據當前請求的URL獲取相應的攔截器鏈，使用Ant模式進行URL匹配；預設使用DefaultFilterChainManager進行攔截器鏈的管理。

PathMatchingFilterChainResolver預設流程：

1. public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {  
2.     //1、首先獲取攔截器鏈管理器  
3.     FilterChainManager filterChainManager = getFilterChainManager();  
4.     if (!filterChainManager.hasChains()) {  
5.         return null;  
6.     }  
7.     //2、接著獲取當前請求的URL（不帶上下文）  
8.     String requestURI = getPathWithinApplication(request);  
9.     //3、迴圈攔截器管理器中的攔截器定義（攔截器鏈的名字就是URL模式）  
10.     for (String pathPattern : filterChainManager.getChainNames()) {  
11.         //4、如當前URL匹配攔截器名字（URL模式）  
12.         if (pathMatches(pathPattern, requestURI)) {  
13.             //5、返回該URL模式定義的攔截器鏈  
14.             return filterChainManager.proxy(originalChain, pathPattern);  
15.         }  
16.     }  
17.     return null;  
18. }   

預設實現有點小問題：

如果多個攔截器鏈都匹配了當前請求URL，那麼只返回第一個找到的攔截器鏈；後續我們可以修改此處的程式碼，將多個匹配的攔截器鏈合併返回。

DefaultFilterChainManager內部使用Map來管理URL模式-攔截器鏈的關係；也就是說相同的URL模式只能定義一個攔截器鏈，不能重複定義；而且如果多個攔截器鏈都匹配時是無序的（因為使用map.keySet()獲取攔截器鏈的名字，即URL模式）。

FilterChainManager介面： 

1. public interface FilterChainManager {  
2.     Map<String, Filter> getFilters(); //得到註冊的攔截器  
3.     void addFilter(String name, Filter filter); //註冊攔截器  
4.     void addFilter(String name, Filter filter, boolean init); //註冊攔截器  
5.     void createChain(String chainName, String chainDefinition); //根據攔截器鏈定義建立攔截器鏈  
6.     void addToChain(String chainName, String filterName); //新增攔截器到指定的攔截器鏈  
7.     void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) throws ConfigurationException; //新增攔截器（帶有配置的）到指定的攔截器鏈  
8.     NamedFilterList getChain(String chainName); //獲取攔截器鏈  
9.     boolean hasChains(); //是否有攔截器鏈  
10.     Set<String> getChainNames(); //得到所有攔截器鏈的名字  
11.     FilterChain proxy(FilterChain original, String chainName); //使用指定的攔截器鏈代理原始攔截器鏈  
12. }   

此介面主要三個功能：註冊攔截器，註冊攔截器鏈，對原始攔截器鏈生成代理之後的攔截器鏈，比如  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2. ……  
3.     <property name="filters">  
4.         <util:map>  
5.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
6.             <entry key="sysUser" value-ref="sysUserFilter"/>  
7.         </util:map>  
8.     </property>  
9.     <property name="filterChainDefinitions">  
10.         <value>  
11.             /login = authc  
12.             /logout = logout  
13.             /authenticated = authc  
14.             /** = user,sysUser  
15.         </value>  
16.     </property>  
17. </bean>   

filters屬性定義了攔截器；filterChainDefinitions定義了攔截器鏈；如/**就是攔截器鏈的名字；而user,sysUser就是攔截器名字列表。

之前說過預設的PathMatchingFilterChainResolver和DefaultFilterChainManager不能滿足我們的需求，我們稍微擴充套件了一下：

CustomPathMatchingFilterChainResolver 

1. public class CustomPathMatchingFilterChainResolver  
2.              extends PathMatchingFilterChainResolver {  
3.   private CustomDefaultFilterChainManager customDefaultFilterChainManager;  
4.   public void setCustomDefaultFilterChainManager(  
5.         CustomDefaultFilterChainManager customDefaultFilterChainManager) {  
6.       this.customDefaultFilterChainManager = customDefaultFilterChainManager;  
7.       setFilterChainManager(customDefaultFilterChainManager);  
8.   }  
9.   public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {  
10.       FilterChainManager filterChainManager = getFilterChainManager();  
11.       if (!filterChainManager.hasChains()) {  
12.           return null;  
13.       }  
14.       String requestURI = getPathWithinApplication(request);  
15.       List<String> chainNames = new ArrayList<String>();  
16.       for (String pathPattern : filterChainManager.getChainNames()) {  
17.         if (pathMatches(pathPattern, requestURI)) {  
18.         chainNames.add(pathPattern);  
19.         }  
20.       }  
21.       if(chainNames.size() == 0) {  
22.         return null;  
23.       }  
24.       return customDefaultFilterChainManager.proxy(originalChain, chainNames);  
25.   }  
26. }   

和預設的PathMatchingFilterChainResolver區別是，此處得到所有匹配的攔截器鏈，然後通過呼叫CustomDefaultFilterChainManager.proxy(originalChain, chainNames)進行合併後代理。

CustomDefaultFilterChainManager    

1. public class CustomDefaultFilterChainManager extends DefaultFilterChainManager {  
2.     private Map<String, String> filterChainDefinitionMap = null;  
3.     private String loginUrl;  
4.     private String successUrl;  
5.     private String unauthorizedUrl;  
6.     public CustomDefaultFilterChainManager() {  
7.         setFilters(new LinkedHashMap<String, Filter>());  
8.         setFilterChains(new LinkedHashMap<String, NamedFilterList>());  
9.         addDefaultFilters(true);  
10.     }  
11.     public Map<String, String> getFilterChainDefinitionMap() {  
12.         return filterChainDefinitionMap;  
13.     }  
14.     public void setFilterChainDefinitionMap(Map<String, String> filterChainDefinitionMap) {  
15.         this.filterChainDefinitionMap = filterChainDefinitionMap;  
16.     }  
17.     public void setCustomFilters(Map<String, Filter> customFilters) {  
18.         for(Map.Entry<String, Filter> entry : customFilters.entrySet()) {  
19.             addFilter(entry.getKey(), entry.getValue(), false);  
20.         }  
21. }  
22.     public void setDefaultFilterChainDefinitions(String definitions) {  
23.         Ini ini = new Ini();  
24.         ini.load(definitions);  
25.         Ini.Section section = ini.getSection(IniFilterChainResolverFactory.URLS);  
26.         if (CollectionUtils.isEmpty(section)) {  
27.             section = ini.getSection(Ini.DEFAULT_SECTION_NAME);  
28.         }  
29.         setFilterChainDefinitionMap(section);  
30.     }  
31.     public String getLoginUrl() {  
32.         return loginUrl;  
33.     }  
34.     public void setLoginUrl(String loginUrl) {  
35.         this.loginUrl = loginUrl;  
36.     }  
37.     public String getSuccessUrl() {  
38.         return successUrl;  
39.     }  
40.     public void setSuccessUrl(String successUrl) {  
41.         this.successUrl = successUrl;  
42.     }  
43.     public String getUnauthorizedUrl() {  
44.         return unauthorizedUrl;  
45.     }  
46.     public void setUnauthorizedUrl(String unauthorizedUrl) {  
47.         this.unauthorizedUrl = unauthorizedUrl;  
48.     }  
49.     @PostConstruct  
50.     public void init() {  
51.         Map<String, Filter> filters = getFilters();  
52.         if (!CollectionUtils.isEmpty(filters)) {  
53.             for (Map.Entry<String, Filter> entry : filters.entrySet()) {  
54.                 String name = entry.getKey();  
55.                 Filter filter = entry.getValue();  
56.                 applyGlobalPropertiesIfNecessary(filter);  
57.                 if (filter instanceof Nameable) {  
58.                     ((Nameable) filter).setName(name);  
59.                 }  
60.                 addFilter(name, filter, false);  
61.             }  
62.         }  
63.         Map<String, String> chains = getFilterChainDefinitionMap();  
64.         if (!CollectionUtils.isEmpty(chains)) {  
65.             for (Map.Entry<String, String> entry : chains.entrySet()) {  
66.                 String url = entry.getKey();  
67.                 String chainDefinition = entry.getValue();  
68.                 createChain(url, chainDefinition);  
69.             }  
70.         }  
71.     }  
72.     protected void initFilter(Filter filter) {  
73.         //ignore   
74.     }  
75.     public FilterChain proxy(FilterChain original, List<String> chainNames) {  
76.         NamedFilterList configured = new SimpleNamedFilterList(chainNames.toString());  
77.         for(String chainName : chainNames) {  
78.             configured.addAll(getChain(chainName));  
79.         }  
80.         return configured.proxy(original);  
81.     }  
82.     private void applyGlobalPropertiesIfNecessary(Filter filter) {  
83.         applyLoginUrlIfNecessary(filter);  
84.         applySuccessUrlIfNecessary(filter);  
85.         applyUnauthorizedUrlIfNecessary(filter);  
86.     }  
87.     private void applyLoginUrlIfNecessary(Filter filter) {  
88.         //請參考原始碼  
89.     }  
90.     private void applySuccessUrlIfNecessary(Filter filter) {  
91.         //請參考原始碼  
92.     }  
93.     private void applyUnauthorizedUrlIfNecessary(Filter filter) {  
94.         //請參考原始碼  
95.     }  
96. }   

1、CustomDefaultFilterChainManager：呼叫其構造器時，會自動註冊預設的攔截器；

2、loginUrl、successUrl、unauthorizedUrl：分別對應登入地址、登入成功後預設跳轉地址、未授權跳轉地址，用於給相應攔截器的；

3、filterChainDefinitionMap：用於儲存如ShiroFilterFactoryBean在配置檔案中配置的攔截器鏈定義，即可以認為是預設的靜態攔截器鏈；會自動與資料庫中載入的合併；

4、setDefaultFilterChainDefinitions：解析配置檔案中傳入的字串攔截器鏈配置，解析為相應的攔截器鏈；

5、setCustomFilters：註冊我們自定義的攔截器；如ShiroFilterFactoryBean的filters屬性；

6、init：初始化方法，Spring容器啟動時會呼叫，首先其會自動給相應的攔截器設定如loginUrl、successUrl、unauthorizedUrl；其次根據filterChainDefinitionMap構建預設的攔截器鏈；

7、initFilter：此處我們忽略實現initFilter，因為交給spring管理了，所以Filter的相關配置會在Spring配置中完成；

8、proxy：組合多個攔截器鏈為一個生成一個新的FilterChain代理。

Web層控制器 

請參考com.github.zhangkaitao.shiro.chapter19.web.controller包，相對於第十六章添加了UrlFilterController用於UrlFilter的維護。另外，移除了控制器方法上的許可權註解，而是使用動態URL攔截進行控制。

Spring配置——spring-config-shiro.xml   

1. <bean id="filterChainManager"   
2.     class="com.github.zhangkaitao.shiro.spring.CustomDefaultFilterChainManager">  
3.     <property name="loginUrl" value="/login"/>  
4.     <property name="successUrl" value="/"/>  
5.     <property name="unauthorizedUrl" value="/unauthorized.jsp"/>  
6.     <property name="customFilters">  
7.         <util:map>  
8.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
9.             <entry key="sysUser" value-ref="sysUserFilter"/>  
10.         </util:map>  
11.     </property>  
12.     <property name="defaultFilterChainDefinitions">  
13.         <value>  
14.             /login = authc  
15.             /logout = logout  
16.             /unauthorized.jsp = authc  
17.             /** = user,sysUser  
18.         </value>  
19.     </property>  
20. </bean>   

filterChainManager是我們自定義的CustomDefaultFilterChainManager，註冊相應的攔截器及預設的攔截器鏈。 

1. <bean id="filterChainResolver"   
2.     class="com.github.zhangkaitao.shiro.spring.CustomPathMatchingFilterChainResolver">  
3.     <property name="customDefaultFilterChainManager" ref="filterChainManager"/>  
4. </bean>   

filterChainResolver是自定義的CustomPathMatchingFilterChainResolver，使用上邊的filterChainManager進行攔截器鏈的管理。 

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.     <property name="securityManager" ref="securityManager"/>  
3. </bean>   

shiroFilter不再定義filters及filterChainDefinitions，而是交給了filterChainManager進行完成。 

1. <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
2.     <property name="targetObject" ref="shiroFilter"/>  
3.     <property name="targetMethod" value="setFilterChainResolver"/>  
4.     <property name="arguments" ref="filterChainResolver"/>  
5. </bean>   

最後把filterChainResolver註冊給shiroFilter，其使用它進行動態URL許可權控制。

其他配置和第十六章一樣，請參考第十六章。

測試

1、首先執行shiro-data.sql初始化資料。

2、然後再URL管理中新增如下資料： 

3、訪問http://localhost:8080/chapter19/user時要求使用者擁有aa角色，此時是沒有的所以會跳轉到未授權頁面；

4、新增aa角色然後授權給使用者，此時就有許可權訪問http://localhost:8080/chapter19/user。

實際專案可以在此基礎上進行擴充套件。