spring boot + mybatis + shiro + cas 单点登录

小鱼儿 2022-05-04 14:26 434阅读 0赞

该项目是在[shiro(三)][shiro]的基础上进行修改的，建议首先将shiro的部分了解一下。

CAS的知识点：

单点登录：简称SSO，SSO使得在多个应用系统中，用户只需要登录一次就可以访问所有互相信任的应用系统

CAS框架：CAS是实现单点登录的框架。

结构：cas分为两个部分，CAS SERVER 和 CAS Client 需要独立部署，主要负责对用户的认证工作，Cas Client 负责对客户端保护资源的请求，需要登录的时候，重定向到CAS Server

盗用一张图：（深深的吸引了我）

![70][]

执行流程：

1：Web Browser去访问CAS Client 的时候，cas客户端会向Web Browser索要session和令牌，如果没有则执行第二步

2：当发现令牌和session的时候，会重定向到cas服务端（重点），在重定向的时候，地址需要按照一定的格式：

原因：service前面的地址是认证中心的地址+"/login"，后面的是认证完成之后，需要跳会的地址，在调回的地址中需要设置

successUrl 和 failureUrl，登录成功和失败的路径。

登出：认证中心的地址加"/logout"+"service="+shiro的地址（你本地项目的地址）

3：如果认证中心发现当前还没有登录，此时会跳转到登录页面，进行登录

4：登录成功之后，认证中心会生成一个Ticket  ,就是唯一的票据

格式：[http://a:8080/?ticket=ST-XXXX-XXX][http_a_8080_ticket_ST-XXXX-XXX]

5：然后客户端会再去向服务器端去认证票据，

6：认证成功之后返回用户信息，认证完成之后，会建立一个全局的session

登出的流程：

1)、客户端向客户端发送登出Logout请求。   
2)、客户端取消本地会话，同时通知认证中心，用户已登出。   
3)、客户端返回客户端登出请求。   
4)、认证中心通知所有用户登录访问的应用，用户已登出。

引用一张图：图片地址，[https://blog.csdn.net/javaloveiphone/article/details/52439613?utm\_source=blogxgwz0][https_blog.csdn.net_javaloveiphone_article_details_52439613_utm_source_blogxgwz0]

![70 1][]

写的小的案例：

shiro在1.2版本的时候就整合了cas，在使用cas的时候，就是将CasFilter添加到shiro的Filter中

**一些常用常量**

//    logger
        private static final Logger logger = LoggerFactory.getLogger(MyShiroCasConfig.class);
    
        //    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 cas 拦截的地址
         public static final String casFilterUrlPattern = "/shiro-cas";
        //    登录的地址
        public static final String loginUrl = casLoginUrl + "?service=" + shiroServerUrlPrefix + casFilterUrlPattern;
        //    退出的地址
        public static final String logoutUrl = casLogoutUrl + "?service=" + casLogoutUrl;
        //    登录成功的地址
        public static final String loginSuccessUrl = "/index";
        //    失败的地址
        public static final String unauthorizedUrl = "/403";

**设置 SecurityManager --- shiro的核心处理器**

@Bean
        public SecurityManager securityManager() {
            DefaultWebSecurityManager defaultWebSecurityManager =
                    new DefaultWebSecurityManager();
    //        才采用缓存
            defaultWebSecurityManager.setCacheManager(getEhCacheManager());
    //        指定shiro
            defaultWebSecurityManager.setRealm(myShiroCasRealm());
    //        指定subjectFactory，如果实现的cas的remember me（免登录） 的功能，
            defaultWebSecurityManager.setSubjectFactory(new CasSubjectFactory());
            return defaultWebSecurityManager;
        }

该类是shiro 的核心处理类，将Realm和用户的数据进行数据的比较，new CasSubjectFactory()的作用是如果要使用面登录的功能，需要添加该类。

**设置Ehcache缓存的Bean**

/**
         * 【配置的ehcache进行数据的缓存
         *
         * @return
         */
        @Bean
        public EhCacheManager getEhCacheManager() {
            EhCacheManager ehCacheManager = new EhCacheManager();
            ehCacheManager.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");
            return ehCacheManager;
        }

Ehcache的配置

**设置自定义的CasRealm的类**

@Bean
        public MyShiroCasRealm myShiroCasRealm() {
            MyShiroCasRealm myShiroCasRealm = new MyShiroCasRealm();
    //        设置cas登录服务器地址的前缀
            myShiroCasRealm.setCasServerUrlPrefix(MyShiroCasConfig.casServerUrlPrefix);
    //        客户端回调地址，登录成功后的跳转的地址（自己的服务器）
            myShiroCasRealm.setCasService(MyShiroCasConfig.shiroServerUrlPrefix + MyShiroCasConfig.casFilterUrlPattern);
            return myShiroCasRealm;
        }

setCasServerUrlPrefix：表示的你访问的认证中心的地址 ，setCasService：表示当你认真中心认证完成之后需要访问的service地址

MyShiroCasRealm的类

package com.sgqing.demo.config;
    
    import com.sgqing.demo.entity.SysPermission;
    import com.sgqing.demo.entity.SysRole;
    import com.sgqing.demo.entity.UserInfo;
    import com.sgqing.demo.sevice.UserInfoService;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.AuthenticationInfo;
    import org.apache.shiro.authc.AuthenticationToken;
    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.springframework.beans.factory.annotation.Autowired;
    
    /**
     * shiro集成cas之后，进行的配置
     */
    public class MyShiroCasRealm extends CasRealm {
        @Autowired
        private UserInfoService userInfoService;
        private static final Logger logger = LoggerFactory.getLogger(MyShiroCasRealm.class);
    
        /**
         * 用于授权
         *
         * @param principalCollection
         * @return
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            System.out.println("进行授权 -------->");
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            String name = (String) super.getAvailablePrincipal(principalCollection);
            UserInfo byUsername = userInfoService.findByUsername(name);
    
            for (SysRole role : byUsername.getRoleList()) {
                info.addRole(role.getRole());
                for (SysPermission permission : role.getPermissions()) {
                    info.addStringPermission(permission.getPermission());
                }
            }
            return info;
        }
    
        /**
         * 用于认证
         *
         * @param authenticationToken
         * @return
         * @throws AuthenticationException
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    //        调用父类的认证，父类认证已经完成了
            AuthenticationInfo authenticationInfo = super.doGetAuthenticationInfo(authenticationToken);
            String name = (String) authenticationInfo.getPrincipals().getPrimaryPrincipal();
            SecurityUtils.getSubject().getSession().setAttribute("no", name);
    
            return authenticationInfo;
        }
    }

上面的类作用：直接继承CasRealm类，然后CasRealm已经完成了数据的认证工作，我们直接调用父类的功能即可

**设置单点退出的监听器**

// 设置单点登出的监听器
        /*
         *SingleSignOutFilter需要配置在所有Filter之前，当Cas Client通过Cas Server登录成功，
         * Cas Server会携带生成的Service Ticket回调Cas Client，
         * 此时SingleSignOutFilter会将Service Ticket与当前的Session绑定在一起。
         * 当Cas Server在进行logout后回调Cas Client应用时也会携带该Service Ticket，
         * 此时Cas Client配置的SingleSignOutFilter将会使对应的Session失效，进而达到登出的目的。
         * 
         *  SingleSignOutHttpSessionListener用于在Cas Client应用中的Session过期时将其从对应的映射关系中移除。
         * */
        @Bean
        @Order(Ordered.HIGHEST_PRECEDENCE)
        public ServletListenerRegistrationBean servletListenerRegistrationBean() {
            ServletListenerRegistrationBean bean = new ServletListenerRegistrationBean();
            bean.setListener(new SingleSignOutHttpSessionListener());
            bean.setEnabled(true);
            return bean;
        }

作用是将所有的过期的session将其从对应的映射关系中移除

**设置单点退出的拦截器**

//    设置单点登出的拦截器
    
    //    FilterRegistrationBean 表示的是设置拦截器的优先级
    
        /*SingleSignOutFilter需要配置在所有Filter之前，当Cas Client通过Cas Server登录成功，
         * Cas Server会携带生成的Service Ticket回调Cas Client，
         * 此时SingleSignOutFilter会将Service Ticket与当前的Session绑定在一起。
         * 当Cas Server在进行logout后回调Cas Client应用时也会携带该Service Ticket，
         * 此时Cas Client配置的SingleSignOutFilter将会使对应的Session失效，进而达到登出的目的。
         * */
        @Bean
        public FilterRegistrationBean registrationBean() {
            FilterRegistrationBean registrationBean = new FilterRegistrationBean();
            registrationBean.setName("registrationBean");
            registrationBean.setFilter(new SingleSignOutFilter());
            registrationBean.addUrlPatterns("/*");//拦截所有的请求
            registrationBean.setEnabled(true);
            registrationBean.setOrder(10);//设置优先级
            return registrationBean;
        }

上面的作用是说，在登录的时候，客户端会去服务端进行认证，此时认证成功之后，服务端会将地址和ST返回给客户端，而在此时该拦截器会将session跟ST绑定在一起，如果访问退出的时候，此时服务端也会将服务地址和ST返回，此时的监听器会将所有的session全部变为失效。

**设置配置的触发的地方；**

//    注册DelegatingFilterProxy(shiro)    是一个代理类，用于管理拦截器的生命周期，  所有的请求都会拦截 ,在创建的时候，filter的执行会优先于bean的执行，所以需要使用该类先来管理bean
        /*
         *   先在filter中加入DelegatingFilterProxy类，"targetFilterLifecycle"指明作用于filter的所有生命周期。
         *   原理是，DelegatingFilterProxy类是一个代理类，所有的请求都会首先发到这个filter代理，然后再按照"filter-name"委派到spring中的这个bean。
         *   在Spring中配置的bean的name要和web.xml中的<filter-name>一样.
            此外，spring bean实现了Filter接口，但默认情况下，是由spring容器来管理其生命周期的(不是由tomcat这种服务器容器来管理)。
            如果设置"targetFilterLifecycle"为True，则spring来管理Filter.init()和Filter.destroy()；若为false，则这两个方法失效！！
    
        该步只是将当前的的生命周期交给了spring管理，具体的管理还是需要下面的LifecycleBeanPostProcessor的对象去进行操作
    
    
     bean.addUrlPatterns("/*"); :表示的是拦截所有的请求
         * */
    
        @Bean
        public FilterRegistrationBean filterRegistrationBean() {
            FilterRegistrationBean bean = new FilterRegistrationBean();
            bean.setFilter(new DelegatingFilterProxy("shiroFilter")); //设置的shiro的拦截器 ShiroFilterFactoryBean
            bean.addInitParameter("targetFilterLifecycle", "true");
            bean.setEnabled(true);
            bean.addUrlPatterns("/*");
            return bean;
        }

作用：用于设置shiro的拦截器，和将每一个拦截器的生命周期交给spring去管理

**上面设置了声明周期，下面进行设置生命周期的自动化：**

//    设置方法的自动初始化和销毁，init和destory方法被自动调用。注意，如果使用了该类，则不需要手动初始化方法和销毁方法，否则出错
        @Bean(name = "lifecycleBeanPostProcessor")
        public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
            return new LifecycleBeanPostProcessor();
        }

**开启注解声明**

//    开启shiro aop 的注解支持，使用代理的方式，所以需要开启代码的支持
        @Bean
        public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
            DefaultAdvisorAutoProxyCreator proxyCreator = new DefaultAdvisorAutoProxyCreator();
    //        设置代理方式，true是cglib的代理方式，false是普通的jdk代理方式
            proxyCreator.setProxyTargetClass(true);
            return proxyCreator;
        }
    
        //    开启注解
        @Bean
        public AuthorizationAttributeSourceAdvisor attributeSourceAdvisor(SecurityManager securityManager) {
            AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
            advisor.setSecurityManager(securityManager);
            return advisor;
        }

**设置shiro的拦截器工厂类**

//  使用工厂模式，创建并初始化ShiroFilter
    
        @Bean(name = "shiroFilter")
        public ShiroFilterFactoryBean getShiroFilterFactoryBean(SecurityManager securityManager, CasFilter casFilter) {
            ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
            factoryBean.setSecurityManager(securityManager);
    //        如果不设置，会自动寻找目录下的/login.jsp页面
            factoryBean.setLoginUrl(loginUrl);
    //        设置无权限访问页面
            factoryBean.setUnauthorizedUrl(unauthorizedUrl);
    //        添加casFilter中，注意，casFilter需要放到shiroFilter的前面
            Map<String, Filter> linkedHashMap = new LinkedHashMap<>();
            linkedHashMap.put("casFilter", casFilter);
    
            factoryBean.setFilters(linkedHashMap);
            loadShiroFilterChain(factoryBean);
            return factoryBean;
        }

说明：loginUrl表示的是：当没有登录的时候，客户端回去访问服务端，请求的参数格式是：认证中心的地址+"/login"+"service="+"当前项目的地址"+"shiro定义的返回的地址"

在设置拦截器的时候，需要先执行cas的拦截器，再执行shiro的拦截器

**设置CasFilter**

//    定义cas的拦截器
        @Bean(name = "casFilter")
        public CasFilter getCasFilter() {
            CasFilter filter = new CasFilter();
    //        自动注入拦截器的名称
            filter.setName("casFilter");
    //        是否自动的将当前的拦截器进行注入
            filter.setEnabled(true);
    //        在登录失败之后，也就是shiro执行CasRealm的doGetAuthenticationInfo  方法向CasServer验证tiker
            filter.setFailureUrl(loginUrl);//认证失败之后，重新登录
            filter.setLoginUrl(loginUrl);
            return filter;
        }

**对shiroFilter所需要的拦截器**

/**
         * 加载shiroFilter权限控制规则（从数据库读取然后配置）,角色/权限信息由MyShiroCasRealm对象提供doGetAuthorizationInfo实现获取来的
         * 生产中会将这部分规则放到数据库中
         *
         * @param shiroFilterFactoryBean
         */
    
        private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean) {
            Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
    
            filterChainDefinitionMap.put(casFilterUrlPattern, "casFilter");
    
            //2.不拦截的请求
            filterChainDefinitionMap.put("/css/**", "anon");
            filterChainDefinitionMap.put("/js/**", "anon");
            filterChainDefinitionMap.put("/login", "anon");
            // 此处将logout页面设置为anon，而不是logout，因为logout被单点处理，而不需要再被shiro的logoutFilter进行拦截
            filterChainDefinitionMap.put("/logout", "anon");
            filterChainDefinitionMap.put("/error", "anon");
            //3.拦截的请求（从本地数据库获取或者从casserver获取(webservice,http等远程方式)，看你的角色权限配置在哪里）
            filterChainDefinitionMap.put("/user", "authc"); //需要登录
    
            //4.登录过的不拦截
            filterChainDefinitionMap.put("/**", "authc");
    
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        }

上面是根据Shiro和Cas整合之后操作的代码。

说一下，执行的流程：

首先在启动的时候会对所有的请求进行拦截 DelegatingFilterProxy，指定的是casFilter和shiroFilter两个拦截器，并同时将生命周期交给spring去管理，当然只是交给还不可以，需要设置一个@Bena，LifecycleBeanPostProcessor这个类用于管理声明周期，

在shiroFilter中首先设置的是 securityManager，在securityManager设置 EhCacheManager 缓存，在缓存中就只是读取缓存的一些配置 -> 同时设置自定义的CasRealm类，在CasRealm类中需要指定远程认证的地址和认证成功之后返回的地址，CasRealm类中去继承CasRealm类，然后覆盖认证和授权这两个类 ,(当设置完成登录的地址的时候，同时设置登出的拦截器（FilterRegistrationBean中有SingleSignOutFilter对象，该对象用于清除过时的session，不过该拦截器要优先于所有的拦截器进行执行）和监听器（ServletListenerRegistrationBean-->监听器中有SingleSignOutHttpSessionListener对象，用于清除session的映射（所谓的映射就是cas客户端和访问端））)- -> 并同时设置参数，修改登录的页面，需要修改成客户端去访问服务端的地址，如果不修改，会自动的去访问当前项目下面的login页面，就不会走cas认证中心的地址，还修改当没有权限访问的时候，请求的路径，同时还设置casFilter拦截器（该拦截器中设置的是如果认证失败之后跳转的位置（一般是登录的页面）和登录的页面）同时设置之前设置的shiro拦截器的一些设置（主要是对一些地址进行权限的设置），设置完成之后，再开启shiro的注解

[shiro]: https://blog.csdn.net/weixin_38297879/article/details/83246224
[70]: /images/20220504/97c0a0e83cac46728ecc91ad90dcc532.png
[http_a_8080_ticket_ST-XXXX-XXX]: http://a:8080/?ticket=ST-XXXX-XXX
[https_blog.csdn.net_javaloveiphone_article_details_52439613_utm_source_blogxgwz0]: https://blog.csdn.net/javaloveiphone/article/details/52439613?utm_source=blogxgwz0
[70 1]: /images/20220504/f8b8b1ae173c4646932da81d7aeb9ce5.png