若依框架（前后端分离）集成cas5.5

一、后端配置

1、添加cas依赖

在common模块pom添加spring-security-cas依赖：

<!-- spring security cas-->
<dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-cas</artifactId>
</dependency>

2、修改配置文件

在admin模块下的application.yml配置文件中添加：

#CAS
cas:server:host:#CAS服务地址url: http://localhost:8080/cas-server#CAS服务登录地址login_url: ${cas.server.host.url}/login#CAS服务登出地址logout_url: ${cas.server.host.url}/logout?service=${app.server.host.url}# 应用访问地址
app:#开启cascasEnable: trueserver:host:url: http://localhost:${server.port}#应用登录地址login_url: /#应用登出地址logout_url: /logout#前端登录地址web_url: http://localhost/index

3、修改com.ruoyi.common.core.domain.model.LoginUser.java

由于CAS认证需要authorities属性，此属性不能为空：

 
@Override
public Collection<? extends GrantedAuthority> getAuthorities()
{//由于CAS认证需要authorities属性，此属性不能为空，此处为了方便直接new HashSet()return new HashSet<>();
}

4、修改com.ruoyi.common.constant.Constants.java

添加CAS认证成功标识：

 
/*** CAS登录成功后的后台标识*/
public static final String CAS_TOKEN = "cas_token";/*** CAS登录成功后的前台Cookie的Key*/
public static final String WEB_TOKEN_KEY = "Admin-Token";

5、修改com.ruoyi.framework.web.service.TokenService.java

增加删除用户登录信息方法：

 
/*** cas 删除用户身份信息*/
public void delClaimsLoginUser(String token)
{if (StringUtils.isNotEmpty(token)){Claims claims = parseToken(token);// 解析对应的权限以及用户信息String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);String userKey = getTokenKey(uuid);redisCache.deleteObject(userKey);}
}

6、在com.ruoyi.framework.config.properties下添加CasProperties.java

读取cas配置信息：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;/*** CAS的配置参数*/
@Component
public class CasProperties {@Value("${cas.server.host.url}")private String casServerUrl;@Value("${cas.server.host.login_url}")private String casServerLoginUrl;@Value("${cas.server.host.logout_url}")private String casServerLogoutUrl;@Value("${app.casEnable}")private boolean casEnable;@Value("${app.server.host.url}")private String appServerUrl;@Value("${app.login_url}")private String appLoginUrl;@Value("${app.logout_url}")private String appLogoutUrl;@Value("${app.web_url}")private String webUrl;public String getWebUrl() {return webUrl;}public String getCasServerUrl() {return casServerUrl;}public void setCasServerUrl(String casServerUrl) {this.casServerUrl = casServerUrl;}public String getCasServerLoginUrl() {return casServerLoginUrl;}public void setCasServerLoginUrl(String casServerLoginUrl) {this.casServerLoginUrl = casServerLoginUrl;}public String getCasServerLogoutUrl() {return casServerLogoutUrl;}public void setCasServerLogoutUrl(String casServerLogoutUrl) {this.casServerLogoutUrl = casServerLogoutUrl;}public boolean isCasEnable() {return casEnable;}public void setCasEnable(boolean casEnable) {this.casEnable = casEnable;}public String getAppServerUrl() {return appServerUrl;}public void setAppServerUrl(String appServerUrl) {this.appServerUrl = appServerUrl;}public String getAppLoginUrl() {return appLoginUrl;}public void setAppLoginUrl(String appLoginUrl) {this.appLoginUrl = appLoginUrl;}public String getAppLogoutUrl() {return appLogoutUrl;}public void setAppLogoutUrl(String appLogoutUrl) {this.appLogoutUrl = appLogoutUrl;}
}

7、在framework.web.service包下添加CasUserDetailsService.java

import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.UserStatus;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.cas.authentication.CasAssertionAuthenticationToken;
import org.springframework.security.core.userdetails.AuthenticationUserDetailsService;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;/*** 用于加载用户信息 实现UserDetailsService接口，或者实现AuthenticationUserDetailsService接口*/@Service
public class CasUserDetailsService implements AuthenticationUserDetailsService<CasAssertionAuthenticationToken> {private static final Logger log = LoggerFactory.getLogger(UserDetailsServiceImpl.class);@Autowiredprivate ISysUserService userService;@Autowiredprivate SysPermissionService permissionService;@Overridepublic UserDetails loadUserDetails(CasAssertionAuthenticationToken token) throws UsernameNotFoundException {String username = token.getName();SysUser user = userService.selectUserByUserName(username);if (StringUtils.isNull(user)) {log.info("登录用户：{} 不存在.", username);throw new ServiceException("登录用户：" + username + " 不存在");} else if (UserStatus.DELETED.getCode().equals(user.getDelFlag())) {log.info("登录用户：{} 已被删除.", username);throw new ServiceException("对不起，您的账号：" + username + " 已被删除");} else if (UserStatus.DISABLE.getCode().equals(user.getStatus())) {log.info("登录用户：{} 已被停用.", username);throw new ServiceException("对不起，您的账号：" + username + " 已停用");}return createLoginUser(user);}public UserDetails createLoginUser(SysUser user) {return new LoginUser(user.getUserId(), user.getDeptId(), user, permissionService.getMenuPermission(user));}
}

8、在framework.security.handle包下添加CasAuthenticationSuccessHandler.java

import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.framework.config.properties.CasProperties;
import com.ruoyi.framework.web.service.TokenService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.security.web.savedrequest.HttpSessionRequestCache;
import org.springframework.security.web.savedrequest.RequestCache;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;@Service
public class CasAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {protected final Log logger = LogFactory.getLog(this.getClass());private RequestCache requestCache = new HttpSessionRequestCache();@Autowiredprivate TokenService tokenService;@Autowiredprivate CasProperties casProperties;/*** 令牌有效期（默认30分钟）*/@Value("${token.expireTime}")private int expireTime;@Overridepublic void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,Authentication authentication) throws ServletException, IOException {String targetUrlParameter = getTargetUrlParameter();if (isAlwaysUseDefaultTargetUrl()|| (targetUrlParameter != null && StringUtils.hasText(request.getParameter(targetUrlParameter)))) {requestCache.removeRequest(request, response);super.onAuthenticationSuccess(request, response, authentication);return;}clearAuthenticationAttributes(request);LoginUser userDetails = (LoginUser) authentication.getPrincipal();String token = tokenService.createToken(userDetails);Cookie casCookie = new Cookie(Constants.WEB_TOKEN_KEY, token);casCookie.setMaxAge(expireTime * 60);casCookie.setPath("/");response.addCookie(casCookie);//设置后端认证成功标识HttpSession httpSession = request.getSession();httpSession.setAttribute(Constants.CAS_TOKEN, token);//登录成功后跳转到前端访问页面String url = request.getParameter("redirect");getRedirectStrategy().sendRedirect(request, response, url);}
}

9、在framework.security.entrypoint包下添加CustomCasAuthenticationEntryPoint.java

import com.fch.common.utils.StringUtils;
import org.springframework.security.cas.web.CasAuthenticationEntryPoint;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class CustomCasAuthenticationEntryPoint extends CasAuthenticationEntryPoint {private String serviceUrlBak=null;@Overrideprotected String createServiceUrl(HttpServletRequest request, HttpServletResponse response) {if (serviceUrlBak==null) {serviceUrlBak = getServiceProperties().getService();}//将前端登录成功后跳转页面加入CAS请求中if(serviceUrlBak!=null){String queryString=request.getQueryString();if (StringUtils.isNotNull(queryString)) {String serviceUrl = "";if (queryString.contains("redirect")) {if (StringUtils.isNotBlank(queryString)) {serviceUrl = "?" + queryString;}}getServiceProperties().setService(serviceUrlBak + serviceUrl);}}return super.createServiceUrl(request, response);}
}

10、在framework.security.entrypoint包下添加CustomSessionMappingStorage.java

import com.ruoyi.common.constant.Constants;
import com.ruoyi.framework.web.service.TokenService;
import org.apache.catalina.session.StandardSessionFacade;
import org.jasig.cas.client.session.SessionMappingStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;@Component
public class CustomSessionMappingStorage implements SessionMappingStorage {private final Map<String, HttpSession> MANAGED_SESSIONS = new HashMap();private final Map<String, String> ID_TO_SESSION_KEY_MAPPING = new HashMap();private final Logger logger = LoggerFactory.getLogger(this.getClass());@Autowiredprivate TokenService tokenService;public CustomSessionMappingStorage() {}@Overridepublic synchronized void addSessionById(String mappingId, HttpSession session) {this.ID_TO_SESSION_KEY_MAPPING.put(session.getId(), mappingId);this.MANAGED_SESSIONS.put(mappingId, session);}@Overridepublic synchronized void removeBySessionById(String sessionId) {this.logger.debug("Attempting to remove Session=[{}]", sessionId);String key = (String)this.ID_TO_SESSION_KEY_MAPPING.get(sessionId);if (this.logger.isDebugEnabled()) {if (key != null) {this.logger.debug("Found mapping for session.  Session Removed.");} else {this.logger.debug("No mapping for session found.  Ignoring.");}}this.MANAGED_SESSIONS.remove(key);this.ID_TO_SESSION_KEY_MAPPING.remove(sessionId);}/*** 根据CAS发送的id,查找后端用户session中的token，并删除* @param mappingId* @return*/@Overridepublic synchronized HttpSession removeSessionByMappingId(String mappingId) {StandardSessionFacade session = (StandardSessionFacade) this.MANAGED_SESSIONS.get(mappingId);if (session != null) {this.removeBySessionById(session.getId());try {String token = (String) session.getAttribute(Constants.CAS_TOKEN);tokenService.delClaimsLoginUser(token);} catch (IllegalStateException e) {this.logger.error("已成功登出");}}return session;}
}

11、修改SecurityConfig.java，添加cas的处理逻辑：

import com.ruoyi.framework.config.properties.CasProperties;
import com.ruoyi.framework.config.properties.PermitAllUrlProperties;
import com.ruoyi.framework.security.entrypoint.CustomCasAuthenticationEntryPoint;
import com.ruoyi.framework.security.entrypoint.CustomSessionMappingStorage;
import com.ruoyi.framework.security.filter.JwtAuthenticationTokenFilter;
import com.ruoyi.framework.security.handle.AuthenticationEntryPointImpl;
import com.ruoyi.framework.security.handle.CasAuthenticationSuccessHandler;
import com.ruoyi.framework.security.handle.LogoutSuccessHandlerImpl;
import com.ruoyi.framework.web.service.CasUserDetailsService;
import org.jasig.cas.client.session.SingleSignOutFilter;
import org.jasig.cas.client.session.SingleSignOutHttpSessionListener;
import org.jasig.cas.client.validation.Cas20ServiceTicketValidator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.cas.ServiceProperties;
import org.springframework.security.cas.authentication.CasAuthenticationProvider;
import org.springframework.security.cas.web.CasAuthenticationEntryPoint;
import org.springframework.security.cas.web.CasAuthenticationFilter;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutFilter;
import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;
import org.springframework.web.filter.CorsFilter;/*** spring security配置** @author ruoyi*/
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter
{/*** 自定义用户认证逻辑*/@Autowiredprivate UserDetailsService userDetailsService;/*** 认证失败处理类*/@Autowiredprivate AuthenticationEntryPointImpl unauthorizedHandler;/*** 退出处理类*/@Autowiredprivate LogoutSuccessHandlerImpl logoutSuccessHandler;/*** token认证过滤器*/@Autowiredprivate JwtAuthenticationTokenFilter authenticationTokenFilter;/*** 跨域过滤器*/@Autowiredprivate CorsFilter corsFilter;/*** 允许匿名访问的地址*/@Autowiredprivate PermitAllUrlProperties permitAllUrl;/*** cas*/@Autowiredprivate CasProperties casProperties;@Autowiredprivate CasUserDetailsService customUserDetailsService;@Autowiredprivate CasAuthenticationSuccessHandler casAuthenticationSuccessHandler;@Autowiredprivate CustomSessionMappingStorage customSessionMappingStorage;/*** 解决 无法直接注入 AuthenticationManager** @return* @throws Exception*/@Bean@Overridepublic AuthenticationManager authenticationManagerBean() throws Exception{return super.authenticationManagerBean();}/*** anyRequest          |   匹配所有请求路径* access              |   SpringEl表达式结果为true时可以访问* anonymous           |   匿名可以访问* denyAll             |   用户不能访问* fullyAuthenticated  |   用户完全认证可以访问（非remember-me下自动登录）* hasAnyAuthority     |   如果有参数，参数表示权限，则其中任何一个权限可以访问* hasAnyRole          |   如果有参数，参数表示角色，则其中任何一个角色可以访问* hasAuthority        |   如果有参数，参数表示权限，则其权限可以访问* hasIpAddress        |   如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问* hasRole             |   如果有参数，参数表示角色，则其角色可以访问* permitAll           |   用户可以任意访问* rememberMe          |   允许通过remember-me登录的用户访问* authenticated       |   用户登录后可访问*/@Overrideprotected void configure(HttpSecurity httpSecurity) throws Exception{// 注解标记允许匿名访问的urlExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = httpSecurity.authorizeRequests();permitAllUrl.getUrls().forEach(url -> registry.antMatchers(url).permitAll());if (!casProperties.isCasEnable()) {httpSecurity// CSRF禁用，因为不使用session.csrf().disable()// 认证失败处理类.exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()// 基于token，所以不需要session.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()// 过滤请求.authorizeRequests()// 对于登录login 注册register 验证码captchaImage 允许匿名访问.antMatchers("/login", "/register", "/captchaImage", "/updatePassword").anonymous()// 静态资源，可匿名访问.antMatchers(HttpMethod.GET, "/", "/*.html", "/**/*.html", "/**/*.css", "/**/*.js", "/profile/**").permitAll().antMatchers("/swagger-ui.html", "/swagger-resources/**", "/webjars/**", "/*/api-docs", "/druid/**").permitAll()// 除上面外的所有请求全部需要鉴权认证.anyRequest().authenticated().and().headers().frameOptions().disable();// 添加Logout filterhttpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);// 添加JWT filterhttpSecurity.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);// 添加CORS filterhttpSecurity.addFilterBefore(corsFilter, JwtAuthenticationTokenFilter.class);httpSecurity.addFilterBefore(corsFilter, LogoutFilter.class);}//开启casif (casProperties.isCasEnable()) {httpSecurity// CSRF禁用，因为不使用session.csrf().disable()// 基于token，所以不需要session.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()// 过滤请求.authorizeRequests()// 对于登录login 验证码captchaImage 允许匿名访问//.antMatchers("/login", "/captchaImage").anonymous().antMatchers(HttpMethod.GET,"/*.html","/**/*.html","/**/*.css","/**/*.js").permitAll()/*.antMatchers("/profile/**").anonymous().antMatchers("/common/download**").anonymous().antMatchers("/common/download/resource**").anonymous()*/.antMatchers("/swagger-ui.html").anonymous().antMatchers("/swagger-resources/**").anonymous().antMatchers("/webjars/**").anonymous().antMatchers("/*/api-docs").anonymous().antMatchers("/druid/**").anonymous()/*.antMatchers("/websocket/**").anonymous().antMatchers("/magic/web/**").anonymous()*/// 除上面外的所有请求全部需要鉴权认证.anyRequest().authenticated().and().headers().frameOptions().disable();//单点登录登出httpSecurity.logout().permitAll().logoutSuccessHandler(logoutSuccessHandler);// Custom JWT based security filterhttpSecurity.addFilter(casAuthenticationFilter()).addFilterBefore(authenticationTokenFilter, CasAuthenticationFilter.class).addFilterBefore(casLogoutFilter(), CasAuthenticationFilter.class).addFilterBefore(singleSignOutFilter(), JwtAuthenticationTokenFilter.class).exceptionHandling()//认证失败.authenticationEntryPoint(casAuthenticationEntryPoint());// 添加CORS filterhttpSecurity.addFilterBefore(corsFilter, JwtAuthenticationTokenFilter.class);httpSecurity.addFilterBefore(corsFilter, LogoutFilter.class);// disable page cachinghttpSecurity.headers().cacheControl();}}/*** 强散列哈希加密实现*/@Beanpublic BCryptPasswordEncoder bCryptPasswordEncoder(){return new BCryptPasswordEncoder();}/*** 身份认证接口*/@Overrideprotected void configure(AuthenticationManagerBuilder auth) throws Exception{if (!casProperties.isCasEnable()) {auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());}// casif (casProperties.isCasEnable()) {super.configure(auth);auth.authenticationProvider(casAuthenticationProvider());}}/*** 认证的入口*/@Beanpublic CasAuthenticationEntryPoint casAuthenticationEntryPoint() {CasAuthenticationEntryPoint casAuthenticationEntryPoint = new CustomCasAuthenticationEntryPoint();casAuthenticationEntryPoint.setLoginUrl(casProperties.getCasServerLoginUrl());casAuthenticationEntryPoint.setServiceProperties(serviceProperties());return casAuthenticationEntryPoint;}/*** 指定service相关信息*/@Beanpublic ServiceProperties serviceProperties() {ServiceProperties serviceProperties = new ServiceProperties();serviceProperties.setService(casProperties.getAppServerUrl()+casProperties.getAppLoginUrl());serviceProperties.setAuthenticateAllArtifacts(true);return serviceProperties;}/*** CAS认证过滤器*/@Beanpublic CasAuthenticationFilter casAuthenticationFilter() throws Exception {CasAuthenticationFilter casAuthenticationFilter = new CasAuthenticationFilter();casAuthenticationFilter.setAuthenticationManager(authenticationManager());casAuthenticationFilter.setFilterProcessesUrl(casProperties.getAppLoginUrl());casAuthenticationFilter.setAuthenticationSuccessHandler(casAuthenticationSuccessHandler);return casAuthenticationFilter;}/*** cas 认证 Provider*/@Beanpublic CasAuthenticationProvider casAuthenticationProvider() {CasAuthenticationProvider casAuthenticationProvider = new CasAuthenticationProvider();casAuthenticationProvider.setAuthenticationUserDetailsService(customUserDetailsService);casAuthenticationProvider.setServiceProperties(serviceProperties());casAuthenticationProvider.setTicketValidator(cas20ServiceTicketValidator());casAuthenticationProvider.setKey("casAuthenticationProviderKey");return casAuthenticationProvider;}@Beanpublic Cas20ServiceTicketValidator cas20ServiceTicketValidator() {return new Cas20ServiceTicketValidator(casProperties.getCasServerUrl());}/*** 单点登出过滤器* 使用customSessionMappingStorage处理cas发送的登出请求*/@Beanpublic SingleSignOutFilter singleSignOutFilter() {SingleSignOutFilter singleSignOutFilter = new SingleSignOutFilter();//singleSignOutFilter.setLogoutCallbackPath(casProperties.getWebUrl());singleSignOutFilter.setSessionMappingStorage(customSessionMappingStorage);singleSignOutFilter.setIgnoreInitConfiguration(true);return singleSignOutFilter;}/*** 请求单点退出过滤器*/@Beanpublic LogoutFilter casLogoutFilter() {LogoutFilter logoutFilter = new LogoutFilter(casProperties.getCasServerLogoutUrl(),new SecurityContextLogoutHandler());logoutFilter.setFilterProcessesUrl(casProperties.getAppLogoutUrl());return logoutFilter;}@Beanpublic ServletListenerRegistrationBean singleSignOutHttpSessionListener() {ServletListenerRegistrationBean bean = new ServletListenerRegistrationBean();bean.setListener(new SingleSignOutHttpSessionListener());
//        bean.setName(""); //默认为bean namebean.setEnabled(true);//bean.setOrder(Ordered.HIGHEST_PRECEDENCE); //设置优先级return bean;}
}

二、前端配置 

1、修改settings.js

添加cas登录和登出地址：

 /*** 开启cas*/casEnable: true,/*** 单点登录url，前面为后端地址，后面为前端地址*/casloginUrl: 'http://localhost:8688/?redirect=http://localhost:8689',/*** 单点登出url，前面为cas服务器地址，后面为前端地址*/caslogoutUrl: 'http://localhost:8080/cas-server/logout?service=http://localhost:8689'

2、修改permission.js，判断没有token时访问cas登录页面：

import router from './router'
import store from './store'
import { Message } from 'element-ui'
import NProgress from 'nprogress'
import 'nprogress/nprogress.css'
import { getToken } from '@/utils/auth'
//引入setting.js
import defaultSettings from '@/settings'NProgress.configure({ showSpinner: false })const whiteList = ['/auth-redirect', '/bind', '/register']router.beforeEach((to, from, next) => {NProgress.start()if (getToken()) {/* has token*/if (to.path === '/login') {next({ path: '/' })NProgress.done()} else {if (store.getters.roles.length === 0) {// 判断当前用户是否已拉取完user_info信息store.dispatch('GetInfo').then(() => {store.dispatch('GenerateRoutes').then(accessRoutes => {// 根据roles权限生成可访问的路由表router.addRoutes(accessRoutes) // 动态添加可访问路由表next({ ...to, replace: true }) // hack方法 确保addRoutes已完成})}).catch(err => {store.dispatch('LogOut').then(() => {Message.error(err)next({ path: '/' })})})} else {next()}}} else {// 没有tokenif (whiteList.indexOf(to.path) !== -1) {if (to.path === '/login' && defaultSettings.casEnable) {// 否则全部重定向到访问页window.location.href = defaultSettings.casloginUrl + to.fullPath} else {// 在免登录白名单，直接进入next()}} else {//casif (!defaultSettings.casEnable) {next(`/login?redirect=${to.fullPath}`) // 否则全部重定向到登录页}if (defaultSettings.casEnable) {// 否则全部重定向到访问页window.location.href = defaultSettings.casloginUrl + to.fullPath}NProgress.done()}}
})router.afterEach(() => {NProgress.done()
})  

3、修改request.js

修改utils目录下request.js文件“响应拦截器”，登出后不做响应：

//引入setting.js
import defaultSettings from '@/settings'// 响应拦截器
service.interceptors.response.use(res => {// 未设置状态码则默认成功状态const code = res.data.code || 200;// 获取错误信息const msg = errorCode[code] || res.data.msg || errorCode['default']// 二进制数据则直接返回if (res.request.responseType === 'blob' || res.request.responseType === 'arraybuffer') {return res.data}if (code === 401) {if (!isRelogin.show) {isRelogin.show = true;ElMessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', {confirmButtonText: '重新登录',cancelButtonText: '取消',type: 'warning'}).then(() => {isRelogin.show = false;useUserStore().logOut().then(() => {//casif (!defaultSettings.casEnable) {location.href = '/index';}})}).catch(() => {isRelogin.show = false;});}return Promise.reject('无效的会话，或者会话已过期，请重新登录。')} else if (code === 500) {ElMessage({message: msg,type: 'error'})return Promise.reject(new Error(msg))} else if (code !== 200) {ElNotification.error({title: msg})return Promise.reject('error')} else {return Promise.resolve(res.data)}
},error => {console.log('err' + error)let { message } = error;if (message == "Network Error") {message = "后端接口连接异常";}else if (message.includes("timeout")) {message = "系统接口请求超时";}else if (message.includes("Request failed with status code")) {message = "系统接口" + message.substr(message.length - 3) + "异常";}ElMessage({message: message,type: 'error',duration: 5 * 1000})return Promise.reject(error)}
)

4、修改Navbar.vue

修改layout/components目录下Navbar.vue文件的logout()方法，登出后不做响应：

//引入setting.js
import defaultSettings from '@/settings'//退出登录
async logout() {this.$confirm('确定注销并退出系统吗？', '提示', {confirmButtonText: '确定',cancelButtonText: '取消',type: 'warning'}).then(() => {this.$store.dispatch('LogOut').then(() => {//casif (!defaultSettings .casEnable) {location.href = '/index';}})})}

5、修改user.js

修改store/modules目录下user.js的logOut()方法：

//引入setting.js
import defaultSettings from '@/settings'// 退出系统LogOut({ commit, state }) {return new Promise((resolve, reject) => {logout(state.token).then(() => {commit('SET_TOKEN', '')commit('SET_ROLES', [])commit('SET_PERMISSIONS', [])removeToken()resolve()//casif (defaultSettings.casEnable) {window.location.href = defaultSettings.caslogoutUrl}}).catch(error => {reject(error)})})},

至此，已完成若依前后端集成CAS单点登录功能。