cas6.6.x~7.0.RC版本自定义多种登录方式手机验证码登录稍加修改即可实现

已于 2023-09-13 13:46:34 修改
阅读量1.1k 收藏 1
点赞数 2
文章标签： java cas spring boot
于 2023-09-13 10:36:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39734430/article/details/132845647
版权

CAS7.0.0RC版本扩展默认登录以及增加多种登录方式

除了扩展默认登录还增加了第三方的钉钉登录

文章目录

前言

CAS在新版本中使用了SpringBoot3以及gradle 所以需要在熟悉SpringBoot3和gradle的前提下进行学习

工作需要需要对cas5.3.x版本进行升级到7.0RC版本
cas5.3升级7.0版本改动较大故升级过程在这里记录一下

注意事项

Jdk版本使用openJDK17 不要使用Oracle版本的JDK 会启动报错的

一、获取cas7.0覆盖war工程

cas 官方给我们提供了基础的工程只需要我们在此基础上进行修改就能实现我们想要的功能

git clone https://github.com/apereo/cas-overlay-template.git

二、扩展步骤

1.在build.gradle文件中引入库

引入位置看下图
引包示例

代码如下（示例）：

implementation "org.apereo.cas:cas-server-core-api-configuration-model"
implementation "org.apereo.cas:cas-server-webapp-init"
implementation "org.apereo.cas:cas-server-support-jdbc-drivers"
implementation "org.apereo.cas:cas-server-support-jdbc"
implementation "org.apereo.cas:cas-server-core-web-api"
implementation "org.apereo.cas:cas-server-core-authentication-mfa-api"
implementation "org.apereo.cas:cas-server-core-webflow-mfa-api"
implementation "org.apereo.cas:cas-server-core-webflow-api"
implementation "org.apereo.cas:cas-server-support-jpa-util"
implementation "org.apereo.cas:cas-server-support-json-service-registry"
implementation "org.apereo.cas:cas-server-core-webflow"
implementation "org.apereo.cas:cas-server-core-authentication"
implementation "org.apereo.cas:cas-server-core-authentication-api"

2.修改cas默认登录自定义数据源以及返回自定义返回属性

创建UsernamePasswordAuthentication并继承AbstractUsernamePasswordAuthenticationHandler

代码如下（示例）：

package com.wangda.cas.auth;


import com.google.common.collect.Lists;
import com.wangda.cas.domain.User;
import org.apereo.cas.authentication.AuthenticationHandlerExecutionResult;
import org.apereo.cas.authentication.PreventedException;
import org.apereo.cas.authentication.credential.UsernamePasswordCredential;
import org.apereo.cas.authentication.exceptions.AccountPasswordMustChangeException;
import org.apereo.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.services.ServicesManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.crypto.password.PasswordEncoder;

import javax.security.auth.login.FailedLoginException;
import java.security.GeneralSecurityException;
import java.util.HashMap;
import java.util.List;

public class UsernamePasswordAuthentication extends AbstractUsernamePasswordAuthenticationHandler {
    private final Logger logger = LoggerFactory.getLogger(UsernamePasswordAuthentication.class);
    private final JdbcTemplate jdbcTemplate;

    private PasswordEncoder passwordEncoder;

    public UsernamePasswordAuthentication(String name, ServicesManager servicesManager, PrincipalFactory principalFactory, Integer order, JdbcTemplate jdbcTemplate, PasswordEncoder passwordEncoder) {
        super(name, servicesManager, principalFactory, order);

        this.jdbcTemplate = jdbcTemplate;
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    protected AuthenticationHandlerExecutionResult authenticateUsernamePasswordInternal(UsernamePasswordCredential credential, String originalPassword) throws GeneralSecurityException, PreventedException {
        String username = credential.getUsername();
        String password = new String(credential.getPassword());
        // 这里修改成你自己的数据源
        User user = jdbcTemplate.queryForObject("select * from xxx where mobile=?", new BeanPropertyRowMapper<>(User.class), username);
        boolean matches = passwordEncoder.matches(password, user.getPassword());
        if (!matches) {
            logger.warn(credential.getUsername() + ":用户密码认证失败");
            throw new FailedLoginException("账号密码错误");
        } else {
            if (!validateStrength(password)) {
            // 抛出这个异常后会让cas进入casMustChangePassView.html
                throw new AccountPasswordMustChangeException();
            }
        }
        // 增加自定义属性
        HashMap<String, List<Object>> payload = new HashMap<>(3);
        payload.put("name", Lists.newArrayList(user.getDisplayName()));
        payload.put("mobile", Lists.newArrayList(user.getMobile()));
        payload.put("sub", Lists.newArrayListWithCapacity(0));
        payload.put("externalId", Lists.newArrayList(user.getExternalId()));
        logger.info(credential.getUsername() + ":用户密码认证登录成功");
        return createHandlerResult(credential, this.principalFactory.createPrincipal(user.getId().toString(), payload));
    }

    private boolean validateStrength(String pwd) {
        int flag = 0;
        if (pwd.matches(".*[0-9].*")) {
            flag++;
        }
        if (pwd.matches(".*[a-z].*")) {
            flag++;
        }
        if (pwd.matches(".*[A-Z].*")) {
            flag++;
        }
        if (pwd.matches(".*[!@*#$\\-_()+=&￥].*")) {
            flag++;
        }
        return flag >= 2;
    }
}

请注意在代码中更换你自己的数据源

接着找到 cas提供给我们的配置类CasOverlayOverrideConfiguration进行bean注册

 @Bean
        public PasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }

        @Bean
        public AuthenticationHandler passwordAuthenticationHandler(JdbcTemplate jdbcTemplate,
                                                                   PasswordEncoder passwordEncoder,
                                                                   @Qualifier("servicesManager") 
                                                                   ServicesManager servicesManager) {
            return new UsernamePasswordAuthentication(PasswordAuthentication.class.getName(), servicesManager, new DefaultPrincipalFactory(), 1, jdbcTemplate, passwordEncoder);
        }

        /**
         *
         * @param passwdlessAuthenticationHandler 增加第二种登录方式
         * @param passwordAuthenticationHandler 修改cas默认登录认证方式
         * @return
         */
        @Bean
        public AuthenticationEventExecutionPlanConfigurer myPlan(
                @Qualifier("passwdlessAuthenticationHandler") final AuthenticationHandler passwdlessAuthenticationHandler,
                @Qualifier("passwordAuthenticationHandler") final AuthenticationHandler passwordAuthenticationHandler) {
            return plan -> {
                plan.registerAuthenticationHandler(passwdlessAuthenticationHandler);
                plan.registerAuthenticationHandler(passwordAuthenticationHandler);
            };
        }

三、增加第二种自定义登录方式

  1. 增加自定义认证Credential

import org.apereo.cas.authentication.credential.OneTimeTokenCredential;

;
public class PasswdlessCredential extends OneTimeTokenCredential {
    private String token;
    private String id;

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    @Override
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    
}
  1. 增加webflow配置
import org.apereo.cas.configuration.CasConfigurationProperties;
import org.apereo.cas.web.flow.CasWebflowConstants;
import org.apereo.cas.web.flow.configurer.AbstractCasMultifactorWebflowConfigurer;
import org.apereo.cas.web.flow.configurer.CasMultifactorWebflowCustomizer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.webflow.definition.registry.FlowDefinitionRegistry;
import org.springframework.webflow.engine.ActionState;
import org.springframework.webflow.engine.Flow;
import org.springframework.webflow.engine.TransitionSet;
import org.springframework.webflow.engine.builder.support.FlowBuilderServices;

import java.util.List;
import java.util.Optional;

public class PassdlessWebflowConfigurer extends AbstractCasMultifactorWebflowConfigurer {

    public static final String LESSACTION = "passdlessWebflowAction";
    public static final String MFA_PASSDLESS_EVENT_ID="passdlessWebflowAction";

    public PassdlessWebflowConfigurer(final FlowBuilderServices flowBuilderServices,
                                      final FlowDefinitionRegistry loginFlowDefinitionRegistry,
                                      final FlowDefinitionRegistry flowDefinitionRegistry,
                                      final ConfigurableApplicationContext applicationContext,
                                      final CasConfigurationProperties casProperties,
                                      final List<CasMultifactorWebflowCustomizer> mfaFlowCustomizers) {
        super(flowBuilderServices, loginFlowDefinitionRegistry, applicationContext,
                casProperties, Optional.of(flowDefinitionRegistry), mfaFlowCustomizers);
    }

    @Override
    protected void doInitialize() {
        Flow loginFlow = getLoginFlow();
        createClientActionActionState(loginFlow);

    }

    private void createClientActionActionState(final Flow flow) {


        final ActionState actionState = createActionState(flow, LESSACTION, createEvaluateAction(LESSACTION));
        final TransitionSet transitionSet = actionState.getTransitionSet();
        transitionSet.add(createTransition(CasWebflowConstants.TRANSITION_ID_SUCCESS, CasWebflowConstants.STATE_ID_CREATE_TICKET_GRANTING_TICKET));
        transitionSet.add(createTransition(CasWebflowConstants.TRANSITION_ID_ERROR, getStartState(flow).getId()));
        transitionSet.add(createTransition(CasWebflowConstants.TRANSITION_ID_RESUME, getStartState(flow).getId()));
        transitionSet.add(createTransition(CasWebflowConstants.TRANSITION_ID_AUTHENTICATION_FAILURE, CasWebflowConstants.STATE_ID_HANDLE_AUTHN_FAILURE));
        transitionSet.add(createTransition(CasWebflowConstants.TRANSITION_ID_WARN, CasWebflowConstants.STATE_ID_WARN));
        setStartState(flow, actionState);

    }


}
  1. 增加处理类

import com.google.common.collect.Lists;
import com.idsmanager.dingdang.jwt.DingdangUserRetriever;
import com.idsmanager.dingdang.jwt.DingdangUserRetriever.User;
import org.apereo.cas.authentication.*;
import org.apereo.cas.authentication.credential.UsernamePasswordCredential;
import org.apereo.cas.authentication.handler.support.AbstractPreAndPostProcessingAuthenticationHandler;
import org.apereo.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;
import org.apereo.cas.authentication.principal.PrincipalFactory;
import org.apereo.cas.authentication.principal.Service;
import org.apereo.cas.services.ServicesManager;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Value;

import javax.security.auth.login.FailedLoginException;
import java.security.GeneralSecurityException;
import java.util.HashMap;
import java.util.List;

public class PasswdlessHandler extends AbstractPreAndPostProcessingAuthenticationHandler {

    @Value("${jwt.publicKey}")
    private String publicKey;


    public PasswdlessHandler(String name, ServicesManager servicesManager, PrincipalFactory principalFactory, Integer order, LoginHandle handle) {
        super(name, servicesManager, principalFactory, order);
        this.handle = handle;
    }

    @Override
    protected AuthenticationHandlerExecutionResult doAuthentication(Credential credential, Service service) throws Exception {


        PasswdlessCredential token = PasswdlessCredential.class.cast(credential);
        DingdangUserRetriever retrieve = new DingdangUserRetriever(token.getToken(), publicKey);
        try {
            User user = retrieve.retrieve();
            if (user != null) {
                com.wangda.cas.domain.User sysUser = //获取用户
                HashMap<String, List<Object>> payload = new HashMap<>(4);
                token.setId(user.getExternalId());
                payload.put("name", Lists.newArrayList(sysUser.getDisplayName()));
                payload.put("mobile", Lists.newArrayList(sysUser.getMobile()));
                payload.put("externalId", Lists.newArrayList(sysUser.getExternalId()));
                return createHandlerResult(credential, this.principalFactory.
                        createPrincipal(sysUser.getId().toString(), payload));
            }
        } catch (Exception e) {
            throw new FailedLoginException(e.getMessage());
        }
        throw new FailedLoginException();
    }


    public boolean supports(final Credential credential) {
        return credential != null && PasswdlessCredential.class.isAssignableFrom(credential.getClass());
    }
    
}
  1. 增加 Action类
import com.wangda.cas.auth.PasswdlessCredential;
import jakarta.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.apereo.cas.authentication.adaptive.AdaptiveAuthenticationPolicy;
import org.apereo.cas.web.flow.actions.AbstractAuthenticationAction;
import org.apereo.cas.web.flow.resolver.CasDelegatingWebflowEventResolver;
import org.apereo.cas.web.flow.resolver.CasWebflowEventResolver;
import org.apereo.cas.web.support.WebUtils;
import org.springframework.webflow.execution.Event;
import org.springframework.webflow.execution.RequestContext;

public class PasswdlessAction extends AbstractAuthenticationAction {

    public PasswdlessAction(CasDelegatingWebflowEventResolver initialAuthenticationAttemptWebflowEventResolver, CasWebflowEventResolver serviceTicketRequestWebflowEventResolver,
            AdaptiveAuthenticationPolicy adaptiveAuthenticationPolicy) {
        super(initialAuthenticationAttemptWebflowEventResolver, serviceTicketRequestWebflowEventResolver, adaptiveAuthenticationPolicy);
    }

    @Override
    public Event doExecute(final RequestContext context) {
		// 这里可以改成任何你想获取的属性方式
        final HttpServletRequest request = WebUtils.getHttpServletRequestFromExternalWebflowContext(context);
        String token = request.getParameter("id_token");
        if (StringUtils.isEmpty(token)) {
            return error();
        }
        String client_name = request.getParameter("client_name");
        // 这里是关键这个credential会触发我们自己定义的认证处理类
        PasswdlessCredential clientCredential = new PasswdlessCredential();
        clientCredential.setId(client_name);
        clientCredential.setToken(token);
        WebUtils.putCredential(context, clientCredential);
        return super.doExecute(context);
    }

}
  1. 向spring中注册我们上面的bean为了职责分明我们这里创建一个新的配置类
    提示 在工程resource/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中增加我们下面的配置类要不然spring扫描不到这个是SpringBoot3中的新特性
@AutoConfiguration
@EnableConfigurationProperties(CasConfigurationProperties.class)
public class CasZzdConfiguration {
 @ConditionalOnMissingBean(name = "passdlessWebflowConfigurer")
    @Bean
    public CasWebflowConfigurer passdlessWebflowConfigurer(
            final CasConfigurationProperties casProperties,
            final ConfigurableApplicationContext applicationContext,
            @Qualifier("passdlessFlowRegistry") final FlowDefinitionRegistry passdlessFlowRegistry,
            @Qualifier(CasWebflowConstants.BEAN_NAME_LOGIN_FLOW_DEFINITION_REGISTRY) final FlowDefinitionRegistry loginFlowDefinitionRegistry,
            @Qualifier(CasWebflowConstants.BEAN_NAME_FLOW_BUILDER_SERVICES) final FlowBuilderServices flowBuilderServices) {
        val cfg = new PassdlessWebflowConfigurer(flowBuilderServices,
                loginFlowDefinitionRegistry, passdlessFlowRegistry, applicationContext, casProperties,
                MultifactorAuthenticationWebflowUtils.getMultifactorAuthenticationWebflowCustomizers(applicationContext));
        cfg.setOrder(100);
        return cfg;
    }
     @Bean
    @ConditionalOnMissingBean(name = "passdlessFlowRegistry")
    public FlowDefinitionRegistry passdlessFlowRegistry(
            final ConfigurableApplicationContext applicationContext,
            @Qualifier(CasWebflowConstants.BEAN_NAME_FLOW_BUILDER_SERVICES) final FlowBuilderServices flowBuilderServices,
            @Qualifier(CasWebflowConstants.BEAN_NAME_FLOW_BUILDER) final FlowBuilder flowBuilder) {

        val builder = new FlowDefinitionRegistryBuilder(applicationContext, flowBuilderServices);
        builder.addFlowBuilder(flowBuilder, PassdlessWebflowConfigurer.MFA_PASSDLESS_EVENT_ID);
        return builder.build();
    }

    @RefreshScope(proxyMode = ScopedProxyMode.DEFAULT)
    @Bean
    public Action passdlessWebflowAction(
            final CasConfigurationProperties casProperties,
            final ConfigurableApplicationContext applicationContext,
            @Qualifier("adaptiveAuthenticationPolicy") final AdaptiveAuthenticationPolicy adaptiveAuthenticationPolicy,
            @Qualifier("serviceTicketRequestWebflowEventResolver") final CasWebflowEventResolver serviceTicketRequestWebflowEventResolver,
            @Qualifier("initialAuthenticationAttemptWebflowEventResolver") final CasDelegatingWebflowEventResolver initialAuthenticationAttemptWebflowEventResolver) {

        return WebflowActionBeanSupplier.builder()
                .withApplicationContext(applicationContext)
                .withProperties(casProperties)
                .withAction(() -> new PasswdlessAction(initialAuthenticationAttemptWebflowEventResolver,
                        serviceTicketRequestWebflowEventResolver,
                        adaptiveAuthenticationPolicy)).build().get();

    }
    @Bean
    @ConditionalOnMissingBean(name = "passdlessCasWebflowExecutionPlanConfigurer")
    public CasWebflowExecutionPlanConfigurer passdlessCasWebflowExecutionPlanConfigurer(
            @Qualifier("passdlessWebflowConfigurer") final CasWebflowConfigurer passdlessWebflowConfigurer) {
        return plan -> plan.registerWebflowConfigurer(passdlessWebflowConfigurer);
    }
}

接着启动服务如何启动如何Debug请查阅读工程中README.md
6. 测试我们刚自定义的登录方式

在浏览器中访问 https://localhost:8443/cas/login?id_token=42343243&client_name=rerew
cas就会进入我们自定义PasswdlessHandler类中的doAuthentication认证方法中
基于这个方法很容易实现微信扫码 钉钉扫码登录

  1. 测试cas默认登录

在浏览器中访问 https://localhost:8443/cas/login
输入账号密码后点击登录后cas会进入 UsernamePasswordAuthentication类中的 authenticateUsernamePasswordInternal方法

修改cas默认登录页面

./gradlew[.bat] listTemplateViews

查看所有可以覆盖的模版
在resource/templates文件夹中创建上面列出来的文件可以实现覆盖例如修改login页面
在templates下创建login/casLoginView.html
在里面添加内容就可以了或者参考看我之前的文章

crudboy_123g
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
springboot+cas5.x+shiro+pac4j实现sso集成
05-18
springboot+cas5.x+shiro+pac4j实现sso集成,请先看我的博客，如果有问题再下载此源码学习，
CAS - 自定义登录页面和数据源
江南烟雨却痴缠丶
02-18 730
配置数据源 1、打开cas\WEB-INF\classes目录的application.properties ①注释掉默认的静态账号密码登录配置 # cas.authn.accept.users=casuser::Mellon ②配置MySQL连接，我这里使用的是MySQL8.0（如果是8.0，需要在部署CAS时打入8.0的Jar包） # 连接的阿里云服务器上的MySQL cas.a...
CAS登录页、登录成功页自定义实现
ASDFGQC的博客
01-16 1296
1、首先在themes下创建你自己的名称，将需要的前端配置文件放到下面添加配置文件读取加载的前端文件2、创建登录页将来走你这个配置使用新建文件夹以及登录页再你的登录表单上加上如下表单提交配置同时登录按钮处加上隐藏配置以及出错配置3、在最外部的配置文件下加入配置的登录页选择4、登录页可能出现的问题修改配置的登录页可能出现没有样式问题，这是因为你的css路径出现了不一致，需要修改如下所示5、正常访问即可显示你自定义的登录页这里比较简单，我们只要把同名文件放到如下位置，里面写上自己的逻辑即可。
cas-overlay-template-6.4 服务端代码
01-28
----------------------------使用--------------------------------- gradle-7.3.3 JDK-11 TOMCAT-9 MYSQL-5.7.35 REDIS-5.X ----------------------------实现功能如下------------------------------------ 1.CAS-集成mysql 2.CAS-日志审计 3.CAS-连接池配置 4.CAS-自定义错误信息 5.CAS-识别json文件 6.CAS-页面缓存记住我 7.CAS-cookie设置 8.CAS-tgc设置 9.CAS-登出 10.CAS-redisCluster集群存储ticket（相应redis必须配置成cluster集群） 11.CAS-加密存储ticket 12.CAS-实习动态验证码 13.CAS-实习自定义登录 14.CAS-实现自定义返回用户登录信息 15.CAS-页面缓存记住我 ------------------------------建表脚本在文件里登录用户/密码：ll/123456
cas.war 做单点登录自己打包的war包，亲测可用,5.2版本
09-15
cas.war 做单点登录自己打包的war包，亲测可用 5.2版本，按教程直接放在tomcat的webapps文件夹下就可以了，tomcat会自动解析包的，注意是5.2版本，低版本的jdk好像不兼容。
CAS5.3服务端配置，链接mysql、自定义密码加密、登录页面、登录校验，自定义异常、ajax登录等
我是混IT圈的
12-24 8852
目录 1、cas服务端配置mysql 2、cas服务端自定义密码加密方式 3、cas服务端自定义主题，也就是登录页面，也可以其他的页面 4、cas服务端在登录时提交的表单中添加字段 5、cas服务端自定义登录校验 6、cas服务端自定义返回异常 7、cas服务端使用ajax进行登录 环境： CAS版本：5.3 下载链接：git地址是：https://github.com/apereo/cas-overlay-template tomcat：8 jdk：1.8 1、先把cas服务端的源代码拷
java与第三方对接，JWT实现单点登录
qq_44948905的博客
02-10 914
【代码】java与第三方对接，实现单点登录。
【CAS6以上报错解决】InvalidAlgorithmParameterException AlgorithmParameterSpec not of GCMParameterSpec
ATFWUS的博客
07-11 649
今天尝试源码构建CAS的时候，发生了如下InvalidAlgorithmParameterException AlgorithmParameterSpec not of GCMParameterSpec的报错，经过长达三小时的仔细排查，最终找到了问题的所在。
cas5.3.9自定义手机短信验证码登录
qq_39734430的博客
07-11 6153
cas自定义多种登录方式cas添加手机短信验证码登录 cas添加手机短信验证码登录 全部基于SpringBoot,以及SpringWebflow开发，请在有此基础再进行学习! 添加Maven依赖 <dependency> <groupId>org.apereo.cas</groupId> <artifact...
CAS单点登录(七)——自定义验证码以及自定义错误信息
热门推荐
Anumbrella
10-19 1万+
在前面我们讲解了CAS单点登录(六)——自定义登录界面和表单信息，知道了如何去实现页面和表单信息的自定义信息提交，就像我们提交表单的信息可能包括手机、邮箱等等，这些都能以我们前面的知识点去解决。但平时登录我们会发现除了必填的信息外，还需要填写一下验证码。这是为了流控、暴力破解、降低数据库压力等等原因，今天我们就讲解一下如何在CAS中添加验证码。 注意：这一节的内容需要上一节的知识点，其中不会再次介...
cas单点登录-自定义登录验证(四)
weixin_42073629的博客
07-28 2149
我们在使用SSO单点登录的时候不只是验证一下用户名和密码是否一致,有时候还需要验证一些别的校验,那么这一张讲一下如何自定义验证器。自定义验证很重要,因为我们后续的很多功能,都是基于自定义验证。 CAS服务器的org.apereo.cas.authentication.AuthenticationManager负责基于提供的凭证信息进行用户认证。与Spring Security很相似，实际的认证委托给了一个或多个实现了org.apereo.cas.authentication.AuthenticationHa
Apereo CAS5.2.3 自定义登录页，验证码，扩展开发，注册功能
04-25
完整项目在https://download.csdn.net/download/u010588262/10327539 这个资源是新增功能之后的main文件夹 对应博客系列：https://blog.csdn.net/u010588262/article/category/7548325 对应博客这篇：https://blog.csdn.net/u010588262/article/details/80014083
CAS自定义加密和登录验证
11-13
对应博客：https://blog.csdn.net/fancheng614/article/details/84038266
cas4.1.x集成 cas4.1.x集成
06-02
cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x集成cas4.1.x...
Windows 环境CAS 5.1.X 单点登录系统配置试验
12-08
在Win XP 32 位本机环境，利用CAS 5.1.X，对LDAP、JDBC 认证机制的多种认证模式进行了单点 登录系统（SSO）的配置试验，并采用Java 和Python 两种客户端作了测试，同时给出了配置流程、以 及个人在20 天的配置试验...
单点登录cas server的5.2版本的cas.war
12-20
cas server 5.2 版 war包。直接丢在tomcat的webapps下面，重启tomcat即可。
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 327
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1438
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 596
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
CAS6.x版本的学习教程
05-25
CAS（Computer Algebra System）是一种计算机代数系统，用于处理数学符号和代数方程式。CAS6.x是CAS的最新版本，具有更强大的功能和更好的性能。以下是学习CAS6.x的教程： 1. 下载和安装CAS6.x：可以从官方网站下载CAS6.x的安装程序。安装程序将指导您完成安装过程。 2. 熟悉CAS6.x界面：CAS6.x具有用户友好的界面，包括命令行和图形化界面。熟悉这些界面是使用CAS6.x的关键。 3. 学习CAS6.x的基本命令：CAS6.x提供了许多命令，用于处理数学方程和符号。您需要学习这些命令，以便能够在CAS6.x中进行计算。 4. 学习CAS6.x的高级功能：CAS6.x还具有许多高级功能，例如求导、积分、解方程、线性代数等。掌握这些功能将使您能够更好地使用CAS6.x。 5. 练习使用CAS6.x：练习使用CAS6.x是学习的关键。您可以使用CAS6.x解决实际问题，或者尝试解决一些数学问题，以便更好地掌握CAS6.x的使用。 6. 查找CAS6.x的资源：CAS6.x拥有广泛的社区和资源，包括文档、教程、论坛等。查找这些资源将帮助您更好地使用CAS6.x。 总之，学习CAS6.x需要耐心和练习。掌握CAS6.x将使您能够更好地处理数学方程和符号，并解决实际问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值