sso 单点登陆 ，动手写sso单点登陆

最新推荐文章于 2022-07-17 09:20:04 发布
最新推荐文章于 2022-07-17 09:20:04 发布
阅读量331 收藏 3
点赞数 1
分类专栏： java sso java 开发-架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq2531246791/article/details/81906096
版权
java 同时被 3 个专栏收录
41 篇文章 0 订阅
订阅专栏
java 开发-架构
22 篇文章 0 订阅
订阅专栏
sso
1 篇文章 0 订阅
订阅专栏

1.创建 server  app1  app2 3个项目   项目结构如下

配置   认证中心和子系统的域名     单点模拟需要 修改 host 配置文件

2，server  端 代码 

创建登陆验证拦截器

package com.lz.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

/**
 * @author pc-ZD
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 在请求处理之前进行调用（Controller方法调用之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

       Map<String,Object> user = (Map<String,Object>) request.getSession().getAttribute("USER");
       if (null == user){
           //子系统 第一次登陆
           response.sendRedirect("/login");
       }else {

       }
        return true;
    }

    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    /**
     * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

创建  控制器处理类 

package com.lz.controller;

import com.alibaba.fastjson.JSONObject;
import com.lz.dao.RegisterApp;
import com.lz.dao.UserDB;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.UUID;

import static com.lz.dao.RegisterApp.appLogoutURL;

/**
 * @author pc-ZD
 */
@Controller
public class LoginController {

    @RequestMapping(value = "/login",method = RequestMethod.GET)
    public String toLogin(HttpServletRequest request,HttpServletResponse response){
        try {
            String redirectURL = request.getParameter("redirectURL");
            request.getSession().setAttribute("redirectURL",redirectURL);

            //如果 用户已经认证登陆   则将令牌  交给子系统，使其系统用户上线
            Map<String,Object> user = (Map<String,Object>) request.getSession().getAttribute("USER");
            if (null != user){
                String token = user.get("token").toString();
                if (null != redirectURL && !redirectURL.equals("")){
                    redirectURL += "?token=" + user.get("token");
                    response.sendRedirect(redirectURL);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "login/login";
    }

    @RequestMapping(value = "/login",method = RequestMethod.POST)
    public String login(HttpServletRequest request, HttpServletResponse response,
                        @RequestParam Map<String, String> paramMap,@RequestParam String redirectURL){
        try {
            String userName =  paramMap.get("userName") == null ? "" :  paramMap.get("userName").trim();
            String possWord =  paramMap.get("possWord") == null ? "" :  paramMap.get("possWord").trim();
            if (userName.equals("admin") && possWord.equals("admin")){
                Map<String,Object> user = new HashMap<>();
                user.put("name","ADMIN");
                user.put("userName","admin");
                user.put("possWord","admin");
                user.put("token", UUID.randomUUID().toString().trim());

                if (null != redirectURL && !redirectURL.equals("")){
                    request.getSession().setAttribute("USER",user);
                    //登陆后 更新数据库  （保存  用户对应的密钥）
                    UserDB.currUserDB.add(user);
                    redirectURL += "?token=" + user.get("token");
                    response.sendRedirect(redirectURL);
                }
                return "login/fail2";
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "login/fail";
    }

    /**
     * 验证密钥
     * @param token
     * @param request
     * @return
     */
    @GetMapping("validToken/{token}")
    public @ResponseBody Map<String,Object> validToken(@PathVariable("token") String token,HttpServletRequest request){
        Map<String,Object> currUser = null;
        for (int i = 0 ; i < UserDB.currUserDB.size() ;i++){
            currUser = UserDB.currUserDB.get(i);
            String userToken = currUser.get("token").toString();
            if (userToken.equals(token)){
                return currUser;
            }
        }
        return null;
    }

    /**
     * 通知子系统  注销 并注销当前 用户
     */
    @RequestMapping(value = "/noticeLogout/{token}",method = RequestMethod.GET)
    public String noticeLogout(HttpServletRequest request,@PathVariable("token") String token,
                               HttpServletResponse response,@RequestParam("redirectURL") String redirectURL){
        try {
            //通知子系统下线
            for (String it: RegisterApp.appLogoutURL) {
                CloseableHttpClient httpCilent = HttpClients.createDefault();
                URI uri = new URI(it);
                HttpGet httpget = new HttpGet(uri);
                HttpResponse httpResponse = httpCilent.execute(httpget);
                HttpEntity entity = httpResponse.getEntity();
                String result = EntityUtils.toString(entity, "utf-8");
                EntityUtils.consume(entity);
                ((CloseableHttpResponse) httpResponse).close();
                JSONObject resultMap = JSONObject.parseObject(result);
                if (resultMap.get("code").equals(200) || resultMap.get("code").equals("200")){
                    System.out.println( "app :" + it +"通知成功");
                }
            }

            //注销当前用户(认证中心 全局session)
            request.getSession().invalidate();
            //将当前令牌信息 清除
            Map<String,Object> currUser = null;
            for (int i = 0 ; i < UserDB.currUserDB.size() ;i++){
                currUser = UserDB.currUserDB.get(i);
                String userToken = currUser.get("token").toString();
                if (userToken.equals(token)){
                    UserDB.currUserDB.remove(i);
                }
            }
            //注销后回到原 app 首页
            response.sendRedirect(redirectURL);

        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }

        return "login/logout";
    }

    @GetMapping("/registerAppLogout/{sessionId}")
    public Map<String,Object> registerAppLogout(@RequestParam("appLogoutURL") String appLogoutURL,
                           @PathVariable("sessionId") String sessionId){
        Map<String,Object> resultMap = new HashMap<>();
        try {
            RegisterApp.appLogoutURL.add(appLogoutURL + "/" + sessionId);
            resultMap.put("code",200);
        } catch (Exception e) {
            resultMap.put("code",500);
            e.printStackTrace();
        }
        return resultMap;
    }


}

  子系统应用注册 信息存储  ，用于通知对应的子系统注销 

package com.lz.dao;

import java.util.ArrayList;
import java.util.List;

/**
 * 这里使用  静态类模拟  redis 数据库
 */
public class RegisterApp {
    /**
     * key  sessionId
     * value  logoutUrl
     */
    public static List<String> appLogoutURL = new ArrayList<>();

}

创建认证中心  用户信息存储

package com.lz.dao;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 这里使用  静态类模拟  redis 数据库
 */
public class UserDB {

    public static List<Map<String,Object>> currUserDB = new ArrayList<>();

}

认证中心启动类配置

package com.lz;

import com.lz.interceptor.LoginInterceptor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * @author pc-ZD
 */
@ComponentScan("com.lz.*")
@SpringBootApplication
public class ServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class, args);
    }

    @Configuration
    static class WebMvcConfigurer extends WebMvcConfigurerAdapter {

        @Override
        public void addInterceptors(InterceptorRegistry registry){
            //指定拦截器类
            registry.addInterceptor(new LoginInterceptor())
                    //指定该类拦截的url
                    .addPathPatterns("/*").excludePathPatterns("/login","/registerAppLogout/*");
        }

    }
}

认证登陆页 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>

<form method="post" action="/login?redirectURL=${redirectURL!}">
    <label>用户名</label>
    <input type="text" name="userName" >
    <label>密码</label>
    <input type="text" name="possWord" >
    <input type="submit">
</form>

</body>
</html>

应用子系统  1 

同样创建登陆验证拦截器

package com.lz.interceptor;

import com.alibaba.fastjson.JSONObject;
import com.lz.dao.SessionDB;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.net.URI;
import java.util.Map;

/**
 * @author pc-ZD
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 在请求处理之前进行调用（Controller方法调用之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String token = request.getParameter("token");
        if (null != token && !token.equals("")){
            // 去认证中心获取  验证  token 票 将 用户上线
            CloseableHttpClient httpCilent = HttpClients.createDefault();
            URI uri = new URI("http://sso.server.com:8888/validToken/"+ token);
            HttpGet httpget = new HttpGet(uri);
            HttpResponse httpResponse = httpCilent.execute(httpget);
            HttpEntity entity = httpResponse.getEntity();
            String result = EntityUtils.toString(entity, "utf-8");
            EntityUtils.consume(entity);
            ((CloseableHttpResponse) httpResponse).close();

            // 令牌不存在
            if (result.equals("")){
                String redirectURL =  "http://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + request.getServletPath();
                response.sendRedirect("http://sso.server.com:8888/login?redirectURL=" + redirectURL);
                return false;
            }
            request.getSession().setAttribute("USER",JSONObject.parseObject(result));
            //保存 客户端session   下线注销使用
            SessionDB.DB.put(request.getSession().getId(),request.getSession());


            //将当前 app 注销地址  注册到认证中心
            String appLogoutURL = "http://sso.client1.com:8889/logout";
            String sessionId = request.getSession().getId();
            uri = new URI("http://sso.server.com:8888/registerAppLogout/" + sessionId + "?appLogoutURL=" + appLogoutURL);
            httpget = new HttpGet(uri);
            httpResponse = httpCilent.execute(httpget);
            entity = httpResponse.getEntity();
            result = EntityUtils.toString(entity, "utf-8");
            EntityUtils.consume(entity);
            ((CloseableHttpResponse) httpResponse).close();
            if (result.equals(200) || result.equals("200")){
                System.out.println(appLogoutURL + " 注册成功");
            }else {
                System.out.println(appLogoutURL + " 注册失败");
            }
            return true;
        }

        Map<String,Object> user = (Map<String,Object>) request.getSession().getAttribute("USER");
       if (null == user){
           String redirectURL =  "http://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + request.getServletPath();
           response.sendRedirect("http://sso.server.com:8888/login?redirectURL=" + redirectURL);
           return false;
       }
        return true;
    }

    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    /**
     * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

创建控制处理类    子系统注销处理

package com.lz.controller;


import com.lz.dao.SessionDB;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * @author pc-ZD
 */
@Controller
public class LoginController {

    @RequestMapping(value = "/logout/{sessionId}",method = RequestMethod.GET)
    public @ResponseBody
    Map<String,Object> toLogin(HttpServletRequest request, @PathVariable("sessionId") String sessionId){
        Map<String,Object> resultMap = new HashMap<>();
        try {
            SessionDB.DB.get(sessionId).invalidate();
            resultMap.put("code",200);
        } catch (Exception e) {
            resultMap.put("code",500);
            e.printStackTrace();
        }
        return resultMap;
    }
}

创建子系统  用户信息存储   （也叫系统局部用户）

package com.lz.dao;

import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 这里使用  静态类 存储 客户端session
 */
public class SessionDB {

    public static Map<String,HttpSession> DB = new HashMap<>();

}

子系统测试   请求接口

package com.lz.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @author pc-ZD
 */
@Controller
public class IndexController {

    @RequestMapping(value = "/",method = RequestMethod.GET)
    public String toIndex(){
        return "index";
    }

    @RequestMapping(value = "/userInfo",method = RequestMethod.GET)
    public String userInfo(){
        return "user/index";
    }

}

测试启动类

package com.lz;

import com.lz.interceptor.LoginInterceptor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * @author pc-ZD
 */
@ComponentScan("com.lz.*")
@SpringBootApplication
public class Client1Application {
    public static void main(String[] args) {
        SpringApplication.run(Client1Application.class, args);
    }

    @Configuration
    static class WebMvcConfigurer extends WebMvcConfigurerAdapter {

        @Override
        public void addInterceptors(InterceptorRegistry registry){
            //指定拦截器类
            registry.addInterceptor(new LoginInterceptor())
                    //指定该类拦截的url
                    .addPathPatterns("/*").excludePathPatterns("/","/logout");
        }

    }

}

创建子系统应用2   与 1基本相同 

创建 登陆拦截器

package com.lz.interceptor;

import com.alibaba.fastjson.JSONObject;
import com.lz.dao.SessionDB;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.net.URI;
import java.util.Map;

/**
 * @author pc-ZD
 */
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 在请求处理之前进行调用（Controller方法调用之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String token = request.getParameter("token");
        if (null != token && !token.equals("")){
            // 去认证中心获取  验证  token 票 将 用户上线
            CloseableHttpClient httpCilent = HttpClients.createDefault();
            URI uri = new URI("http://sso.server.com:8888/validToken/"+ token);
            HttpGet httpget = new HttpGet(uri);
            HttpResponse httpResponse = httpCilent.execute(httpget);
            HttpEntity entity = httpResponse.getEntity();
            String result = EntityUtils.toString(entity, "utf-8");
            EntityUtils.consume(entity);
            ((CloseableHttpResponse) httpResponse).close();

            // 改令牌不存在
            if (result.equals("")){
                String redirectURL =  "http://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + request.getServletPath();
                response.sendRedirect("http://sso.server.com:8888/login?redirectURL=" + redirectURL);
                return false;
            }
            request.getSession().setAttribute("USER",JSONObject.parseObject(result));
            //保存 客户端session   下线注销使用
            SessionDB.DB.put(request.getSession().getId(),request.getSession());

            //将当前 app 注销地址  注册到认证中心
            String appLogoutURL = "http://sso.client2.com:8890/logout";
            String sessionId = request.getSession().getId();
            uri = new URI("http://sso.server.com:8888/registerAppLogout/" + sessionId + "?appLogoutURL=" + appLogoutURL);
            httpget = new HttpGet(uri);
            httpResponse = httpCilent.execute(httpget);
            entity = httpResponse.getEntity();
            result = EntityUtils.toString(entity, "utf-8");
            EntityUtils.consume(entity);
            ((CloseableHttpResponse) httpResponse).close();
            if (result.equals(200) || result.equals("200")){
                System.out.println(appLogoutURL + " 注册成功");
            }else {
                System.out.println(appLogoutURL + " 注册失败");
            }
            return true;
        }

       Map<String,Object> user = (Map<String,Object>) request.getSession().getAttribute("USER");
       if (null == user){
           String redirectURL =  "http://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath() + request.getServletPath();
           response.sendRedirect("http://sso.server.com:8888/login?redirectURL=" + redirectURL);
           return false;
       }

        return true;
    }

    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    /**
     * 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

 

创建控制器处理类  （用于用户注销）

package com.lz.controller;

import com.lz.dao.SessionDB;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @author pc-ZD
 */
@Controller
public class LoginController {

    @RequestMapping(value = "/logout/{sessionId}",method = RequestMethod.GET)
    public @ResponseBody
    Map<String,Object> toLogin(HttpServletRequest request, @PathVariable("sessionId") String sessionId){
        Map<String,Object> resultMap = new HashMap<>();
        try {
            SessionDB.DB.get(sessionId).invalidate();
            resultMap.put("code",200);
        } catch (Exception e) {
            resultMap.put("code",500);
            e.printStackTrace();
        }
        return resultMap;
    }


}

创建子系统的 用户 存储（局部用户）

package com.lz.dao;

import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;

/**
 * 这里使用  静态类 存储 客户端session
 */
public class SessionDB {

    public static Map<String,HttpSession> DB = new HashMap<>();

}

测试请求接口

package com.lz.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @author pc-ZD
 */
@Controller
public class IndexController {

    @RequestMapping(value = "/",method = RequestMethod.GET)
    public String toIndex(){
        return "index";
    }

    @RequestMapping(value = "/userInfo",method = RequestMethod.GET)
    public String userInfo(){
        return "user/index";
    }

}

启动类

package com.lz;

import com.lz.interceptor.LoginInterceptor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * @author pc-ZD
 */
@ComponentScan("com.lz.*")
@SpringBootApplication
public class Client2Application {
    public static void main(String[] args) {
        SpringApplication.run(Client2Application.class, args);
    }

    @Configuration
    static class WebMvcConfigurer extends WebMvcConfigurerAdapter {

        @Override
        public void addInterceptors(InterceptorRegistry registry){
            //指定拦截器类
            registry.addInterceptor(new LoginInterceptor())
                    //指定该类拦截的url
                    .addPathPatterns("/*").excludePathPatterns("/","/logout");
        }

    }

}

测试结果

 

 

核心思想推荐阅读 ： 


https://blog.csdn.net/u011277123/article/details/53404269

我的小站   zegoto.cn  如有疑问 ，欢迎留言沟通 

 

代码下载：

https://download.csdn.net/download/qq2531246791/10617326

 

qq2531246791
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sso 单点登陆 java 动手写sso
08-21
SSO（Single Sign-On）单点登录是一种身份验证机制，允许用户在一次登录后，就能访问多个相互关联的应用系统，而无需再次进行身份验证。在Java中实现SSO，我们可以利用Spring Boot框架的强大功能，它提供了丰富的...
MVC SSO 单点登陆完整demo
08-26
**SSO（Single Sign-On）单点登录**是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需再次输入凭证。在Web应用程序中，MVC（Model-View-Controller）架构常被用来构建SSO系统，因为它...
SpringBoot整合SSO(single sign on)单点登录
08-19
主要介绍了SpringBoot整合SSO(single sign on)单点登录，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
手撸SSO单点登录（五）登录验证-OA系统页面刷新或者跳转新OA系统页面
kiduo08的专栏
05-08 1868
目标  上一章节手撸SSO单点登录（四）登录验证-首次登录已经成功登陆并且跳转至OA系统,当OA系统刷新，或者OA系统打开其他菜单是怎么实现无需登陆，直接验证通过，跳转页面或者刷新页面。 二 、系统UML工程类图 三、代码实现 a.当刷新OA系统页面的时候，进入com.yuantai.filter.LoginFilter请求拦截、进入isAccessAllowed方法 @Override public boolean isAccessAllowed(HttpServletRequest reque
手撸SSO单点登录（一）：序言
kiduo08的专栏
04-27 2754
基于Springboot、Oath2实现的sso单点登录系统
手撸SSO单点登录（六）SSO单点退出原理
kiduo08的专栏
05-09 3882
目标 这一章节我们来一起学习,单点退出登录，是怎么让所有sso系统一起退出登录的。 视频详细讲解请见https://www.bilibili.com/video/BV1b5411d7be/ 源码下载地址：https://gitcode.net/kiduo08/yuantai-sso.git 时序图 当用户点击某一个系统的退出登录时候 统一的发起跳转到认证中心http://authentication.sso.com:8080/logout?redirectUri=http://client.sso.co
手撸SSO单点登录（二）：系统部署
kiduo08的专栏
04-28 2329
前言 以idea为例，导入并分别运行认证服务端和客户端，展示验证单点登录功能。 1.代码下载导入 从gitlab 克隆代码 https://gitcode.net/kiduo08/yuantai-sso.git idea 导入代码
sso单点登录ppt.ppt
10-30
sso单点登录ppt.ppt
单点登陆（sso+shiro+cas）
04-11
单点登录（Single Sign-On，简称SSO）是一种在多应用环境中实现用户只需一次登录就能访问所有系统的身份验证机制。SSO技术简化了用户的登录流程，提高了用户体验，同时也能强化安全控制，统一管理用户权限。在Java...
spring boot 实现SSO单点登陆
09-19
spring boot整合spring security 实现SSO单点登陆 完整DEMO. 1、配置本地hosts 127.0.0.1 sso-login 127.0.0.1 sso-resource 127.0.0.1 sso-tmall 127.0.0.1 sso-taobao windows系统的路径在C:\WINDOWS\system32\drivers\etc Linux系统路径/etc/hosts 2、先后启动SsoServer、sso-resource、sso-client1、sso-client2 3、访问http://sso-taobao:8083/client1/ 或 http://sso-tmall:8084/client2/
springboot简单实现sso单点登入
03-07
分别运行三个项目,访问客户端接口
详解spring boot配置单点登录
08-31
本篇文章主要介绍了详解spring boot配置单点登录，常用的安全框架有spring security和apache shiro。shiro的配置和使用相对简单，本文使用shrio对接CAS服务。
springboot单点登录的项目
12-20
基于springboot几种实现单点登录的方式都有：1.用redis缓存实现2.基于jwt实现sso3.基于spring-security oauth实现单点登录4.基于shiro实现单点登录
springBoot单点登录实例
04-02
该项目为springBoot单点登录实例，其中包含了权限设置。前端为HTML写的简单示例。开发工具为IDEA,启动项目根据模块划分，1、mysql-->MysqlTest(创建数据库实例，根据实际情况可自行更改，)。2、web1。2、web2
手撸SSO单点登录（四）登录验证-首次登录
kiduo08的专栏
05-03 2271
目标 这一章节的目标主要是讲解OA（这里代表client.sso.com:8082）统一登录后怎么回跳至OA页面，无论OA系统，还是认证系统等，在未登录的情况下怎么统一跳转至SSO登录页面。client 用OA系统代替更直观 ...
手把手教你用代码实现 SSO 单点登录
架构文摘
07-17 227
1. 概述1.1. 什么是SSO?单点登录（ Single Sign-On , 简称 SSO ）是目前比较流行的服务于企业业务整合的解决方案之一， SSO 使得在多个应用系统中，用户只需要 登录一次 就可以访问所有相互信任的应用系统。1.2. 什么是CAS?随着SSO技术的流行，相关产品也比较多，其中CAS就是一套解决方案，CAS（Central Authenticati...
手把手教你用代码实现SSO单点登录
HollisChuang's Blog
07-14 401
1. 概述1.1. 什么是SSO?Hollis的新书限时折扣中，一本深入讲解Java基础的干货笔记！单点登录（ Single Sign-On , 简称 SSO ）是目前比较流行的服务于企业业务整合的解决方案之一， SSO 使得在多个应用系统中，用户只需要 登录一次 就可以访问所有相互信任的应用系统。1.2. 什么是CAS?随着SSO技术的流行，相关产品也比较多，其中CAS...
手撕一套sso(单点登录)系统之原理篇1
qq_41544289的博客
02-22 5113
在手撕之前，你首先要了解一些原理，我写的案例成品可以访问zauth
普元SSO单点登录集成详解
"普元SSO单点登陆集成指南" 该文档是普元信息技术股份有限公司提供的SSO（Single Sign-On）集成指南，主要介绍如何实现各个应用之间的单点登录功能，让用户在不同应用之间切换时无需重复登录。SSO技术旨在提供便捷...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值