SSO单点登录

最新推荐文章于 2022-12-04 14:29:55 发布
最新推荐文章于 2022-12-04 14:29:55 发布
阅读量675 收藏 1
点赞数 3
分类专栏： sso 文章标签： restful 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46596133/article/details/121189887
版权

文章目录

SSO简介

web系统由单系统发展成多系统组成的应用群，复杂性应该由系统内部承担，而不是用户。无论web系统内部多么复杂，对用户而言，都是一个统一的整体，也就是说，用户访问web系统的整个应用群与访问单个系统一样，登录/注销只要一次就够了。
在这里插入图片描述
单系统登录解决方案的核心是cookie，cookie携带会话id在浏览器与服务器之间维护会话状态。但cookie是有限制的，这个限制就是cookie的域（通常对应网站的域名），浏览器发送http请求时会自动携带与该域匹配的cookie，而不是所有cookie。

单点登录涉及sso认证中心与众子系统，子系统与sso认证中心需要通信以交换令牌、校验令牌及发起注销请求，因而子系统必须集成sso的客户端，sso认证中心则是sso服务端，整个单点登录过程实质是sso客户端与服务端通信的过程。sso认证中心与sso客户端通信方式有多种，httpClient，web service、rpc、restful api都可以。

什么是单点登录

什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分。

登录

sso需要一个独立的认证中心，只有认证中心能接受用户的用户名密码等安全信息，其他系统不提供登录入口，只接受认证中心的间接授权。间接授权通过令牌实现，sso认证中心验证用户的用户名密码没问题，创建授权令牌，在接下来的跳转过程中，授权令牌作为参数发送给各个子系统，子系统拿到令牌，即得到了授权，可以借此创建局部会话，局部会话登录方式与单系统的登录方式相同。这个过程，也就是单点登录的原理，用下图说明
在这里插入图片描述

下面对上图简要描述

  1. 用户访问系统1的受保护资源，系统1发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
  2. sso认证中心发现用户未登录，将用户引导至登录页面
  3. 用户输入用户名密码提交登录申请
  4. sso认证中心校验用户信息，创建用户与sso认证中心之间的会话，称为全局会话，同时创建授权令牌
  5. sso认证中心带着令牌跳转会最初的请求地址（系统1）
  6. 系统1拿到令牌，去sso认证中心校验令牌是否有效
  7. sso认证中心校验令牌，返回有效，注册系统1
  8. 系统1使用该令牌创建与用户的会话，称为局部会话，返回受保护资源
  9. 用户访问系统2的受保护资源
  10. 系统2发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
  11. sso认证中心发现用户已登录，跳转回系统2的地址，并附上令牌
  12. 系统2拿到令牌，去sso认证中心校验令牌是否有效
  13. sso认证中心校验令牌，返回有效，注册系统2
  14. 系统2使用该令牌创建与用户的局部会话，返回受保护资源

用户登录成功之后，会与sso认证中心及各个子系统建立会话，用户与sso认证中心建立的会话称为全局会话，用户与各个子系统建立的会话称为局部会话，局部会话建立之后，用户访问子系统受保护资源将不再通过sso认证中心，全局会话与局部会话有如下约束关系

  1. 局部会话存在，全局会话一定存在
  2. 全局会话存在，局部会话不一定存在
  3. 全局会话销毁，局部会话必须销毁

注销

单点登录自然也要单点注销，在一个子系统中注销，所有子系统的会话都将被销毁，用下面的图来说明
在这里插入图片描述
sso认证中心一直监听全局会话的状态，一旦全局会话销毁，监听器将通知所有注册系统执行注销操作

下面对上图简要说明

  1. 用户向系统1发起注销请求
  2. 系统1根据用户与系统1建立的会话id拿到令牌，向sso认证中心发起注销请求
  3. sso认证中心校验令牌有效，销毁全局会话，同时取出所有用此令牌注册的系统地址
  4. sso认证中心向所有注册系统发起注销请求
  5. 各注册系统接收sso认证中心的注销请求，销毁局部会话
  6. sso认证中心引导用户至登录页面

单一服务器模式 登录

（1）使用session对象实现登录
登录成功之后，把用户数据放到session里面，session.setAttrinute(“user”,user)
判断是否登录，从session获取数据，可以获取登录信息，session.getAttrinute(“user”,user)

单点登录常见的三种方式

session广播机制实现

在一个模块中登录将用户信息写入到session，其他的模块进行一个复制

session过期时间：如果登录之后不做任何操作默认30分钟就失效了

缺点：如果只有几个模块，做个复制session没有什么问题，但是如果项目中有二十个模块，那我们的session就会复制二十次，而每次复制对于我们的资源都是一个极大的消耗。
在这里插入图片描述

cookie + redis实现

cookie是客户端技术存放在浏览器中，每次发送请求，都会带着cookie值进行发送。
redis基于key-value存储。

可以设置redis的过期时间做到跟session一样的效果

实现过程：
1、在项目中的任何一个模块进行登录，登录之后，把数据放到两个地方
redis：在key:生成唯一值（ip,用户id，UUID等等） 在value: 用户数据
cookie:把redis里面生成的key值放到cookie里面

2、访问项目中其他模块，发送请求带着cookie进行发送,获取到cookie值，拿着cookie做事情：
（1）把cookie获取值，到redis进行查询，根据key进行查询，如果查询到数据就是登录

token实现

token是什么?
按照一定规划生成字符串，字符串包括用户信息

实现过程：
1、在项目中的任何一个模块进行登录，登录之后，按照规则生成字符串，把登录必须用户包含到生成字符串里面，把字符串返回
（1）可以把字符串通过cookie返回
（2）把字符串通过地址栏返回

2、再去访问项目其他模块，每次访问在地址栏带着生成字符串，在访问模块里面获取地址栏字符串，根据字符串获取用户信息。可以获取到就是登录

token实现单点登录及注册Demo

点击跳转到码云仓库

技术桟

spring boot
mybatis-plus
jwt
swagger

pom

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

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

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

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

        <!--   jwt -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!--swagger ui-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

application.properties

# 服务端口
server.port=8150

# 服务名
spring.application.name=ssodemo

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/alibaba?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root

#返回json的全局时间格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

#配置mapper xml文件的路径
mybatis-plus.mapper-locations=classpath:com/alibaba/ssodemo/mapper/xml/*.xml

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

主程序

package com.alibaba.ssodemo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = {"com.alibaba"})
@MapperScan("com.alibaba.ssodemo.mapper")
public class SsodemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SsodemoApplication.class, args);
    }

}

entity

package com.alibaba.ssodemo.entity;


import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class UcenterMember implements Serializable {
        private static final long serialVersionUID = 1L;

        @TableId(value = "id", type = IdType.ID_WORKER_STR)
        private String id;
        private String openid;
        private String mobile;
        private String password;
        private String nickname;
        private Integer sex;
        private Integer age;
        private String avatar;
        private String sign;
        private Boolean isDisabled;
        private Boolean isDeleted;
        @TableField(fill = FieldFill.INSERT)
        private Date gmtCreate;
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date gmtModified;
}

vo

package com.alibaba.ssodemo.entity.vo;

import lombok.Data;

@Data
public class RegisterVo {
    private String nickname;    //昵称
    private String mobile;      //手机号
    private String password;    //密码
}

自定为异常

package com.alibaba.ssodemo.exception;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor //有参构造方法
@NoArgsConstructor //无参构造方法
public class ServiceException extends RuntimeException {

    private Integer code;//状态码

    private String msg;//异常信息

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

controller

package com.alibaba.ssodemo.controller;

import com.alibaba.ssodemo.entity.UcenterMember;
import com.alibaba.ssodemo.entity.vo.RegisterVo;
import com.alibaba.ssodemo.service.UcenterMemberService;
import com.alibaba.ssodemo.utils.JwtUtils;
import com.alibaba.ssodemo.utils.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("/ssodemo/")
public class UcenterMemberController {

    @Autowired
    private UcenterMemberService ucenterMemberService;

    //登录
    @PostMapping("/login")
    public R loginUser(@RequestBody UcenterMember member){
        //调用service方法实现登录，返回token值，使用jwt生成
        String token = ucenterMemberService.login(member);
        return R.ok().data("token",token);
    }

    //注册
    @PostMapping("register")
    public R register(@RequestBody RegisterVo registerVo){
        ucenterMemberService.register(registerVo);
        return R.ok();
    }

    //根据token获取用户的信息
    @GetMapping("getMemberInfo")
    public R getMemberInfo(HttpServletRequest response){
        //调用工具类，根据response对象获取头信息，返回用户id
        String idByJwtToken = JwtUtils.getMemberIdByJwtToken(response);
        UcenterMember byId = ucenterMemberService.getById(idByJwtToken);
        return R.ok().data("byId",byId);
    }
}

mapper

package com.alibaba.ssodemo.mapper;

import com.alibaba.ssodemo.entity.UcenterMember;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UcenterMemberMapper extends BaseMapper<UcenterMember> {
}

servuce

package com.alibaba.ssodemo.service;

import com.alibaba.ssodemo.entity.UcenterMember;
import com.alibaba.ssodemo.entity.vo.RegisterVo;
import com.baomidou.mybatisplus.extension.service.IService;

public interface UcenterMemberService extends IService<UcenterMember> {

    //登录方法
    String login(UcenterMember member);

    //注册的方法
    void register(RegisterVo registerVo);
}

serviceimpl

package com.alibaba.ssodemo.service.impl;

import com.alibaba.ssodemo.entity.UcenterMember;
import com.alibaba.ssodemo.entity.vo.RegisterVo;
import com.alibaba.ssodemo.exception.ServiceException;
import com.alibaba.ssodemo.mapper.UcenterMemberMapper;
import com.alibaba.ssodemo.service.UcenterMemberService;
import com.alibaba.ssodemo.utils.JwtUtils;
import com.alibaba.ssodemo.utils.MD5;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

@Service
public class UcenterMemberServiceImpl extends ServiceImpl<UcenterMemberMapper, UcenterMember> implements UcenterMemberService {

    //登录的方法
    @Override
    public String login(UcenterMember member) {
        String mobile = member.getMobile();//手机号
        String password = member.getPassword();//密码

        //对手机号及密码做非空判断
        if (StringUtils.isEmpty(mobile) || StringUtils.isEmpty(password))
            throw new ServiceException(20001,"手机号或密码不能为空");

        //判断手机号是正确
        QueryWrapper<UcenterMember> wrapper = new QueryWrapper<>();
        wrapper.eq("mobile",mobile);
        UcenterMember ucenterMember = baseMapper.selectOne(wrapper);
        //判断查询对象是否为空
        if (ucenterMember == null)
            throw new ServiceException(20001,"输入的手机号错误");

        //判断密码是否正确
        if (!MD5.encrypt(password).equals(ucenterMember.getPassword()))
            throw new ServiceException(20001,"输入的密码有误");

        //登录成功,根据用户的id及昵称生成token
        String jwtToken = JwtUtils.getJwtToken(ucenterMember.getId(), ucenterMember.getNickname());

        return jwtToken;
    }

    //注册的方法
    @Override
    public void register(RegisterVo registerVo) {
        //获取注册的数据
        String mobile = registerVo.getMobile();//手机号
        String nickname = registerVo.getNickname();//昵称
        String password = registerVo.getPassword();//秘密

        //对传过来的参数进行判断
        if (StringUtils.isEmpty(mobile) || StringUtils.isEmpty(nickname) || StringUtils.isEmpty(password))
            throw new ServiceException(20001,"注册失败，请填写相应的数据");

        //对相同的手机号不进行添加
        QueryWrapper<UcenterMember> wrapper = new QueryWrapper<>();
        wrapper.eq("mobile",mobile);
        Integer integer = baseMapper.selectCount(wrapper);

        if (integer > 0 )
            throw new ServiceException(20001,"手机号已经注册过了");

        //将数据加入数据库中
        UcenterMember ucenterMember = new UcenterMember();
        ucenterMember.setNickname(nickname);
        ucenterMember.setMobile(mobile);
        ucenterMember.setPassword(MD5.encrypt(password));
        ucenterMember.setIsDisabled(false);//用户不禁用
        baseMapper.insert(ucenterMember);
    }
}

utils

Jwt生成令牌

package com.alibaba.ssodemo.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.lang.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * Jwt生成令牌
 */
public class JwtUtils {

    //常量
    public static final long EXPIRE = 1000 * 60 * 60 * 24;  //tokent过期时间
    public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO";   //秘钥

    //生成token字符串的方法
    public static String getJwtToken(String id, String nickname){

        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("guli-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("id", id)
                .claim("nickname", nickname)
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();

        return JwtToken;
    }

    /**
     * 判断token是否存在与有效
     * @param jwtToken
     * @return
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 判断token是否存在与有效
     * @param request
     * @return
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 根据token获取会员id
     * @param request
     * @return
     */
    public static String getMemberIdByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("token");
        if(StringUtils.isEmpty(jwtToken)) return "";
        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        Claims claims = claimsJws.getBody();
        return (String)claims.get("id");
    }
}

MD5加密

package com.alibaba.ssodemo.utils;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * MD5加密方法
 */
public final class MD5 {

    public static String encrypt(String strSrc) {
        try {
            char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f' };
            byte[] bytes = strSrc.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (int i = 0; i < bytes.length; i++) {
                byte b = bytes[i];
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错！！+" + e);
        }
    }

    public static void main(String[] args) {
        System.out.println("123456");
    }

}

统一返回值

package com.alibaba.ssodemo.utils;

import lombok.Data;

import java.util.HashMap;
import java.util.Map;

/**
 * 统一返回值
 */
@Data
public class R {
    private Boolean succes;

    private Integer code;

    private String message;

    private Map<String,Object> data = new HashMap<String,Object>();

    //构造方法私有
    private R(){}

    //成功方法
    public static R ok(){
        R r = new R();
        r.setSucces(true);
        r.setCode(ResultCode.SUCCESS);
        r.setMessage("成功");
        return r;
    }

    //失败方法
    public static R error(){
        R r = new R();
        r.setSucces(false);
        r.setCode(ResultCode.ERROR);
        r.setMessage("失败");
        return r;
    }

    public Boolean getSucces() {
        return succes;
    }

    public void setSucces(Boolean succes) {
        this.succes = succes;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Map<String, Object> getData() {
        return data;
    }

    public void setData(Map<String, Object> data) {
        this.data = data;
    }
    public R success(Boolean success){
        this.setSucces(success);
        return this;
    }

    public R message(String message){
        this.setMessage(message);
        return this;
    }

    public R code(Integer code){
        this.setCode(code);
        return this;
    }

    public R data(String key, Object value){
        this.data.put(key, value);
        return this;
    }

    public R data(Map<String, Object> map){
        this.setData(map);
        return this;
    }
}

返回值状态码

package com.alibaba.ssodemo.utils;

/**
 * 返回值状态码
 */
public interface ResultCode {

    public static Integer SUCCESS = 20000;  //成功

    public static Integer ERROR = 20001;    //失败
}

swagger

package com.alibaba.ssodemo.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration//配置类
@EnableSwagger2//swagger配置
public class SwaggerConfig {
    @Bean
    public Docket webApiConfig(){

        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                //.paths(Predicates.not(PathSelectors.regex("/admin/.*")))
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .build();
    }

    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("网站-API文档")
                .description("本文档描述了单点登录接口定义")
                .version("1.0")
                .contact(new Contact("Helen", "http://bing.com", "hq1162759071@foxmail.com"))
                .build();
    }
}
Uncle_Gu
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSO单点登陆问题
qq_45132844的博客
09-08 386
首先是我要到授权中心，是授权中心给我颁发token，然后我前端有这个token，访问其他微服务只要tokn可以被解析，就表明用户登陆没有问题。例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。为了保证客户端cookie的安全性，服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。无状态登陆：微服务集群中的每个服务，对外提供的都是Rest风格的接口。
单点登录
技术人员
04-07 178
码云单点登录项目 xxl： 登录任何一个项目，如果没有进行登录 就要跳转到登录服务器， 后面的redirect_url 是登录成功后需要callback的地址； 再接着去登录服务器，如果没有登录就到登录页， 填写登录信息后把redirect_url 放在后面； 登录成功后将cookie放在redis中，然后跳到redirect_url页面，然后在页面存放cookie； 跳转页后面也带上cooki...
单点登录-认证服务器与客户端的session过期时间如何统一
秃了也弱了
07-22 1429
之前画了一个单点登录的逻辑图，其中有很多细节没有展现清楚。终于把单点登录完整流程图画明白了！史上最完整的CAS单点登录完整图解！今天就来讨论一下，认证服务器登录完成之后，如何与客户端保持session过期时间的统一？...
单点登录session超时
linlinxie的博客
03-10 3754
session过期后跳到单点登录地址，带着ticket参数去验证用户，如果单点登录验证到ticket没过期，就不会去登录页面，但是会刷新当前页，因为从单点登录地址重定向到了当前页面地址。所以给用户的感觉就是长时间不操作时，点击页面元素会出现刷新页面的情况。另外，java项目和shiro集成时有两个地方可以设置session过期时间，如图所示1.shiro配置xml文件中，这个优先级最高2.web....
页面过期请重新登录_跨域单点登录方案实现
weixin_39771614的博客
11-25 1184
跨域单点登录方案实现SSO英文全称Single Sign On，单点登录。当我们搜索单点登录的时候，会发现很多的文章，然而这些文章一般都是基于一种通用的场景描述，通常在各自的业务环境会更加复杂。在本篇文章，我将描述具体场景下实现单点登录的方案。SSO英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登...
sso单点登录ppt.ppt
10-30
sso单点登录ppt.ppt
使用springboot结合vue实现sso单点登录
08-25
使用 Spring Boot 结合 Vue 实现 SSO 单点登录 本文主要为大家详细介绍了如何使用 Spring Boot 和 Vue 实现 SSO 单点登录，具有一定的参考价值。下面我们将从技术角度深入探讨该实现的细节。 Spring Boot 的选择 ...
Spring Security基于JWT实现SSO单点登录详解
08-25
Spring Security 基于 JWT 实现 SSO 单点登录详解 基于 Spring Security 框架和 JWT（JSON Web Token）技术，可以实现 SSO（Single Sign-On）单点登录系统。SSO 是一种常见的身份验证机制，允许用户使用同一个...
sso单点登录
11-25
SSO单点登录技术是现代企业级应用架构中不可或缺的一部分，它通过统一的身份认证服务提升了用户体验，降低了运维复杂度。"Simple-SSO"项目为开发者提供了一个学习和实践SSO的平台，结合Maven的项目管理，使得分布式...
PHP 使用TP5.0 实现SSO单点登录
07-28
因为公司要实现SSO单点登录的效果，最近在网上找了一些资料，但是都没有好用的， 所以自己用PHP 使用TP5.0 实现了SSO单点登录，可以跨多个域名。 下载后在本地配置好 A,B,C 3个网站，就可以模拟效果了。
cas sso session过期问题详谈
schenjiannan的专栏
02-06 4531
最近在设置sso session的过期问题，发现网上基本没有4.2.*版本的设置详情，特地研究了下； Configuring-Ticket-Expiration-Policy.md是记录session 过期时间的配置； TicketGrantingTicketExpirationPolicy 当用户在2个小时（7200秒）之内不动移动鼠标或者进行系统超过8个小时（28800秒），则t
(五)SSO之CAS框架单点登录, session超时, ajax链接处理
Xinghf
08-21 2万+
1 错误场景 cas session 超时问题：XMLHttpRequest cannot loadhttps://www.hf.com:8443/cas/login?service=http%3A%2F%2Flocalhost%3A8080%2Fvms%2Fcheck%2FfindPendingCheck%2F. No 'Access-Control-Allow-Origin' header is present on the
单点登录SSO(Single Sign On)
最新发布
weixin_38380811的博客
12-04 548
单点登录SSO(Single Sign On)
Dataset之LFW：LFW人脸数据库的简介、安装、使用方法之详细攻略
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
10-01 6万+
Dataset之LFW：LFW人脸数据库的简介、安装、使用方法之详细攻略 目录 LFW人脸数据库的简介 1、LFW数据集的重要意义 LFW人脸数据库的安装 LFW人脸数据库的使用方法 LFW人脸数据库的简介 LFW (Labled Faces in the Wild)人脸数据集：是目前人脸识别的常用测试集，其中提供的人脸图片均来源于生活中的自然...
单点登录基本概念
市民景先生
06-04 283
目录单一服务器模式单点登录（SSO）1）使用session对象实现在登录成功之后，把用户数据放到session里面，判断是否登录，从session获取数据获取登录session.setAttribute("user",user)session.getAttribute("user")在集群和分布式的时候会出现问题比如搭建微服务的时候，每一个项目有很多子模块互不影响，通过子模块登录，其他模块的也可以正常访问eg：百度有很多子模块，网页，贴吧，知道等，你在任意一个模块登录其他模块也可以使用......
单点登录（SSO）
qq_41913971的博客
01-26 2万+
什么是单点登录？ 单点登录的来源 单点登录技术实现 Cookie的属性详细介绍 Koa Cookie 的设置与获取 利用Node.js koa异步中间件——用户登录验证拦截器
SSO单点登录系统详解
"sso单点登录ppt.ppt" SSO单点登录系统是一种高效的身份验证解决方案，它允许用户只需登录一次即可访问多个相互信任的应用系统。这种技术在现代企业环境中非常常见，因为它能够提高用户体验，简化身份管理，并增强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值