SSO单点登录系统的实现

Myth丶恋晨 2022-05-09 07:40 386阅读 0赞

# 什么是SSO? #

维基百科的解释是：

![70][]

个人理解：

我们刚学javaweb所写的程序都是一些比较小的用来练手学习的程序，所有的系统都在一个tomcat内完成，在一个tomcat内session可以共享，之后在企业项目都会被拆分成分布式的项目，也就是每个系统都是一个单独的项目，这种情况下session不能共享，那么如何保存用户的登录信息，于是我们就要用到SSO单点登录系统。我们平时用的支付宝，淘宝等阿里的产品，只需要登录一次就可以使用其各个其他产品，这也是单点登陆在大型互联网企业里的应用。即所谓的“一次登录，处处使用”，下面就介绍下单点登录的实现过程。

# 传统登录流程 #

![70 1][]

（图片来源黑马程序员教学视频）

#  单点登陆的流程 #

![70 2][]

#  Java语言实现过程 #

1.首先创建maven工程，然后导入依赖jar包。

<dependencies>
    		
    		
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aspects</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.github.abel533</groupId>
    			<artifactId>mapper</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.6.0</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-databind</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>com.jolbox</groupId>
    			<artifactId>bonecp-spring</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>servlet-api</artifactId>
    			<scope>provided</scope>
    		</dependency>
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>jsp-api</artifactId>
    			<scope>provided</scope>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-io</artifactId>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>commons-codec</groupId>
    			<artifactId>commons-codec</artifactId>
    			<version>1.9</version>
    		</dependency>
    		
    		
    		<dependency>
    			<groupId>org.hibernate</groupId>
    			<artifactId>hibernate-validator</artifactId>
    			<version>5.1.3.Final</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			
    			<plugin>
    				<groupId>org.apache.tomcat.maven</groupId>
    				<artifactId>tomcat7-maven-plugin</artifactId>
    				<configuration>
    					<port>8083</port>
    					<path>/</path>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>

这里的maven继承了一个父工程，里面定义好了各种依赖的版本号，因此子工程里不需要定义了版本号了

2.生成web.xml,编写springmvc入口等等操作。

<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:spring/applicationContext*.xml</param-value>
    	</context-param>
    
    	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    
    	
    	<filter>
    		<filter-name>encodingFilter</filter-name>
    		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    		<init-param>
    			<param-name>encoding</param-name>
    			<param-value>UTF8</param-value>
    		</init-param>
    	</filter>
    	<filter-mapping>
    		<filter-name>encodingFilter</filter-name>
    		<url-pattern>/*</url-pattern>
    	</filter-mapping>
    
    	
    	<servlet>
    		<servlet-name>taotao-sso</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:spring/taotao-sso-servlet.xml</param-value>
    		</init-param>
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    
    	<servlet-mapping>
    		<servlet-name>taotao-sso</servlet-name>
    		<url-pattern>*.html</url-pattern>
    	</servlet-mapping>
    
    	<welcome-file-list>
    		<welcome-file>index.html</welcome-file>
    	</welcome-file-list>

3.搭建SSM环境的配置环境。

首先是spring的主配置文件applicationContext.xml（加载文件，配置基础扫描包，添加数据源）

<beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    
    	
    	<bean
    		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    		
    		<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
    		
    		<property name="ignoreResourceNotFound" value="true" />
    		
    		<property name="locations">
    			<list>
    				<value>classpath:jdbc.properties</value>
    				<value>classpath:env.properties</value>
    				<value>classpath:redis.properties</value>
    			</list>
    		</property>
    	</bean>
    	
    	
    	<context:component-scan base-package="com.taotao"/>
    
    	 
    	<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
    		destroy-method="close">
    		
    		<property name="driverClass" value="${jdbc.driverClassName}" />
    		
    		<property name="jdbcUrl" value="${jdbc.url}" />
    		
    		<property name="username" value="${jdbc.username}" />
    		
    		<property name="password" value="${jdbc.password}" />
    		
    		<property name="idleConnectionTestPeriod" value="60" />
    		
    		<property name="idleMaxAge" value="30" />
    		
    		
    		<property name="maxConnectionsPerPartition" value="100" />
    		
    		<property name="minConnectionsPerPartition" value="5" />
    	</bean>
    
    </beans>

配置springmvc整合文件sso-servlet.xml（注解驱动，扫描controller包，视图解析器页面跳转）

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:mvc="http://www.springframework.org/schema/mvc"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    	
    	<mvc:annotation-driven>
    		
    		<mvc:message-converters register-defaults="true">
    			<bean
    				class="com.taotao.sso.util.CallBackMappingJackson2HttpMessageConvert">
    				<property name="callbackName" value="callback" />
    			</bean>
    		</mvc:message-converters>
    	</mvc:annotation-driven>
    
    	
    	<context:component-scan base-package="com.taotao.sso.controller" />
    
    	
    	
    	<bean
    		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		<property name="prefix" value="/WEB-INF/views/" />
    		<property name="suffix" value=".jsp" />
    	</bean>
    
    </beans>

配置spring事务管理context-transaction.xml（事务管理器，策略，增强切入点）

配置spring和redis整合文件spring-redis.xml(redis集群配置，连接池配置)

配置spring和mybaits整合文件spring-mybatis（配置sqlSessionFactory,mapper扫描代理）

4.编写dao层，这里使用的是通用mapper，直接继承通用mapper的Mapper接口类就行了。就省略了，通用mapper的用法前几期文章有介绍过有兴趣可以去看看。

5.编写service层。

package com.taotao.sso.service.impl;
    
    import org.apache.commons.codec.digest.DigestUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.taotao.sso.mapper.UserMapper;
    import com.taotao.sso.pojo.User;
    import com.taotao.sso.service.RedisService;
    import com.taotao.sso.service.UserService;
    
    @Service("userService")
    public class UserServiceImpl implements UserService {
    	@Autowired
    	private UserMapper userMapper;
    	
    	@Autowired
    	private RedisService redisService;
    	
    	private static final ObjectMapper MAPPER=new ObjectMapper();
    	
    	@Override
    	public String doLogin(String username, String password) throws Exception {
    		User record=new User();
    		record.setUsername(username);
    		User user=this.userMapper.selectOne(record);
    		if(null == user){
    			return null;
    		}
    		if(! StringUtils.equals(DigestUtils.md5Hex(password), user.getPassword())){
    			return null;
    		}
    		
    		//登录成功
    		String token=DigestUtils.md5Hex(System.currentTimeMillis()+username);
    		this.redisService.set("token"+token, MAPPER.writeValueAsString(user),60*30);
    		
    		return token;
    	}
    
    }

redisService和一些CookieUtils工具类

package com.taotao.sso.service;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import redis.clients.jedis.ShardedJedis;
    import redis.clients.jedis.ShardedJedisPool;
    
    @Service
    public class RedisService {
    
        @Autowired(required = false)//运行的Spring环境中如果存在就注入，没有就忽略
        private ShardedJedisPool shardedJedisPool;
    
        private <T> T execute(Function<T, ShardedJedis> fun) {
            ShardedJedis shardedJedis = null;
            try {
                // 从连接池中获取到jedis分片对象
                shardedJedis = shardedJedisPool.getResource();
                return fun.callback(shardedJedis);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (null != shardedJedis) {
                    // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
                    shardedJedis.close();
                }
            }
            return null;
        }
    
        /**
         * 执行set操作
         * 
         * @param key
         * @param value
         * @return
         */
        public String set(final String key, final String value) {
            return this.execute(new Function<String, ShardedJedis>() {
                @Override
                public String callback(ShardedJedis e) {
                    return e.set(key, value);
                }
            });
        }
    
        /**
         * 执行GET操作
         * 
         * @param key
         * @return
         */
        public String get(final String key) {
            return this.execute(new Function<String, ShardedJedis>() {
                @Override
                public String callback(ShardedJedis e) {
                    return e.get(key);
                }
            });
        }
    
        /**
         * 执行DEL操作
         * 
         * @param key
         * @return
         */
        public Long del(final String key) {
            return this.execute(new Function<Long, ShardedJedis>() {
                @Override
                public Long callback(ShardedJedis e) {
                    return e.del(key);
                }
            });
        }
    
        /**
         * 设置生存时间，单位为秒
         * 
         * @param key
         * @param seconds
         * @return
         */
        public Long expire(final String key, final Integer seconds) {
            return this.execute(new Function<Long, ShardedJedis>() {
                @Override
                public Long callback(ShardedJedis e) {
                    return e.expire(key, seconds);
                }
            });
        }
    
        /**
         * 执行set操作并且设置生存时间，单位为秒
         * 
         * @param key
         * @param value
         * @return
         */
        public String set(final String key, final String value, final Integer seconds) {
            return this.execute(new Function<String, ShardedJedis>() {
                @Override
                public String callback(ShardedJedis e) {
                    String str = e.set(key, value);
                    e.expire(key, seconds);
                    return str;
                }
            });
        }
    
    }
    
    
    package com.taotao.sso.service;
    
    public interface Function<T, E> {
    
        public T callback(E e);
    
    }
    
    
    package com.taotao.sso.util;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.net.URLEncoder;
    
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * 
     * Cookie 工具类
     *
     */
    public final class CookieUtils {
    
        protected static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);
    
        /**
         * 得到Cookie的值, 不编码
         * 
         * @param request
         * @param cookieName
         * @return
         */
        public static String getCookieValue(HttpServletRequest request, String cookieName) {
            return getCookieValue(request, cookieName, false);
        }
    
        /**
         * 得到Cookie的值,
         * 
         * @param request
         * @param cookieName
         * @return
         */
        public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
            Cookie[] cookieList = request.getCookies();
            if (cookieList == null || cookieName == null) {
                return null;
            }
            String retValue = null;
            try {
                for (int i = 0; i < cookieList.length; i++) {
                    if (cookieList[i].getName().equals(cookieName)) {
                        if (isDecoder) {
                            retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
                        } else {
                            retValue = cookieList[i].getValue();
                        }
                        break;
                    }
                }
            } catch (UnsupportedEncodingException e) {
                logger.error("Cookie Decode Error.", e);
            }
            return retValue;
        }
    
        /**
         * 得到Cookie的值,
         * 
         * @param request
         * @param cookieName
         * @return
         */
        public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
            Cookie[] cookieList = request.getCookies();
            if (cookieList == null || cookieName == null) {
                return null;
            }
            String retValue = null;
            try {
                for (int i = 0; i < cookieList.length; i++) {
                    if (cookieList[i].getName().equals(cookieName)) {
                        retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
                        break;
                    }
                }
            } catch (UnsupportedEncodingException e) {
                logger.error("Cookie Decode Error.", e);
            }
            return retValue;
        }
    
        /**
         * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
         */
        public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
                String cookieValue) {
            setCookie(request, response, cookieName, cookieValue, -1);
        }
    
        /**
         * 设置Cookie的值 在指定时间内生效,但不编码
         */
        public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
                String cookieValue, int cookieMaxage) {
            setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
        }
    
        /**
         * 设置Cookie的值 不设置生效时间,但编码
         */
        public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
                String cookieValue, boolean isEncode) {
            setCookie(request, response, cookieName, cookieValue, -1, isEncode);
        }
    
        /**
         * 设置Cookie的值 在指定时间内生效, 编码参数
         */
        public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
                String cookieValue, int cookieMaxage, boolean isEncode) {
            doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
        }
    
        /**
         * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
         */
        public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
                String cookieValue, int cookieMaxage, String encodeString) {
            doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
        }
    
        /**
         * 删除Cookie带cookie域名
         */
        public static void deleteCookie(HttpServletRequest request, HttpServletResponse response,
                String cookieName) {
            doSetCookie(request, response, cookieName, "", -1, false);
        }
    
        /**
         * 设置Cookie的值，并使其在指定时间内生效
         * 
         * @param cookieMaxage cookie生效的最大秒数
         */
        private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
                String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
            try {
                if (cookieValue == null) {
                    cookieValue = "";
                } else if (isEncode) {
                    cookieValue = URLEncoder.encode(cookieValue, "utf-8");
                }
                Cookie cookie = new Cookie(cookieName, cookieValue);
                if (cookieMaxage > 0)
                    cookie.setMaxAge(cookieMaxage);
                if (null != request)// 设置域名的cookie
                    cookie.setDomain(getDomainName(request));
                cookie.setPath("/");
                response.addCookie(cookie);
            } catch (Exception e) {
                logger.error("Cookie Encode Error.", e);
            }
        }
    
        /**
         * 设置Cookie的值，并使其在指定时间内生效
         * 
         * @param cookieMaxage cookie生效的最大秒数
         */
        private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
                String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
            try {
                if (cookieValue == null) {
                    cookieValue = "";
                } else {
                    cookieValue = URLEncoder.encode(cookieValue, encodeString);
                }
                Cookie cookie = new Cookie(cookieName, cookieValue);
                if (cookieMaxage > 0)
                    cookie.setMaxAge(cookieMaxage);
                if (null != request)// 设置域名的cookie
                    cookie.setDomain(getDomainName(request));
                cookie.setPath("/");
                response.addCookie(cookie);
            } catch (Exception e) {
                logger.error("Cookie Encode Error.", e);
            }
        }
    
        /**
         * 得到cookie的域名
         */
        private static final String getDomainName(HttpServletRequest request) {
            String domainName = null;
    
            String serverName = request.getRequestURL().toString();
            if (serverName == null || serverName.equals("")) {
                domainName = "";
            } else {
                serverName = serverName.toLowerCase();
                serverName = serverName.substring(7);
                final int end = serverName.indexOf("/");
                serverName = serverName.substring(0, end);
                final String[] domains = serverName.split("\\.");
                int len = domains.length;
                if (len > 3) {
                    // www.xxx.com.cn
                    domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
                } else if (len <= 3 && len > 1) {
                    // xxx.com or xxx.cn
                    domainName = "." + domains[len - 2] + "." + domains[len - 1];
                } else {
                    domainName = serverName;
                }
            }
    
            if (domainName != null && domainName.indexOf(":") > 0) {
                String[] ary = domainName.split("\\:");
                domainName = ary[0];
            }
            return domainName;
        }
    
    }
    
    
    package com.taotao.sso.util;
    
    import java.io.IOException;
    
    import javax.servlet.http.HttpServletRequest;
    
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.http.HttpOutputMessage;
    import org.springframework.http.converter.HttpMessageNotWritableException;
    import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import com.fasterxml.jackson.core.JsonEncoding;
    import com.fasterxml.jackson.core.JsonProcessingException;
    
    public class CallBackMappingJackson2HttpMessageConvert extends MappingJackson2HttpMessageConverter {
    	//做jsonP统一支持标识
    	private String callbackName;
    	public String getCallbackName() {
    		return callbackName;
    	}
    	public void setCallbackName(String callbackName) {
    		this.callbackName = callbackName;
    	}
    	@Override
    	protected void writeInternal(Object object, HttpOutputMessage outputMessage)
    			throws IOException, HttpMessageNotWritableException {
    		HttpServletRequest request=((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest();
    		String callbackParam=request.getParameter(callbackName);
    		if(StringUtils.isEmpty(callbackParam)){
    			super.writeInternal(object, outputMessage);//调用父类方法直接返回。
    		}else{
    			JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
    			try {
    				String result =callbackParam+"("+super.getObjectMapper().writeValueAsString(object)+");";
    				IOUtils.write(result, outputMessage.getBody(),encoding.getJavaName());
    			}
    			catch (JsonProcessingException ex) {
    				throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
    			}
    		}
    		
    		super.writeInternal(object, outputMessage);
    	}
    	
    }

编写controller层

package com.taotao.sso.controller;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    
    import com.taotao.sso.service.UserService;
    import com.taotao.sso.util.CookieUtils;
    
    @RequestMapping("service/user")
    @Controller
    public class UserController {
    	@Autowired
    	private UserService userService;
    	/**
    	 * 注册
    	 * @return
    	 */
    	@RequestMapping(value="/register",method=RequestMethod.GET)
    	public String register(){
    		return "register";
    	}
    	
    	/**
    	 * 登录
    	 * @return
    	 */
    	@RequestMapping(value="/login",method=RequestMethod.GET)
    	public String login(){
    		return "login";
    	}
    	
    	@RequestMapping(value="/doLogin",method=RequestMethod.POST)
    	public Map<String, Object> doLogin(@RequestParam("username") String userName,
    			@RequestParam("password")String password,
    			HttpServletRequest request,HttpServletResponse response){
    		Map<String, Object> result=new HashMap<>();
    		try {
    			String token=this.userService.doLogin(userName, password);
    			if(token != null && !token.isEmpty()){
    				result.put("status", 200);
    				CookieUtils.setCookie(request,response,"token", token);
    			}else{
    				result.put("status", 400);//400参数列表错误。
    			}
    		} catch (Exception e) {
    			
    			e.printStackTrace();
    			result.put("status", 500);
    		}
    		return result;
    	}
    }

至此sso系统就写完了。

参考：黑马程序员淘淘商城教学视频。需要资源的可以留言。

[70]: /images/20220509/af449aff18c6487a9fef35b895fb7869.png
[70 1]: /images/20220509/e8b2214e427b4287b48aeafe300da35a.png
[70 2]: /images/20220509/b673fa39b6e3436faff4eb686198f222.png