請大家在看本文之前，先了解如下知識點：
1、Shiro 是什麼？怎麼用？
2、Cas 是什麼？怎麼用？
3、最好有Spring基礎

首先看一下下面這張圖：
第一個流程是單純使用Shiro的流程。
第二個流程是單純使用Cas的流程。
第三個圖是Shiro整合Cas後的流程。

PS：流程圖急急忙忙畫的，整體上應該沒有什麼問題，具體細節問題還請大家留言指正。

如果你只是打算用到你的Spring Boot專案中，那麼看著如下配置完成便可。
如果你想進一步瞭解其中的細節，還是建議大家單獨配置Shiro、單獨配置Cas，看看官方相關文件。
Shiro在1.2版本開始提供了對cas的整合，按下面新增依賴到pom.xml中：

        <!--Apache Shiro所需的jar包 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-ehcache</artifactId>  
            <version>1.2.4</version>  
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-cas</artifactId>
            <version>1.2.4</version>
        </dependency>
 

shiro-cas 依賴 shiro-web，shiro-web 依賴 shiro-core，所以新增shiro-cas後shiro-web.jar和shiro-core.jar會自動被引用。
cas被shiro整合後，其原理就是shiro將casFilter加入到shiroFilter的filterChain中。

在SpringBoot工程中建立ShiroCasConfiguration.java

package org.springboot.sample.config;

import java.util.HashMap;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springboot.sample.dao.IScoreDao;
import org.springboot.sample.security.MyShiroCasRealm;
import org.springboot.sample.service.StudentService;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.boot.context.embedded.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.DelegatingFilterProxy;

/** * Shiro整合Cas配置 * * @author 單紅宇(365384722) * @myblog http://blog.csdn.net/catoop/ * @create 2016年1月17日 */
@Configuration
public class ShiroCasConfiguration {

    private static final Logger logger = LoggerFactory.getLogger(ShiroCasConfiguration.class);

    // CasServerUrlPrefix
    public static final String casServerUrlPrefix = "https://localhost:8443/cas";
    // Cas登入頁面地址
    public static final String casLoginUrl = casServerUrlPrefix + "/login";
    // Cas登出頁面地址
    public static final String casLogoutUrl = casServerUrlPrefix + "/logout";
    // 當前工程對外提供的服務地址
    public static final String shiroServerUrlPrefix = "http://localhost:9090/myspringboot";
    // casFilter UrlPattern
    public static final String casFilterUrlPattern = "/shiro-cas";
    // 登入地址
    public static final String loginUrl = casLoginUrl + "?service=" + shiroServerUrlPrefix + casFilterUrlPattern;

    public EhCacheManager getEhCacheManager() {  
        EhCacheManager em = new EhCacheManager();  
        em.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");  
        return em;  
    }  

    /** * 註冊DelegatingFilterProxy（Shiro） * * @param dispatcherServlet * @return * @author SHANHY * @create 2016年1月13日 */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new DelegatingFilterProxy("shiroFilter"));
        // 該值預設為false,表示生命週期由SpringApplicationContext管理,設定為true則表示由ServletContainer管理 
        filterRegistration.addInitParameter("targetFilterLifecycle", "true");
        filterRegistration.setEnabled(true);
        filterRegistration.addUrlPatterns("/*");
        return filterRegistration;
    }

    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator();
        daap.setProxyTargetClass(true);
        return daap;
    }

    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(MyShiroCasRealm myShiroCasRealm) {
        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
        dwsm.setRealm(myShiroCasRealm);
// <!-- 使用者授權/認證資訊Cache, 採用EhCache 快取 --> 
        dwsm.setCacheManager(getEhCacheManager());
        // 指定 SubjectFactory
        dwsm.setSubjectFactory(new CasSubjectFactory());
        return dwsm;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(securityManager);
        return aasa;
    }

    /** * 載入shiroFilter許可權控制規則（從資料庫讀取然後配置） * * @author SHANHY * @create 2016年1月14日 */
    private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean, StudentService stuService, IScoreDao scoreDao){
        /////////////////////// 下面這些規則配置最好配置到配置檔案中 ///////////////////////
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();

        filterChainDefinitionMap.put(casFilterUrlPattern, "casFilter");// shiro整合cas後，首先新增該規則

        // authc：該過濾器下的頁面必須驗證後才能訪問，它是Shiro內建的一個攔截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter
        filterChainDefinitionMap.put("/user", "authc");// 這裡為了測試，只限制/user，實際開發中請修改為具體攔截的請求規則
        // anon：它對應的過濾器裡面是空的,什麼都沒做
        logger.info("##################從資料庫讀取許可權規則，載入到shiroFilter中##################");
        filterChainDefinitionMap.put("/user/edit/**", "authc,perms[user:edit]");// 這裡為了測試，固定寫死的值，也可以從資料庫或其他配置中讀取

        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/**", "anon");//anon 可以理解為不攔截

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
    }

    /** * CAS過濾器 * * @return * @author SHANHY * @create 2016年1月17日 */
    @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);// 我們選擇認證失敗後再開啟登入頁面
        return casFilter;
    }

    /** * ShiroFilter<br/> * 注意這裡引數中的 StudentService 和 IScoreDao 只是一個例子，因為我們在這裡可以用這樣的方式獲取到相關訪問資料庫的物件， * 然後讀取資料庫相關配置，配置到 shiroFilterFactoryBean 的訪問規則中。實際專案中，請使用自己的Service來處理業務邏輯。 * * @param myShiroCasRealm * @param stuService * @param scoreDao * @return * @author SHANHY * @create 2016年1月14日 */
    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager, CasFilter casFilter, StudentService stuService, IScoreDao scoreDao) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 必須設定 SecurityManager 
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 如果不設定預設會自動尋找Web工程根目錄下的"/login.jsp"頁面
        shiroFilterFactoryBean.setLoginUrl(loginUrl);
        // 登入成功後要跳轉的連線
        shiroFilterFactoryBean.setSuccessUrl("/user");
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
        // 新增casFilter到shiroFilter中
        Map<String, Filter> filters = new HashMap<>();
        filters.put("casFilter", casFilter);
        shiroFilterFactoryBean.setFilters(filters);

        loadShiroFilterChain(shiroFilterFactoryBean, stuService, scoreDao);
        return shiroFilterFactoryBean;
    }

}
 

建立許可權認證的 MyShiroCasRealm.java

package org.springboot.sample.security;

import java.util.List;

import javax.annotation.PostConstruct;

import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.cas.CasRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springboot.sample.config.ShiroCasConfiguration;
import org.springboot.sample.dao.IUserDao;
import org.springboot.sample.entity.Role;
import org.springboot.sample.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("myShiroCasRealm")
@Transactional
public class MyShiroCasRealm extends CasRealm{

    private static final Logger logger = LoggerFactory.getLogger(MyShiroCasRealm.class);

    @Autowired
    private IUserDao userDao; 

    @PostConstruct
    public void initProperty(){
// setDefaultRoles("ROLE_USER");
        setCasServerUrlPrefix(ShiroCasConfiguration.casServerUrlPrefix);
        // 客戶端回撥地址
        setCasService(ShiroCasConfiguration.shiroServerUrlPrefix + ShiroCasConfiguration.casFilterUrlPattern);
    }

    /** * 許可權認證，為當前登入的Subject授予角色和許可權 * @see 經測試：本例中該方法的呼叫時機為需授權資源被訪問時 * @see 經測試：並且每次訪問需授權資源時都會執行該方法中的邏輯，這表明本例中預設並未啟用AuthorizationCache * @see 經測試：如果連續訪問同一個URL（比如重新整理），該方法不會被重複呼叫，Shiro有一個時間間隔（也就是cache時間，在ehcache-shiro.xml中配置），超過這個時間間隔再重新整理頁面，該方法會被執行 */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        logger.info("##################執行Shiro許可權認證##################");
        //獲取當前登入輸入的使用者名稱，等價於(String) principalCollection.fromRealm(getName()).iterator().next();
        String loginName = (String)super.getAvailablePrincipal(principalCollection); 
        //到資料庫查是否有此物件
        User user=userDao.findByName(loginName);// 實際專案中，這裡可以根據實際情況做快取，如果不做，Shiro自己也是有時間間隔機制，2分鐘內不會重複執行該方法
        if(user!=null){
            //許可權資訊物件info,用來存放查出的使用者的所有的角色（role）及許可權（permission）
            SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
            //使用者的角色集合
            info.setRoles(user.getRolesName());
            //使用者的角色對應的所有許可權，如果只使用角色定義訪問許可權，下面的四行可以不要
            List<Role> roleList=user.getRoleList();
            for (Role role : roleList) {
                info.addStringPermissions(role.getPermissionsName());
            }
            // 或者按下面這樣新增
            //新增一個角色,不是配置意義上的新增,而是證明該使用者擁有admin角色 
// simpleAuthorInfo.addRole("admin"); 
            //新增許可權 
// simpleAuthorInfo.addStringPermission("admin:manage"); 
// logger.info("已為使用者[mike]賦予了[admin]角色和[admin:manage]許可權");
            return info;
        }
        // 返回null的話，就會導致任何使用者訪問被攔截的請求時，都會自動跳轉到unauthorizedUrl指定的地址
        return null;
    }

}

在Controller中新增一個方法，用於將登入URL簡單化，提供一個重定向功能

    @RequestMapping(value="/login",method=RequestMethod.GET)
    public String loginForm(Model model){
        model.addAttribute("user", new User());
// return "login";
        return "redirect:" + ShiroCasConfiguration.loginUrl;
    }

本文主要是介紹如何在Spring Boot中整合Shiro+Cas，並非一個從零建立工程到整體完成的介紹。
上面貼出了2個主要的Java類，整個工程的其他所有程式碼沒有任何與Shiro和Cas耦合的地方。如果需要jsp頁面、Controller、實體類、連線資料庫測試資料等程式碼，可以先參考文章：http://blog.csdn.net/catoop/article/details/50520958（建議先看這篇文章再看本文）