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

最新推荐文章于 2022-04-28 19:28:21 发布
最新推荐文章于 2022-04-28 19:28:21 发布
阅读量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
    评论
专栏目录
单点登陆sso实现(基于全局session实现)
沐雨金鳞
09-18 1235
本篇博客实现借鉴自：大厂架构演进实战之手写 CAS 单点登录 如果不想按下面的步骤一个一个粘贴，我也提供了github地址：https://github.com/XuBaozhao/sso 一、实现目标： 登陆淘宝，跳转登陆页面，登陆后，进入淘宝主页，再次登陆天猫，发现不用登陆，直接进入了天猫主页。 我省略了和数据库打交道的一点，并且也省略了验证token相同的环节，因为只是简单的熟悉流程，细节问题并不考虑在内。 看下面的结果展示，你就明白了。 （1）taobao 首先访问，被拦截，检测到没有
java 银行项目对于金额的面试题_Java电商项目面试题这些东西你必须要知道（二）...
weixin_39952190的博客
12-18 136
目前Java市场竞争力度大家都是有目共睹的，但是相对而言有竞争也就意味着高薪。不过如此大的竞争中你要怎么样才能脱颖而出你有考虑过么？如果没有的话那你要抓紧时间考虑一下了。项目实战在面试这一关里面是必不可少的，今天分享一下我之前面试遇到的电商项目相关的面试题，由于内容比较多，所以分几部分发布。感兴趣的朋友记得关注一下小编，第二部来了持续更新中。什么是SolrCloudSolrCloud是Solr提供...
基于Session共享的方式解决单点登录问题
wangpf2011的博客
06-20 1409
本文主要讲述集群环境下解决Session共享的问题，从而实现集群环境下的单点登录。Session共享问题已经有很多解决方案，这里主要讲述常用四种方法。 Session Sticky Session Sticky(粘性) 保证同一个会话的请求都在同一个Web服务器上处理，这样就完全不需要考虑到会话问题了。比如负载均衡算法中哈希算法就是一个典型的Session Sticky实现手段。 这种实现方...
SSO 轻量级实现指南（原生 Java 实现）：SSO Client 部分
zhangxin09的专栏
04-28 2277
作为统一的认证中心，SSO 中心无疑拥有最根本的用户状态记录，一切皆以 SSO 中心的为准。但每次访问资源的认证工作都要通讯 SSO 中心，性能成本会不会太高呢？对于 SSO 中心服务器的性能也是严重的考验。对此，笔者考虑了以下几个个解决方案。
SSO单点登录Java实现实例
热门推荐
程序员小强的博客
02-05 1万+
随着公司系统的增加，每次新建一个项目是否还在做登录功能呢，还在做重复的工作？统一登录SSO你值得拥有。本文主要讲解，基于令牌token方式实现，SpringBoot工程下的SSO单点登录整合代码实例Demo，文末附源码地址。 1.环境准备 SSO认证中心服务（ www.mysso.com） 客户端1（www.myclient1.com） 客户端2（www.myclient2.com） 由于是Demo实例，这里若有要访问-需要修改一下本机host，添加如下映射 127.0.0.1 www.mysso.
基于.Net的单点登录(SSO)实现解决方案
01-20
前些天一位朋友要我帮忙做一单点登录，其实这个概念早已耳熟能详，但实际应用很少，难得最近轻闲，于是决定通过本文来详细描述一个SSO解决方案，希望对大家有所帮助。SSO的解决方案很多，但搜索结果令人大失所望，大...
基于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，通常涉及几个关键步骤和技术，包括用户凭证管理、会话共享以及...
ssh登录发生加密算法报错解决办法
新广州人的网络安全
09-15 1330
SSH登录加密算法报错环境解决办法本次解决方案网上的其它解决方案 环境 堡垒机的操作系统及系统版本 root@fort:~# uname -a Linux fort 4.9.0-6-amd64 #1 SMP Debian 4.9.82-1+deb9u3 (2018-03-02) x86_64 GNU/Linux root@fort:~# cat /etc/os-release PRETTY_NAME="Debian GNU/Linux 9 (stretch)" NAME="Debian GNU/Li
SSO单点登录三种情况的实现方式详解
json_li的博客
06-26 1万+
单点登录（SSO——Single Sign On）对于我们来说已经不陌生了。对于大型系统来说使用单点登录可以减少用户很多的麻烦。就拿百度来说吧，百度下面有很多的子系统——百度经验、百度知道、百度文库等等，如果我们使用这些系统的时候，每一个系统都需要我们输入用户名和密码登录一次的话，我相信用户体验肯定会直线下降。当然，对于个人博客这类系统来说根本就用不上单点登录了。 假如，我们的系统很庞大，但是就
单点登录实现（spring session+redis完成session共享）
sniper007的专栏
03-02 1万+
一、前言 项目中用到的SSO，使用开源框架cas做的。简单的了解了一下cas，并学习了一下 单点登录的原理，有兴趣的同学也可以学习一下，写个demo玩一玩。 二、工程结构 我模拟了 sso的客户端和sso的服务端， sso-core中主要是一些sso需要的过滤器和工具类，缓存和session共享的一些XML配置文件，还有springmvc需要的一下jar包的管理。ss
javaweb实现单点登录，防止重复登录，获取sessionid,对session及时销毁回收，只允许一个用户登录，结合struts2实现
博客
08-25 2390
首先我们目的是实现一个单点登录，即只允许单个账户单个登录。 实现异地与同地登录判断 要将先登录的用户强制下线。不免用到session。 单点登录的最大难题：已经登录且重复登录的用户的session怎么web全局操作它 我们来解决它。 基本目的实现的方法之一是{ 1.建立一个可以全局存储当前登录人员信息的Map;推荐hashmap，因为更快。 2.建立一个登录人员监听，} 怎么建立全局呢，还记得js...
单点登录系统SSO中的session的共享问题
sunzhiqiang6的博客
06-14 2708
什么是单点登录：SSO英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一。比如现在有:OA系统、门户系统、人力资源管理系统、档案管理系统、生产管理系统、xx系统等，这么多个系统。在一个公司里面，如果一个用户需要...
基于cookie和session实现单点登录
qq_45810870的博客
01-20 812
实现单点登录的方式有很多种，再此记录简单的一种基于cookie实现的单点登录 1、在第一次登录时判断cookie是否有值 /** * * @param target 从哪个页面跳转到了登录页 * 判断cookie是否有值，没有的跳转倒登陆页面；有的话跳转到原来跳转过来的页面 */ @RequestMapping("/login") public String toLogin(@RequestParam(defaultValue = "", required = false) St
登录带session到页面_单点登录SSO基于缓存的使用
weixin_39793319的博客
12-10 321
首先我创建了一个SpringCloud项目，项目分层分别如下：其中sso_common是公共调用模块~创建前台，后台的重定向跳转，前台页面滤过。。。首先测试一下，在首页点登录是否能够正常跳到登陆页面(这里携带了本次路径的参数)而这里重点说下后台的写法，首先是需要在后台的viewcontroller层重定向跳转页面的：//跳转到登录页面//@RequestParam(required = ...
服务器端 Cookie生成和读取
dabing1989的专栏
12-17 1万+
目前手上的一个电商系统，有要实现游览过的商品的功能，需要用cookie实现该功能。先说说需求吧：用户点击商品后进入商品详情页面后就属于游览一操作，考虑到jsp很多页面都可以点击，为每一个点击都添加一段js控制cookie很不实际，所以考虑在服务器端生成cookie，这样就可以在服务器端 打开商品详情的action控制。何乐而不为。。。 使用cookie首先要知道：cookie其实就是name
SSO - 使用cookie和session实现单点登录
江南烟雨却痴缠丶
06-22 3747
什么是单点登录 单点登录(SingleSignOn，SSO)，就是通过用户的一次性鉴别登录。当用户在身份认证服务器上登录一次以后，即可获得访问单点登录系统中其他关联系统和应用软件的权限，同时这种实现是不需要管理员对用户的登录状态或其他信息进行修改的，这意味着在多个应用系统中，用户只需一次登录就可以访问所有相互信任的应用系统。这种方式减少了由登录产生的时间消耗，辅助了用户管理，是目前比较流行的。 cookie+session实现单点登录 之前的文章有记录过使用CAS开源项目来实现单点登录，也有通过JWT来实现
SAP SSO单点登录
最新发布
06-28
SAP Single Sign-On (SSO) 是一种身份管理解决方案，它允许用户在一个系统中进行一次身份验证后，能够无感知地安全访问多个相关的 SAP 应用程序和系统。SAP SSO 的核心目标是提高用户体验、简化安全管理并增强安全性。 1. **原理**： SSO 基于 Kerberos 或者 SAML（Security Assertion Markup Language）等标准协议，通过一个集中式的身份验证服务器，用户只需输入一次用户名和密码，系统会验证这些信息后，生成一个安全令牌（或称为 session ticket），这个令牌包含了用户的权限信息，可以在多个受保护的应用之间共享，从而避免了每次切换应用都需要重新登录的过程。 2. **优势**： - **效率提升**：减少了登录次数和验证时间，提高了工作效率。 - **安全性**：通过集中式管理，减少了每个应用程序单独存储用户凭证的安全风险。 - **易于管理**：统一的身份管理策略，便于审计和合规性要求。 3. **应用场景**： SAP SSO 可以应用于 SAP NetWeaver 环境中的企业门户（EP）、SAP HANA 云平台、SAP Business Suite 和其他 SAP 应用程序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值