springboot+vue+cas实现单点登录、退出

最新推荐文章于 2023-10-27 12:05:53 发布
最新推荐文章于 2023-10-27 12:05:53 发布
阅读量1.7k 收藏 9
点赞数 1
分类专栏： 单点登录 文章标签： spring boot vue.js cas sso 单点登录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29467891/article/details/130379326
版权

springboot+vue+cas实现单点登录、退出

1.添加依赖包

<!-- 单点登录 20230426-->
<dependency>
    <groupId>org.jasig.cas.client</groupId>
    <artifactId>cas-client-core</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.10</version>
</dependency>

2.添加cas过滤器

/**
 * @author huangquanguang
 * @date 2023/4/25 13:57
 * @description cas过滤器配置
 */
@Configuration
@ConditionalOnProperty(prefix = "cas",name = "is-open",havingValue = "true")
public class CasFilterConfig implements Serializable, InitializingBean {

    private static final Logger LOGGER = LoggerFactory.getLogger(CasFilterConfig.class);

    public static final String CAS_SIGNOUT_FILTER_NAME = "CAS Single Sign Out Filter";
    public static final String CAS_AUTH_FILTER_NAME = "CAS Filter";
    public static final String CAS_IGNOREL_SSL_FILTER_NAME = "CAS Ignore SSL Filter";
    public static final String CAS_FILTER_NAME = "CAS Validation Filter";
    public static final String CAS_WRAPPER_NAME = "CAS HttpServletRequest Wrapper Filter";
    public static final String CAS_ASSERTION_NAME = "CAS Assertion Thread Local Filter";
    public static final String CHARACTER_ENCODING_NAME = "Character encoding Filter";

    @Value("${cas.server-url-prefix:http://127.0.0.1:8443/cas}")
    public String casServerUrlPrefix;
    @Value("${cas.client-host-url:http://127.0.0.1}")
    public String casClientHostUrl;
    @Value("${cas.client-host-api-url:http://127.0.0.1/api/api-demo/cas/ssoLogin}")
    public String casClientHostApiUrl;

    public CasFilterConfig() {

    }

    /**
     * 单点登出功能,放在其他filter之前
     * casSigntouServerUrlPrefix为登出前缀:https://127.0.0.1/cas/logout
     *
     * @return
     */
    @Bean
    @Order(0)
    public FilterRegistrationBean getCasSignoutFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(getCasSignoutFilter());
        Map<String, String> initParameters = new HashMap<String, String>();
        initParameters.put("casServerLoginUrl", casServerUrlPrefix + "/login");
        initParameters.put("serverName", casClientHostUrl);
        //忽略的url，"|"分隔多个url
        initParameters.put("ignorePattern", "/logout/success|/index|/test|/login");
        registration.setInitParameters(initParameters);
        registration.addUrlPatterns("/*");
        registration.addInitParameter("casServerUrlPrefix", casServerUrlPrefix + "/logout");
        registration.setName(CAS_SIGNOUT_FILTER_NAME);
        registration.setEnabled(true);
        return registration;
    }

    @Bean(name = CAS_SIGNOUT_FILTER_NAME)
    public Filter getCasSignoutFilter() {
        return new SingleSignOutFilter();
    }

    /**
     * 忽略SSL认证
     *
     * @return
     */
    @Bean
    @Order(1)
    public FilterRegistrationBean getCasSkipSSLValidationFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(getCasSkipSSLValidationFilter());
        registration.addUrlPatterns("/*");
        registration.setName(CAS_IGNOREL_SSL_FILTER_NAME);
        registration.setEnabled(true);
        return registration;
    }

    @Bean(name = CAS_IGNOREL_SSL_FILTER_NAME)
    public Filter getCasSkipSSLValidationFilter() {
        return new IgnoreSSLValidateFilter();
    }

    /**
     * 负责用户的认证
     * casServerLoginUrl：https://127.0.0.1/api/api-demo/cas/login
     * casServerName：https://127.0.0.1/
     *
     * @return
     */
    @Bean
    @Order(2)
    public FilterRegistrationBean getCasAuthFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        final Filter casAuthFilter = getCasAuthFilter();
        registration.setFilter(casAuthFilter);
        registration.addUrlPatterns("/*");
        registration.addInitParameter("casServerLoginUrl", casServerUrlPrefix + "/login");
        registration.addInitParameter("serverName", casClientHostUrl);
        registration.setName(CAS_AUTH_FILTER_NAME);
        registration.setEnabled(true);
        return registration;
    }

    @Bean(name = CAS_AUTH_FILTER_NAME)
    public Filter getCasAuthFilter() {
        return new MyAuthenticationFilter();
    }

    /**
     * 对Ticket进行校验
     * casServerUrlPrefix
     *
     * @return
     */
    @Bean
    @Order(3)
    public FilterRegistrationBean getCasValidationFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        final Filter casValidationFilter = getCasValidationFilter();
        registration.setFilter(casValidationFilter);
        registration.addUrlPatterns("/*");
        registration.addInitParameter("casServerUrlPrefix", casServerUrlPrefix);
        registration.addInitParameter("serverName", casClientHostUrl);
        registration.addInitParameter("encoding", "UTF-8");
        registration.setName(CAS_FILTER_NAME);
        registration.setEnabled(true);
        return registration;
    }

    @Bean(name = CAS_FILTER_NAME)
    public Filter getCasValidationFilter() {
        //按照对方提供的文档使用Cas10TicketValidationFilter
//        return new Cas20ProxyReceivingTicketValidationFilter();
        return new Cas10TicketValidationFilter();
    }

    /**
     * 设置response的默认编码方式：UTF-8。
     *
     * @return
     */
    @Bean
    @Order(4)
    public FilterRegistrationBean getCharacterEncodingFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(getCharacterEncodingFilter());
        registration.addUrlPatterns("/*");
        registration.setName(CHARACTER_ENCODING_NAME);
        registration.setEnabled(true);
        return registration;
    }

    @Bean(name = CHARACTER_ENCODING_NAME)
    public Filter getCharacterEncodingFilter() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        return characterEncodingFilter;
    }

    @Bean
    public FilterRegistrationBean casHttpServletRequestWrapperFilter() {
        FilterRegistrationBean authenticationFilter = new FilterRegistrationBean();
        authenticationFilter.setFilter(new HttpServletRequestWrapperFilter());
        authenticationFilter.setOrder(6);
        List<String> urlPatterns = new ArrayList<>();
        urlPatterns.add("/*");
        authenticationFilter.setUrlPatterns(urlPatterns);
        return authenticationFilter;
    }

    @Override
    public void afterPropertiesSet() throws Exception {

    }
}

3.重写拦截器自定义状态码、在前端进行重定向

/**
 * @author huangquanguang
 * @date 2023/4/25 13:57
 * @description 重写拦截器自定义状态码，实现前后端分离的单点登录
 */
public class MyAuthenticationFilter extends AbstractCasFilter {

    @Value("${cas.server-url-prefix:http://127.0.0.1:8443/cas}")
    public String casServerUrlPrefix;
    @Value("${cas.client-host-url:http://127.0.0.1}")
    public String casClientHostUrl;
    @Value("${cas.client-host-ticket-url:http://127.0.0.1/api/api-demo/cas/checkTicket}")
    public String casClientHostTicketUrl;
    private boolean renew = false;
    private boolean gateway = false;
    private GatewayResolver gatewayStorage = new DefaultGatewayResolverImpl();
    private AuthenticationRedirectStrategy authenticationRedirectStrategy = new DefaultAuthenticationRedirectStrategy();
    private UrlPatternMatcherStrategy ignoreUrlPatternMatcherStrategyClass = null;
    private static final Map<String, Class<? extends UrlPatternMatcherStrategy>> PATTERN_MATCHER_TYPES = new HashMap();

    public MyAuthenticationFilter() {
        super(Protocol.CAS1);
    }

    //升级cas-client版本后
//    @Override
//    protected void initInternal(FilterConfig filterConfig) throws ServletException {
//        if (!this.isIgnoreInitConfiguration()) {
//            super.initInternal(filterConfig);
//            this.setCasServerLoginUrl(this.getPropertyFromInitParams(filterConfig, "casServerLoginUrl", (String)null));
//            this.logger.trace("Loaded CasServerLoginUrl parameter: {}", this.casServerLoginUrl);
//            this.setRenew(this.parseBoolean(this.getPropertyFromInitParams(filterConfig, "renew", "false")));
//            this.logger.trace("Loaded renew parameter: {}", this.renew);
//            this.setGateway(this.parseBoolean(this.getPropertyFromInitParams(filterConfig, "gateway", "false")));
//            this.logger.trace("Loaded gateway parameter: {}", this.gateway);
//            String ignorePattern = this.getPropertyFromInitParams(filterConfig, "ignorePattern", (String)null);
//            this.logger.trace("Loaded ignorePattern parameter: {}", ignorePattern);
//            String ignoreUrlPatternType = this.getPropertyFromInitParams(filterConfig, "ignoreUrlPatternType", "REGEX");
//            this.logger.trace("Loaded ignoreUrlPatternType parameter: {}", ignoreUrlPatternType);
//            if (ignorePattern != null) {
//                Class<? extends UrlPatternMatcherStrategy> ignoreUrlMatcherClass = (Class)PATTERN_MATCHER_TYPES.get(ignoreUrlPatternType);
//                if (ignoreUrlMatcherClass != null) {
//                    this.ignoreUrlPatternMatcherStrategyClass = (UrlPatternMatcherStrategy) ReflectUtils.newInstance(ignoreUrlMatcherClass.getName(), new Object[0]);
//                } else {
//                    try {
//                        this.logger.trace("Assuming {} is a qualified class name...", ignoreUrlPatternType);
//                        this.ignoreUrlPatternMatcherStrategyClass = (UrlPatternMatcherStrategy)ReflectUtils.newInstance(ignoreUrlPatternType, new Object[0]);
//                    } catch (IllegalArgumentException var6) {
//                        this.logger.error("Could not instantiate class [{}]", ignoreUrlPatternType, var6);
//                    }
//                }
//
//                if (this.ignoreUrlPatternMatcherStrategyClass != null) {
//                    this.ignoreUrlPatternMatcherStrategyClass.setPattern(ignorePattern);
//                }
//            }
//
//            String gatewayStorageClass = this.getPropertyFromInitParams(filterConfig, "gatewayStorageClass", (String)null);
//            if (gatewayStorageClass != null) {
//                this.gatewayStorage = (GatewayResolver)ReflectUtils.newInstance(gatewayStorageClass, new Object[0]);
//            }
//
//            String authenticationRedirectStrategyClass = this.getPropertyFromInitParams(filterConfig, "authenticationRedirectStrategyClass", (String)null);
//            if (authenticationRedirectStrategyClass != null) {
//                this.authenticationRedirectStrategy = (AuthenticationRedirectStrategy)ReflectUtils.newInstance(authenticationRedirectStrategyClass, new Object[0]);
//            }
//        }
//
//    }

    @Override
    public void init() {
        super.init();
        CommonUtils.assertNotNull(this.casServerUrlPrefix + "/login", "casServerLoginUrl cannot be null.");
    }

    @Override
    public final void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        if (this.isRequestUrlExcluded(request)) {
            this.logger.debug("Request is ignored.");
            filterChain.doFilter(request, response);
        } else {
            HttpSession session = request.getSession(false);
            Assertion assertion = session != null ? (Assertion) session.getAttribute("_const_cas_assertion_") : null;
            if (assertion != null) {
                filterChain.doFilter(request, response);
            } else {
                String serviceUrl = this.constructServiceUrl(request, response);
                String ticket = this.retrieveTicketFromRequest(request);
                boolean wasGatewayed = this.gateway && this.gatewayStorage.hasGatewayedAlready(request, serviceUrl);
                if (!CommonUtils.isNotBlank(ticket) && !wasGatewayed) {
                    this.logger.debug("no ticket and no assertion found");
                    String modifiedServiceUrl;
                    if (this.gateway) {
                        this.logger.debug("setting gateway attribute in session");
                        modifiedServiceUrl = this.gatewayStorage.storeGatewayInformation(request, serviceUrl);
                    } else {
                        modifiedServiceUrl = serviceUrl;
                    }

                    this.logger.debug("Constructed service url: {}", modifiedServiceUrl);

//                    String xRequested = request.getHeader("x-requested-with");
                    String casHeader = request.getHeader("casHeader");
                    //这里是重点、前端根据状态码判断是否跳转
                    if ("true".equals(casHeader)) {
                        response.getWriter().write("{\"code\":202, \"msg\":\"no ticket and no assertion found\", \"url\":\""+ casClientHostTicketUrl +"\"}");
                    } else {
                        String urlToRedirectTo = CommonUtils.constructRedirectUrl(this.casServerUrlPrefix + "/login", "service", modifiedServiceUrl, this.renew, this.gateway);
                        this.logger.debug("redirecting to \"{}\"", urlToRedirectTo);
                        this.authenticationRedirectStrategy.redirect(request, response, urlToRedirectTo);
                    }
                } else {
                    filterChain.doFilter(request, response);
                }
            }
        }
    }

    public final void setRenew(boolean renew) {
        this.renew = renew;
    }

    public final void setGateway(boolean gateway) {
        this.gateway = gateway;
    }

    public final void setGatewayStorage(GatewayResolver gatewayStorage) {
        this.gatewayStorage = gatewayStorage;
    }

    private boolean isRequestUrlExcluded(HttpServletRequest request) {
        if (this.ignoreUrlPatternMatcherStrategyClass == null) {
            return false;
        } else {
            StringBuffer urlBuffer = request.getRequestURL();
            if (request.getQueryString() != null) {
                urlBuffer.append("?").append(request.getQueryString());
            }

            String requestUri = urlBuffer.toString();
            return this.ignoreUrlPatternMatcherStrategyClass.matches(requestUri);
        }
    }

    static {
        PATTERN_MATCHER_TYPES.put("CONTAINS", ContainsPatternUrlPatternMatcherStrategy.class);
        PATTERN_MATCHER_TYPES.put("REGEX", RegexUrlPatternMatcherStrategy.class);
        PATTERN_MATCHER_TYPES.put("EXACT", ExactUrlPatternMatcherStrategy.class);
    }
}

4.忽略ssl认证

public class IgnoreSSLValidateFilter implements Filter {
    static {
        //执行设置，禁用ssl认证
        try {
            TrustManager[] trustAllCerts = {new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }

                @Override
                public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                        throws CertificateException {
                }

                @Override
                public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                        throws CertificateException {
                }
            }};
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

            HostnameVerifier allHostsValid = new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            };
            HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }

}

5.接口编写

/**
 * @author huangquanguang
 * @date 2023/4/25 13:57
 * @description cas单点登录集成
 */
@Controller
@RequestMapping("/cas")
public class CasLoginController {

    @Autowired
    private AuthClient authClient;
    @Value("${cas.server-url-prefix:http://127.0.0.1:8443/cas}")
    public String casServerUrlPrefix;
    @Value("${cas.client-host-url:http://127.0.0.1}")
    public String casClientHostUrl;
    @Value("${cas.client-host-api-url:http://127.0.0.1/api/api-demo/cas/ssoLogin}")
    public String casClientHostApiUrl;
    @Value("${cas.client-host-ticket-url:http://127.0.0.1/api/api-demo/cas/checkTicket}")
    public String casClientHostTicketUrl;

    /**
     * 登录
     * @return
     */
    @GetMapping("/ssoLogin")
    @ResponseBody
    public JsonResult login(HttpServletRequest httpServletRequest){
        HttpSession session = httpServletRequest.getSession(false);
        if (session != null) {
            org.jasig.cas.client.validation.Assertion assertion = (Assertion) session.getAttribute(AbstractCasFilter.CONST_CAS_ASSERTION);
            String username = assertion.getPrincipal().getName();
            //调用auth接口获取jxbp的accessToken
            JsonResult tysfrz = authClient.tysfrz(username);
            return JsonResult.Success().setData(tysfrz.getData());
        }
        //处理登录的逻辑
        return JsonResult.Success().setData(httpServletRequest.getRemoteUser());
    }

    @GetMapping("/checkTicket")
    public void index(HttpServletResponse response,HttpServletRequest httpServletRequest) throws IOException {
        // 前端页面地址
        response.sendRedirect(casClientHostUrl+"/appPortal/casLogin");
    }

    /**
     * 注销
     * @return
     */
    @RequestMapping("/logout")
    public String logout(){
        return "redirect:"+ casServerUrlPrefix +"/logout?service="+ casClientHostTicketUrl;
    }

    @RequestMapping("/checkStatus")
    @ResponseBody
    public JsonResult checkStatus(HttpServletRequest request, HttpServletResponse response) {
        String user = request.getRemoteUser();
        if (StringUtils.isNotBlank(user)) {
            return JsonResult.Success();
        } else {
            return JsonResult.Fail("登录已过期");
        }
    }
}

6.前端首页处理

<template xmlns="http://www.w3.org/1999/html">
	<div >

		<header style="height: 60px">
			<span>客户端2验证:{{name}}</span>
			<button @click="logout">安全退出</button>
		</header>
		<router-view></router-view>
		<!--

	  <my-vue v-bind:lineID="lineID"></my-vue>-->
	</div>
</template>
<style lang="scss">
</style>
<script type="text/ecmascript-6">
	import LoginApi from '@/api/login'
	import Vue from "vue";
	import {ACCESS_TOKEN, CODE, PATH} from '@/store/mutation-types'
	import {timeFix} from '@/utils/util'
	import {mapState} from 'vuex';

	export default {

		data() {

			return {
				name:'ss'
			}

		},
		computed:{
			...mapState({
				//用户对象
				user: state => state.appSetting.user,
				//是否根租户
				isRootTenant: state => state.appSetting.user.tenantId==ROOT_TENANT,
				//当前租户ID
				tenantId:state => state.appSetting.user.tenantId,
				//是否管理员
				isAdmin:state => state.appSetting.user.admin,
				//是否根租户管理员
				isRootAdmin:state => state.appSetting.user.admin && state.appSetting.user.tenantId==ROOT_TENANT
			})
		},
		mounted(){
			let header = {headers: {'casHeader': true}};//一定要添加这个请求头
			let url = "http://127.0.0.1/api/api-demo/cas/ssoLogin";
			LoginApi.casLogin(url,header).then(res => {
				// 单点登录用户未登录，打开认证中心登录地址并将前端地址作为参数传回，以便登录成功跳转到前端页面
				if (res.code === 202) {
					//console.log(response);
					window.location.href = res.url
				} else if (res.code === 200) {
					var token = res.data.access_token;
					//设置登录token。
					Vue.ls.set(ACCESS_TOKEN, token, 12 * 60 * 60 * 1000);
					this.name = this.user.fullName
					// this.handRedirect(token);
				}
				console.log(res);
			})
		},
		created() {
			// this.times = setInterval(() => {
			// 	this.checkStatus();
			// }, 1000 * 60);
		},
		methods: {
			handRedirect(token) {
				this.$notification.success({
					message: '欢迎',
					description: `${timeFix()}，欢迎回来`,
					duration: 1,
					onClose: function () {
						location.href = PATH + '/' + CODE + '/home/index';
					}
				})
			},
			logout() {
				//清除系统登录信息session
				Vue.ls.remove(ACCESS_TOKEN);
				window.location.href = "http://127.0.0.1/api/api-demo/cas/logout"
			},
			checkStatus(){
				LoginApi.checkStatus("http://127.0.0.1/api/api-demo/cas/checkStatus").then(res => {
					if(res.code!=200){
						Vue.ls.remove(ACCESS_TOKEN);
						window.location.href = "http://127.0.0.1/api/api-demo/cas/logout"
					}
				})
			}
		}
	}
</script>

7.cas相关地址配置

##cas单点登录配置
#是否开启cas单点登录
checkTicketcas.is-open=true
#单点登录前缀
cas.server-url-prefix=http://127.0.0.1:8443/cas
#自定义项目后台地址
cas.client-host-url=http://127.0.0.1
#自定义项目后台单点登录接口
cas.client-host-api-url=http://127.0.0.1/api/api-demo/cas/ssoLogin
#检查票据接口地址
cas.client-host-ticket-url=http://127.0.0.1/api/api-demo/cas/

8.nginx配置

必须把前端访问地址和后端接口放在相同的域名下

#应用开发 前端
location /appPortal {
    proxy_set_header Host       $host;
    proxy_pass http://127.0.0.1:8083;
}
#gateway网关 后端
location /api/ {
    proxy_set_header Host       $host;
    #proxy_pass http://192.168.4.178:9900/;
    proxy_pass http://127.0.0.1:9900/;
}

9.测试效果

首次访问时，跳转统一身份登录页

http://127.0.0.1:8443/cas/login?service=http%3A%2F%2F127.0.0.1%3A7206%2Fcas%2FcheckTicket

登录成功后，跳转回来首页

http://127.0.0.1/appPortal/casLogin

在这里插入图片描述
点击安全退出后、再回到原来的登录页

http://127.0.0.1:8443/cas/login?service=http%3A%2F%2F127.0.0.1%3A7206%2Fcas%2FcheckTicket
今年下半年
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
cas退出流程设置解析之spring webflow的应用
m0_60635321的博客
04-11 543
接下来就随子涵先生结合cas的流程控制一探究竟吧~二、cas的登出流程控制我们知道cas的登录、登出流程是分别通过：login-webflow.xml、logout-webflow.xml定义的。
SpringBoot+CAS整合服务端和客户端实现SSO单点登录与登出快速入门上手
热门推荐
杨杨吖的博客
03-04 1万+
SpringBoot+CAS整合服务端和客户端实现SSO单点登录与登出快速入门上手
SpringBoot+Vue+Cas单点登录与登出
Curtisjia的博客
07-02 6016
前言 什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分.我们常见的实现框架有OAuth2和cas. 我下面的例子是基于其他博客的作者发给我的一个可运行示例进行一些说明, 实际上也就一个关键点, 一直困扰我们. 环境 cas服务5.2 springboot2.0.3 vue2.0 Tomcat8.5.39 这里需要注意, 我在内网运行cas服务端的时候,发现Tomcat8.0
前后端分离（springboot+Vue）集成cas
qq_65642052的博客
08-08 3655
springboot+Vue实现前后端分离项目集成cas
SpringBoot+Vue 前后端分离实现单点登录方案
java思维导图
08-15 1175
文章目录前言一、CAS是什么？二、搭建客户端系统引入CAS客户端后端搭建总结前言什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分，如图(不标准，只是方便理解)。一、CAS是什么？CAS 是 Yale 大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点...
前后端分离项目(springboot+vue)接入单点登录cas
u011322072的博客
10-27 3346
前后端分离单点登录cas解决方案
SpringBoot+Vue整合CAS
蒯厅博客
05-26 758
【代码】SpringBoot+Vue整合CAS。
SpringBoot+Vue+Redis实现单点登录(一处登录另一处退出登录)
08-25
小编接到一个需求，需要实现用户在浏览器登录后，跳转到其他页面，当用户在其它地方又登录时，前面用户登录的页面退出登录，这篇文章主要介绍了SpringBoot+Vue+Redis实现单点登录,需要的朋友可以参考下
使用springboot结合vue实现sso单点登录
08-25
使用 Spring Boot 结合 Vue 实现 SSO 单点登录 本文主要为大家详细介绍了如何使用 Spring Boot 和 Vue 实现 SSO 单点登录，具有一定的参考价值。下面我们将从技术角度深入探讨该实现的细节。 Spring Boot 的选择 ...
基于springboot+vue的网上书店系统源码.zip
05-12
基于springboot+vue的网上书店系统 开发语言：Java 框架：springboot JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7 数据库工具：Navicat 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 浏览器：...
前后端 springboot+Vue 实现登录注册功能
07-13
第一次做 还是后端错了 大佬勿喷 有不对的请多多指教呀
基于springboot+vue的商城管理系统源码+数据库（高分毕业设计）.zip
06-08
基于springboot+vue的商城管理系统源码+数据库（高分毕业设计）.zip 高分毕业设计项目，代码完整下载可用，纯手打高分毕业设计，也可作为期末大作业和课程设计，小白也可实战。 基于springboot+vue的商城管理系统...
SpringBoot+Vue+CAS 前后端分离实现单点登录方案
Java笔记虾
05-31 898
点击关注公众号，利用碎片时间学习文章目录前言一、CAS是什么？二、搭建客户端系统引入CAS客户端后端搭建总结前言什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分，如图(不标准，只是方便理解)。一、CAS是什么？CAS 是 Yale 大学发起...
2小时学会CAS+Security实现单点登录
02-29
   本课程全程使用目前比较流行的开发工具idea进行开发,涉及到目前互联网项目中最常用的高并发解决方案技术, 如  dubbo,redis,solr,freemarker,activeMQ,springBoot框架,微信支付,nginx负载均衡,电商活动秒杀,springSecurity安全框架,FastDFS分布式文件服务器,还会涉及到代码生成器,   前台的技术有angularJS和BootStrap框架,此课程内容丰富实战性强,如果你还是传统项目的开发人员,那你学完本课程会有很大的收获,让你的薪资上涨,5K以上,让你完全感受到了互联网思维带来的高并发解决方案的思路,如果你是开发的小白,建议你学完Spring,SpringMVC,MyBatis框架后再来学习本门课程,学完以后会让你完全体验到企业级开发的流程.在职开发人员学完后会让你的薪资更高,让你更了解互联网是如何解决高并发 学完SSM框架的同学就可以学习,能让你切身感受到企业级开发环境目标1：搭建单点登录服务端，开发单点登录客户端目标2：实现CAS 认证数据源设置目标3：更换CAS 登录页面目标4：掌握CAS与SpringSecurity集成 目标5：完成用户中心单点登录功能 
CAS退出问题
海浪博客|技术|游戏|生活|随心
08-20 2979
CAS 3.5.2.1 版本 退出的解决方法： 1.将
cas入门之二十三：单点登出基本机制
snoopy
08-12 7879
cas支持单点登出了，那么它的基本机制是什么呢？ 当用户经cas认证成功之后，就可以访问集成于cas的所有应用，而无需登录。那么认证是基于cookie 的，因为cas在cookie是放了tgt，这样用户就可以无须二次登录，就可以访问另外的应用。 但是cas为了安全，会给tgt设置一个过期的期限。当tgt过期之后，则cas会轮训这个tgt所访问的cas client端 应用，并向每个cas
(七)CAS 本地localhost调试,无法单点退出疑问
Xinghf
03-19 3707
干活的时候要多思考-------- 题记 昨天下午接到任务把内容汇聚平台和分发平台加上统一认证登录，之前弄过CAS，想想这个过程也就是按部就班的事情。在两个系统中web.xml添加 CAS相关filter，添加上CAS Client 端的jar包，修改退出接口为CAS退出接口，修改把用户信息写入到session模块，设置session的失效时间等，关于这一切配置完毕后执行，登录是可以成功登录的，并且实现了统一登录认证。但是在退出的时候貌似失效了，当遇到问题的时候不管三七
Shiro+Cas+Spring+Vue 前后端分离单点登录实现
qq_35167373的博客
12-29 9850
要实现单点登录的重点其实就是将  账号密码的验证 给独立出来当做一个独立的项目，只需要在此项目上一次通过验证即可。 而此项目不需要自己从头来写，已经有很多开源的实现。这里使用的是CAS 使用 CAS+Shiro 之前一定要，搞明白运行原理，可以少出和解决问题 去网上下载 cas-server-webapp-4.2.6.war 这个war（版本随意，4.2后配置文件可能有差别),修改为cas....
springboot+vue前后分离集成cas单点登录
最新发布
06-21
Spring Boot 和 Vue 前后分离项目中集成 CAS (Central Authentication Service，集中认证服务) 单点登录通常是一个常见的需求，这样可以提供统一的登录入口，用户在登录一次后可以在多个系统间无需再次登录。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值