第二十三章多项目集中权限管理及分布式会话——《跟我学Shiro》

1.     public String getRequestUrl() {  


2.         String requestURI = getRequestURI();  


3.         if(backUrl != null) {//1  


4.             if(backUrl.toLowerCase().startsWith("http://") || backUrl.toLowerCase().startsWith("https://")) {  


5.                 return backUrl;  


6.             } else if(!backUrl.startsWith(contextPath)) {//2  


7.                 requestURI = contextPath + backUrl;  


8.             } else {//3  


9.                 requestURI = backUrl;  


10.             }  


11.         }  


12.         StringBuilder requestUrl = new StringBuilder(scheme);//4  


13.         requestUrl.append("://");  


14.         requestUrl.append(domain);//5  


15.         //6  


16.         if("http".equalsIgnoreCase(scheme) && port != 80) {  


17.             requestUrl.append(":").append(String.valueOf(port));  


18.         } else if("https".equalsIgnoreCase(scheme) && port != 443) {  


19.             requestUrl.append(":").append(String.valueOf(port));  


20.         }  


21.         //7  


22.         requestUrl.append(requestURI);  


23.         //8  


24.         if (backUrl == null && getQueryString() != null) {  


25.             requestUrl.append("?").append(getQueryString());  


26.         }  


27.         return requestUrl.toString();  


28.     }  


29.    

1、如果从外部传入了successUrl（登录成功之后重定向的地址），且以http://或https://开头那么直接返回（相应的拦截器直接重定向到它即可）；

2、如果successUrl有值但没有上下文，拼上上下文；

3、否则，如果successUrl有值，直接赋值给requestUrl即可；否则，如果successUrl没值，那么requestUrl就是当前请求的地址；

5、拼上url前边的schema，如http或https；

6、拼上域名；

7、拼上重定向到的地址（带上下文）；

8、如果successUrl没值，且有查询参数，拼上；

9返回该地址，相应的拦截器直接重定向到它即可。

shiro-example-chapter23-server模块

简单的实体关系图  

简单数据字典

用户(sys_user)

应用(sys_app)

授权(sys_authorization)

用户：比《第十六章 综合实例》少了role_ids，因为本章是多项目集中权限管理；所以授权时需要指定相应的应用；而不是直接给用户授权；所以不能在用户中出现role_ids了；

应用：所有集中权限的应用；在此处需要指定应用key(app_key)和应用安全码（app_secret），app在访问server时需要指定自己的app_key和用户名来获取该app对应用户权限信息；另外app_secret可以认为app的密码，比如需要安全访问时可以考虑使用它，可参考《第二十章 无状态Web应用集成》。另外available属性表示该应用当前是否开启；如果false表示该应用当前不可用，即不能获取到相应的权限信息。

授权：给指定的用户在指定的app下授权，即角色是与用户和app存在关联关系。

因为本章使用了《第十六章 综合实例》代码，所以还有其他相应的表结构（本章未使用到）。

表/数据SQL

具体请参考

sql/ shiro-schema.sql （表结构）

sql/ shiro-data.sql  （初始数据）

实体

具体请参考com.github.zhangkaitao.shiro.chapter23.entity包下的实体，此处就不列举了。

DAO

具体请参考com.github.zhangkaitao.shiro.chapter23.dao包下的DAO接口及实现。

Service

具体请参考com.github.zhangkaitao.shiro.chapter23.service包下的Service接口及实现。以下是出了基本CRUD之外的关键接口： 

1. public interface AppService {  


2.     public Long findAppIdByAppKey(String appKey);// 根据appKey查找AppId   


3. }  

1. public interface AuthorizationService {  


2.     //根据AppKey和用户名查找其角色  


3.     public Set findRoles(String appKey, String username);  


4.     //根据AppKey和用户名查找权限字符串  


5.     public Set findPermissions(String appKey, String username);  


6. }   

根据AppKey和用户名查找用户在指定应用中对于的角色和权限字符串。

UserRealm  

1. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  


2.     String username = (String)principals.getPrimaryPrincipal();  


3.     SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  


4.     authorizationInfo.setRoles(  


5.         authorizationService.findRoles(Constants.SERVER_APP_KEY, username));  


6.     authorizationInfo.setStringPermissions(  


7.     authorizationService.findPermissions(Constants.SERVER_APP_KEY, username));  


8.     return authorizationInfo;  


9. }   

此处需要调用AuthorizationService的findRoles/findPermissions方法传入AppKey和用户名来获取用户的角色和权限字符串集合。其他的和《第十六章 综合实例》代码一样。

ServerFormAuthenticationFilter 

1. public class ServerFormAuthenticationFilter extends FormAuthenticationFilter {  


2.     protected void issueSuccessRedirect(ServletRequest request, ServletResponse response) throws Exception {  


3.         String fallbackUrl = (String) getSubject(request, response)  


4.                 .getSession().getAttribute("authc.fallbackUrl");  


5.         if(StringUtils.isEmpty(fallbackUrl)) {  


6.             fallbackUrl = getSuccessUrl();  


7.         }  


8.         WebUtils.redirectToSavedRequest(request, response, fallbackUrl);  


9.     }  


10. }   

因为是多项目登录，比如如果是从其他应用中重定向过来的，首先检查Session中是否有“authc.fallbackUrl”属性，如果有就认为它是默认的重定向地址；否则使用Server自己的successUrl作为登录成功后重定向到的地址。

MySqlSessionDAO

将会话持久化到Mysql数据库；此处大家可以将其实现为如存储到Redis/Memcached等，实现策略请参考《第十章 会话管理》中的会话存储/持久化章节的MySessionDAO，完全一样。

MySqlSessionValidationScheduler

和《第十章 会话管理》中的会话验证章节部分中的MySessionValidationScheduler完全一样。如果使用如Redis之类的有自动过期策略的DB，完全可以不用实现SessionValidationScheduler，直接借助于这些DB的过期策略即可。

RemoteService  

1. public class RemoteService implements RemoteServiceInterface {  


2.     @Autowired  private AuthorizationService authorizationService;  


3.     @Autowired  private SessionDAO sessionDAO;  


4.   


5.     public Session getSession(String appKey, Serializable sessionId) {  


6.         return sessionDAO.readSession(sessionId);  


7.     }  


8.     public Serializable createSession(Session session) {  


9.         return sessionDAO.create(session);  


10.     }  


11.     public void updateSession(String appKey, Session session) {  


12.         sessionDAO.update(session);  


13.     }  


14.     public void deleteSession(String appKey, Session session) {  


15.         sessionDAO.delete(session);  


16.     }  


17.     public PermissionContext getPermissions(String appKey, String username) {  


18.         PermissionContext permissionContext = new PermissionContext();  


19.         permissionContext.setRoles(authorizationService.findRoles(appKey, username));  


20.         permissionContext.setPermissions(authorizationService.findPermissions(appKey, username));  


21.         return permissionContext;  


22.     }  


23. }   

将会使用HTTP调用器暴露为远程服务，这样其他应用就可以使用相应的客户端调用这些接口进行Session的集中维护及根据AppKey和用户名获取角色/权限字符串集合。此处没有实现安全校验功能，如果是局域网内使用可以通过限定IP完成；否则需要使用如《第二十章 无状态Web应用集成》中的技术完成安全校验。

然后在spring-mvc-remote-service.xml配置文件把服务暴露出去：  

1. 
   
2.   class="com.github.zhangkaitao.shiro.chapter23.remote.RemoteService"/>  


3. 
   
4.   class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">  


5.     

     



6.     

   
   

7.       value="com.github.zhangkaitao.shiro.chapter23.remote.RemoteServiceInterface"/>  


8.   

Shiro配置文件spring-config-shiro.xml 

和《第十六章 综合实例》配置类似，但是需要在shiroFilter中的filterChainDefinitions中添加如下配置，即远程调用不需要身份认证：  

1. /remoteService = anon  

对于userRealm的缓存配置直接禁用；因为如果开启，修改了用户权限不会自动同步到缓存；另外请参考《第十一章 缓存机制》进行缓存的正确配置。

服务器端数据维护

1、首先开启ngnix反向代理；然后就可以直接访问http://localhost/chapter23-server/；

2、输入默认的用户名密码：admin/123456登录

3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。 

4、授权管理，维护在哪个应用中用户的角色列表。这样客户端就可以根据应用KEY及用户名获取到对应的角色/权限字符串列表了。 

shiro-example-chapter23-client模块

Client模块提供给其他应用模块依赖，这样其他应用模块只需要依赖Client模块，然后再在相应的配置文件中配置如登录地址、远程接口地址、拦截器链等等即可，简化其他应用模块的配置。

配置远程服务spring-client-remote-service.xml      

1. 
   
2.   class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  


3.     

     



4.     

   
   

5.       value="com.github.zhangkaitao.shiro.chapter23.remote.RemoteServiceInterface"/>  


6.    

client.remote.service.url是远程服务暴露的地址；通过相应的properties配置文件配置，后续介绍。然后就可以通过remoteService获取会话及角色/权限字符串集合了。

ClientRealm  

1. public class ClientRealm extends AuthorizingRealm {  


2.     private RemoteServiceInterface remoteService;  


3.     private String appKey;  


4.     public void setRemoteService(RemoteServiceInterface remoteService) {  


5.         this.remoteService = remoteService;  


6.     }  


7.     public void setAppKey(String appKey) {  


8.         this.appKey = appKey;  


9.     }  


10.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  


11.         String username = (String) principals.getPrimaryPrincipal();  


12.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  


13.         PermissionContext context = remoteService.getPermissions(appKey, username);  


14.         authorizationInfo.setRoles(context.getRoles());  


15.         authorizationInfo.setStringPermissions(context.getPermissions());  


16.         return authorizationInfo;  


17.     }  


18.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  


19.         //永远不会被调用  


20.         throw new UnsupportedOperationException("永远不会被调用");  


21.     }  


22. }   

ClientRealm提供身份认证信息和授权信息，此处因为是其他应用依赖客户端，而这些应用不会实现身份认证，所以doGetAuthenticationInfo获取身份认证信息直接无须实现。另外获取授权信息，是通过远程暴露的服务RemoteServiceInterface获取，提供appKey和用户名获取即可。

ClientSessionDAO 

1. public class ClientSessionDAO extends CachingSessionDAO {  


2.     private RemoteServiceInterface remoteService;  


3.     private String appKey;  


4.     public void setRemoteService(RemoteServiceInterface remoteService) {  


5.         this.remoteService = remoteService;  


6.     }  


7.     public void setAppKey(String appKey) {  


8.         this.appKey = appKey;  


9.     }  


10.     protected void doDelete(Session session) {  


11.         remoteService.deleteSession(appKey, session);  


12.     }  


13.     protected void doUpdate(Session session) {  


14.         remoteService.updateSession(appKey, session);  


15. }  


16. protected Serializable doCreate(Session session) {  


17.         Serializable sessionId = remoteService.createSession(session);  


18.         assignSessionId(session, sessionId);  


19.         return sessionId;  


20.     }  


21.     protected Session doReadSession(Serializable sessionId) {  


22.         return remoteService.getSession(appKey, sessionId);  


23.     }  


24. }   

Session的维护通过远程暴露接口实现，即本地不维护会话。

ClientAuthenticationFilter  

1. public class ClientAuthenticationFilter extends AuthenticationFilter {  


2.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {  


3.         Subject subject = getSubject(request, response);  


4.         return subject.isAuthenticated();  


5.     }  


6.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  


7.         String backUrl = request.getParameter("backUrl");  


8.         saveRequest(request, backUrl, getDefaultBackUrl(WebUtils.toHttp(request)));  


9.         return false;  


10.     }  


11.     protected void saveRequest(ServletRequest request, String backUrl, String fallbackUrl) {  


12.         Subject subject = SecurityUtils.getSubject();  


13.         Session session = subject.getSession();  


14.         HttpServletRequest httpRequest = WebUtils.toHttp(request);  


15.         session.setAttribute("authc.fallbackUrl", fallbackUrl);  


16.         SavedRequest savedRequest = new ClientSavedRequest(httpRequest, backUrl);  


17.         session.setAttribute(WebUtils.SAVED_REQUEST_KEY, savedRequest);  


18. }  


19.     private String getDefaultBackUrl(HttpServletRequest request) {  


20.         String scheme = request.getScheme();  


21.         String domain = request.getServerName();  


22.         int port = request.getServerPort();  


23.         String contextPath = request.getContextPath();  


24.         StringBuilder backUrl = new StringBuilder(scheme);  


25.         backUrl.append("://");  


26.         backUrl.append(domain);  


27.         if("http".equalsIgnoreCase(scheme) && port != 80) {  


28.             backUrl.append(":").append(String.valueOf(port));  


29.         } else if("https".equalsIgnoreCase(scheme) && port != 443) {  


30.             backUrl.append(":").append(String.valueOf(port));  


31.         }  


32.         backUrl.append(contextPath);  


33.         backUrl.append(getSuccessUrl());  


34.         return backUrl.toString();  


35.     }  


36. }   

ClientAuthenticationFilter是用于实现身份认证的拦截器（authc），当用户没有身份认证时；

1、首先得到请求参数backUrl，即登录成功重定向到的地址；

2、然后保存保存请求到会话，并重定向到登录地址（server模块）；

3、登录成功后，返回地址按照如下顺序获取：backUrl、保存的当前请求地址、defaultBackUrl（即设置的successUrl）；

ClientShiroFilterFactoryBean  

1. public class ClientShiroFilterFactoryBean extends ShiroFilterFactoryBean implements ApplicationContextAware {  


2.     private ApplicationContext applicationContext;  


3.     public void setApplicationContext(ApplicationContext applicationContext) {  


4.         this.applicationContext = applicationContext;  


5.     }  


6.     public void setFiltersStr(String filters) {  


7.         if(StringUtils.isEmpty(filters)) {  


8.             return;  


9.         }  


10.         String[] filterArray = filters.split(";");  


11.         for(String filter : filterArray) {  


12.             String[] o = filter.split("=");  


13.             getFilters().put(o[0], (Filter)applicationContext.getBean(o[1]));  


14.         }  


15.     }  


16.     public void setFilterChainDefinitionsStr(String filterChainDefinitions) {  


17.         if(StringUtils.isEmpty(filterChainDefinitions)) {  


18.             return;  


19.         }  


20.         String[] chainDefinitionsArray = filterChainDefinitions.split(";");  


21.         for(String filter : chainDefinitionsArray) {  


22.             String[] o = filter.split("=");  


23.             getFilterChainDefinitionMap().put(o[0], o[1]);  


24.         }  


25.     }  


26. }   

1、setFiltersStr：设置拦截器，设置格式如“filterName=filterBeanName; filterName=filterBeanName”；多个之间分号分隔；然后通过applicationContext获取filterBeanName对应的Bean注册到拦截器Map中；

2、setFilterChainDefinitionsStr：设置拦截器链，设置格式如“url=filterName1[config],filterName2; url=filterName1[config],filterName2”；多个之间分号分隔；

Shiro客户端配置spring-client.xml

提供了各应用通用的Shiro客户端配置；这样应用只需要导入相应该配置即可完成Shiro的配置，简化了整个配置过程。  

1. 
   
2.     "classpath:client/shiro-client-default.properties,classpath:client/shiro-client.properties"/>   

提供给客户端配置的properties属性文件，client/shiro-client-default.properties是客户端提供的默认的配置；classpath:client/shiro-client.properties是用于覆盖客户端默认配置，各应用应该提供该配置文件，然后提供各应用个性配置。

appKey：使用${client.app.key}占位符替换，即需要在之前的properties文件中配置。 

Session Id COOKIE，COOKIE名字、域名、路径等都是通过配置文件配置。  

1. 
   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientSessionDAO">  


3.     

     



4.     

     



5.     

     



6.    

SessionDAO的appKey，也是通过${ client.app.key }占位符替换，需要在配置文件配置。

1. 
   
2.   class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  


3.         

   //省略其他  



4.    

其他应用无须进行会话过期调度，所以sessiOnValidationSchedulerEnabled=false。  

1. 
   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientAuthenticationFilter"/>   

应用的身份认证使用ClientAuthenticationFilter，即如果没有身份认证，则会重定向到Server模块完成身份认证，身份认证成功后再重定向回来。 

1. 
   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientShiroFilterFactoryBean">  


3.     

     



4.     

     



5.     

     



6.     

     



7.     

     



8.           


9.               


10.           


11.       


12.     

      



13.     

      



14.    

ShiroFilter使用我们自定义的ClientShiroFilterFactoryBean，然后loginUrl（登录地址）、successUrl（登录成功后默认的重定向地址）、unauthorizedUrl（未授权重定向到的地址）通过占位符替换方式配置；另外filtersStr和filterChainDefinitionsStr也是使用占位符替换方式配置；这样就可以在各应用进行自定义了。

默认配置client/ shiro-client-default.properties 

1. #各应用的appKey  


2. client.app.key=  


3. #远程服务URL地址  


4. client.remote.service.url=http://localhost/chapter23-server/remoteService  


5. #登录地址  


6. client.login.url=http://localhost/chapter23-server/login  


7. #登录成功后，默认重定向到的地址  


8. client.success.url=/  


9. #未授权重定向到的地址  


10. client.unauthorized.url=http://localhost/chapter23-server/unauthorized  


11. #session id 域名  


12. client.COOKIE.domain=  


13. #session id 路径  


14. client.COOKIE.path=/  


15. #COOKIE中的session id名称  


16. client.session.id=sid  


17. #COOKIE中的remember me名称  


18. client.rememberMe.id=rememberMe  


19. #过滤器 name=filter-ref;name=filter-ref  


20. client.filters=  


21. #过滤器链 格式 url=filters;url=filters  


22. client.filter.chain.definitiOns=/**=anon   

在各应用中主要配置client.app.key、client.filters、client.filter.chain.definitions。

shiro-example-chapter23-app*模块

继承shiro-example-chapter23-pom模块 

1.   



2.     shiro-example-chapter23-pom  


3.     com.github.zhangkaitao  


4.     1.0-SNAPSHOT  


5.   

依赖shiro-example-chapter23-client模块

com.github.zhangkaitao
shiro-example-chapter23-client
1.0-SNAPSHOT
 

客户端配置client/shiro-client.properties

配置shiro-example-chapter23-app1  

1. client.app.key=645ba612-370a-43a8-a8e0-993e7a590cf0  


2. client.success.url=/hello  


3. client.filter.chain.definitiOns=/hello=anon;/login=authc;/**=authc   

client.app.key是server模块维护的，直接拷贝过来即可；client.filter.chain.definitions定义了拦截器链；比如访问/hello，匿名即可。

配置shiro-example-chapter23-app2 

1. client.app.key=645ba613-370a-43a8-a8e0-993e7a590cf0  


2. client.success.url=/hello  


3. client.filter.chain.definitiOns=/hello=anon;/login=authc;/**=authc   

和app1类似，client.app.key是server模块维护的，直接拷贝过来即可；client.filter.chain.definitions定义了拦截器链；比如访问/hello，匿名即可。

web.xml 

1.   


2.     

   contextConfigLocation  



3.     

     



4.         classpath:client/spring-client.xml  


5.       


6.   


7.   


8.       


9.         org.springframework.web.context.ContextLoaderListener  


10.       


11.    

指定加载客户端Shiro配置，client/spring-client.xml。 

1.   


2.     shiroFilter  


3.     org.springframework.web.filter.DelegatingFilterProxy  


4.       


5.         

   targetFilterLifecycle  



6.         

   true  



7.       


8.   


9.   


10.     shiroFilter  


11.     /*  


12.   

 配置ShiroFilter拦截器。

控制器

shiro-example-chapter23-app1

1. @Controller  


2. public class HelloController {  


3.     @RequestMapping("/hello")  


4.     public String hello() {  


5.         return "success";  


6.     }  


7.     @RequestMapping(value = "/attr", method = RequestMethod.POST)  


8.     public String setAttr(  


9.             @RequestParam("key") String key, @RequestParam("value") String value) {  


10.         SecurityUtils.getSubject().getSession().setAttribute(key, value);  


11.         return "success";  


12.     }  


13.     @RequestMapping(value = "/attr", method = RequestMethod.GET)  


14.     public String getAttr(  


15.             @RequestParam("key") String key, Model model) {  


16.         model.addAttribute("value",   


17.             SecurityUtils.getSubject().getSession().getAttribute(key));  


18.         return "success";  


19.     }  


20.     @RequestMapping("/role1")  


21.     @RequiresRoles("role1")  


22.     public String role1() {  


23.         return "success";  


24.     }  


25. }   

shiro-example-chapter23-app2的控制器类似，role2方法使用@RequiresRoles("role2")注解，即需要角色2。

其他配置请参考源码。 

测试

1、安装配置启动nginx

1. location ~ ^/(chapter23-server)/ {  


2.  proxy_pass http://127.0.0.1:8080;   


3.  index /;  


4.         proxy_set_header Host $host;  


5. }  


6. location ~ ^/(chapter23-app1)/ {  


7.  proxy_pass http://127.0.0.1:9080;   


8.  index /;  


9.         proxy_set_header Host $host;  


10. }  


11. location ~ ^/(chapter23-app2)/ {  


12.  proxy_pass http://127.0.0.1:10080;   


13.  index /;  


14.         proxy_set_header Host $host;  


15. }  

3、最后双击nginx.exe启动Nginx即可。

已经配置好的nginx请到shiro-example-chapter23-nginx模块下下周nginx-1.5.11.rar即可。

2、安装依赖

1、首先安装shiro-example-chapter23-core依赖，到shiro-example-chapter23-core模块下运行mvn install安装core模块。

2、接着到shiro-example-chapter23-client模块下运行mvn install安装客户端模块。

3、启动Server模块

到shiro-example-chapter23-server模块下运行mvn jetty:run启动该模块；使用http://localhost:8080/chapter23-server/即可访问，因为启动了nginx，那么可以直接访问http://localhost/chapter23-server/。

4、启动App*模块

到shiro-example-chapter23-app1和shiro-example-chapter23-app2模块下分别运行mvn jetty:run启动该模块；使用http://localhost:9080/chapter23-app1/和http://localhost:10080/chapter23-app2/即可访问，因为启动了nginx，那么可以直接访问http://localhost/chapter23-app1/和http://localhost/chapter23-app2/。

5、服务器端维护

1、访问http://localhost/chapter23-server/；

2、输入默认的用户名密码：admin/123456登录

3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。

4、授权管理，维护在哪个应用中用户的角色列表。这样客户端就可以根据应用KEY及用户名获取到对应的角色/权限字符串列表了。


  

6、App*模块身份认证及授权

1、在未登录情况下访问http://localhost/chapter23-app1/hello，看到下图：

 2、登录地址是http://localhost/chapter23-app1/login?backUrl=/chapter23-app1，即登录成功后重定向回http://localhost/chapter23-app1（这是个错误地址，为了测试登录成功后重定向地址），点击登录按钮后重定向到Server模块的登录界面： 

3、登录成功后，会重定向到相应的登录成功地址；接着访问http://localhost/chapter23-app1/hello，看到如下图：

4、可以看到admin登录，及其是否拥有role1/role2角色；可以在server模块移除role1角色或添加role2角色看看页面变化；

5、可以在http://localhost/chapter23-app1/hello页面设置属性，如key=123；接着访问http://localhost/chapter23-app2/attr?key=key就可以看到刚才设置的属性，如下图：

另外在app2，用户默认拥有role2角色，而没有role1角色。

到此整个测试就完成了，可以看出本示例实现了：会话的分布式及权限的集中管理。

本示例缺点

1、没有加缓存；

2、客户端每次获取会话/权限都需要通过客户端访问服务端；造成服务端单点和请求压力大；单点可以考虑使用集群来解决；请求压力大需要考虑配合缓存服务器（如Redis）来解决；即每次会话/权限获取时首先查询缓存中是否存在，如果有直接获取即可；否则再查服务端；降低请求压力；

3、会话的每次更新（比如设置属性/更新最后访问时间戳）都需要同步到服务端；也造成了请求压力过大；可以考虑在请求的最后只同步一次会话（需要对Shiro会话进行改造，通过如拦截器在执行完请求后完成同步，这样每次请求只同步一次）；

4、只能同域名才能使用，即会话ID是从同一个域名下获取，如果跨域请考虑使用CAS/OAuth2之实现。

所以实际应用时可能还是需要改造的，但大体思路是差不多的。

示例源代码：https://github.com/zhangkaitao/shiro-example；可加群 231889722 探讨Spring/Shiro技术。