Spring Security整合CAS

最新推荐文章于 2025-04-11 15:01:00 发布
最新推荐文章于 2025-04-11 15:01:00 发布
阅读量1.2w 收藏 60
点赞数 10
分类专栏： Spring Boot 文章标签： java spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/new_ord/article/details/109709181
版权
本文详细介绍了如何在Spring Boot项目中集成CAS（Central Authentication Service）以处理前后端分离场景的用户登录和登出流程，包括配置CasAuthenticationEntryPoint、CasAuthenticationFilter和定制重定向策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

CAS(中央认证服务)

从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS Client 负责处理对客户端受保护资源的访问请求，需要登录时，重定向到 CAS Server。图1 是 CAS 最基本的协议过程：

CAS Client 与受保护的客户端应用部署在一起，以 Filter 方式保护受保护的资源。对于访问受保护资源的每个 Web 请求，CAS Client 会分析该请求的 Http 请求中是否包含 Service Ticket，如果没有，则说明当前用户尚未登录，于是将请求重定向到指定好的 CAS Server 登录地址，并传递 Service （也就是要访问的目的资源地址），以便登录成功过后转回该地址。用户在第 3 步中输入认证信息，如果登录成功，CAS Server 随机产生一个相当长度、唯一、不可伪造的 Service Ticket，并缓存以待将来验证，之后系统自动重定向到 Service 所在地址，并为客户端浏览器设置一个 Ticket Granted Cookie（TGC），CAS Client 在拿到 Service 和新产生的 Ticket 过后，在第 5，6 步中与 CAS Server 进行身份核实，以确保 Service Ticket 的合法性

在该协议中，所有与 CAS 的交互均采用 SSL 协议，确保，ST 和 TGC 的安全性。协议工作过程中会有 2 次重定向的过程，但是 CAS Client 与 CAS Server 之间进行 Ticket 验证的过程对于用户是透明的

另外，CAS 协议中还提供了 Proxy （代理）模式，以适应更加高级、复杂的应用场景，具体介绍可以参考 CAS 官方网站上的相关文档

以上摘自百度百科


数据库设计

建表主要以下几张表，不过也可以添加一些其他表，比如保存前端模块的表module，保存前端菜单的表menu，至于表中字段根据自己需求来设计，学习也是需要自己来参与的。


相关依赖

主要依赖版本：

springboot-2.3.0
spring-security-casspring-security-cas 5.2.2

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-cas</artifactId>
    <version>5.2.2.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
  </dependency>

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
  </dependency>

  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
  </dependency>

  <dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
  </dependency>

  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
  </dependency>
</dependencies>

配置文件

对于CAS服务端搭建就省略了，可以去官网 下载，实际就是一个war包，放到tomcat的webapps下就可以了，具体安装流程可以自行Google，资源有很多。

server:
  servlet:
    context-path: "/test"

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cas?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456

#客户端地址
app:
  server:
    host:
      url: http://${host:localhost}:8080/test
  login:
    url: /login
  logout:
    url: /logout

#cas认证中心地址
cas:
  server:
    host: http://localhost:8081/cas
    login_url: http://localhost:8081/cas/login
    logout_url: http://localhost:8081/cas/logout?service=http://${host:localhost}:8080/test/app/login
#logging:
#  level:
#    root: debug

相关配置类

声明一下主要展示spring security如何配置CAS，其他基本操作就不一一列举。

首先新建一个YmlProperties类来读取application.yml的相关配置

@Component
@Data
public class YmlProperties {

  @Value("${app.server.host.url}")
  private String appServerUrl;

  @Value("${app.login.url}")
  private String appLoginUrl;

  @Value("${app.logout.url}")
  private String appLogoutUrl;

  @Value("${cas.server.host}")
  private String casServerUrl;

  @Value("${cas.server.login_url}")
  private String casServerLoginUrl;

  @Value("${cas.server.logout_url}")
  private String casServerLogoutUrl;
}

新建UserDetail类封装我们需要的用户信息

注意如果没有相关需求，此类可以不建，直接使用spring security提供的org.springframework.security.core.userdetails.User类。

public class UserDetail extends User implements UserDetails, CredentialsContainer {

  private Long userId;

  public UserDetail(String username,String password, Collection<? extends GrantedAuthority> authorities){
    super(username,password,true,true,true,true,authorities);
  }

  public Long getUserId() {
    return userId;
  }

  public void setUserId(Long userId) {
    this.userId = userId;
  }
}

新建MyUserDetailsService类实现AuthenticationUserDetailsService接口

涉及的查询语句可以自己完成，一个是根据用户名查询用户信息，一个是根据用户id查询角色权限，根据上述建的中间表关联查询，都是一些基础的查询语句，这里就不贴出来了。

@Service
public class MyUserDetailsService implements AuthenticationUserDetailsService<CasAssertionAuthenticationToken>{

  @Autowired
  private UserService userService;

  @Autowired
  private PermissionMapper permissionMapper;


  @Override
  public UserDetails loadUserDetails(CasAssertionAuthenticationToken token)
      throws UsernameNotFoundException {
    User user = userService.findByName(token.getName());
    if (Objects.isNull(user)) {
      throw new RuntimeException("用户不存在");
    }
List<String> roleCodes = permissionMapper.getPermissionByUser(user.getId());
    if (CollectionUtils.isEmpty(roleCodes)) {
      throw new RuntimeException("账户[" + user.getUsername() + "]未绑定角色");
    }
    Set<GrantedAuthority> authorities = new HashSet<>();
    for (String roleCode : roleCodes) {
      authorities.add(new SimpleGrantedAuthority(roleCode));
    }

    UserDetail userDetail=new UserDetail(user.getUsername(),user.getPassword(),authorities);
    userDetail.setUserId(user.getId());
    return userDetail;
  }

}

新建SecurityConfiguration类实现WebSecurityConfigurerAdapter接口

如果想了解每个Bean的相关作用和spring security是如何和CAS交互的，参考spring官网说明 ,官网详细介绍了整个流程，一定要自己理解。

不管是spring security还是其他技术，个人建议还是首先去看官网给的文档，他可以解决大部分问题，而后再去Google。

其实以下这些配置就是根据官网一步一步配置的，官网给的是xml配置，可能有的小伙伴一看到就直接放弃不看去Google了，如今都用springboot谁还学习xml如何配置，不过如果静下心去看的话，完全可以根据xml配置自己转化成配置类。

@Slf4j
@EnableWebSecurity
//开启@Secured和@PreAuthorize
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

  @Autowired
  private YmlProperties ymlProperties;

  @Autowired
  private MyUserDetailsService myUserDetailsService;

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests() //配置安全策略
        .antMatchers("/login").permitAll()
        .anyRequest().authenticated() 
        .and()
        .csrf().disable()
        .logout().permitAll() //logout不需要验证
        .and()
        .headers().frameOptions().disable()
        .and()
        .cors()
        .and().formLogin(); //使用form表单登录

    http.exceptionHandling().authenticationEntryPoint(myCasAuthenticationEntryPoint)
        .and()
        .addFilter(casAuthenticationFilter())
        .addFilterBefore(casLogoutFilter(), LogoutFilter.class)
        .addFilterBefore(singleSignOutFilter(), CasAuthenticationFilter.class);
  }


  @Override
  protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    super.configure(auth);
    auth.authenticationProvider(casAuthenticationProvider());
  }

  /**
   * 主要配置的是ServiceProperties的service属性，它指定的是cas回调的地址
   */
  @Bean
  public ServiceProperties serviceProperties() {
    ServiceProperties serviceProperties = new ServiceProperties();
    serviceProperties.setService(ymlProperties.getAppServerUrl() + ymlProperties.getAppLoginUrl());
    serviceProperties.setSendRenew(false);
    serviceProperties.setAuthenticateAllArtifacts(true);
    return serviceProperties;
  }

  /**
   * 认证的入口，指定cas服务器的登录地址，指定ServiceProperties(主要是获取回调地址)
   */
  @Bean
  public CasAuthenticationEntryPoint casAuthenticationEntryPoint() {
    CasAuthenticationEntryPoint casAuthenticationEntryPoint = new CasAuthenticationEntryPoint();
    casAuthenticationEntryPoint
        .setLoginUrl(ymlProperties.getCasServerLoginUrl());
    casAuthenticationEntryPoint.setServiceProperties(serviceProperties());
    return casAuthenticationEntryPoint;
  }


  @Bean
  public CasAuthenticationFilter casAuthenticationFilter() throws Exception {
    CasAuthenticationFilter casAuthenticationFilter = new CasAuthenticationFilter();
    casAuthenticationFilter.setServiceProperties(serviceProperties());    casAuthenticationFilter.setFilterProcessesUrl(ymlProperties.getAppLoginUrl());
    casAuthenticationFilter.setAuthenticationManager(authenticationManager());

    //指定登录成功后跳转页面，也可以使用SavedRequestAwareAuthenticationSuccessHandler
//    SavedRequestAwareAuthenticationSuccessHandler handler=new SavedRequestAwareAuthenticationSuccessHandler();
//    handler.setRedirectStrategy(new MyRedirectStrategy());
//    casAuthenticationFilter.setAuthenticationSuccessHandler(handler);
    casAuthenticationFilter.setAuthenticationSuccessHandler(
        new SimpleUrlAuthenticationSuccessHandler(
            ymlProperties.getAppServerUrl() + "/hello"));
    casAuthenticationFilter.setSessionAuthenticationStrategy(sessionAuthenticationStrategy());
    return casAuthenticationFilter;
  }

//  class MyRedirectStrategy extends DefaultRedirectStrategy {
//
//    @Override
//    public void sendRedirect(HttpServletRequest request, HttpServletResponse response, String url)
//        throws IOException {
//      String redirectUrl = calculateRedirectUrl(request.getContextPath(), url);
//      redirectUrl = response.encodeRedirectURL(redirectUrl);
//      log.info(redirectUrl);
//      if(redirectUrl.startsWith("http://")){
//        if(redirectUrl.contains("/app/login")){
//          redirectUrl="http://localhost:8080/test/index";
//        }
//      }
//      response.sendRedirect(redirectUrl);
//    }
//  }


  @Bean
  public CasAuthenticationProvider casAuthenticationProvider() {
    CasAuthenticationProvider casAuthenticationProvider = new CasAuthenticationProvider();
    casAuthenticationProvider.setServiceProperties(serviceProperties());
    casAuthenticationProvider.setTicketValidator(cas20ServiceTicketValidator());
    casAuthenticationProvider
        .setAuthenticationUserDetailsService(myUserDetailsService);
    casAuthenticationProvider.setKey("casAuthenticationProviderKey");
    return casAuthenticationProvider;
  }


  /**
   * 验证ticker，向cas服务器发送验证请求
   */
  @Bean
  public Cas20ServiceTicketValidator cas20ServiceTicketValidator() {
    //转Https请求
//    HttpURLConnectionFactory httpURLConnectionFactory=new HttpURLConnectionFactory() {
//      @Override
//      public HttpURLConnection buildHttpURLConnection(URLConnection urlConnection) {
//        SSLContext sslContext=null;
//        try {
//          sslContext = SSLContext.getInstance("SSL");
//          sslContext.init(new KeyManager[]{},new TrustManager[]{new X509TrustManager() {
//            @Override
//            public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
//                throws CertificateException {
//
//            }
//
//            @Override
//            public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
//                throws CertificateException {
//
//            }
//
//            @Override
//            public X509Certificate[] getAcceptedIssuers() {
//              return new X509Certificate[0];
//            }
//          }},null);
//          SSLSocketFactory socketFactory=sslContext.getSocketFactory();
//
//          if(urlConnection instanceof HttpsURLConnection){
//            HttpsURLConnection httpsURLConnection=(HttpsURLConnection)urlConnection;
//            httpsURLConnection.setSSLSocketFactory(socketFactory);
//            httpsURLConnection.setHostnameVerifier((s,l)->true);
//          }
//
//          return (HttpURLConnection)urlConnection;
//
//        }catch (Exception e){
//          throw new RuntimeException(e);
//        }
//      }
//    };
    Cas20ServiceTicketValidator cas20ServiceTicketValidator = new Cas20ServiceTicketValidator(
        ymlProperties.getCasServerUrl());
    cas20ServiceTicketValidator.setEncoding("UTF-8");
    return cas20ServiceTicketValidator;
  }


  @Bean
  public SessionAuthenticationStrategy sessionAuthenticationStrategy() {
    SessionAuthenticationStrategy sessionAuthenticationStrategy = new SessionFixationProtectionStrategy();
    return sessionAuthenticationStrategy;
  }


  /**
   * 此过滤器向cas发送登出请求
   */
  @Bean
  public SingleSignOutFilter singleSignOutFilter() {
    SingleSignOutFilter singleSignOutFilter = new SingleSignOutFilter();
    singleSignOutFilter.setCasServerUrlPrefix(ymlProperties.getCasServerUrl());
    singleSignOutFilter.setIgnoreInitConfiguration(true);
    return singleSignOutFilter;
  }

  /**
   * 此过滤器拦截客户端的logout请求，发现logout请求后向cas服务器发送登出请求
   */
  @Bean
  public LogoutFilter casLogoutFilter() {
    LogoutFilter logoutFilter = new LogoutFilter(ymlProperties.getCasServerLogoutUrl(),
        new SecurityContextLogoutHandler());
    logoutFilter.setFilterProcessesUrl(ymlProperties.getAppLogoutUrl());
    return logoutFilter;
  }

  /**
   * 去除@Secured的前缀 "ROLE_"
   * @return
   */
  @Bean
  public GrantedAuthorityDefaults grantedAuthorityDefaults() {
    return new GrantedAuthorityDefaults("");
  }

}

新建HelloController

@Slf4j
@RestController
public class HelloController {

  @Secured("security_index") 
  //@PreAuthorize("hasAnyAuthority('security_index')")
  @GetMapping("/hello")
  public String hello() {
    return "首页";
  }
}

浏览器访问http://localhost:8080/test/login 如果未登录会跳转到CAS服务端登录页。


前后端分离项目遇到的问题

对于前后端分离面临的问题是后端不干涉前端页面跳转，在退出登录后，访问前端页面仍可以访问，前端向后端发送请求后端拦截重定向到CAS服务端地址，但是前端页面跳转失败。虽说页面数据是不会加载，但是这不符合我们希望实现的。

目前想到通过实现AuthenticationEntryPoint并重定向到指定接口，返回页面
CAS服务端跳转地址，前端通过拦截器在每个页面访问时都会向后端指定接口发送请求，如果没有登录就会返回CAS服务端地址，登录后直接放行，具体判断我们通过返回状态码来实现。

新建AuthController

方法中Result类是自定义的统一返回json格式，我会在下面贴出来。

@Slf4j
@RestController
public class HelloController {

  @Autowired
  private YmlProperties ymlProperties;

  /**
   * 适用前后端分离
   * 当未登录时重定向到此请求，返回给前端CAS服务器登录地址，通过前端跳转
   * @return
   */
  @GetMapping("/send")
  public Result send() {
    String url =
        ymlProperties.getCasServerLoginUrl() + "?service=" + ymlProperties.getAppServerUrl()
            + ymlProperties.getAppLoginUrl();
    return Result.failed().setCode(444).setData(url).setMessage("未登录").setSuccess(false);
  }

  /**
   * 适用前后端分离
   * 当登录成功后返回前端数据
   * @return
   */
  @GetMapping("/login")
  public Result login(){
    return Result.success(null,"已登录");
  }
}

Result统一返回json格式

对于Result类中静态方法可以自己扩展。

public interface IErrorCode {
    long getCode();
    String getMessage();
}

public enum ResultCode implements IErrorCode {
    FAILED(500,"操作失败"),
    SUCCESS(200,"操作成功");
    private long code;
    private String message;

    private ResultCode(long code,String message){
        this.code=code;
        this.message=message;
    }

    @Override
    public long getCode() {
        return code;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

@Data
@Accessors(chain = true)
public class Result<T> {
    private boolean success;
    private long code;
    private String message;
    private T data;

    private Result() {
    }
    private Result(boolean success,long code,String message,T data){
        this.success=success;
        this.code=code;
        this.message=message;
        this.data=data;
    }

    /**
     * 成功返回结果
     * @param data  获取的数据
     */
    public static <T> Result<T> success(T data){
        return new Result<T>(true,ResultCode.SUCCESS.getCode(),ResultCode.SUCCESS.getMessage(),data);
    }

    /**
     * 成功返回结果
     * @param data  获取的数据
     * @param message   提示信息
     */
    public static <T> Result<T> success(T data,String message){
        return new Result<>(true,ResultCode.SUCCESS.getCode(),message,data);
    }

    /**
     * 失败返回结果
     * @param <T>
     * @return
     */
    public static <T> Result<T> failed(){
        return new Result<>(false,ResultCode.FAILED.getCode(),ResultCode.FAILED.getMessage(),null);
    }

    /**
     * 失败返回结果
     * @param message 提示信息
     */
    public static <T> Result<T> failed(String message){
        return new Result<>(false,ResultCode.FAILED.getCode(),message,null);
    }
}

新建MyCasAuthenticationEntryPoint类实现AuthenticationEntryPoint

@Component
public class MyCasAuthenticationEntryPoint implements AuthenticationEntryPoint {

  @Autowired
  private YmlProperties ymlProperties;

  @Override
  public void commence(HttpServletRequest request, HttpServletResponse response,
      AuthenticationException authException) throws IOException, ServletException {
    response.sendRedirect(ymlProperties.getAppServerUrl()+"/send");
  }
}

重写SecurityConfiguration配置类

@Slf4j
@EnableWebSecurity
//开启@Secured和@PreAuthorize
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

  @Autowired
  private YmlProperties ymlProperties;

  @Autowired
  private MyCasAuthenticationEntryPoint myCasAuthenticationEntryPoint;

  @Autowired
  private MyUserDetailsService myUserDetailsService;

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests() //配置安全策略
        .antMatchers("/login","/send").permitAll() 
        .anyRequest().authenticated() //所有请求都要验证
        .and()
        .csrf().disable()
        .logout().permitAll() //logout不需要验证
        .and()
        .headers().frameOptions().disable()
        .and()
        .cors()
        .and().formLogin(); //使用form表单登录

    http.exceptionHandling().authenticationEntryPoint(myCasAuthenticationEntryPoint)
        .and()
        .addFilter(casAuthenticationFilter())
        .addFilterBefore(casLogoutFilter(), LogoutFilter.class)
        .addFilterBefore(singleSignOutFilter(), CasAuthenticationFilter.class);
  }


  @Override
  protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    super.configure(auth);
    auth.authenticationProvider(casAuthenticationProvider());
  }

  /**
   * 主要配置的是ServiceProperties的service属性，它指定的是cas回调的地址
   */
  @Bean
  public ServiceProperties serviceProperties() {
    ServiceProperties serviceProperties = new ServiceProperties();
    serviceProperties.setService(ymlProperties.getAppServerUrl() + ymlProperties.getAppLoginUrl());
    serviceProperties.setSendRenew(false);
    serviceProperties.setAuthenticateAllArtifacts(true);
    return serviceProperties;
  }

  /**
   * 认证的入口，指定cas服务器的登录地址，指定ServiceProperties(主要是获取回调地址)
   */
//  @Bean
//  public CasAuthenticationEntryPoint casAuthenticationEntryPoint() {
//    CasAuthenticationEntryPoint casAuthenticationEntryPoint = new CasAuthenticationEntryPoint();
//    casAuthenticationEntryPoint
//        .setLoginUrl(casProperties.getCasServerLoginUrl());
//    casAuthenticationEntryPoint.setServiceProperties(serviceProperties());
//    return casAuthenticationEntryPoint;
//  }


  @Bean
  public CasAuthenticationFilter casAuthenticationFilter() throws Exception {
    CasAuthenticationFilter casAuthenticationFilter = new CasAuthenticationFilter();
    casAuthenticationFilter.setServiceProperties(serviceProperties());
    casAuthenticationFilter.setFilterProcessesUrl(ymlProperties.getAppLoginUrl());
    casAuthenticationFilter.setAuthenticationManager(authenticationManager());

    //指定登录成功后跳转页面，也可以使用SavedRequestAwareAuthenticationSuccessHandler
//    SavedRequestAwareAuthenticationSuccessHandler handler=new SavedRequestAwareAuthenticationSuccessHandler();
//    handler.setRedirectStrategy(new MyRedirectStrategy());
//    casAuthenticationFilter.setAuthenticationSuccessHandler(handler);
    casAuthenticationFilter.setAuthenticationSuccessHandler(
        new SimpleUrlAuthenticationSuccessHandler(
            ymlProperties.getAppServerUrl() + "/hello"));
    casAuthenticationFilter.setSessionAuthenticationStrategy(sessionAuthenticationStrategy());
    return casAuthenticationFilter;
  }

//  class MyRedirectStrategy extends DefaultRedirectStrategy {
//
//    @Override
//    public void sendRedirect(HttpServletRequest request, HttpServletResponse response, String url)
//        throws IOException {
//      String redirectUrl = calculateRedirectUrl(request.getContextPath(), url);
//      redirectUrl = response.encodeRedirectURL(redirectUrl);
//      log.info(redirectUrl);
//      if(redirectUrl.startsWith("http://")){
//        if(redirectUrl.contains("/app/login")){
//          redirectUrl="http://10.11.36.21:8080/test/hello";
//        }
//      }
//      response.sendRedirect(redirectUrl);
//    }
//  }


  @Bean
  public CasAuthenticationProvider casAuthenticationProvider() {
    CasAuthenticationProvider casAuthenticationProvider = new CasAuthenticationProvider();
    casAuthenticationProvider.setServiceProperties(serviceProperties());
    casAuthenticationProvider.setTicketValidator(cas20ServiceTicketValidator());
    casAuthenticationProvider
        .setAuthenticationUserDetailsService(myUserDetailsService);
    casAuthenticationProvider.setKey("casAuthenticationProviderKey");
    return casAuthenticationProvider;
  }


  /**
   * 验证ticker，向cas服务器发送验证请求
   */
  @Bean
  public Cas20ServiceTicketValidator cas20ServiceTicketValidator() {
    //转Https请求
//    HttpURLConnectionFactory httpURLConnectionFactory=new HttpURLConnectionFactory() {
//      @Override
//      public HttpURLConnection buildHttpURLConnection(URLConnection urlConnection) {
//        SSLContext sslContext=null;
//        try {
//          sslContext = SSLContext.getInstance("SSL");
//          sslContext.init(new KeyManager[]{},new TrustManager[]{new X509TrustManager() {
//            @Override
//            public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
//                throws CertificateException {
//
//            }
//
//            @Override
//            public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
//                throws CertificateException {
//
//            }
//
//            @Override
//            public X509Certificate[] getAcceptedIssuers() {
//              return new X509Certificate[0];
//            }
//          }},null);
//          SSLSocketFactory socketFactory=sslContext.getSocketFactory();
//
//          if(urlConnection instanceof HttpsURLConnection){
//            HttpsURLConnection httpsURLConnection=(HttpsURLConnection)urlConnection;
//            httpsURLConnection.setSSLSocketFactory(socketFactory);
//            httpsURLConnection.setHostnameVerifier((s,l)->true);
//          }
//
//          return (HttpURLConnection)urlConnection;
//
//        }catch (Exception e){
//          throw new RuntimeException(e);
//        }
//      }
//    };
    Cas20ServiceTicketValidator cas20ServiceTicketValidator = new Cas20ServiceTicketValidator(
        ymlProperties.getCasServerUrl());
    cas20ServiceTicketValidator.setEncoding("UTF-8");
    return cas20ServiceTicketValidator;
  }


  @Bean
  public SessionAuthenticationStrategy sessionAuthenticationStrategy() {
    SessionAuthenticationStrategy sessionAuthenticationStrategy = new SessionFixationProtectionStrategy();
    return sessionAuthenticationStrategy;
  }


  /**
   * 此过滤器向cas发送登出请求
   */
  @Bean
  public SingleSignOutFilter singleSignOutFilter() {
    SingleSignOutFilter singleSignOutFilter = new SingleSignOutFilter();
    singleSignOutFilter.setCasServerUrlPrefix(ymlProperties.getCasServerUrl());
    singleSignOutFilter.setIgnoreInitConfiguration(true);
    return singleSignOutFilter;
  }

  /**
   * 此过滤器拦截客户端的logout请求，发现logout请求后向cas服务器发送登出请求
   */
  @Bean
  public LogoutFilter casLogoutFilter() {
    LogoutFilter logoutFilter = new LogoutFilter(ymlProperties.getCasServerLogoutUrl(),
        new SecurityContextLogoutHandler());
    logoutFilter.setFilterProcessesUrl(ymlProperties.getAppLogoutUrl());
    return logoutFilter;
  }

  /**
   * 取出@Secured的前缀 "ROLE_"
   * @return
   */
  @Bean
  public GrantedAuthorityDefaults grantedAuthorityDefaults() {
    return new GrantedAuthorityDefaults("");
  }

}

前端只需要访问/login请求，登录就会返回200状态码和“已登录”提示信息，未登录后端就会重定向/send请求，并返回444状态码和CAS服务端地址，前端根据444状态码拿到CAS服务端地址并跳转页面。

注意未登录时后端会重定向一次，所以想一想前端如何拿到重定向的数据。



对于以上有什么建议，请在评论区留下宝贵意见！

【SpringBoot】SpringBoot+SpringSecurity+CAS实现单点登录
墩墩分墩
11-22 3196
CAS（Central Authentication Service的缩写，中央认证服务） 是耶鲁大学 Technology and Planning 实验室的 Shawn Bayern 在2002年出的一个开源系统。刚开始名字叫。Yale CAS 1.0的目标只是一个单点登录的系统，随着慢慢公开，功能就越来越多了，就提供了多种认证的方式。从结构上看，CAS 包含两个部分：。只要将开发单点登录的系统集成CAS Client，然后部署好CAS Server ，就可以实现多系统的单点登录。官网地址：https:
springboot springsecurity接入cas单点登录,前后端分离
weixin_47914635的博客
02-25 5371
springsecurity接入cas单点登录并支持切换认证方式
16.Spring Boot 使用Spring security 集成CAS
热门推荐
编码语言Codelang
01-03 4万+
在上一篇中说了Spring Boot 使用Spring security，在这一篇中将讲讲Spring security 集成CAS。
CAS单点登录系统集成指南：从原理到Spring Boot与Vue实践
最新发布
lingding_cn的专栏
04-11 464
本文详细介绍了CAS单点登录系统的开发方、实现原理，并提供了在Spring Boot后端和Vue2/Vue3前端中的集成示例代码。内容涵盖CAS核心流程、Spring Boot安全配置、Vue前端对接CAS的完整实现方案，帮助开发者快速实现企业级单点登录功能。
spring security 整合 CAS
hwt_211博客
12-03 1540
Spring security+CAS单点登录 Spring security 版本 3.2.4  CAS Server版本  3.4.10 CAS client 版本 3.2.1 JDK 1.7 Tomcat 8.0   原理： 从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS
spring security 整合cas
极客on之路
03-23 4008
目录 1.1           配置登录认证 1.1.1     配置AuthenticationEntryPoint 1.1.2     配置CasAuthenticationFilter 1.1.3     配置AuthenticationManager 1.2           单点登出 1.3           使用代理 1.3.1     代理端 1.3.2    
Spring Security（20）——整合Cas
weixin_33979363的博客
01-13 162
整合Cas 目录 1.1 配置登录认证 1.1.1 配置AuthenticationEntryPoint 1.1.2 配置CasAuthenticationFilter 1.1.3 配置AuthenticationManager 1.2 单点登出 1.3 使...
spring security 集成cas
qq_37001186的博客
07-13 820
pom.xml增加 security.xml <!-- 指定登录入口为casEntryPoint --> <http auto-config="true" use-expressions="true" entry-point-ref="casEntryPoint"> <custom-filter ref="casAuthenticationFilter" position="CA
springSecurity集成cas
06-18
cas是Central Authentication Service的简写.提供中央认证服务,实现企业级单点登录.详细参考:http://blog.csdn.net/xiejx618/article/details/51703469
Spring Security整合CAS的示例代码
08-27
在本文中，我们将探讨如何将Spring Security与中央认证服务（CAS）进行整合，以实现单点登录（SSO）功能。首先，我们注意到没有使用Spring Security提供的`spring-security-cas`模块，这可能是因为原生的jasig cas包...
spring boot整合CAS Client实现单点登陆验证的示例
08-28
Spring Boot 整合 CAS Client 实现单点登录验证的示例 Spring Boot 整合 CAS Client 是一种流行的解决方案，用于实现单点登录（Single Sign-On，简称 SSO）。在多个应用系统中，用户只需要登录一次就可以访问所有...
Spring Security集成CAS客户端实例
03-02
这是一个Spring Security集成CAS实现单点登录的客户端实例，使用Maven集成开发，项目中使用到的Oframer和otauser（CAS服务端）请至我的资源中寻找下载。
springboot+security+cas集成demo
11-23
springboot+security+cas集成demo。。
springsecurity整合cas客户端
funkMusic的博客
08-11 679
springsecurity整合cas客户端新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 新的改变 这几天都...
Spring security集成CAS
韦军辉
08-31 910
什么是Spring security? Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IOC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用...
【Spring Security系列】10分钟实现 SpringSecurity + CAS 完美单点登录方案
c18213590220的博客
11-12 3311
在本文中，我们将通过简单易懂的步骤，带领大家完成一个基于 Spring Security + CAS 的单点登录方案实现。无论您是初次接触 SSO，还是有一定经验的开发者，都能通过本篇教程快速掌握 CAS 的基本原理、部署方式，以及如何通过 Spring Security 实现应用的统一认证。同时，我们还会进行功能测试，确保单点登录效果满足预期。
解锁Spring Security注解鉴权与CAS整合实践
weixin_44837153的博客
03-06 1959
在这个例子中，我们使用SimpleGrantedAuthority表示自定义权限，并在构造CustomUserDetails时进行相应的处理。在上述配置中，我们通过authenticationUserDetailsService()方法返回了一个自定义的AuthenticationUserDetailsService实现，用于从CAS验证结果中构建CustomUserDetails对象。在接口层面，我们可以使用Spring Security提供的注解鉴权功能，结合CAS验证结果的权限信息进行精细控制。
Spring Security整合CAS实现单点登录
战丶后风！！的博客
09-14 1202
CAS-Client03项目结构图 CAS-Client03项目运行示例 ① 初次访问没有登录会跳转至CAS登录页面 ② 登录成功后 ③ 退出登录 pom.xml依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> ...
spring-security整合cas
JzCm__的博客
12-22 469
异常描述 异常解决 异常信息 No bean named 'springSecurityFilterChain' available 异常描述 Spring-security整合CAS 启动tomcat没有异常,访问服务器出现异常 异常代码 &lt;!-- 配置Spring MVC前端控制器(核心控制器) --&gt; &lt;servlet&gt; &lt;se...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值