Shiro学习（23）多项目集中权限管理

Love The Way You Lie 2022-07-26 06:04 171阅读 0赞

在做一些企业内部项目时或一些互联网后台时；可能会涉及到集中权限管理，统一进行多项目的权限管理；另外也需要统一的会话管理，即实现单点身份认证和授权控制。

学习本章之前，请务必先学习《第十章 会话管理》和《第十六章 综合实例》，本章代码都是基于这两章的代码基础上完成的。

本章示例是同域名的场景下完成的，如果跨域请参考《第十五章 单点登录》和《第十七章 OAuth2集成》了解使用CAS或OAuth2实现跨域的身份验证和授权。另外比如客户端/服务器端的安全校验可参考《第二十章 无状态Web应用集成》。

**部署架构**

1、有三个应用：用于用户/权限控制的Server（端口：8080）；两个应用App1（端口9080）和App2（端口10080）；  
2、使用Nginx反向代理这三个应用，nginx.conf的server配置部分如下：  
Java代码

server {  
        listen 80;  
        server_name  localhost;  
        charset utf-8;  
        location ~ ^/(chapter23-server)/ {  
            proxy_pass http://127.0.0.1:8080;   
            index /;  
                proxy_set_header Host $host;  
        }  
        location ~ ^/(chapter23-app1)/ {  
            proxy_pass http://127.0.0.1:9080;   
            index /;  
                proxy_set_header Host $host;  
        }  
        location ~ ^/(chapter23-app2)/ {  
            proxy_pass http://127.0.0.1:10080;   
            index /;  
                proxy_set_header Host $host;  
        }  
    }

如访问[http://localhost/chapter23-server][http_localhost_chapter23-server]会自动转发到[http://localhost:8080/chapter23-server][http_localhost_8080_chapter23-server]；  
访问[http://localhost/chapter23-app1][http_localhost_chapter23-app1]会自动转发到[http://localhost:9080/chapter23-app1][http_localhost_9080_chapter23-app1]；访问[http://localhost/chapter23-app3][http_localhost_chapter23-app3]会自动转发到[http://localhost:10080/chapter23-app3][http_localhost_10080_chapter23-app3]；

Nginx的安装及使用请自行搜索学习，本文不再阐述。

**项目架构**  
![这里写图片描述][20160408133654788]  
1、首先通过用户/权限Server维护用户、应用、权限信息；数据都持久化到MySQL数据库中；  
2、应用App1/应用App2使用客户端Client远程调用用户/权限Server获取会话及权限信息。

此处使用Mysql存储会话，而不是使用如Memcached/Redis之类的，主要目的是降低学习成本；如果换成如Redis也不会很难；如：

![这里写图片描述][20160408133710164]  
使用如Redis还一个好处就是无需在用户/权限Server中开会话过期调度器，可以借助Redis自身的过期策略来完成。

**模块关系依赖**

![这里写图片描述][20160408133739180]

![这里写图片描述][20160408133753649]  
1、shiro-example-chapter23-pom模块：提供了其他所有模块的依赖；这样其他模块直接继承它即可，简化依赖配置，如shiro-example-chapter23-server：  
Java代码

<parent>  
        <artifactId>shiro-example-chapter23-pom</artifactId>  
        <groupId>com.github.zhangkaitao</groupId>  
        <version>1.0-SNAPSHOT</version>  
    </parent>

2、shiro-example-chapter23-core模块：提供给shiro-example-chapter23-server、shiro-example-chapter23-client、shiro-example-chapter23-app\*模块的核心依赖，比如远程调用接口等；

3、shiro-example-chapter23-server模块：提供了用户、应用、权限管理功能；

4、shiro-example-chapter23-client模块：提供给应用模块获取会话及应用对应的权限信息；

5、shiro-example-chapter23-app\*模块：各个子应用，如一些内部管理系统应用；其登录都跳到shiro-example-chapter23-server登录；另外权限都从shiro-example-chapter23-server获取（如通过远程调用）。

**shiro-example-chapter23-pom模块**

其pom.xml的packaging类型为pom，并且在该pom中加入其他模块需要的依赖，然后其他模块只需要把该模块设置为parent即可自动继承这些依赖，如shiro-example-chapter23-server模块：  
Java代码

<parent>  
        <artifactId>shiro-example-chapter23-pom</artifactId>  
        <groupId>com.github.zhangkaitao</groupId>  
        <version>1.0-SNAPSHOT</version>  
    </parent>

简化其他模块的依赖配置等。

**shiro-example-chapter23-core模块**

提供了其他模块共有的依赖，如远程调用接口：  
Java代码

public interface RemoteServiceInterface {  
        public Session getSession(String appKey, Serializable sessionId);  
        Serializable createSession(Session session);  
        public void updateSession(String appKey, Session session);  
        public void deleteSession(String appKey, Session session);  
        public PermissionContext getPermissions(String appKey, String username);  
    }

提供了会话的CRUD，及根据应用key和用户名获取权限上下文（包括角色和权限字符串）；shiro-example-chapter23-server模块服务端实现；shiro-example-chapter23-client模块客户端调用。

另外提供了com.github.zhangkaitao.shiro.chapter23.core.ClientSavedRequest，其扩展了org.apache.shiro.web.util.SavedRequest；用于shiro-example-chapter23-app\*模块当访问一些需要登录的请求时，自动把请求保存下来，然后重定向到shiro-example-chapter23-server模块登录；登录成功后再重定向回来；因为SavedRequest不保存URL中的schema://domain:port部分；所以才需要扩展SavedRequest；使得ClientSavedRequest能保存schema://domain:port；这样才能从一个应用重定向另一个（要不然只能在一个应用内重定向）：  
Java代码

public String getRequestUrl() {  
            String requestURI = getRequestURI();  
            if(backUrl != null) {
       //1 
                if(backUrl.toLowerCase().startsWith("http://") || backUrl.toLowerCase().startsWith("https://")) {  
                    return backUrl;  
                } else if(!backUrl.startsWith(contextPath)) {
       //2 
                    requestURI = contextPath + backUrl;  
                } else {
       //3 
                    requestURI = backUrl;  
                }  
            }  
            StringBuilder requestUrl = new StringBuilder(scheme);//4 
            requestUrl.append("://");  
            requestUrl.append(domain);//5 
            //6 
            if("http".equalsIgnoreCase(scheme) && port != 80) {  
                requestUrl.append(":").append(String.valueOf(port));  
            } else if("https".equalsIgnoreCase(scheme) && port != 443) {  
                requestUrl.append(":").append(String.valueOf(port));  
            }  
            //7 
            requestUrl.append(requestURI);  
            //8 
            if (backUrl == null && getQueryString() != null) {  
                requestUrl.append("?").append(getQueryString());  
            }  
            return requestUrl.toString();  
        }

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模块**  
简单的实体关系图

![这里写图片描述][20160408133910353]  
简单数据字典  
用户(sys\_user)  
![这里写图片描述][20160408133944010]  
应用(sys\_app)  
![这里写图片描述][20160408134000337]  
授权(sys\_authorization)  
![这里写图片描述][20160408134007495]

**用户**：比《第十六章 综合实例》少了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之外的关键接口：  
Java代码

public interface AppService {  
        public Long findAppIdByAppKey(String appKey);// 根据appKey查找AppId 
    }

Java代码

public interface AuthorizationService {  
        //根据AppKey和用户名查找其角色 
        public Set<String> findRoles(String appKey, String username);  
        //根据AppKey和用户名查找权限字符串 
        public Set<String> findPermissions(String appKey, String username);  
    }

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

**UserRealm**  
Java代码

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
        String username = (String)principals.getPrimaryPrincipal(); 
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); 
        authorizationInfo.setRoles(  
            authorizationService.findRoles(Constants.SERVER_APP_KEY, username)); 
        authorizationInfo.setStringPermissions(  
        authorizationService.findPermissions(Constants.SERVER_APP_KEY, username)); 
        return authorizationInfo; 
    }

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

**ServerFormAuthenticationFilter**  
Java代码

public class ServerFormAuthenticationFilter extends FormAuthenticationFilter {   
        protected void issueSuccessRedirect(ServletRequest request, ServletResponse response) throws Exception {  
            String fallbackUrl = (String) getSubject(request, response)  
                    .getSession().getAttribute("authc.fallbackUrl");  
            if(StringUtils.isEmpty(fallbackUrl)) {  
                fallbackUrl = getSuccessUrl();  
            }  
            WebUtils.redirectToSavedRequest(request, response, fallbackUrl);  
        }  
    }

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

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

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

**RemoteService**  
Java代码

public class RemoteService implements RemoteServiceInterface {   
        @Autowired  private AuthorizationService authorizationService;  
        @Autowired  private SessionDAO sessionDAO;  
    
        public Session getSession(String appKey, Serializable sessionId) {  
            return sessionDAO.readSession(sessionId);  
        }  
        public Serializable createSession(Session session) {  
            return sessionDAO.create(session);  
        }  
        public void updateSession(String appKey, Session session) {  
            sessionDAO.update(session);  
        }  
        public void deleteSession(String appKey, Session session) {  
            sessionDAO.delete(session);  
        }  
        public PermissionContext getPermissions(String appKey, String username) {  
            PermissionContext permissionContext = new PermissionContext();  
            permissionContext.setRoles(authorizationService.findRoles(appKey, username));  
            permissionContext.setPermissions(authorizationService.findPermissions(appKey, username));  
            return permissionContext;  
        }  
    }

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

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

**Shiro配置文件spring-config-shiro.xml**  
和《第十六章 综合实例》配置类似，但是需要在shiroFilter中的filterChainDefinitions中添加如下配置，即远程调用不需要身份认证：  
Java代码

/remoteService = anon

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

**服务器端数据维护**  
1、首先开启ngnix反向代理；然后就可以直接访问[http://localhost/chapter23-server/][http_localhost_chapter23-server 1]；  
2、输入默认的用户名密码：admin/123456登录  
3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。  
![这里写图片描述][20160408134512449]

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

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

**配置远程服务spring-client-remote-service.xml**  
Java代码

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

**ClientRealm**  
Java代码

public class ClientRealm extends AuthorizingRealm {   
        private RemoteServiceInterface remoteService;  
        private String appKey;  
        public void setRemoteService(RemoteServiceInterface remoteService) {  
            this.remoteService = remoteService;  
        }  
        public void setAppKey(String appKey) {  
            this.appKey = appKey;  
        }  
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
            String username = (String) principals.getPrimaryPrincipal();  
            SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
            PermissionContext context = remoteService.getPermissions(appKey, username);  
            authorizationInfo.setRoles(context.getRoles());  
            authorizationInfo.setStringPermissions(context.getPermissions());  
            return authorizationInfo;  
        }  
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
            //永远不会被调用 
            throw new UnsupportedOperationException("永远不会被调用");  
        }  
    }

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

**ClientSessionDAO**  
Java代码

public class ClientSessionDAO extends CachingSessionDAO {   
        private RemoteServiceInterface remoteService;  
        private String appKey;  
        public void setRemoteService(RemoteServiceInterface remoteService) {  
            this.remoteService = remoteService;  
        }  
        public void setAppKey(String appKey) {  
            this.appKey = appKey;  
        }  
        protected void doDelete(Session session) {  
            remoteService.deleteSession(appKey, session);  
        }  
        protected void doUpdate(Session session) {  
            remoteService.updateSession(appKey, session);  
    }  
    protected Serializable doCreate(Session session) {  
            Serializable sessionId = remoteService.createSession(session);  
            assignSessionId(session, sessionId);  
            return sessionId;  
        }  
        protected Session doReadSession(Serializable sessionId) {  
            return remoteService.getSession(appKey, sessionId);  
        }  
    }

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

**ClientAuthenticationFilter**  
Java代码

public class ClientAuthenticationFilter extends AuthenticationFilter {   
        protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {  
            Subject subject = getSubject(request, response);  
            return subject.isAuthenticated();  
        }  
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
            String backUrl = request.getParameter("backUrl");  
            saveRequest(request, backUrl, getDefaultBackUrl(WebUtils.toHttp(request)));  
            return false;  
        }  
        protected void saveRequest(ServletRequest request, String backUrl, String fallbackUrl) {  
            Subject subject = SecurityUtils.getSubject();  
            Session session = subject.getSession();  
            HttpServletRequest httpRequest = WebUtils.toHttp(request);  
            session.setAttribute("authc.fallbackUrl", fallbackUrl);  
            SavedRequest savedRequest = new ClientSavedRequest(httpRequest, backUrl);  
            session.setAttribute(WebUtils.SAVED_REQUEST_KEY, savedRequest);  
    }  
        private String getDefaultBackUrl(HttpServletRequest request) {  
            String scheme = request.getScheme();  
            String domain = request.getServerName();  
            int port = request.getServerPort();  
            String contextPath = request.getContextPath();  
            StringBuilder backUrl = new StringBuilder(scheme);  
            backUrl.append("://");  
            backUrl.append(domain);  
            if("http".equalsIgnoreCase(scheme) && port != 80) {  
                backUrl.append(":").append(String.valueOf(port));  
            } else if("https".equalsIgnoreCase(scheme) && port != 443) {  
                backUrl.append(":").append(String.valueOf(port));  
            }  
            backUrl.append(contextPath);  
            backUrl.append(getSuccessUrl());  
            return backUrl.toString();  
        }  
    }

ClientAuthenticationFilter是用于实现身份认证的拦截器（authc），当用户没有身份认证时；  
1、首先得到请求参数backUrl，即登录成功重定向到的地址；  
2、然后保存保存请求到会话，并重定向到登录地址（server模块）；  
3、登录成功后，返回地址按照如下顺序获取：backUrl、保存的当前请求地址、defaultBackUrl（即设置的successUrl）；

**ClientShiroFilterFactoryBean**  
Java代码

public class ClientShiroFilterFactoryBean extends ShiroFilterFactoryBean implements ApplicationContextAware {   
        private ApplicationContext applicationContext;  
        public void setApplicationContext(ApplicationContext applicationContext) {  
            this.applicationContext = applicationContext;  
        }  
        public void setFiltersStr(String filters) {  
            if(StringUtils.isEmpty(filters)) {  
                return;  
            }  
            String[] filterArray = filters.split(";");  
            for(String filter : filterArray) {  
                String[] o = filter.split("=");  
                getFilters().put(o[0], (Filter)applicationContext.getBean(o[1]));  
            }  
        }  
        public void setFilterChainDefinitionsStr(String filterChainDefinitions) {  
            if(StringUtils.isEmpty(filterChainDefinitions)) {  
                return;  
            }  
            String[] chainDefinitionsArray = filterChainDefinitions.split(";");  
            for(String filter : chainDefinitionsArray) {  
                String[] o = filter.split("=");  
                getFilterChainDefinitionMap().put(o[0], o[1]);  
            }  
        }  
    }

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的配置，简化了整个配置过程。  
Java代码

<context:property-placeholder location=   
        "classpath:client/shiro-client-default.properties,classpath:client/shiro-client.properties"/>

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

Java代码

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

Java代码

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

Java代码

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

Java代码

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

Java代码

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

Java代码

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

**默认配置client/ shiro-client-default.properties**  
Java代码

#各应用的appKey 
    client.app.key=  
    #远程服务URL地址 
    client.remote.service.url=http://localhost/chapter23-server/remoteService  
    #登录地址 
    client.login.url=http://localhost/chapter23-server/login  
    #登录成功后，默认重定向到的地址 
    client.success.url=/  
    #未授权重定向到的地址 
    client.unauthorized.url=http://localhost/chapter23-server/unauthorized  
    #session id 域名 
    client.cookie.domain=  
    #session id 路径 
    client.cookie.path=/  
    #cookie中的session id名称 
    client.session.id=sid  
    #cookie中的remember me名称 
    client.rememberMe.id=rememberMe  
    #过滤器 name=filter-ref;name=filter-ref 
    client.filters=  
    #过滤器链 格式 url=filters;url=filters 
    client.filter.chain.definitions=/**=anon

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

**shiro-example-chapter23-app\*模块**  
**继承shiro-example-chapter23-pom模块**  
Java代码

<parent>  
        <artifactId>shiro-example-chapter23-pom</artifactId>  
        <groupId>com.github.zhangkaitao</groupId>  
        <version>1.0-SNAPSHOT</version>  
    </parent>

**依赖shiro-example-chapter23-client模块**

<dependency>    <groupId>com.github.zhangkaitao</groupId>    <artifactId>shiro-example-chapter23-client</artifactId>    <version>1.0-SNAPSHOT</version></dependency>

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

**配置shiro-example-chapter23-app1**  
Java代码

client.app.key=645ba612-370a-43a8-a8e0-993e7a590cf0  
    client.success.url=/hello  
    client.filter.chain.definitions=/hello=anon;/login=authc;/**=authc

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

**配置shiro-example-chapter23-app2**  
Java代码

client.app.key=645ba613-370a-43a8-a8e0-993e7a590cf0  
    client.success.url=/hello  
    client.filter.chain.definitions=/hello=anon;/login=authc;/**=authc

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

**web.xml**  
Java代码

<context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>  
            classpath:client/spring-client.xml  
        </param-value>  
    </context-param>  
    <listener>  
        <listener-class>  
            org.springframework.web.context.ContextLoaderListener  
        </listener-class>  
    </listener>

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

Java代码

<filter>  
        <filter-name>shiroFilter</filter-name>  
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
        <init-param>  
            <param-name>targetFilterLifecycle</param-name>  
            <param-value>true</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>shiroFilter</filter-name>  
        <url-pattern>/*</url-pattern> </filter-mapping>

配置ShiroFilter拦截器。

**控制器**  
shiro-example-chapter23-app1  
Java代码

@Controller  
    public class HelloController {  
        @RequestMapping("/hello")  
        public String hello() {  
            return "success";  
        }  
        @RequestMapping(value = "/attr", method = RequestMethod.POST)  
        public String setAttr(  
                @RequestParam("key") String key, @RequestParam("value") String value) {  
            SecurityUtils.getSubject().getSession().setAttribute(key, value);  
            return "success";  
        }  
        @RequestMapping(value = "/attr", method = RequestMethod.GET)  
        public String getAttr(  
                @RequestParam("key") String key, Model model) {  
            model.addAttribute("value",   
                SecurityUtils.getSubject().getSession().getAttribute(key));  
            return "success";  
        }  
        @RequestMapping("/role1")  
        @RequiresRoles("role1")  
        public String role1() {  
            return "success";  
        }  
    }

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

其他配置请参考源码。

**测试**  
**1、安装配置启动nginx**  
1、首先到[http://nginx.org/en/download.html][http_nginx.org_en_download.html]下载，比如我下载的是windows版本的；

2、然后编辑conf/nginx.conf配置文件，在server部分添加如下部分：  
Java代码

location ~ ^/(chapter23-server)/ {  
     proxy_pass http://127.0.0.1:8080;   
     index /;  
            proxy_set_header Host $host;  
    }  
    location ~ ^/(chapter23-app1)/ {  
     proxy_pass http://127.0.0.1:9080;   
     index /;  
            proxy_set_header Host $host;  
    }  
    location ~ ^/(chapter23-app2)/ {  
     proxy_pass http://127.0.0.1:10080;   
     index /;  
            proxy_set_header Host $host;  
    }

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/][http_localhost_8080_chapter23-server 1]即可访问，因为启动了nginx，那么可以直接访问[http://localhost/chapter23-server/][http_localhost_chapter23-server 1]。

**4、启动App\*模块**  
到shiro-example-chapter23-app1和shiro-example-chapter23-app2模块下分别运行mvn jetty:run启动该模块；使用[http://localhost:9080/chapter23-app1/][http_localhost_9080_chapter23-app1 1]和[http://localhost:10080/chapter23-app2/][http_localhost_10080_chapter23-app2]即可访问，因为启动了nginx，那么可以直接访问[http://localhost/chapter23-app1/][http_localhost_chapter23-app1 1]和[http://localhost/chapter23-app2/][http_localhost_chapter23-app2]。  
**5、服务器端维护**  
1、访问[http://localhost/chapter23-server/][http_localhost_chapter23-server 1]；  
2、输入默认的用户名密码：admin/123456登录

3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。  
![这里写图片描述][20160408135207715]  
4、授权管理，维护在哪个应用中用户的角色列表。这样客户端就可以根据应用KEY及用户名获取到对应的角色/权限字符串列表了。  
![这里写图片描述][20160408135223811]

![这里写图片描述][20160408135255310]  
6、App\*模块身份认证及授权  
1、在未登录情况下访问[http://localhost/chapter23-app1/hello][http_localhost_chapter23-app1_hello]，看到下图：  
![这里写图片描述][20160408135317889]  
2、登录地址是[http://localhost/chapter23-app1/login?backUrl=/chapter23-app1][http_localhost_chapter23-app1_login_backUrl_chapter23-app1]，即登录成功后重定向回[http://localhost/chapter23-app1][http_localhost_chapter23-app1]（这是个错误地址，为了测试登录成功后重定向地址），点击登录按钮后重定向到Server模块的登录界面：  
![这里写图片描述][20160408135419453]  
3、登录成功后，会重定向到相应的登录成功地址；接着访问[http://localhost/chapter23-app1/hello][http_localhost_chapter23-app1_hello]，看到如下图：  
![这里写图片描述][20160408135431937]  
4、可以看到admin登录，及其是否拥有role1/role2角色；可以在server模块移除role1角色或添加role2角色看看页面变化；

5、可以在[http://localhost/chapter23-app1/hello][http_localhost_chapter23-app1_hello]页面设置属性，如key=123；接着访问[http://localhost/chapter23-app2/attr?key=key][http_localhost_chapter23-app2_attr_key_key]就可以看到刚才设置的属性，如下图：  
![这里写图片描述][20160408135456750]  
另外在app2，用户默认拥有role2角色，而没有role1角色。

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

本示例缺点  
1、没有加缓存；  
2、客户端每次获取会话/权限都需要通过客户端访问服务端；造成服务端单点和请求压力大；单点可以考虑使用集群来解决；请求压力大需要考虑配合缓存服务器（如Redis）来解决；即每次会话/权限获取时首先查询缓存中是否存在，如果有直接获取即可；否则再查服务端；降低请求压力；  
3、会话的每次更新（比如设置属性/更新最后访问时间戳）都需要同步到服务端；也造成了请求压力过大；可以考虑在请求的最后只同步一次会话（需要对Shiro会话进行改造，通过如拦截器在执行完请求后完成同步，这样每次请求只同步一次）；  
4、只能同域名才能使用，即会话ID是从同一个域名下获取，如果跨域请考虑使用CAS/OAuth2之实现。

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

示例源代码：[https://github.com/zhangkaitao/shiro-example][https_github.com_zhangkaitao_shiro-example]

[http_localhost_chapter23-server]: http://localhost/chapter23-server
[http_localhost_8080_chapter23-server]: http://localhost:8080/chapter23-server
[http_localhost_chapter23-app1]: http://localhost/chapter23-app1
[http_localhost_9080_chapter23-app1]: http://localhost:9080/chapter23-app1
[http_localhost_chapter23-app3]: http://localhost/chapter23-app3
[http_localhost_10080_chapter23-app3]: http://localhost:10080/chapter23-app3
[20160408133654788]: /images/20220724/99b21b278e174af081e68c594532710b.png
[20160408133710164]: /images/20220724/0e74f35668fd48d7be5e1359dfca6cb7.png
[20160408133739180]: /images/20220724/02ecd3d1056449208ff1560a2cd5e119.png
[20160408133753649]: /images/20220724/4c2dd53a520441c0b8ccab23a88fc841.png
[20160408133910353]: /images/20220724/4bd0d2f041c448eba3b3cd332548039b.png
[20160408133944010]: /images/20220724/0e31046a1ae14ad18af48c953394cf0a.png
[20160408134000337]: /images/20220724/26234032097f4cbd9f47521a1c72feb7.png
[20160408134007495]: /images/20220724/16811e9600d64126885e7c4f2d72a4e6.png
[http_localhost_chapter23-server 1]: http://localhost/chapter23-server/
[20160408134512449]: /images/20220724/fcd6a0985750406ebaa8ac9c6028eb7c.png
[20160408134519667]: /images/20220724/418b56272ec149f5a90a6f9366495218.png
[20160408134530581]: /images/20220724/5fc14536852d4b688188043d7b4a54df.png
[http_nginx.org_en_download.html]: http://nginx.org/en/download.html
[http_localhost_8080_chapter23-server 1]: http://localhost:8080/chapter23-server/
[http_localhost_9080_chapter23-app1 1]: http://localhost:9080/chapter23-app1/
[http_localhost_10080_chapter23-app2]: http://localhost:10080/chapter23-app2/
[http_localhost_chapter23-app1 1]: http://localhost/chapter23-app1/
[http_localhost_chapter23-app2]: http://localhost/chapter23-app2/
[20160408135207715]: /images/20220724/ecfca4dfcb5e4a2fb58cff5beb7e1ffd.png
[20160408135223811]: /images/20220724/d6d2668268e04291a1f94718babb142b.png
[20160408135255310]: /images/20220724/6a137768310a499fb6fdf42fd1e122bb.png
[http_localhost_chapter23-app1_hello]: http://localhost/chapter23-app1/hello
[20160408135317889]: /images/20220724/ee363df207124a12853ed166ab39eb5c.png
[http_localhost_chapter23-app1_login_backUrl_chapter23-app1]: http://localhost/chapter23-app1/login?backUrl=/chapter23-app1
[20160408135419453]: /images/20220724/47a2b828fb404f91b005a04a77733e70.png
[20160408135431937]: /images/20220724/316d4fab1d5f4fc8b348bbb87a5a446b.png
[http_localhost_chapter23-app2_attr_key_key]: http://localhost/chapter23-app2/attr?key=key
[20160408135456750]: /images/20220724/3e603081c83c46f595f1177fa1913f33.png
[https_github.com_zhangkaitao_shiro-example]: https://github.com/zhangkaitao/shiro-example