CAS Vue 前后台分离

最新推荐文章于 2023-11-08 18:06:15 发布
最新推荐文章于 2023-11-08 18:06:15 发布
阅读量805 收藏
点赞数
分类专栏： cas 文章标签： vue.js 前端 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43903629/article/details/127284953
版权

google浏览器高本版 新增cookie安全机制 不好使了！！！

pom
  <!--CAS Client-->
    <dependency>
      <groupId>org.jasig.cas.client</groupId>
         <artifactId>cas-client-core</artifactId>
         <version>3.5.1</version>
   </dependency>

在这里插入图片描述

application.yml
# 应用名称
spring:
  application:
    name=vue-cas-client: vue-cas-client
server:
  port: 8012
cas:
  enable: true
  #后端服务地址(回调地址)
  client-host-url: http://192.168.0.113:8012/
  #cas认证中心地址
  server-url-prefix: http://192.168.0.113:8089/cas
  #cas认证中心登录地址
  server-login-url: http://192.168.0.113:8089/cas/login
  #cas不拦截
  ignore-pattern: (/file/*)|(/js)|(/test/*)
CasConfig
package com.example.vuecasclient.config;

import com.example.vuecasclient.filter.MyAuthenticationFilter;
import org.jasig.cas.client.session.SingleSignOutFilter;
import org.jasig.cas.client.session.SingleSignOutHttpSessionListener;
import org.jasig.cas.client.util.AssertionThreadLocalFilter;
import org.jasig.cas.client.util.HttpServletRequestWrapperFilter;
import org.jasig.cas.client.validation.Cas30ProxyReceivingTicketValidationFilter;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Configuration
public class CasConfig {

    @Autowired
    private CasProperties casProperties;

    public CasConfig() {
    }

    @Bean
    public CasProperties getCasProperties()
    {
        return new CasProperties();
    }

    @Bean
    public ServletListenerRegistrationBean<SingleSignOutHttpSessionListener> singleSignOutHttpSessionListener() {
        ServletListenerRegistrationBean<SingleSignOutHttpSessionListener> listener = new ServletListenerRegistrationBean<SingleSignOutHttpSessionListener>();
        listener.setEnabled(casProperties.getEnable());
        listener.setListener(new SingleSignOutHttpSessionListener());
        listener.setOrder(1);
        return listener;
    }

    /**
     * 该过滤器用于实现单点登出功能，单点退出配置，一定要放在其他filter之前
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean singleSignOutFilter() {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new SingleSignOutFilter());
        filterRegistration.setEnabled(casProperties.getEnable());
        filterRegistration.addUrlPatterns("/*");
        filterRegistration.addInitParameter("casServerUrlPrefix", casProperties.getServerUrlPrefix());
        filterRegistration.setOrder(3);
        return filterRegistration;
    }

    /**
     * 该过滤器负责用户的认证工作
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean authenticationFilter() {
        FilterRegistrationBean authenticationFilter = new FilterRegistrationBean();
        authenticationFilter.setFilter(new MyAuthenticationFilter());
        authenticationFilter.addUrlPatterns("/*");
        Map<String, String> initParameters = new HashMap<String, String>();
        initParameters.put("ignorePattern", casProperties.getIgnorePattern());
        initParameters.put("casServerLoginUrl", casProperties.getServerLoginUrl());
        initParameters.put("serverName", casProperties.getClientHostUrl());
        authenticationFilter.setInitParameters(initParameters);
        authenticationFilter.setOrder(2);
        List<String> urlPatterns = new ArrayList<String>();
        // 设置匹配的url
        authenticationFilter.setUrlPatterns(urlPatterns);
        return authenticationFilter;
    }

    /**
     * 该过滤器负责对Ticket的校验工作,使用CAS 3.0协议
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean cas30ProxyReceivingTicketValidationFilter() {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new Cas30ProxyReceivingTicketValidationFilter());
        filterRegistration.setEnabled(casProperties.getEnable());
        filterRegistration.addUrlPatterns("/*");
        filterRegistration.addInitParameter("casServerUrlPrefix", casProperties.getServerUrlPrefix());
        filterRegistration.addInitParameter("serverName", casProperties.getClientHostUrl());
        filterRegistration.setOrder(5);
        return filterRegistration;
    }

    /**
     * request wraper过滤器
     * @return
     */
    @Bean
    public FilterRegistrationBean httpServletRequestWrapperFilter() {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new HttpServletRequestWrapperFilter());
        filterRegistration.setEnabled(true);
        filterRegistration.addUrlPatterns("/*");
        filterRegistration.setOrder(6);
        return filterRegistration;
    }

    /**
     * 该过滤器使得可以通过org.jasig.cas.client.util.AssertionHolder来获取用户的登录名。
     * 比如AssertionHolder.getAssertion().getPrincipal().getName()。
     * 这个类把Assertion信息放在ThreadLocal变量中，这样应用程序不在web层也能够获取到当前登录信息
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean assertionThreadLocalFilter() {
        FilterRegistrationBean filterRegistration = new FilterRegistrationBean();
        filterRegistration.setFilter(new AssertionThreadLocalFilter());
        filterRegistration.setEnabled(true);
        filterRegistration.addUrlPatterns("/*");
        filterRegistration.setOrder(7);
        return filterRegistration;
    }
}
CasProperties
package com.example.vuecasclient.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix="cas")
public class CasProperties {

    private Boolean enable;

    private String clientHostUrl;

    private String serverUrlPrefix;

    private String serverLoginUrl;

    private String ignorePattern;

    public Boolean getEnable() {
        return enable;
    }

    public void setEnable(Boolean enable) {
        this.enable = enable;
    }

    public String getClientHostUrl() {
        return clientHostUrl;
    }

    public void setClientHostUrl(String clientHostUrl) {
        this.clientHostUrl = clientHostUrl;
    }

    public String getServerUrlPrefix() {
        return serverUrlPrefix;
    }

    public void setServerUrlPrefix(String serverUrlPrefix) {
        this.serverUrlPrefix = serverUrlPrefix;
    }

    public String getServerLoginUrl() {
        return serverLoginUrl;
    }

    public void setServerLoginUrl(String serverLoginUrl) {
        this.serverLoginUrl = serverLoginUrl;
    }

    public String getIgnorePattern() {
        return ignorePattern;
    }

    public void setIgnorePattern(String ignorePattern) {
        this.ignorePattern = ignorePattern;
    }
}
CorsConfig
package com.example.vuecasclient.config;


import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;


@Configuration
public class CorsConfig
{
    @Bean
    public FilterRegistrationBean corsFilter()
    {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(Boolean.valueOf(true));
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source), new ServletRegistrationBean[0]);
        bean.setOrder(0);
        return bean;
    }
}
LoginController
package com.example.vuecasclient.controller;

import org.jasig.cas.client.authentication.AttributePrincipal;
import org.jasig.cas.client.validation.Assertion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.security.Principal;
import java.util.HashMap;
import java.util.Map;

@Controller
public class LoginController {
    @Autowired
    private HttpServletRequest request;

    @Value("${cas.server-url-prefix}")
    private String casServerUrlPrefix;

    @RequestMapping({"/getUserInfo"})
    @ResponseBody
    public Object getUserInfo() {
        Map<String, Object> userApi = new HashMap();

        Assertion assertion = (Assertion) this.request.getSession().getAttribute("_const_cas_assertion_");
        if (assertion != null) {
            String loginName = assertion.getPrincipal().getName();

            Principal principal = (AttributePrincipal) this.request.getUserPrincipal();
            String id = this.request.getSession().getId();
            System.out.println("JSESSIONID:  "+id);
            if ((this.request.getUserPrincipal() != null) &&
                    ((principal instanceof AttributePrincipal))) {
                Map<String, Object> result = ((AttributePrincipal) principal).getAttributes();
                userApi.put("loginName", loginName);
                userApi.put("sex", result.get("sex"));
                userApi.put("userName", result.get("userName"));
                userApi.put("telephone", result.get("telephone"));
                userApi.put("remark", result.get("remark"));
                userApi.put("JSESSIONID",id);
            }
        }
        return userApi;
    }

    @RequestMapping(value = {"/redirect"}, produces = {"text/plain;charset=UTF-8"})
    public String redirect(String url,HttpSession session) {
        String sessionId = session.getId();
        return "redirect:" + url;
    }

    @RequestMapping({"/loginout"})
    public String loginout(String url, HttpSession session) {
        session.invalidate();
        return "redirect:" + casServerUrlPrefix + "/logout?service=" + url;
    }

    @RequestMapping(value = {"/test"})
    @ResponseBody
    public String test(HttpSession session) {
        System.out.println("test......");
        return "test";
    }
}
MyAuthenticationFilter
// An highlighted block
package com.example.vuecasclient.filter;

import com.example.vuecasclient.config.CasProperties;
import com.example.vuecasclient.utils.SpringUtil;
import org.apache.commons.lang3.StringUtils;
import org.jasig.cas.client.Protocol;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.jasig.cas.client.authentication.*;
import org.jasig.cas.client.configuration.ConfigurationKeys;
import org.jasig.cas.client.util.AbstractCasFilter;
import org.jasig.cas.client.util.CommonUtils;
import org.jasig.cas.client.util.ReflectUtils;
import org.jasig.cas.client.validation.Assertion;
import org.springframework.stereotype.Component;

@Component
public class MyAuthenticationFilter extends AbstractCasFilter {


    private String casServerLoginUrl;

    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<String, Class<? extends UrlPatternMatcherStrategy>>();

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

    public MyAuthenticationFilter() {
        this(Protocol.CAS2);
    }

    protected MyAuthenticationFilter(final Protocol protocol) {
        super(protocol);
    }

    @Override
    protected void initInternal(final FilterConfig filterConfig) throws ServletException {
        if (!isIgnoreInitConfiguration()) {
            super.initInternal(filterConfig);

            String loginUrl = getString(ConfigurationKeys.CAS_SERVER_LOGIN_URL);
            if (loginUrl != null) {
                setCasServerLoginUrl(loginUrl);
            } else {
                setCasServerUrlPrefix(getString(ConfigurationKeys.CAS_SERVER_URL_PREFIX));
            }

            setRenew(getBoolean(ConfigurationKeys.RENEW));
            setGateway(getBoolean(ConfigurationKeys.GATEWAY));

            final String ignorePattern = getString(ConfigurationKeys.IGNORE_PATTERN);
            final String ignoreUrlPatternType = getString(ConfigurationKeys.IGNORE_URL_PATTERN_TYPE);

            if (ignorePattern != null) {
                final Class<? extends UrlPatternMatcherStrategy> ignoreUrlMatcherClass = PATTERN_MATCHER_TYPES.get(ignoreUrlPatternType);
                if (ignoreUrlMatcherClass != null) {
                    this.ignoreUrlPatternMatcherStrategyClass = ReflectUtils.newInstance(ignoreUrlMatcherClass.getName());
                } else {
                    try {
                        logger.trace("Assuming {} is a qualified class name...", ignoreUrlPatternType);
                        this.ignoreUrlPatternMatcherStrategyClass = ReflectUtils.newInstance(ignoreUrlPatternType);
                    } catch (final IllegalArgumentException e) {
                        logger.error("Could not instantiate class [{}]", ignoreUrlPatternType, e);
                    }
                }
                if (this.ignoreUrlPatternMatcherStrategyClass != null) {
                    this.ignoreUrlPatternMatcherStrategyClass.setPattern(ignorePattern);
                }
            }

            final Class<? extends GatewayResolver> gatewayStorageClass = getClass(ConfigurationKeys.GATEWAY_STORAGE_CLASS);

            if (gatewayStorageClass != null) {
                setGatewayStorage(ReflectUtils.newInstance(gatewayStorageClass));
            }

            final Class<? extends AuthenticationRedirectStrategy> authenticationRedirectStrategyClass = getClass(ConfigurationKeys.AUTHENTICATION_REDIRECT_STRATEGY_CLASS);

            if (authenticationRedirectStrategyClass != null) {
                this.authenticationRedirectStrategy = ReflectUtils.newInstance(authenticationRedirectStrategyClass);
            }
        }
    }

    @Override
    public void init() {
        super.init();

        String message = String.format(
                "one of %s and %s must not be null.",
                ConfigurationKeys.CAS_SERVER_LOGIN_URL.getName(),
                ConfigurationKeys.CAS_SERVER_URL_PREFIX.getName());

        CommonUtils.assertNotNull(this.casServerLoginUrl, message);
    }

    @Override
    public final void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse,
                               final FilterChain filterChain) throws IOException, ServletException {

        final HttpServletRequest request = (HttpServletRequest) servletRequest;
        final HttpServletResponse response = (HttpServletResponse) servletResponse;

        String id = request.getSession().getId();
        System.out.println("Authentication id  "+id);

//        response.setHeader("Set-Cookie", "JSESSIONID="+id+";SameSite=None;Secure");

        if (isRequestUrlExcluded(request)) {
            logger.debug("Request is ignored.");
            filterChain.doFilter(request, response);
            return;
        }

        final HttpSession session = request.getSession(false);
        final Assertion assertion = session != null ? (Assertion) session.getAttribute(CONST_CAS_ASSERTION) : null;

        if (assertion != null) {
            filterChain.doFilter(request, response);
            return;
        }

        final String serviceUrl = constructServiceUrl(request, response);
        final String ticket = retrieveTicketFromRequest(request);
        final boolean wasGatewayed = this.gateway && this.gatewayStorage.hasGatewayedAlready(request, serviceUrl);

        if (CommonUtils.isNotBlank(ticket) || wasGatewayed) {
            filterChain.doFilter(request, response);
            return;
        }

        final String modifiedServiceUrl;

        logger.debug("no ticket and no assertion found");
        if (this.gateway) {
            logger.debug("setting gateway attribute in session");
            modifiedServiceUrl = this.gatewayStorage.storeGatewayInformation(request, serviceUrl);
        } else {
            modifiedServiceUrl = serviceUrl;
        }

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

        String urlToRedirectTo = CommonUtils.constructRedirectUrl(this.casServerLoginUrl,
                getProtocol().getServiceParameterName(), modifiedServiceUrl, this.renew, this.gateway);

        this.logger.debug("redirecting to \"{}\"", urlToRedirectTo);
        CasProperties prop = (CasProperties) SpringUtil.getBean("casProperties");
        String subUrl = StringUtils.substringBefore(urlToRedirectTo, "service=");
        String redirectUrl = subUrl + "service=" + prop.getClientHostUrl() + "redirect?url=";
        response.setStatus(403);
        response.setHeader("Access-Control-Expose-Headers", "TOKEN_URL");
        response.setHeader("TOKEN_URL", redirectUrl);

//        String xRequested = request.getHeader("x-requested-with");
//            if ("XMLHttpRequest".equals(xRequested)) {
//            String urlToRedirectTo = CommonUtils.constructRedirectUrl(this.casServerLoginUrl,
//                    getProtocol().getServiceParameterName(), modifiedServiceUrl, this.renew, this.gateway);
//
//            this.logger.debug("redirecting to \"{}\"", urlToRedirectTo);
//            CasProperties prop = (CasProperties) SpringUtil.getBean("casProperties");
//            String subUrl = StringUtils.substringBefore(urlToRedirectTo, "service=");
//            String redirectUrl = subUrl + "service=" + prop.getClientHostUrl() + "redirect?url=";
//            response.setStatus(403);
//            response.setHeader("Access-Control-Expose-Headers", "TOKEN_URL");
//            response.setHeader("TOKEN_URL", redirectUrl);
//        } else {
//            final String urlToRedirectTo = CommonUtils.constructRedirectUrl(this.casServerLoginUrl,
//                    getProtocol().getServiceParameterName(), modifiedServiceUrl, this.renew, this.gateway);
//
//            logger.debug("redirecting to \"{}\"", urlToRedirectTo);
//            this.authenticationRedirectStrategy.redirect(request, response, urlToRedirectTo);
//        }

    }

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

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

    public final void setCasServerUrlPrefix(final String casServerUrlPrefix) {
        setCasServerLoginUrl(CommonUtils.addTrailingSlash(casServerUrlPrefix) + "login");
    }

    public final void setCasServerLoginUrl(final String casServerLoginUrl) {
        this.casServerLoginUrl = casServerLoginUrl;
    }

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

    private boolean isRequestUrlExcluded(final HttpServletRequest request) {
        if (this.ignoreUrlPatternMatcherStrategyClass == null) {
            return false;
        }

        final StringBuffer urlBuffer = request.getRequestURL();
        if (request.getQueryString() != null) {
            urlBuffer.append("?").append(request.getQueryString());
        }
        final String requestUri = urlBuffer.toString();
        return this.ignoreUrlPatternMatcherStrategyClass.matches(requestUri);
    }

    public final void setIgnoreUrlPatternMatcherStrategyClass(
            final UrlPatternMatcherStrategy ignoreUrlPatternMatcherStrategyClass) {
        this.ignoreUrlPatternMatcherStrategyClass = ignoreUrlPatternMatcherStrategyClass;
    }

}

前端

sso-login.js
/*
 * @Descripttion: 
 * @Author: jibl
 * @Date: 2022-06-16 17:07:21
 * @LastEditors: jibl
 * @LastEditTime: 2022-10-12 15:19:46
 */
'use strict'

import axios from 'axios'

axios.defaults.withCredentials = true
axios.defaults.crossDomain = true

axios.interceptors.response.use(
  response => {
    return response;
  },
  error => {
    // && response.config.url !== 'http://192.168.0.30:7003/polymerization/getMsgErrorLst'
    const response = error.response
    if (response && response.status === 403) {
      window.location.href = response.headers['token_url'] + window.location.href
    }
  })
;

main.js引入sso-login.js后测试：

<el-button @click="postRequest" type="primary">发送请求</el-button>
postRequest() {
        axios({
            method: "get",
            url: "http://192.168.0.113:8012/getUserInfo",
            params: {},
            headers: {
              "Content-Type": "application/json; charset=UTF-8",
              "x-requested-with": "XMLHttpRequest",
            },
          })
          .then((res) => {
            console.log("userinfo.......", res)
          })
          .catch((err) => {
            console.log(err);
          });
一只散修道友
关注
专栏目录
前后端分离集成cas
04-30
springboot(springboot + shiro + oracle) + vue 集成cas
springboot+vue+cas前后端分离实现单点登录
weixin_43483911的博客
06-11 5278
springboot+vue+cas前后端分离实现单点登录 提示：cas服务已经搭建完毕 文章目录前言一、CAS是什么？二、搭建客户端系统1.引入CAS2.客户端后端搭建总结 前言 什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分，如图(不标准，只是方便理解)。 一、CAS是什么？ CAS 是 Yale 大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点
Springboot和vue前后端分离项目接入cas单点登录，解决跨域
明晓默的博客
03-08 6544
前后端分离项目接入cas单点的登录，解决跨域
Vue 接入 CAS统一认证登录
dongwuming的专栏
07-11 3335
CAS（Central Authentication Service）是一种单点登录协议，可以实现多个应用程序之间的用户身份认证和授权。在 Vue 中接入 CAS 统一认证，可以实现用户在一个应用程序中登录后，在其他应用程序中无需再次登录，提高用户体验。以下是在 Vue 中接入 CAS 统一认证的一般步骤：安装库在main.js中引入库其中，是 CAS 服务器的 URL 前缀，是 Vue 应用程序的 URL。在需要进行认证的组件中使用方法进行登录login() {在需要进行认证的路由中添加属性在。
SpringBoot+Vue+Cas单点登录与登出
Curtisjia的博客
07-02 6187
前言 什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分.我们常见的实现框架有OAuth2和cas. 我下面的例子是基于其他博客的作者发给我的一个可运行示例进行一些说明, 实际上也就一个关键点, 一直困扰我们. 环境 cas服务5.2 springboot2.0.3 vue2.0 Tomcat8.5.39 这里需要注意, 我在内网运行cas服务端的时候,发现Tomcat8.0
前后台分离 + vue
12-27
在现代Web开发中，"前后台分离 + Vue"是一种常见的架构模式，旨在提高开发效率、增强系统的可维护性和可扩展性。Vue.js 是一个轻量级的JavaScript框架，以其易用性、灵活性和高性能而备受开发者青睐。在这个项目中，...
SpringBoot+Vue前后端分离
06-29
本文将深入探讨基于"Spring Boot+Vue"实现的前后端分离项目，以及其中涉及到的关键技术点。 首先，Spring Boot是Java领域的一个轻量级框架，它简化了Spring应用程序的初始设置和配置。通过内置的Tomcat服务器、自动...
egg云部署vue前后台
07-13
主要是解决云部署egg时，不借助nginx的情况下，egg访问前后台 ，演示地址请点链接https://blog.csdn.net/xuelang532777032/article/details/125757453
Spring Boot Vue前后端分离开发实战.pdf
04-21
综上所述，文档《Spring Boot Vue前后端分离开发实战.pdf》涵盖了前后端分离的开发模式、Spring Boot和Vue.js的基础知识和使用、开发环境的搭建、前后端交互的实现、项目配置与启动、数据库操作、前端开发的实践等多...
单点登录CAS集成前后台分离vue项目
热门推荐
Amustrming的博客
07-08 1万+
spring boot项目访问jsp页面已经介绍了如何在springboot项目中访问jsp页面，有了上面的基础在下面实现cas集成vue项目，由于vue项目是前后台分离的，在此记录下具体集成的步骤，方便以后查看 项目背景：cas集成的项目是使用renren-fast提供的开源框架，后台是用spring boot写的，前台使用vue。这里用cas集成的项目是在不改变项目原有登录机制的情况下，为项...
前后端分离项目(springboot+vue)接入单点登录cas
u011322072的博客
10-27 4974
前后端分离单点登录cas解决方案
前后端分离（springboot+Vue）集成cas
qq_65642052的博客
08-08 4243
springboot+Vue实现前后端分离项目集成cas
【Java编程】-CAS单点登录
路漫漫的博客
04-10 622
CAS-Ticket TGT（Ticket Grangting Ticket） TGT是CAS为用户签发的登录票据，拥有了TGT，用户就可以证明自己在CAS成功登录过 TGT封装了Cookie值以及此Cookie值对应的用户信息。 用户在CAS认证成功后，CAS生成cookie（叫TGC），写入浏览器，同时生成一个TGT对象，放入自己的缓存，TGT对象的ID就是cookie的值。 当HTTP再次请...
Cas单点登录集成前后端分离项目
weixin_44837750的博客
11-24 7063
文章目录前言一、整合前后端分离遇到的问题二、CAS整合前后端分离项目实战第一步、引入CAS客户端依赖第二步、编写Cas经典拦截器的配置类第三步、编写一个CasController，专门负责Cas的业务第四步、进行完整测试单点退出功能总结 前言     现在由于单点登录的普及，Cas和Oauth2都能完成，最简单的方法是将Cas的依赖导入后，添加上Cas的过滤器，当用户访问系统时就会被拦截，然后就可以重定向到SSO单点登录界面进行单点登录了，登录完成后就会将用户信息.
SpringBoot前后端分离整合cas（客户端）
最新发布
weixin_42949219的博客
11-08 1171
cas认证详细流程：前后端分离：项目前端使用nginx启动，后端是springBoot服务；，避免出现跨域问题。
springboot+vue+cas实现单点登录、退出
qq_29467891的博客
04-26 2049
*** @description 重写拦截器自定义状态码，实现前后端分离的单点登录*/} //升级cas-client版本后// if(!} else {
SpringBoot+Vue+CAS 前后端分离实现单点登录方案
Java笔记虾
05-31 926
点击关注公众号，利用碎片时间学习文章目录前言一、CAS是什么？二、搭建客户端系统引入CAS客户端后端搭建总结前言什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分，如图(不标准，只是方便理解)。一、CAS是什么？CAS 是 Yale 大学发起...
【工作记录】前后端分离场景下CAS单点登录的集成思路与实践@20230926
泽济天下的专栏
09-26 1055
主要记录前后端分离场景下实现CAS单点登录的流程和思路。
Spring Boot与Vue前后端分离实战教程
"该资源是关于《Spring Boot Vue前后端分离开发实战》的PDF文档，适合初学者，内容详实易懂。文档中提到了如何使用Spring Boot与Vue.js进行前后端分离的开发，以及相关的工具和配置。" 在本文档中，作者详细介绍了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值