spring boot整合Shiro实现单点登录的示例代码

Shiro是什么

Shiro是一个Java平台的开源权限框架，用于认证和访问授权。具体来说，满足对如下元素的支持：

用户，角色，权限（仅仅是操作权限，数据权限必须与业务需求紧密结合），资源（url）。
用户分配角色，角色定义权限。
访问授权时支持角色或者权限，并且支持多级的权限定义。

Q：对组的支持？
A：shiro默认不支持对组设置权限。

Q：是否可以满足对组进行角色分配的需求？
A：扩展Realm，可以支持对组进行分配角色，其实就是给该组下的所有用户分配权限。

Q：对数据权限的支持？在业务系统中定义？
A：shiro仅仅实现对操作权限的控制，用于在前端控制元素隐藏或者显示，以及对资源访问权限进行检查。数据权限与具体的业务需求紧密关联，shiro本身无法实现对数据权限的控制。

Q：动态权限分配？
A：扩展org.apache.shiro.realm.Realm，支持动态权限分配。

Q：与Spring集成？
A：可以支持与Spring集成，shiro还支持jsp标签。

前面的博客中，我们说道了Shiro的两个最大的特点，认证和授权，而单点登录也是属于认证的一部分，默认情况下，Shiro已经为我们实现了和Cas的集成，我们加入集成的一些配置就ok了。

1、加入shiro-cas包

 
     
      org.apache.shiro 
      shiro-cas 
      1.2.4

2、加入单点登录的配置

这里，我将所有的配置都贴出来，方便参考，配置里面已经加了详尽的说明。

package com.chhliu.springboot.shiro.config;  
import java.util.linkedHashMap; 
import java.util.Map; 
import javax.servlet.Filter; 
import org.apache.shiro.cache.ehcache.EhCacheManager; 
import org.apache.shiro.cas.CasFilter; 
import org.apache.shiro.cas.CasSubjectFactory; 
import org.apache.shiro.spring.LifecycleBeanPostProcessor; 
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor; 
import org.apache.shiro.spring.web.ShiroFilterFactoryBean; 
import org.apache.shiro.web.mgt.DefaultWebSecurityManager; 
import org.jasig.cas.client.session.SingleSignOutFilter; 
import org.jasig.cas.client.session.SingleSignOutHttpSessionListener; 
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator; 
import org.springframework.boot.web.servlet.FilterRegistrationBean; 
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.DependsOn; 
import org.springframework.core.Ordered; 
import org.springframework.core.annotation.Order; 
import org.springframework.web.filter.DelegatingFilterProxy; 
 
 
@Configuration 
public class ShiroConfiguration { 
   
  // cas server地址 
  public static final String casServerUrlPrefix = "http://127.0.0.1"; 
  // Cas登录页面地址 
  public static final String casLoginUrl = casServerUrlPrefix + "/login"; 
  // Cas登出页面地址 
  public static final String casLogoutUrl = casServerUrlPrefix + "/logout"; 
  // 当前工程对外提供的服务地址 
  public static final String shiroServerUrlPrefix = "http://127.0.1.28:8080"; 
  // casFilter UrlPattern 
  public static final String casFilterUrlPattern = "/index"; 
  // 登录地址 
  public static final String loginUrl = casLoginUrl + "?service=" + shiroServerUrlPrefix + casFilterUrlPattern; 
  // 登出地址（casserver启用service跳转功能，需在webappscasWEB-INFcas.properties文件中启用cas.logout.followServiceRedirects=true） 
  public static final String logoutUrl = casLogoutUrl+"?service="+loginUrl; 
  // 登录成功地址 
//  public static final String loginSuccessUrl = "/index"; 
  // 权限认证失败跳转地址 
  public static final String unauthorizedUrl = "/error/403.html"; 
   
   
  @Bean 
  public DefaultWebSecurityManager securityManager() { 
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); 
    securityManager.setRealm(myShiroCasRealm()); 
//    
    securityManager.setCacheManager(getEhCacheManager()); 
    // 指定 SubjectFactory,如果要实现cas的remember me的功能，需要用到下面这个CasSubjectFactory，并设置到securityManager的subjectFactory中 
    securityManager.setSubjectFactory(new CasSubjectFactory()); 
    return securityManager; 
  } 
 
   
  @Bean 
  public EhCacheManager getEhCacheManager() { 
    EhCacheManager em = new EhCacheManager(); 
    em.setCacheManagerConfigFile("classpath:config/ehcache-shiro.xml"); 
    return em; 
  } 
 
   
  @Bean 
  public MyShiroRealm myShiroCasRealm() { 
    MyShiroRealm realm = new MyShiroRealm(); 
    // cas登录服务器地址前缀 
    realm.setCasServerUrlPrefix(ShiroConfiguration.casServerUrlPrefix); 
    // 客户端回调地址，登录成功后的跳转地址(自己的服务地址) 
    realm.setCasService(ShiroConfiguration.shiroServerUrlPrefix + ShiroConfiguration.casFilterUrlPattern); 
    // 登录成功后的默认角色，此处默认为user角色 
    realm.setDefaultRoles("user"); 
    return realm; 
  } 
 
   
  @SuppressWarnings({ "rawtypes", "unchecked" }) 
  @Bean 
  @Order(Ordered.HIGHEST_PRECEDENCE)// 优先级需要高于Cas的Filter 
  public ServletListenerRegistrationBean singleSignOutHttpSessionListener(){ 
    ServletListenerRegistrationBean bean = new ServletListenerRegistrationBean(); 
    bean.setListener(new SingleSignOutHttpSessionListener()); 
    bean.setEnabled(true); 
    return bean; 
  } 
 
   
  @Bean 
  public FilterRegistrationBean singleSignOutFilter(){ 
    FilterRegistrationBean bean = new FilterRegistrationBean(); 
    bean.setName("singleSignOutFilter"); 
    bean.setFilter(new SingleSignOutFilter()); 
    bean.addUrlPatterns(" 
  @Bean 
  public FilterRegistrationBean delegatingFilterProxy() { 
    FilterRegistrationBean filterRegistration = new FilterRegistrationBean(); 
    filterRegistration.setFilter(new DelegatingFilterProxy("shiroFilter")); 
    // 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 
    filterRegistration.addInitParameter("targetFilterLifecycle", "true"); 
    filterRegistration.setEnabled(true); 
    filterRegistration.addUrlPatterns(" 
  @Bean(name = "lifecycleBeanPostProcessor") 
  public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() { 
    return new LifecycleBeanPostProcessor(); 
  } 
 
   
  @Bean 
  @DependsOn("lifecycleBeanPostProcessor") 
  public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() { 
    DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator(); 
    daap.setProxyTargetClass(true); 
    return daap; 
  } 
   
   
  @Bean 
  public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) { 
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor(); 
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager); 
    return authorizationAttributeSourceAdvisor; 
  } 
 
   
  @Bean(name = "casFilter") 
  public CasFilter getCasFilter() { 
    CasFilter casFilter = new CasFilter(); 
    casFilter.setName("casFilter"); 
    casFilter.setEnabled(true); 
    // 登录失败后跳转的URL，也就是 Shiro 执行 CasRealm 的 doGetAuthenticationInfo 方法向CasServer验证tiket 
    casFilter.setFailureUrl(loginUrl);// 我们选择认证失败后再打开登录页面 
    casFilter.setLoginUrl(loginUrl); 
    return casFilter; 
  } 
 
   
  @Bean(name = "shiroFilter") 
  public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager, CasFilter casFilter) { 
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean(); 
    // 必须设置 SecurityManager 
    shiroFilterFactoryBean.setSecurityManager(securityManager); 
    // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面 
    shiroFilterFactoryBean.setLoginUrl(loginUrl); 
     
//    shiroFilterFactoryBean.setSuccessUrl(loginSuccessUrl); 
     
    // 设置无权限访问页面 
    shiroFilterFactoryBean.setUnauthorizedUrl(unauthorizedUrl); 
     
    Map filters = new linkedHashMap<>(); 
    filters.put("casFilter", casFilter); 
     
    // logout已经被单点登录的logout取代 
    // filters.put("logout",logoutFilter()); 
    shiroFilterFactoryBean.setFilters(filters); 
 
    loadShiroFilterChain(shiroFilterFactoryBean); 
    return shiroFilterFactoryBean; 
  } 
 
   
  private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean){ 
    /////////////////////// 下面这些规则配置最好配置到配置文件中，注意，此处加入的filter需要保证有序，所以用的linkedHashMap /////////////////////// 
    Map filterChainDefinitionMap = new linkedHashMap();  
    filterChainDefinitionMap.put(casFilterUrlPattern, "casFilter");  
    //2.不拦截的请求 
    filterChainDefinitionMap.put("/css 
public class MyShiroRealm extends CasRealm { 
 
  @Resource 
  private UserInfoService userInfoService; 
 
   
  @Override 
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) { 
 
    // 调用父类中的认证方法，CasRealm已经为我们实现了单点认证。 
    AuthenticationInfo authc = super.doGetAuthenticationInfo(token); 
 
    // 获取登录的账号，cas认证成功后，会将账号存起来 
    String account = (String) authc.getPrincipals().getPrimaryPrincipal(); 
 
    // 将用户信息存入session中,方便程序获取,此处可以将根据登录账号查询出的用户信息放到session中 
    SecurityUtils.getSubject().getSession().setAttribute("no", account); 
 
    return authc; 
  } 
 
   
  @Override 
  protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { 
    System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()"); 
 
    SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); 
    // 获取单点登陆后的用户名，也可以从session中获取，因为在认证成功后，已经将用户名放到session中去了 
    String userName = (String) super.getAvailablePrincipal(principals); 
//principals.getPrimaryPrincipal(); 这种方式也可以获取用户名 
 
    // 根据用户名获取该用户的角色和权限信息 
    UserInfo userInfo = userInfoService.findByUsername(userName); 
 
    // 将用户对应的角色和权限信息打包放到AuthorizationInfo中 
    for (SysRole role : userInfo.getRoleList()) { 
      authorizationInfo.addRole(role.getRole()); 
      for (SysPermission p : role.getPermissions()) { 
 authorizationInfo.addStringPermission(p.getPermission()); 
      } 
    } 
 
    return authorizationInfo; 
  } 
}

下面，我们就可以进行验证测试了！

在浏览器输入http:127.0.1.28:8080/userInfo/userList 我们会发现，会自动跳转到单点的登录页面

然后我们输入用户名和密码，就会自动跳转到http:127.0.1.28:8080/userInfo/userList页面了。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持考高分网。

spring boot整合Shiro实现单点登录的示例代码

Java相关栏目本月热门文章