SSO单点登陆基于Session简单实现

最新推荐文章于 2023-03-13 14:17:44 发布
最新推荐文章于 2023-03-13 14:17:44 发布
阅读量1k 收藏 3
点赞数
分类专栏： SSO单点登陆 文章标签： SSO 单点登录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sadlay/article/details/100041408
版权

SSO单点登陆基于Session简单实现

单点登陆活动图

在这里插入图片描述
废话不多说直接上代码咯，什么好处，实现原理相关资料baidu去，基本都一样，就不复制了

1 服务端代码

1.1 登陆跳转注销代码

controller层代码

package com.ffcs.sso.controller;  
  
import javax.servlet.http.HttpSession;  
  
import org.apache.commons.lang.StringUtils;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Controller;  
import org.springframework.ui.Model;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.servlet.ModelAndView;  
  
import com.ffcs.sso.pojo.User;  
import com.ffcs.sso.service.LogoutManagerService;  
import com.ffcs.sso.service.TicketManagerService;  
import com.ffcs.sso.service.UserManagerService;  
import com.ffcs.sso.utils.Constant;  
/** 
 *  
 * @author damon 
 * 
 */  
@Controller  
public class SSOController {  
      
    private final static Logger LOGGER=LoggerFactory.getLogger(SSOController.class);  
   
    @Autowired  
    private TicketManagerService ticketManagerService;  
      
    @Autowired  
    private UserManagerService userManagerService;  
      
    @Autowired  
    private LogoutManagerService logoutManagerService;  
  
    /** 
     * 主页 
     * @return 
     */  
    @RequestMapping(value="manager/index",method=RequestMethod.GET)  
    public String index(){  
          
        return "index";  
    }  
    /** 
     * 登陆首页 
     * @return 
     */  
    @RequestMapping(value="login",method=RequestMethod.GET)  
    public ModelAndView loginIndex(String queryParams,String targetUrl,ModelAndView modelAndView){  
          
        modelAndView.addObject("queryParams", queryParams);  
          
        modelAndView.addObject("targetUrl", targetUrl);  
          
        modelAndView.setViewName("login");  
          
        return modelAndView;  
    }  
      
    @RequestMapping(value="login",method=RequestMethod.POST)  
    public String login(@RequestParam(required = true) String account, @RequestParam(required = true) String password,  
  
            String targetUrl, String queryParams, Model model, HttpSession session) {  
  
        User user = userManagerService.getUserInfo(account, password);  
  
        if (user != null) {  
  
            String homeCookieId = session.getId();  
  
            session.setAttribute(Constant.SSO_IS_LOGIN, true);  
  
            session.setAttribute(Constant.SSO_LOGIG_INFO, account);  
  
            logoutManagerService.saveLoginUserInfo(homeCookieId, user);  
  
            if (StringUtils.isNotBlank(targetUrl)) {  
  
                // 生成targetURL对应的票  
  
                String ticket = ticketManagerService.generateTicket(targetUrl, homeCookieId);  
  
                String params = StringUtils.isNotBlank(queryParams) ? "&" + queryParams : "";  
  
                LOGGER.info("###################  用户账号:[{}]  对应主站cookieId:[{}] 登陆系统 :[{}]", account, homeCookieId, targetUrl);  
  
                return "redirect:" + targetUrl + "?" + Constant.SSO_TICKET + "=" + ticket + params;  
  
            }  
            return "redirect:manager/index";  
  
        } else {  
  
            model.addAttribute("error", "用户名或密码错误！");  
  
            if (StringUtils.isNotBlank(targetUrl)) {  
  
                model.addAttribute("targetUrl", targetUrl);  
            }  
            return "login";  
        }  
    }  
      
    /** 
     * 重定向到子系统并生成票 
     * @param targetUrl 
     * @param queryParams 
     * @param modelAndView 
     * @param session 
     * @return 
     */  
    @RequestMapping(value="redirect",method=RequestMethod.GET)  
    public ModelAndView redirect(@RequestParam(value="targetUrl",required=true)String targetUrl,  
              
            String queryParams,ModelAndView modelAndView,HttpSession session) {  
      
        if(session.getAttribute(Constant.SSO_IS_LOGIN)==null){  
              
            modelAndView.setViewName("redirect:login");  
              
            modelAndView.addObject("targetUrl", targetUrl);  
              
            modelAndView.addObject("queryParams", queryParams);       
          
            //重定向到login方法，带上目标网页地址  
          
        }else{  
              
            String homeCookieId=session.getId();  
              
            String account=(String) session.getAttribute(Constant.SSO_LOGIG_INFO);  
              
            //生成targetURL对应的票  
              
            String ticket=ticketManagerService.generateTicket(targetUrl,homeCookieId);  
                      
            String params=StringUtils.isNotBlank(queryParams)?"&"+queryParams:"";  
              
            modelAndView.setViewName("redirect:" + targetUrl + "?" + Constant.SSO_TICKET + "=" + ticket + params);    
  
            LOGGER.info("############### 用户账号:[{}] 主站cookieId:[{}] 重定向到系统:[{}] 对应ticket:[{}]", account, homeCookieId, targetUrl, ticket);  
        }  
          
        return modelAndView;  
    }  
      
    /** 
     * 单点注销 
     * @param session 
     * @return 
     */  
    @RequestMapping(value="logout",method=RequestMethod.GET)  
    public String logout(HttpSession session){  
          
        if(session.getAttribute(Constant.SSO_IS_LOGIN)!=null){  
          
            String cookieId=session.getId();  
              
            String account=(String) session.getAttribute(Constant.SSO_LOGIG_INFO);  
              
            logoutManagerService.logout(cookieId);  
              
            session.invalidate();     
                  
            LOGGER.info("########### 单点退出用户账号:[{}] 对应主站cookieId为:[{}] ",account,cookieId);  
        }  
        return "redirect:login";  
    }     
      
}

1.2 生成票管理接口代码（对外restful webservice发布）

package com.ffcs.sso.service;  
  
import java.util.UUID;  
  
import net.rubyeye.xmemcached.MemcachedClient;  
  
import org.apache.commons.lang.StringUtils;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.stereotype.Service;  
  
import com.ffcs.sso.exception.SSOException;  
import com.ffcs.sso.pojo.TicketInfo;  
import com.ffcs.sso.pojo.TicketResponseInfo;  
import com.ffcs.sso.pojo.User;  
import com.ffcs.sso.utils.Constant;  
/** 
 *  
 * 票管理 
 *  
 *  
 *  damon 
 * 
 */  
@Service  
public class TicketManagerServiceImpl implements TicketManagerService{    
      
    @Autowired  
    @Qualifier(value="memcachedSSOClient")  
    private MemcachedClient memcachedClient;  
    @Autowired  
    private LogoutManagerService logoutManagerService;  
  
    @Override  
    public String generateTicket(String target,String homeCookieId){  
          
        if(StringUtils.isBlank(target)){  
              
            throw new IllegalArgumentException("target不可以为空！");  
              
        }  
          
        if(StringUtils.isBlank(homeCookieId)){  
              
            throw new IllegalArgumentException("homeCookieId不可以为空！");  
              
        }  
          
        String ticket=UUID.randomUUID().toString();  
      
        try {  
              
            memcachedClient.set(ticket, Constant.MAX_TICKET_INACTIVE_INTERVAL, new TicketInfo(ticket,target,homeCookieId));  
              
            return ticket;  
              
        } catch (Exception e) {  
  
            throw new SSOException(e);  
        }  
    }  
    @Override   
    public TicketResponseInfo validateTicket(String ticket,String target,  
              
            String subCookieId,String subCookieName,String subLogoutPath){  
          
        if(StringUtils.isBlank(ticket)){  
  
            throw new IllegalArgumentException("ticket不可以为空！");  
        }  
          
        if(StringUtils.isBlank(target)){  
  
            throw new IllegalArgumentException("target不可以为空！");  
        }  
          
        if(StringUtils.isBlank(subCookieId)){  
  
            throw new IllegalArgumentException("subCookieId不可以为空！");  
        }  
  
        if(StringUtils.isBlank(subCookieName)){  
  
            throw new IllegalArgumentException("subCookieName不可以为空！");  
        }  
          
        if(StringUtils.isBlank(subLogoutPath)){  
  
            throw new IllegalArgumentException("subLogoutPath不可以为空！");  
        }  
  
        try {  
              
            TicketInfo ticketInfo = memcachedClient.get(ticket);  
              
            if(ticketInfo==null||!target.equals(ticketInfo.getTargetUrl())){  
                  
                //返回空验证不通过  
                  
                return new TicketResponseInfo(false);  
            }  
              
            //删除票保存的临时信息  
              
            memcachedClient.delete(ticket);  
              
            String homeCookieId=ticketInfo.getHomeCookieId();  
              
            //验证后保存登出信息（原本验证和登出信息分开提交，一并提交减少访问次数）  
              
            logoutManagerService.saveSubWebsiteLogouInfo(homeCookieId, subLogoutPath, subCookieId, subCookieName);  
               
            User user= logoutManagerService.getLoginUserInfo(homeCookieId);  
              
            return new TicketResponseInfo(true,user.getAccount(),homeCookieId);  
  
        } catch (Exception e) {  
              
            throw new SSOException(e);  
        }   
      
    }  
  
  
}

1.3 单点退出接口（对外restful webservice发布）

package com.ffcs.sso.service;  
  
import java.util.Set;  
  
import net.rubyeye.xmemcached.MemcachedClient;  
  
import org.apache.commons.lang.StringUtils;  
import org.apache.http.HttpResponse;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.methods.HttpPost;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.stereotype.Service;  
  
import com.ffcs.sso.exception.SSOException;  
import com.ffcs.sso.pojo.ActivationInfo;  
import com.ffcs.sso.pojo.LogoutInfo;  
import com.ffcs.sso.pojo.User;  
import com.ffcs.sso.utils.Constant;  
  
/** 
 * 单点退出 
 *  
 * damon 
 */  
  
  
@Service  
public class LogoutManagerServiceImpl implements LogoutManagerService {  
      
    private static final Logger LOGGER=LoggerFactory.getLogger(LogoutManagerServiceImpl.class);  
      
    private final String LOGOUT_PREFIX="LOGOUT_";  
  
    @Autowired  
    @Qualifier("memcachedSSOClient")  
    private MemcachedClient memcachedClient;  
      
    @Autowired  
    private HttpClient httpClient;  
  
    @Override  
    public boolean saveSubWebsiteLogouInfo(String homeCookieId, String logoutPath,String subCookieId,String subCookieName) {  
          
        if(StringUtils.isBlank(homeCookieId)){  
              
            throw new IllegalArgumentException("homeCookieId 不可以为空！");  
        }  
        if(StringUtils.isBlank(logoutPath)){  
          
            throw new IllegalArgumentException("logoutPath 不可以为空！");  
        }  
        if(StringUtils.isBlank(subCookieId)){  
              
            throw new IllegalArgumentException("subWebSite 不可以为空！");  
        }  
        ActivationInfo info=null;  
          
        Set<LogoutInfo> logoutInfos=null;  
          
        try {  
              
            info=memcachedClient.get(LOGOUT_PREFIX + homeCookieId);  
              
            if(info==null){  
                  
                info=new ActivationInfo();  
      
            }  
            logoutInfos=info.getLogoutInfo();  
              
            logoutInfos.add(new LogoutInfo(logoutPath,subCookieId,subCookieName));  
              
            info.setLogoutInfo(logoutInfos);  
              
            memcachedClient.set(LOGOUT_PREFIX + homeCookieId, Constant.MAX_USERINFO_INACTIVE_INTERVAL, info);  
                  
            LOGGER.debug("############### 保存子站登出信息 ,子站登出地址 url:{}, 子站cookie:{}, 主站cookie:{}", logoutPath, subCookieId, homeCookieId);  
              
            return true;  
          
        } catch (Exception e) {  
              
            throw new SSOException(e);  
        }   
  
    }  
  
    @Override  
    public void logout(String homeCookieId) {  
          
        if(StringUtils.isBlank(homeCookieId)){  
              
            throw new IllegalArgumentException("cookieId 不可以为空！");  
        }  
           
        ActivationInfo info=null;  
          
        Set<LogoutInfo> logoutInfos=null;  
          
        try {  
              
            info = memcachedClient.get(LOGOUT_PREFIX+homeCookieId);  
              
            memcachedClient.delete(LOGOUT_PREFIX+homeCookieId);  
              
            if(info==null|| (logoutInfos=info.getLogoutInfo())==null){  
                  
                LOGGER.debug("##############  用户 cookieId:[{}] 未登陆任何系统   ！",homeCookieId);  
  
                return;  
            }     
        } catch (Exception e) {  
              
            LOGGER.error("###############   Memcached获取单点登出信息失败", e);  
              
            return;  
        }   
          
        for (LogoutInfo logoutInfo:logoutInfos) {  
  
            HttpPost post=null;  
              
            try {  
  
                post = new HttpPost(logoutInfo.getLogoutPath());  
                  
                post.setHeader("charset", "UTF-8");  
                  
                post.setHeader("Connection", "close");    
                  
                //添加cookie模拟回调时候子系统能找到session  
                  
                post.setHeader("Cookie",logoutInfo.getSubCookieName()+"="+logoutInfo.getSubCookieId());  
  
                HttpResponse response = httpClient.execute(post);  
  
                LOGGER.debug("########## 登出子站  :[{}] 主站cookie:[{}] 子站cookie:[{}]  登出返回状态码:[{}]  ",  
                          
                        logoutInfo.getLogoutPath(), homeCookieId, logoutInfo.getSubCookieId(),  response.getStatusLine().getStatusCode());  
                  
            } catch (Exception e) {  
                  
                LOGGER.error("########## 注销子系统失败,子系统信息:{}",logoutInfo.toString(),e);  
              
            }  finally {  
  
                if(post!=null){  
                      
                    post.releaseConnection();                 
                }  
            }  
        }  
    }  
    @Override  
    public void saveLoginUserInfo(String homeCookieId,User userInfo){  
          
        try {  
              
            ActivationInfo info=memcachedClient.get(LOGOUT_PREFIX+homeCookieId);  
              
            if(info==null){  
                  
                info=new ActivationInfo();  
            }  
              
            info.setUserInfo(userInfo);  
              
            memcachedClient.set(LOGOUT_PREFIX+homeCookieId, Constant.MAX_USERINFO_INACTIVE_INTERVAL, info);  
              
        } catch (Exception e) {  
              
            throw new SSOException("#############  保存用户登陆信息失败 ",e);  
        }  
          
          
    }  
    @Override  
    public User getLoginUserInfo(String homeCookieId){  
          
        ActivationInfo info = null;  
          
        try {  
            info=memcachedClient.get(LOGOUT_PREFIX+homeCookieId);  
              
            if(info!=null){  
                  
                return info.getUserInfo();            
            }  
              
            throw new RuntimeException("找不到该cookie:["+homeCookieId+"]的用户信息");  
              
        } catch (Exception e) {  
              
            throw new SSOException("############# 获取登陆用户信息失败 ####",e);  
        }   
          
    }  
  
    @Override  
    public boolean updateUserInfoTimeout(String homeCookieId) {  
          
        if(StringUtils.isBlank(homeCookieId)){  
              
            throw new IllegalArgumentException("homeCookieId 不可以为空！");  
        }  
          
        try {  
              
            return memcachedClient.touch(LOGOUT_PREFIX+homeCookieId, Constant.MAX_USERINFO_INACTIVE_INTERVAL);  
          
        } catch (Exception e) {  
              
            LOGGER.error("############ 定时更新主站登陆用户信息失败 ",e);  
        }   
        return false;  
  
    }  
      
}

2 客户端代码

2.1 过滤器代码

package com.ffcs.sso.filter;  
  
import java.io.IOException;  
import java.net.URLEncoder;  
import java.util.Iterator;  
import java.util.Map;  
import java.util.Map.Entry;  
  
import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.FilterConfig;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import javax.servlet.http.HttpSession;  
  
import org.apache.commons.lang.StringUtils;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPut;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
import com.ffcs.sso.exception.HttpRequestException;  
import com.ffcs.sso.pojo.TicketResponseInfo;  
import com.ffcs.sso.utils.Constant;  
import com.ffcs.sso.utils.HttpClientUtils;  
import com.ffcs.sso.utils.JsonUtil;  
  
public class SSOFilter implements Filter {  
      
    private final static Logger LOGGER=LoggerFactory.getLogger(SSOFilter.class);  
  
    private String ticketValidateURL;  
      
    private String redirectLoginURL;  
      
    private String updateUserInfoTimeOutURL;  
  
    @Override  
    public void destroy() {  
          
    }  
  
    @Override  
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {  
          
        HttpServletRequest request = (HttpServletRequest) req;  
          
        HttpServletResponse response = (HttpServletResponse) res;  
          
        HttpSession session=request.getSession();  
          
        if(session.getAttribute(Constant.SSO_IS_LOGIN)==null){  
          
            String targetUrl = request.getRequestURL().toString();  
  
            String ticket = request.getParameter(Constant.SSO_TICKET);        
              
            //子站单点退出路径  
              
            String subLogoutPath = request.getScheme()+"://"+request.getServerName()+":"  
                      
                        +request.getServerPort()+ request.getContextPath() +"/"+Constant.SSO_LOGOUT_SUFFIX;  
                   
            TicketResponseInfo responseInfo=new TicketResponseInfo(false);  
              
            if(StringUtils.isNotBlank(ticket)){  
                  
                //校验票如果校验通过同时保存子站的登出信息(减少提交次数，原本验证成功后在提交登出信息),并返回主站的cookieId和主站登陆的账号  
                  
                responseInfo=validateTicketInfo(ticket,targetUrl,Constant.SSO_SUB_COOKIE_NAME,session.getId(),subLogoutPath);  
            }  
  
            if(!responseInfo.isSuccess()){  
                  
                String queryParams =this.getQureyParams(request);  
  
                String params=StringUtils.isNotBlank(queryParams)?"&queryParams="+URLEncoder.encode(queryParams,"UTF-8"):"";  
                  
                //重定向到主站判断系统是否登陆过  
                  
                response.sendRedirect(redirectLoginURL + "?targetUrl=" + targetUrl + params);  
                      
                LOGGER.debug("############## 重定向到主系统：" + redirectLoginURL + "?targetUrl=" + targetUrl + params);                      
                  
                return;  
            }  
              
            session.setAttribute(Constant.SSO_IS_LOGIN, true);  
              
            session.setAttribute(Constant.SSO_ACCOUNT, responseInfo.getAccount());  
              
            session.setAttribute(Constant.SSO_HOME_COOKIEID, responseInfo.getHomeCookieId());     
        }  
  
        Long updateInterval = (System.currentTimeMillis() - session.getLastAccessedTime()) / 1000;  
          
        if( updateInterval > Constant.SSO_HOME_USERINFO_UPDATE_TIMEOUT){  
              
            //更新主站用户信息超时时间  
              
            updateUserInfoTimeOut((String)session.getAttribute(Constant.SSO_HOME_COOKIEID));  
                  
            LOGGER.debug("############## 更新主站用户信息超时时间,间隔{}秒   ########",Constant.SSO_HOME_USERINFO_UPDATE_TIMEOUT);                   
      
        }  
          
        chain.doFilter(request, response);  
                  
        return;  
    }  
  
    private String getQureyParams(HttpServletRequest request) {  
          
        StringBuilder queryParams=new StringBuilder();  
          
        Map<String,String[]> map=request.getParameterMap();  
          
        Iterator<Entry<String, String[]>>  params=map.entrySet().iterator();  
          
        boolean tag=false;  
          
        while (params.hasNext()) {  
              
            Map.Entry<String,String[]> entry = params.next();  
              
            if(!entry.getKey().equals(Constant.SSO_TICKET)){  
                  
                String[] values=entry.getValue();  
                  
                for(String value:values){  
  
                    if(tag){  
                          
                        queryParams.append("&");  
                    }  
                    queryParams.append(entry.getKey()).append("=").append(value);                         
                }  
                tag=true;  
            }  
        }  
        return queryParams.toString();  
    }  
      
    private void updateUserInfoTimeOut(String homeCookieId){  
      
        HttpPut put=new HttpPut(updateUserInfoTimeOutURL);  
          
        //添加cookie主站那边能够找到session  
          
        put.setHeader("Cookie",Constant.SSO_HOME_COOKIE_NAME+"="+homeCookieId);  
          
        put.setHeader("accept", "text/plain; charset=UTF-8");  
          
        try {  
              
            HttpClientUtils.getResponse(put);  
              
        } catch (HttpRequestException e) {  
              
            LOGGER.error("###################### 定时更新主站用户信息失败 ",e);  
        }  
    }  
  
    /** 
     * 根据ticket验证是否正确，验证通过返回主站的cookieId 
     *  
     * @param ticket 
     *  
     * @param target 
     *  
     * @return  返回验证空失败  成功cookieId 
     */  
    private TicketResponseInfo validateTicketInfo(String ticket, String target,String subCookieName,  
              
            String subCookieId, String subLogoutPath) {  
          
        HttpGet httpget = new HttpGet(ticketValidateURL + "/"+ ticket + "?target=" + target  
                  
                +"&subCookieId="+subCookieId+"&subCookieName="+subCookieName+"&subLogoutPath="+subLogoutPath);  
          
        httpget.setHeader("accept", "application/json; charset=UTF-8");  
          
        String result;  
          
        try {  
              
            result = HttpClientUtils.getResponse(httpget);  
              
            return JsonUtil.fromJson(result, TicketResponseInfo.class);  
              
        } catch (HttpRequestException e) {  
              
            throw new RuntimeException("############### 子站验证ticket失败  ",e);  
        }     
          
          
    }  
  
    @Override  
    public void init(FilterConfig filterConfig) {  
          
        if (filterConfig != null) {  
              
            LOGGER.info("#######   SSOFilter:Initializing filter");  
        }  
          
        this.ticketValidateURL = filterConfig.getInitParameter("ticketValidateURL");  
          
        this.redirectLoginURL=filterConfig.getInitParameter("redirectLoginURL");  
  
        this.updateUserInfoTimeOutURL=filterConfig.getInitParameter("updateUserInfoTimeOutURL");  
    }  
      
}

2.2 登出过滤器代码

比较简单，服务端通过httpclient回调这个路口进行退出，服务端必须把客户端登陆的cookie返回过来，不然找不到session

package com.ffcs.sso.filter;  
  
import java.io.IOException;  
  
import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.FilterConfig;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.http.HttpServletRequest;  
  
public class LogoutFilter implements Filter{  
      
    @Override  
    public void destroy() {  
          
          
    }  
  
    @Override  
    public void doFilter(ServletRequest req, ServletResponse res,FilterChain chain) throws IOException, ServletException {  
          
        HttpServletRequest request = (HttpServletRequest) req;  
          
        request.getSession().invalidate();  
          
        return;  
          
    }  
  
    @Override  
    public void init(FilterConfig filterConfig) {  
  
    }  
      
}

2.3 客户端web.xml配置

<?xml version="1.0" encoding="UTF-8"?>  
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
    version="3.0">  
    <filter>  
        <filter-name>DisableUrlSessionFilter</filter-name>  
        <filter-class>com.ffcs.sso.filter.DisableUrlSessionFilter</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>DisableUrlSessionFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
  
    <filter>  
        <filter-name>sessionFilter</filter-name>  
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>sessionFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
  
    <filter>  
        <filter-name>LogoutFilter</filter-name>  
        <filter-class>com.ffcs.sso.filter.LogoutFilter</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>LogoutFilter</filter-name>  
        <url-pattern>/SSO_LOGOUT</url-pattern>  
    </filter-mapping>  
    <listener>  
        <description>spring监听器</description>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <listener>  
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
    </listener>  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:spring.xml</param-value>  
    </context-param>  
  
    <filter>  
        <description>字符集过滤器</description>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <init-param>  
            <description>字符集编码</description>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
  
    <filter>  
        <filter-name>SSOFilter</filter-name>  
        <filter-class>com.ffcs.sso.filter.SSOFilter</filter-class>  
        <init-param>  
            <!-- 获取票保存的信息 ,并发送单点登陆子站信息  GET方式 -->  
            <param-name>ticketValidateURL</param-name>   
            <param-value>http://127.0.0.1:8080/SSO/webservice/ticket</param-value>  
        </init-param>  
        <init-param>  
            <!-- 定时更新主站用户超时信息，防止子站用户没过期，主站登陆信息已经过期  PUT方式 -->  
            <param-name>updateUserInfoTimeOutURL</param-name>  
            <param-value>http://127.0.0.1:8080/SSO/webservice/userinfo/timeout</param-value>  
        </init-param>  
        <init-param>  
            <!-- 重定向获取 -->  
            <param-name>redirectLoginURL</param-name>  
            <param-value>http://127.0.0.1:8080/SSO/redirect</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>SSOFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    <servlet>  
        <servlet-name>springMvc</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:spring-mvc.xml</param-value>  
        </init-param>  
        <!-- <load-on-startup>1</load-on-startup> -->  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>springMvc</servlet-name>  
        <url-pattern>/</url-pattern>  
    </servlet-mapping>  
  
    <!-- 浏览器不支持put,delete等method,由该filter将/blog?_method=delete转换为标准的http delete方法 -->  
    <filter>  
        <filter-name>HiddenHttpMethodFilter</filter-name>  
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>  
    </filter>  
  
    <filter-mapping>  
        <filter-name>HiddenHttpMethodFilter</filter-name>  
        <servlet-name>springMvc</servlet-name>  
    </filter-mapping>  
    <error-page>  
        <error-code>404</error-code>  
        <location>/error/404.jsp</location>  
    </error-page>  
    <error-page>  
        <error-code>500</error-code>  
        <location>/error/500.jsp</location>  
    </error-page>  
</web-app>  

    <!-- <load-on-startup>1</load-on-startup> -->  
</servlet>  
<servlet-mapping>  
    <servlet-name>springMvc</servlet-name>  
    <url-pattern>/</url-pattern>  
</servlet-mapping>  

<!-- 浏览器不支持put,delete等method,由该filter将/blog?_method=delete转换为标准的http delete方法 -->  
<filter>  
    <filter-name>HiddenHttpMethodFilter</filter-name>  
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>  
</filter>  

<filter-mapping>  
    <filter-name>HiddenHttpMethodFilter</filter-name>  
    <servlet-name>springMvc</servlet-name>  
</filter-mapping>  
<error-page>  
    <error-code>404</error-code>  
    <location>/error/404.jsp</location>  
</error-page>  
<error-page>  
    <error-code>500</error-code>  
    <location>/error/500.jsp</location>  
</error-page>
```
Sadlay
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于.Net的单点登录(SSO)实现解决方案
01-20
前些天一位朋友要我帮忙做一单点登录，其实这个概念早已耳熟能详，但实际应用很少，难得最近轻闲，于是决定通过本文来详细描述一个SSO解决方案，希望对大家有所帮助。SSO的解决方案很多，但搜索结果令人大失所望，大...
基于Session的单点登录(SSO)流程
水冰月的小兔子的博客
07-01 3596
一.背景 做项目过程中遇到了所做的系统需要和用户的门户还有app联通，并且支持单点登录的问题，本身自己的系统身份验证采用了基于token的验证方式。 二.方案比较 用户在登录的时候需要输入用户名和密码等服务器知道的信息来确认用户身份进行身份验证，常见的身份验证方式有两种： 基于session的验证 Session 方案中，登录成功后，服务端将用户的身份信息存储在 Session 里，并且服务端会...
SpringSession单点登录（Single Sign On）
asmall_cat的博客
05-09 2229
什么是单点登录 单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO 的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统，企业间需互相授信。 -->微服务 客户端-->-------------<--sso服务 -->微服务 一、 分布式系统 Session 共享方案 1 分布式系统中 HttpSession...
单点登陆sso实现(基于全局session实现)
沐雨金鳞
09-18 1242
本篇博客实现借鉴自：大厂架构演进实战之手写 CAS 单点登录 如果不想按下面的步骤一个一个粘贴，我也提供了github地址：https://github.com/XuBaozhao/sso 一、实现目标： 登陆淘宝，跳转登陆页面，登陆后，进入淘宝主页，再次登陆天猫，发现不用登陆，直接进入了天猫主页。 我省略了和数据库打交道的一点，并且也省略了验证token相同的环节，因为只是简单的熟悉流程，细节问题并不考虑在内。 看下面的结果展示，你就明白了。 （1）taobao 首先访问，被拦截，检测到没有
SSO基于全局Session和局部Session的实现
Coder_Joker的博客 joke a joker
05-24 6161
推荐一下自己的一个数据结构与算法整合的库,还处于更新状态 2019-01-12 18:23 更: demo明天给出 .   emmmmm我记得这个demo应该是18年的啊,怎么19是上个月给的?蛤?--- 2019-01-13 18:51 更: https://github.com/ItsFunny/examples/tree/master/sso_demo 什么是sso:single si...
单点登录 SSO Session
白强
03-14 480
  单点登录在现在的系统架构中广泛存在，他将多个子系统的认证体系打通，实现了一个入口多处使用，而在架构单点登录时，也会遇到一些小问题，在不同的应用环境中可以采用不同的单点登录实现方案来满足需求。我将以我所遇到的应用环境以及在其中所经历的各个阶段与大家分享，若有不足，希望各位不吝赐教。 一、共享Session 共享Session可谓是实现单点登录最直接、最简单的方式。将用户认证信息保存于Se...
基于oauth2+security实现的SSO单点登录案例
10-14
总的来说，通过实践这个基于Spring Security OAuth2的SSO单点登录案例，你将能够掌握如何在分布式系统中构建安全的单点登录系统，这对于任何需要统一用户管理的大型企业或平台都是非常有价值的。
.NET Core2.0+MVC 用session，cookie实现的sso单点登录
04-11
通过以上步骤和理解，你将能够在.NET Core 2.0+MVC的环境中实现一个基于session和cookie的SSO单点登录系统。项目的源代码（如SSO.Core.Solution压缩包）可以作为学习和参考，帮助你深入理解和实践这些概念。
PHP实现SSO单点登录三种情况的实现方式详解编程小技巧共
11-22
SSO（Single Sign-On）单点登录是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需再次进行身份验证。在PHP环境中实现SSO，通常涉及几个关键步骤和技术，包括用户凭证管理、会话共享以及...
Session、Cookie、Token、单点登录
玄霄
05-22 4200
Session、Cookie、Token、单点登录HTTP无状态Cookiecookie认证流程图缺点Session认证过程session认证的流程图token认证token认证的流程图优缺点JWT认证JWT认证流程图基于session认证的单点登录单点登录基于session认证的单点登录流程图基于JWT的单点登录Cookie 和 Session 的区别Token 和 Session 的区别Token 和 JWT 的区别相同区别使用 cookie 时需要考虑的问题使用 session 时需要考虑的问题分布式
单点登录的实现原理
ajg87686的博客
06-22 926
　　单点登录在现在的系统架构中广泛存在，他将多个子系统的认证体系打通，实现了一个入口多处使用，而在架构单点登录时，也会遇到一些小问题，在不同的应用环境中可以采用不同的单点登录实现方案来满足需求。我将以我所遇到的应用环境以及在其中所经历的各个阶段与大家分享，若有不足，希望各位不吝赐教。 一、共享Session 　　共享Session可谓是实现单点登录最直接、最简单的方式。将用户认证信息...
单点登录 cas 设置回调地址_单点登录（SSO）看这一篇就够了
weixin_39875629的博客
11-21 1264
背景在企业发展初期，企业使用的系统很少，通常一个或者两个，每个系统都有自己的登录模块，运营人员每天用自己的账号登录，很方便。但随着企业的发展，用到的系统随之增多，运营人员在操作不同的系统时，需要多次登录，而且每个系统的账号都不一样，这对于运营人员来说，很不方便。于是，就想到是不是可以在一个系统登录，其他系统就不用登录了呢？这就是单点登录要解决的问题。单点登录英文全称Single Sign On，简...
Session跨域共享及SSO解决方案实战
长沙老码农
03-09 4742
目录 1、什么是Session跨域共享 2、什么是SSO 3、Session跨域共享简单实现 3.1 Spring Session 共享 （了解） 3.2 Nginx Session共享 3.3 Token + Redis + Cookie机制 3.4 Spring Security Oauth2 4、开源项目CAS应用 4.1 CAS简介 4.2 下载CAS Server并构建 4.3 CAS Server部署 4.4 CAS客户端项目 4.5 拓展 1、什么是Sessi.
单点登录SSO
weixin_43889487的博客
03-27 1056
为什么要实现单点登录？ 我们希望在分布式开发的过程中，当用户在登录任何一个子系统的时候，在一定时间范围内，相关联的系统在一定时间范围内可实现免登录。 1、在单体架构下： 步骤：（cookie和session） 假如客端对模块进行访问，对某一功能接口进行访问（即对受保护的资源进行访问） 1、客户端会将当前的浏览器里以cookie的方式保存一个对应访问地址的sessionId，携带去服务端请求 2、首次登陆服务端检测不到会返回一个登录界面 3、输入用户名密码 4、服务端会和DB进行一个校验 5、通过校验服务端会
怎么实现单点登录？面试必问！
emprere的博客
10-07 800
来源：https://dwz.cn/d90vKSJE单点登录的实现原理单点登录在现在的系统架构中广泛存在，他将多个子系统的认证体系打通，实现了一个入口多处使用，而在架构单...
基于session的单点登陆
supertianjia
11-10 481
1、第一次访问，登录成功 (1)登陆界面 &lt;%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%&gt; &lt;!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.
java 银行项目对于金额的面试题_Java电商项目面试题这些东西你必须要知道（二）...
weixin_39952190的博客
12-18 136
目前Java市场竞争力度大家都是有目共睹的，但是相对而言有竞争也就意味着高薪。不过如此大的竞争中你要怎么样才能脱颖而出你有考虑过么？如果没有的话那你要抓紧时间考虑一下了。项目实战在面试这一关里面是必不可少的，今天分享一下我之前面试遇到的电商项目相关的面试题，由于内容比较多，所以分几部分发布。感兴趣的朋友记得关注一下小编，第二部来了持续更新中。什么是SolrCloudSolrCloud是Solr提供...
单点登录(SSO)看这一篇就够了
最新发布
乌龟的专栏
03-13 9594
单点登录(SSO)看这一篇就够了
单点登录（SSO）以及Cookie、Session和Token的区别
weixin_57541178的博客
03-01 1451
单点登录（SSO）以及Cookie、Session和Token的区别
基于Session共享的方式解决单点登录问题
wangpf2011的博客
06-20 1410
本文主要讲述集群环境下解决Session共享的问题，从而实现集群环境下的单点登录。Session共享问题已经有很多解决方案，这里主要讲述常用四种方法。 Session Sticky Session Sticky(粘性) 保证同一个会话的请求都在同一个Web服务器上处理，这样就完全不需要考虑到会话问题了。比如负载均衡算法中哈希算法就是一个典型的Session Sticky实现手段。 这种实现方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值