单点登录SSO

最新推荐文章于 2024-07-04 22:55:50 发布
最新推荐文章于 2024-07-04 22:55:50 发布
阅读量456 收藏 2
点赞数
分类专栏： JWT Spring Boot 文章标签： jwt redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperstarSteven/article/details/104394104
版权
  1. 分布式，SSO(single sign on)模式在这里插入图片描述

解决 ：
1.用户身份信息独立管理，更好的分布式管理。
2.可以自己扩展安全策略
3,跨域不是问题
缺点：
1.认证服务器访问压力较大。

  1. 单点登录流程图
    在这里插入图片描述

3.UmsMember.java

public class UmsMember implements Serializable {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    private String id;
    private String memberLevelId;
    private String username;
    private String password;
    private String nickname;
    private String phone;
    private int status;
    private Date createTime;
    private String icon;
    private String gender;
    private Date birthday;
    private String city;
    private String job;
    private String personalizedSignature;
    private String sourceType;
    private int integration;
    private int growth;
    private int luckeyCount;
    private int historyIntegration;

    private Long sourceUid;
    private String accessToken;
    private String accessCode;

4.UmsService.java

public interface UserService {
    List<UmsMember> getAllUser();

    List<UmsMemberReceiveAddress> getUmsMemberReceiveAddress(String memberId);

    UmsMember login(UmsMember umsMember);

    void addUserToken(String token, String memberId);

    UmsMember addOldOauthUser(UmsMember umsMember);

    UmsMember checkOauthUser(UmsMember umsCheck);

    UmsMemberReceiveAddress getReceiveAddressById(String receiveAddressId);
}

4.UserMapper.java

public interface UserMapper extends Mapper<UmsMember>{
    List<UmsMember> selectAllUser();
}

5.UmsMemberReceiveAddressMapper.java

public interface UmsMemberReceiveAddressMapper extends Mapper<UmsMemberReceiveAddress>{
}

6.UserServiceImpl.java

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private UmsMemberReceiveAddressMapper umsMemberReceiveAddressMapper;

    @Autowired
    RedisUtil redisUtil;

    @Override
    public List<UmsMember> getAllUser() {
        List<UmsMember> umsMemberList= userMapper.selectAll();
        return umsMemberList;
    }

    @Override
    public List<UmsMemberReceiveAddress> getUmsMemberReceiveAddress(String memberId) {
        UmsMemberReceiveAddress umsMemberReceiveAddress=new UmsMemberReceiveAddress();
        umsMemberReceiveAddress.setMemberId(memberId);
        List<UmsMemberReceiveAddress> umsMemberReceiveAddresses = umsMemberReceiveAddressMapper.select(umsMemberReceiveAddress);
        return umsMemberReceiveAddresses;
    }

    @Override
    public UmsMember login(UmsMember umsMember) {
        Jedis jedis=null;
        try {
            jedis = redisUtil.getJedis();
            if(jedis!=null){

                String umsMemberStr = jedis.get("user:" + umsMember.getPassword() + ":info");

                if (StringUtils.isNotBlank(umsMemberStr)) {
                    //密码正确
                    UmsMember umsMemberFromCache = JSON.parseObject(umsMemberStr, UmsMember.class);
                    return umsMemberFromCache;
                }
            }
            //连接redis失败，开启数据库
            UmsMember umsMemberFromDb= loginFromDb(umsMember);
            if(umsMemberFromDb!=null){
                jedis.setex("user:" + umsMember.getPassword() +umsMember.getUsername()+ ":info",60*60*24,JSON.toJSONString(umsMemberFromDb));
            }
            return umsMemberFromDb;
        }finally {
            jedis.close();
        }
    }

    @Override
    public void addUserToken(String token, String memberId) {
        Jedis jedis = redisUtil.getJedis();
        jedis.setex("user:"+memberId+":token",60*60*2,token);

        jedis.close();
    }

    @Override
    public UmsMember addOldOauthUser(UmsMember umsMember) {
        userMapper.insertSelective(umsMember);
        return umsMember;
    }

    @Override
    public UmsMember checkOauthUser(UmsMember umsCheck) {
        UmsMember umsMember = userMapper.selectOne(umsCheck);
        return umsMember;
    }

    @Override
    public UmsMemberReceiveAddress getReceiveAddressById(String receiveAddressId) {
        UmsMemberReceiveAddress umsMemberReceiveAddress=new UmsMemberReceiveAddress();
        umsMemberReceiveAddress.setId(receiveAddressId);
        UmsMemberReceiveAddress memberReceiveAddress = umsMemberReceiveAddressMapper.selectOne(umsMemberReceiveAddress);
        return memberReceiveAddress;
    }


    private UmsMember loginFromDb(UmsMember umsMember) {
        List<UmsMember> umsMembers = userMapper.select(umsMember);

        if(umsMembers!=null){
            return umsMembers.get(0);
        }
        return null;
    }
}

7.PassPortController.java

@Controller
public class PassPortController {

    @Reference
    UserService userService;

    @RequestMapping("vlogin")
    public String vlogin(String code,HttpServletRequest request){

        //授权码换取access_token
        String s3="https://api.weibo.com/oauth2/access_token?";
        //?client_id=3193708961&client_secret=df2b2370fbd3483cdd8a9eb422ca325&grant_type=authorization_code&redirect_uri=http://passport.gmall.com:8085/vlogin&code=CODE";

        HashMap<String, String> paramMap = new HashMap<>();
        paramMap.put("client_id","3193708961");
        paramMap.put("client_secret","df2b2370fbd3483cdd8a9eb422ca3253");
        paramMap.put("grant_type","authorization_code");
        paramMap.put("redirect_uri","http://passport.gmall.com:8085/vlogin");
        paramMap.put("code",code);

        String access_token_json = HttpclientUtil.doPost(s3, paramMap);
        Map<String,String> access_map = JSON.parseObject(access_token_json, Map.class);

        //access_token获取用户信息
        String access_token = access_map.get("access_token");
        String uid = access_map.get("uid");
        String s4="https://api.weibo.com/2/users/show.json?access_token="+access_token+"&uid="+uid;
        String s = HttpclientUtil.doGet(s4);
        Map<String,Object> map = JSON.parseObject(s, Map.class);

        //将用户信息保存到数据库，将用户类型设置为微博用户
        UmsMember umsMember = new UmsMember();
        umsMember.setSourceType("2");
        umsMember.setAccessCode(code);
        umsMember.setAccessToken(access_token);
        umsMember.setNickname((String)map.get("screen_name"));
        umsMember.setSourceUid(((Long)map.get("id")));
        umsMember.setCity((String) map.get("location"));
        umsMember.setGender((String) (map.get("gender")));

        UmsMember umsCheck = new UmsMember();
        umsCheck.setSourceUid(umsMember.getSourceUid());
        UmsMember checkUmsMember = userService.checkOauthUser(umsCheck);
        if(checkUmsMember==null){
            umsMember=userService.addOldOauthUser(umsMember);
        }else{
            umsMember=umsCheck;
        }

        //生成JWT的token,并且重定向到首页，携带token
        String token=null;
        //rpc主键返回策略失效
        String memberId = umsMember.getId();
        String nickname = umsMember.getNickname();

        Map<String,Object> userMap=new HashMap<>();
        userMap.put("memberId",memberId);
        userMap.put("nickname",nickname);

        String ip = request.getHeader("x-forwarded-for");
        //从request中获取IP
        if(StringUtils.isBlank(ip)) {
            ip=request.getRemoteAddr();
            if(StringUtils.isBlank(ip)) {
                ip="127.0.0.1";
            }
        }

        //按照设计的算法对参数进行加密后，生成token
        token = JwtUtil.encode("2019gmall0105", userMap, ip);

        return "redirect:http://search.gmall.com:8083/index?token="+token;
    }

    @RequestMapping("verify")
    @ResponseBody
    public String verify(String token,String currentIp){

        //通过jwt校验token真假
        Map<String,String> map=new HashMap<>();

        Map<String, Object> decode = JwtUtil.decode(token, "2019gmall0105", currentIp);
        if(decode!=null) {
            map.put("status", "success");
            map.put("memberId", (String) decode.get("memberId"));
            map.put("nickName", (String) decode.get("nickName"));
        }else{
            map.put("status", "fail");
        }
        return JSON.toJSONString(map);
    }

    @RequestMapping("login")
    @ResponseBody
    public String login(UmsMember umsMember, HttpServletRequest request){

        String token="";
        //调用用户服务验证用户名和密码
        UmsMember userMemberLogin= userService.login(umsMember);
        if(userMemberLogin!=null){
            //登陆成功

            //用jwt制作token

            //将token存入redis一份
            String memberId = userMemberLogin.getId();
            String nickname = userMemberLogin.getNickname();
            Map<String,Object> userMap=new HashMap<>();
            userMap.put("memberId",memberId);
            userMap.put("nickname",nickname);

            String ip = request.getHeader("x-forwarded-for");
            //从request中获取IP
            if(StringUtils.isBlank(ip)) {
                ip=request.getRemoteAddr();
                if(StringUtils.isBlank(ip)) {
                    ip="127.0.0.1";
                }
            }

            //按照设计的算法对参数进行加密后，生成token
            token = JwtUtil.encode("2019gmall0105", userMap, ip);

            //将token放入redis一份
            userService.addUserToken(token,memberId);

        }else{
            //登陆失败
            token="fail";
        }
        return token;
    }

    @RequestMapping("index")
    public String index(String ReturnUrl, ModelMap map){

        map.put("ReturnUrl",ReturnUrl);
        return "index";
    }
}

6.AuthInterceptor.java拦截器

@Component
public class AuthInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        /**
         * 拦截代码
         */

        //判断被拦截请求的访问方法的注解是否需要拦截
        HandlerMethod mh = (HandlerMethod) handler;
        LoginRequired methodAnnotation = mh.getMethodAnnotation(LoginRequired.class);

        StringBuffer url = request.getRequestURL();
        //是否拦截
        if(methodAnnotation==null){
            return true;
        }

        String token="";

        String oldToken = CookieUtil.getCookieValue(request, "oldToken", true);

        if(StringUtils.isNotBlank(oldToken)){
            token=oldToken;
        }
        String newToken = request.getParameter("token");
        if(StringUtils.isNotBlank(newToken)){
            token=newToken;
        }


        /**
         * 该请求是否登录成功
         */
        boolean loginSuccess = methodAnnotation.loginSuccess();

        //请用认证中心进行验证
        String success="fail";
        Map<String,String> successMap=new HashMap<String, String>();
        if(StringUtils.isNotBlank(token)){
            String ip = request.getHeader("x-forwarded-for");
            //从request中获取IP
            if(StringUtils.isBlank(ip)) {
                ip=request.getRemoteAddr();
                if(StringUtils.isBlank(ip)) {
                    ip="127.0.0.1";
                }
            }
            String successJson = HttpclientUtil.doGet("http://passport.gmall.com:8085/verify?token=" + token+"&currentIp="+ip);
            successMap = JSON.parseObject(successJson, Map.class);

            success=successMap.get("status");
        }
        if(loginSuccess){
            //必须登陆成功才能使用
           if(!success.equals("success")){
               //重定向passport登陆
               StringBuffer requestURL = request.getRequestURL();
               response.sendRedirect("http://passport.gmall.com:8085/index?ReturnUrl="+requestURL);
               return false;
           }
               //验证通过，覆盖token
               request.setAttribute("memberId",successMap.get("memberId"));
               request.setAttribute("nickname",successMap.get("nickName"));
            //验证通过，覆盖cookie里的token
            if(StringUtils.isNotBlank(token)) {
                CookieUtil.setCookie(request, response, "oldToken", token, 60 * 60 * 2, true);
            }

        }else{
            //没有登陆也可以用，但是必须校验
            if(success.equals("success")){
                //重定向passport登陆
                request.setAttribute("memberId",successMap.get("memberId"));
                request.setAttribute("nickname",successMap.get("nickName"));
            }

        }
        return true;
    }
}

7.application.properties

server.port=8070

#jdbc 配置
spring.datasource.url=jdbc:mysql://localhost:3306/crm?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=09091995aq


mybatis.mapper-locations=classpath:mapper/*Mapper.xml
mybatis.configuration.map-underscore-to-camel-case=true

#设置日志级别
logging.level.root=info

#扫描dubbo的配置
#dubbo中的服务名称
spring.dubbo.application=user-service
#dubbo的通讯协议名称
spring.dubbo.protocol.name=dubbo
#zookeeper注册中心地址
spring.dubbo.registry.address=47.101.36.177:2181
#zookeeper的注册名称
spring.dubbo.registry.protocol=zookeeper
#dubbo服务的扫描路径
spring.dubbo.base-package=com.atguigu.gmall

spring.dubbo.protocol.port=20880


#spring整合redis
#取配置文件中的redis的ip地址
#Redis数据库连接配置
spring.redis.host=47.101.36.177
spring.redis.port=6379
spring.redis.password=123
spring.redis.timeout=1000
spring.redis.database=0

8.GmallUserServiceApplication.java

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.gmall.user.mapper")
public class GmallUserServiceApplication {

	public static void main(String[] args) {
		SpringApplication.run(GmallUserServiceApplication.class, args);
	}
}
Java实现单点登录（SSO）详解
勤劳的小琪
04-24 4793
单点登录（Single Sign-On，简称SSO）是目前比较流行的企业业务整合的解决方案之一，它的主要功能是：在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。单点登录的实现机制是：当用户第一次访问应用系统1的时候，因为还没有登录，所以会被引导到认证系统中进行登录；根据用户提供的登录信息，认证系统进行验证，如果通过验证，则应该返回给用户一个认证的凭据——ticket；
Java中的SSO（单点登录）：从入门到精通
最新发布
weixin_46372265的博客
07-10 910
单点登录（Single Sign-On，SSO）是一种认证机制，允许用户在多个独立的软件系统中使用同一套登录凭证。也就是说，用户只需登录一次，就能访问所有相互信任的应用系统，而无需重复登录。SSO通过一个集中式的认证服务器管理用户的认证信息，当用户尝试访问受保护的资源时，该服务器验证用户的身份，并返回一个认证令牌给应用系统，从而实现单点登录的效果【6†source】【7†source】。单点登录（SSO）通过简化用户认证流程，提升了用户体验和安全性。
Java实现单点登录（SSO）详解：从理论到实践
喔的嘛呀的博客
07-04 1665
单点登录是一种身份认证的机制，允许用户在访问多个相关但独立的软件系统时，只需一次登录，便可无缝访问所有系统。这大大提高了用户体验，并简化了管理和维护的复杂性。通过本文，我们详细讨论了SSO的核心概念、选择了适当的身份验证协议，并提供了完整的Java代码实现。实现SSO系统需要深入理解身份验证协议、使用合适的框架，以及合理配置认证和资源服务器。希望这篇博客能够为你提供深度且全面的SSO实现指南。通过这个实践，你将更好地理解和应用SSO技术，提升应用的用户体验和安全性。
java实现单点登陆（SSO）
weixin_44026997的博客
03-30 2439
java实现单点登陆（SSO） 网络域名必须完全一致，才代表同一站点。 域名映射 ：访问后面的 会跳转到前面 单点登陆概念： 多系统，单一位置登录，实现多系统同时登陆。常出现在互联网和企业级平台中。 单点登陆一般是用于互相授信的系统，实现单一位置登录，全系统有效。 三方登录：某系统使用其他系统的用户，实现本系统登录的方式，如在jd上使用wx登录。解决信息孤岛（共享用户的名字，而不是密码，用户在每...
SSO 轻量级实现指南（原生 Java 实现）：SSO Client 部分
zhangxin09的专栏
04-28 2396
作为统一的认证中心，SSO 中心无疑拥有最根本的用户状态记录，一切皆以 SSO 中心的为准。但每次访问资源的认证工作都要通讯 SSO 中心，性能成本会不会太高呢？对于 SSO 中心服务器的性能也是严重的考验。对此，笔者考虑了以下几个个解决方案。
单点登录SSO原理.docx
09-04
单点登录（Single Sign-On，简称SSO）是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需再次输入凭证。在大型企业或网站中，SSO的实施大大提升了用户体验，减少了重复认证的过程，同时也...
单点登录sso
12-06
单点登录（Single Sign-On，简称SSO）是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需再次输入凭证。这种技术极大地提升了用户体验，减少了用户记忆和管理多套用户名和密码的负担，...
SSO 单点登录(java）
m0_73194691的博客
11-28 597
登陆页面 携带 ==hidden== 隐藏的 客户端url。这里参照 controller 的login方法。携带重定向的 url发给认证服务器。这样 服务器处理完登陆结果，也知道把信息返回给哪个服务器的地址。使用Spring Initializr 初始化springBoot项目。2.1 client 客户端编写。2.2 客户端的html文件。2.4 认证服务器页面。2.3 认证服务器端。添加 redis依赖。
SSO个人实现方式
05-23
下载前请参考这篇文章http://blog.csdn.net/javaee_ssh/article/details/25998553
单点登录sso的原理与java实现详细讲解与示例(文档与源码)
06-23
单点登录sso的原理与java实现详细讲解与示例(文档与源码)
sso 单点登陆 java 动手写sso
08-21
自己动手写sso java 简单实现 使用 目前流行的 springboot 做基础
单点登录（sso）
05-30
single sign on（sso）单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统
java 单点登录（SSO）
FireAny2010的专栏
03-26 5454
java 单点登录（SSO） 一、背景 在企业发展初期，企业使用的系统很少，通常一个或者两个，每个系统都有自己的登录模块，运营人员每天用自己的账号登录，很方便。 但随着企业的发展，用到的系统随之增多，运营人员在操作不同的系统时，需要多次登录，而且每个系统的账号都不一样，这对于运营人员来说，很不方便。 于是，就想到是不是可以在一个系统登录，...
Java学习四阶段-05 单点登录系统（SSO）
奔跑的小猫
08-07 390
系统简介 Http协议 web应用采用browser/server架构，http作为通信协议。http是无状态协议，浏览器的每一次请求，服务器会独立处理，不与之前或之后的请求产生关联，这个过程用下图说明，三次请求/响应对之间没有任何联系。 但这也同时意味着，任何用户都能通过...
SSO 轻量级实现指南（原生 Java 实现）：SSO Server 部分
zhangxin09的专栏
04-22 2518
OAuth 是当前单点登录（SSO）和用户授权的标准协议——现在就让我们一起动手撸一个 SSO 的实现吧！
友盟社会化Android组件之第三方登录
mmsx
11-28 9048
前段时间公司需要，逐步了新浪微博、腾讯qq、微信等授权登录验证的问题。如果要一个个申请，看文档写代码也是很多流程的。干脆用友盟社会化Android组件之第三方登录。友盟是集成了这些平台，还有其他主流的平台的。我在这里主要讲一下友盟里面微博登录。先看看友盟是怎么介绍自已的。 一、友盟社会化分享介绍 友盟社会化分享组件，帮助移动应用快速具备微信分享，微博分享、登录、评论、喜欢等社会化组件功能，助力
SSO实现单点登录
wz122330的博客
12-27 1627
最近在项目中，需要为客户集成单点登录，cas-server和cas-client均是客户提供。本篇文章主要介绍如何实现单点登录。cas-server和client可以去官网下载：http://www.jasig.org/cas
深度解析：跨域单点登录SSO实现与细节
"单点登录SSO的图示与讲解，包括示例运行效果动画、跨域WebSSO时序图、代码截图和基本概念解析。" 单点登录（Single Sign-On，简称SSO）是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值