SSO单点登录系统的实现

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

什么是SSO?

维基百科的解释是：

70

个人理解：

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

传统登录流程

70 1

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

单点登陆的流程

70 2

Java语言实现过程

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

  1. <dependencies>
  3.         <!-- 单元测试 -->
  4.         <dependency>
  5.             <groupId>junit</groupId>
  6.             <artifactId>junit</artifactId>
  7.             <scope>test</scope>
  8.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework</groupId>
  12.             <artifactId>spring-webmvc</artifactId>
  13.         </dependency>
  14.         <dependency>
  15.             <groupId>org.springframework</groupId>
  16.             <artifactId>spring-jdbc</artifactId>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>org.springframework</groupId>
  20.             <artifactId>spring-aspects</artifactId>
  21.         </dependency>
  23.         <!-- Mybatis -->
  24.         <dependency>
  25.             <groupId>org.mybatis</groupId>
  26.             <artifactId>mybatis</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.mybatis</groupId>
  30.             <artifactId>mybatis-spring</artifactId>
  31.         </dependency>
  32.         <!-- 通用Mapper -->
  33.         <dependency>
  34.             <groupId>com.github.abel533</groupId>
  35.             <artifactId>mapper</artifactId>
  36.         </dependency>
  38.         <!-- MySql -->
  39.         <dependency>
  40.             <groupId>mysql</groupId>
  41.             <artifactId>mysql-connector-java</artifactId>
  42.         </dependency>
  44.         <dependency>
  45.             <groupId>org.slf4j</groupId>
  46.             <artifactId>slf4j-log4j12</artifactId>
  47.         </dependency>
  49.         <!-- jedis依赖包，用来做redis相关的-->
  50.         <dependency>
  51.             <groupId>redis.clients</groupId>
  52.             <artifactId>jedis</artifactId>
  53.             <version>2.6.0</version>
  54.         </dependency>
  56.         <!-- Jackson Json处理工具包 -->
  57.         <dependency>
  58.             <groupId>com.fasterxml.jackson.core</groupId>
  59.             <artifactId>jackson-databind</artifactId>
  60.         </dependency>
  62.         <!-- 连接池 -->
  63.         <dependency>
  64.             <groupId>com.jolbox</groupId>
  65.             <artifactId>bonecp-spring</artifactId>
  66.         </dependency>
  68.         <!-- JSP相关 -->
  69.         <dependency>
  70.             <groupId>jstl</groupId>
  71.             <artifactId>jstl</artifactId>
  72.         </dependency>
  73.         <dependency>
  74.             <groupId>javax.servlet</groupId>
  75.             <artifactId>servlet-api</artifactId>
  76.             <scope>provided</scope>
  77.         </dependency>
  78.         <dependency>
  79.             <groupId>javax.servlet</groupId>
  80.             <artifactId>jsp-api</artifactId>
  81.             <scope>provided</scope>
  82.         </dependency>
  84.         <!-- Apache工具组件 -->
  85.         <dependency>
  86.             <groupId>org.apache.commons</groupId>
  87.             <artifactId>commons-lang3</artifactId>
  88.         </dependency>
  89.         <dependency>
  90.             <groupId>org.apache.commons</groupId>
  91.             <artifactId>commons-io</artifactId>
  92.         </dependency>
  94.         <!-- 加密解密的工具 -->
  95.         <dependency>
  96.             <groupId>commons-codec</groupId>
  97.             <artifactId>commons-codec</artifactId>
  98.             <version>1.9</version>
  99.         </dependency>
  101.         <!-- 数据校验 -->
  102.         <dependency>
  103.             <groupId>org.hibernate</groupId>
  104.             <artifactId>hibernate-validator</artifactId>
  105.             <version>5.1.3.Final</version>
  106.         </dependency>
  107.     </dependencies>
  109.     <build>
  110.         <plugins>
  111.             <!-- 配置Tomcat插件 -->
  112.             <plugin>
  113.                 <groupId>org.apache.tomcat.maven</groupId>
  114.                 <artifactId>tomcat7-maven-plugin</artifactId>
  115.                 <configuration>
  116.                     <port>8083</port>
  117.                     <path>/</path>
  118.                 </configuration>
  119.             </plugin>
  120.         </plugins>
  121.     </build>

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

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

  1. <context-param>
  2.         <param-name>contextConfigLocation</param-name>
  3.         <param-value>classpath:spring/applicationContext*.xml</param-value>
  4.     </context-param>
  6.     <!--Spring的ApplicationContext 载入 -->
  7.     <listener>
  8.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  9.     </listener>
  11.     <!-- 编码过滤器，以UTF8编码 -->
  12.     <filter>
  13.         <filter-name>encodingFilter</filter-name>
  14.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  15.         <init-param>
  16.             <param-name>encoding</param-name>
  17.             <param-value>UTF8</param-value>
  18.         </init-param>
  19.     </filter>
  20.     <filter-mapping>
  21.         <filter-name>encodingFilter</filter-name>
  22.         <url-pattern>/*</url-pattern>
  23.     </filter-mapping>
  25.     <!-- 配置SpringMVC框架入口 -->
  26.     <servlet>
  27.         <servlet-name>taotao-sso</servlet-name>
  28.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  29.         <init-param>
  30.             <param-name>contextConfigLocation</param-name>
  31.             <param-value>classpath:spring/taotao-sso-servlet.xml</param-value>
  32.         </init-param>
  33.         <load-on-startup>1</load-on-startup>
  34.     </servlet>
  36.     <servlet-mapping>
  37.         <servlet-name>taotao-sso</servlet-name>
  38.         <url-pattern>*.html</url-pattern>
  39.     </servlet-mapping>
  41.     <welcome-file-list>
  42.         <welcome-file>index.html</welcome-file>
  43.     </welcome-file-list>

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

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

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  3.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  6.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  7.     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
  8.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
  10.     <!-- 使用spring自带的占位符替换功能 -->
  11.     <bean
  12.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  13.         <!-- 允许JVM参数覆盖 -->
  14.         <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
  15.         <!-- 忽略没有找到的资源文件 -->
  16.         <property name="ignoreResourceNotFound" value="true" />
  17.         <!-- 配置资源文件 -->
  18.         <property name="locations">
  19.             <list>
  20.                 <value>classpath:jdbc.properties</value>
  21.                 <value>classpath:env.properties</value>
  22.                 <value>classpath:redis.properties</value>
  23.             </list>
  24.         </property>
  25.     </bean>
  27.     <!-- 扫描包，将相关的bean注入spring，交由spring管理 -->
  28.     <context:component-scan base-package="com.taotao"/>
  30.      <!-- 定义数据源 -->
  31.     <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
  32.         destroy-method="close">
  33.         <!-- 数据库驱动 -->
  34.         <property name="driverClass" value="${jdbc.driverClassName}" />
  35.         <!-- 相应驱动的jdbcUrl -->
  36.         <property name="jdbcUrl" value="${jdbc.url}" />
  37.         <!-- 数据库的用户名 -->
  38.         <property name="username" value="${jdbc.username}" />
  39.         <!-- 数据库的密码 -->
  40.         <property name="password" value="${jdbc.password}" />
  41.         <!-- 检查数据库连接池中空闲连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0 -->
  42.         <property name="idleConnectionTestPeriod" value="60" />
  43.         <!-- 连接池中未使用的链接最大存活时间，单位是分，默认值：60，如果要永远存活设置为0 -->
  44.         <property name="idleMaxAge" value="30" />
  45.         <!-- 每个分区最大的连接数 -->
  46.         <!-- 
  47.             判断依据：请求并发数
  48.          -->
  49.         <property name="maxConnectionsPerPartition" value="100" />
  50.         <!-- 每个分区最小的连接数 -->
  51.         <property name="minConnectionsPerPartition" value="5" />
  52.     </bean>
  54. </beans>

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  7.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
  10.     <!-- 注解驱动 -->
  11.     <mvc:annotation-driven>
  12.         <!-- 添加jsonp统一支持。 -->
  13.         <mvc:message-converters register-defaults="true">
  14.             <bean
  15.                 class="com.taotao.sso.util.CallBackMappingJackson2HttpMessageConvert">
  16.                 <property name="callbackName" value="callback" />
  17.             </bean>
  18.         </mvc:message-converters>
  19.     </mvc:annotation-driven>
  21.     <!-- 扫描包 -->
  22.     <context:component-scan base-package="com.taotao.sso.controller" />
  24.     <!-- 视图解析器 -->
  25.     <!-- Example: prefix="/WEB-INF/jsp/", suffix=".jsp", viewname="test" -> 
  26.         "/WEB-INF/jsp/test.jsp" -->
  27.     <bean
  28.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  29.         <property name="prefix" value="/WEB-INF/views/" />
  30.         <property name="suffix" value=".jsp" />
  31.     </bean>
  33. </beans>

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

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  3.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  6.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  7.     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
  8.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
  10.     <!-- 定义事务管理器 -->
  11.     <bean id="transactionManager"
  12.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  13.         <property name="dataSource" ref="dataSource" />
  14.     </bean>
  16.     <!-- 定义事务策略 -->
  17.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  18.         <tx:attributes>
  19.             <!--所有以query开头的方法都是只读的 -->
  20.             <tx:method name="query*" read-only="true" />
  21.             <!--其他方法使用默认事务策略 -->
  22.             <tx:method name="*" />
  23.         </tx:attributes>
  24.     </tx:advice>
  26.     <aop:config>
  27.         <!--pointcut元素定义一个切入点，execution中的第一个星号 用以匹配方法的返回类型，
  28.             这里星号表明匹配所有返回类型。 com.abc.dao.*.*(..)表明匹配cn.itcast.mybatis.service包下的所有类的所有 
  29.             方法 -->
  30.         <aop:pointcut id="myPointcut" expression="execution(* com.taotao.sso.service.*.*(..))" />
  31.         <!--将定义好的事务处理策略应用到上述的切入点 -->
  32.         <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut" />
  33.     </aop:config>
  35. </beans>

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

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  3.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  6.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  7.     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
  8.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
  10.     <!-- 集群的配置 -->
  11.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  12.         <!-- 最大连接数 -->
  13.         <property name="maxTotal" value="${redis.maxTotal}" />
  14.     </bean>
  16.     <!-- 集群连接池 -->
  17.     <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
  18.         <constructor-arg index="0" ref="jedisPoolConfig" />
  19.         <constructor-arg index="1">
  20.             <list>
  21.                 <bean class="redis.clients.jedis.JedisShardInfo">
  22.                     <constructor-arg index="0" value="${redis.node1.host}"/>
  23.                     <constructor-arg index="1" value="${redis.node1.port}"/>
  24.                 </bean>
  25.             </list>
  26.         </constructor-arg>
  27.     </bean>
  29. </beans>

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

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  3.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  6.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  7.     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
  8.     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
  10.     <!-- 定义sqlSessionFactory -->
  11.     <bean class="org.mybatis.spring.SqlSessionFactoryBean">
  12.         <!-- 配置数据源 -->
  13.         <property name="dataSource" ref="dataSource"/>
  14.         <!-- 配置mybatis的全局配置文件 -->
  15.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
  16.         <!-- 配置mapper.xml文件扫描路径 -->
  17.         <!-- <property name="mapperLocations" value="classpath:mybatis/mappers/**/*.xml"/> -->
  18.         <!-- 配置别名包 -->
  19.         <property name="typeAliasesPackage" value="com.taotao.sso.pojo"/>
  20.     </bean>
  22.     <!-- 配置mapper接口扫描包 -->
  23.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  24.         <property name="basePackage" value="com.taotao.sso.mapper"/>
  25.     </bean>
  27. </beans>

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

5.编写service层。

  1. package com.taotao.sso.service.impl;
  3. import org.apache.commons.codec.digest.DigestUtils;
  4. import org.apache.commons.lang3.StringUtils;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import com.fasterxml.jackson.databind.ObjectMapper;
  9. import com.taotao.sso.mapper.UserMapper;
  10. import com.taotao.sso.pojo.User;
  11. import com.taotao.sso.service.RedisService;
  12. import com.taotao.sso.service.UserService;
  14. @Service("userService")
  15. public class UserServiceImpl implements UserService {
  16.     @Autowired
  17.     private UserMapper userMapper;
  19.     @Autowired
  20.     private RedisService redisService;
  22.     private static final ObjectMapper MAPPER=new ObjectMapper();
  24.     @Override
  25.     public String doLogin(String username, String password) throws Exception {
  26.         User record=new User();
  27.         record.setUsername(username);
  28.         User user=this.userMapper.selectOne(record);
  29.         if(null == user){
  30.             return null;
  31.         }
  32.         if(! StringUtils.equals(DigestUtils.md5Hex(password), user.getPassword())){
  33.             return null;
  34.         }
  36.         //登录成功
  37.         String token=DigestUtils.md5Hex(System.currentTimeMillis()+username);
  38.         this.redisService.set("token"+token, MAPPER.writeValueAsString(user),60*30);
  40.         return token;
  41.     }
  43. }

redisService和一些CookieUtils工具类

  1. package com.taotao.sso.service;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Service;
  6. import redis.clients.jedis.ShardedJedis;
  7. import redis.clients.jedis.ShardedJedisPool;
  9. @Service
  10. public class RedisService {
  12.     @Autowired(required = false)//运行的Spring环境中如果存在就注入，没有就忽略
  13.     private ShardedJedisPool shardedJedisPool;
  15.     private <T> T execute(Function<T, ShardedJedis> fun) {
  16.         ShardedJedis shardedJedis = null;
  17.         try {
  18.             // 从连接池中获取到jedis分片对象
  19.             shardedJedis = shardedJedisPool.getResource();
  20.             return fun.callback(shardedJedis);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         } finally {
  24.             if (null != shardedJedis) {
  25.                 // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
  26.                 shardedJedis.close();
  27.             }
  28.         }
  29.         return null;
  30.     }
  32.     /**
  33.      * 执行set操作
  34.      * 
  35.      * @param key
  36.      * @param value
  37.      * @return
  38.      */
  39.     public String set(final String key, final String value) {
  40.         return this.execute(new Function<String, ShardedJedis>() {
  41.             @Override
  42.             public String callback(ShardedJedis e) {
  43.                 return e.set(key, value);
  44.             }
  45.         });
  46.     }
  48.     /**
  49.      * 执行GET操作
  50.      * 
  51.      * @param key
  52.      * @return
  53.      */
  54.     public String get(final String key) {
  55.         return this.execute(new Function<String, ShardedJedis>() {
  56.             @Override
  57.             public String callback(ShardedJedis e) {
  58.                 return e.get(key);
  59.             }
  60.         });
  61.     }
  63.     /**
  64.      * 执行DEL操作
  65.      * 
  66.      * @param key
  67.      * @return
  68.      */
  69.     public Long del(final String key) {
  70.         return this.execute(new Function<Long, ShardedJedis>() {
  71.             @Override
  72.             public Long callback(ShardedJedis e) {
  73.                 return e.del(key);
  74.             }
  75.         });
  76.     }
  78.     /**
  79.      * 设置生存时间，单位为秒
  80.      * 
  81.      * @param key
  82.      * @param seconds
  83.      * @return
  84.      */
  85.     public Long expire(final String key, final Integer seconds) {
  86.         return this.execute(new Function<Long, ShardedJedis>() {
  87.             @Override
  88.             public Long callback(ShardedJedis e) {
  89.                 return e.expire(key, seconds);
  90.             }
  91.         });
  92.     }
  94.     /**
  95.      * 执行set操作并且设置生存时间，单位为秒
  96.      * 
  97.      * @param key
  98.      * @param value
  99.      * @return
  100.      */
  101.     public String set(final String key, final String value, final Integer seconds) {
  102.         return this.execute(new Function<String, ShardedJedis>() {
  103.             @Override
  104.             public String callback(ShardedJedis e) {
  105.                 String str = e.set(key, value);
  106.                 e.expire(key, seconds);
  107.                 return str;
  108.             }
  109.         });
  110.     }
  112. }
  115. package com.taotao.sso.service;
  117. public interface Function<T, E> {
  119.     public T callback(E e);
  121. }
  124. package com.taotao.sso.util;
  126. import java.io.UnsupportedEncodingException;
  127. import java.net.URLDecoder;
  128. import java.net.URLEncoder;
  130. import javax.servlet.http.Cookie;
  131. import javax.servlet.http.HttpServletRequest;
  132. import javax.servlet.http.HttpServletResponse;
  134. import org.slf4j.Logger;
  135. import org.slf4j.LoggerFactory;
  137. /**
  138.  * 
  139.  * Cookie 工具类
  140.  *
  141.  */
  142. public final class CookieUtils {
  144.     protected static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);
  146.     /**
  147.      * 得到Cookie的值, 不编码
  148.      * 
  149.      * @param request
  150.      * @param cookieName
  151.      * @return
  152.      */
  153.     public static String getCookieValue(HttpServletRequest request, String cookieName) {
  154.         return getCookieValue(request, cookieName, false);
  155.     }
  157.     /**
  158.      * 得到Cookie的值,
  159.      * 
  160.      * @param request
  161.      * @param cookieName
  162.      * @return
  163.      */
  164.     public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
  165.         Cookie[] cookieList = request.getCookies();
  166.         if (cookieList == null || cookieName == null) {
  167.             return null;
  168.         }
  169.         String retValue = null;
  170.         try {
  171.             for (int i = 0; i < cookieList.length; i++) {
  172.                 if (cookieList[i].getName().equals(cookieName)) {
  173.                     if (isDecoder) {
  174.                         retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
  175.                     } else {
  176.                         retValue = cookieList[i].getValue();
  177.                     }
  178.                     break;
  179.                 }
  180.             }
  181.         } catch (UnsupportedEncodingException e) {
  182.             logger.error("Cookie Decode Error.", e);
  183.         }
  184.         return retValue;
  185.     }
  187.     /**
  188.      * 得到Cookie的值,
  189.      * 
  190.      * @param request
  191.      * @param cookieName
  192.      * @return
  193.      */
  194.     public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
  195.         Cookie[] cookieList = request.getCookies();
  196.         if (cookieList == null || cookieName == null) {
  197.             return null;
  198.         }
  199.         String retValue = null;
  200.         try {
  201.             for (int i = 0; i < cookieList.length; i++) {
  202.                 if (cookieList[i].getName().equals(cookieName)) {
  203.                     retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
  204.                     break;
  205.                 }
  206.             }
  207.         } catch (UnsupportedEncodingException e) {
  208.             logger.error("Cookie Decode Error.", e);
  209.         }
  210.         return retValue;
  211.     }
  213.     /**
  214.      * 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
  215.      */
  216.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
  217.             String cookieValue) {
  218.         setCookie(request, response, cookieName, cookieValue, -1);
  219.     }
  221.     /**
  222.      * 设置Cookie的值 在指定时间内生效,但不编码
  223.      */
  224.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
  225.             String cookieValue, int cookieMaxage) {
  226.         setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
  227.     }
  229.     /**
  230.      * 设置Cookie的值 不设置生效时间,但编码
  231.      */
  232.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
  233.             String cookieValue, boolean isEncode) {
  234.         setCookie(request, response, cookieName, cookieValue, -1, isEncode);
  235.     }
  237.     /**
  238.      * 设置Cookie的值 在指定时间内生效, 编码参数
  239.      */
  240.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
  241.             String cookieValue, int cookieMaxage, boolean isEncode) {
  242.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
  243.     }
  245.     /**
  246.      * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
  247.      */
  248.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
  249.             String cookieValue, int cookieMaxage, String encodeString) {
  250.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
  251.     }
  253.     /**
  254.      * 删除Cookie带cookie域名
  255.      */
  256.     public static void deleteCookie(HttpServletRequest request, HttpServletResponse response,
  257.             String cookieName) {
  258.         doSetCookie(request, response, cookieName, "", -1, false);
  259.     }
  261.     /**
  262.      * 设置Cookie的值，并使其在指定时间内生效
  263.      * 
  264.      * @param cookieMaxage cookie生效的最大秒数
  265.      */
  266.     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
  267.             String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
  268.         try {
  269.             if (cookieValue == null) {
  270.                 cookieValue = "";
  271.             } else if (isEncode) {
  272.                 cookieValue = URLEncoder.encode(cookieValue, "utf-8");
  273.             }
  274.             Cookie cookie = new Cookie(cookieName, cookieValue);
  275.             if (cookieMaxage > 0)
  276.                 cookie.setMaxAge(cookieMaxage);
  277.             if (null != request)// 设置域名的cookie
  278.                 cookie.setDomain(getDomainName(request));
  279.             cookie.setPath("/");
  280.             response.addCookie(cookie);
  281.         } catch (Exception e) {
  282.             logger.error("Cookie Encode Error.", e);
  283.         }
  284.     }
  286.     /**
  287.      * 设置Cookie的值，并使其在指定时间内生效
  288.      * 
  289.      * @param cookieMaxage cookie生效的最大秒数
  290.      */
  291.     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
  292.             String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
  293.         try {
  294.             if (cookieValue == null) {
  295.                 cookieValue = "";
  296.             } else {
  297.                 cookieValue = URLEncoder.encode(cookieValue, encodeString);
  298.             }
  299.             Cookie cookie = new Cookie(cookieName, cookieValue);
  300.             if (cookieMaxage > 0)
  301.                 cookie.setMaxAge(cookieMaxage);
  302.             if (null != request)// 设置域名的cookie
  303.                 cookie.setDomain(getDomainName(request));
  304.             cookie.setPath("/");
  305.             response.addCookie(cookie);
  306.         } catch (Exception e) {
  307.             logger.error("Cookie Encode Error.", e);
  308.         }
  309.     }
  311.     /**
  312.      * 得到cookie的域名
  313.      */
  314.     private static final String getDomainName(HttpServletRequest request) {
  315.         String domainName = null;
  317.         String serverName = request.getRequestURL().toString();
  318.         if (serverName == null || serverName.equals("")) {
  319.             domainName = "";
  320.         } else {
  321.             serverName = serverName.toLowerCase();
  322.             serverName = serverName.substring(7);
  323.             final int end = serverName.indexOf("/");
  324.             serverName = serverName.substring(0, end);
  325.             final String[] domains = serverName.split("\\.");
  326.             int len = domains.length;
  327.             if (len > 3) {
  328.                 // www.xxx.com.cn
  329.                 domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
  330.             } else if (len <= 3 && len > 1) {
  331.                 // xxx.com or xxx.cn
  332.                 domainName = "." + domains[len - 2] + "." + domains[len - 1];
  333.             } else {
  334.                 domainName = serverName;
  335.             }
  336.         }
  338.         if (domainName != null && domainName.indexOf(":") > 0) {
  339.             String[] ary = domainName.split("\\:");
  340.             domainName = ary[0];
  341.         }
  342.         return domainName;
  343.     }
  345. }
  348. package com.taotao.sso.util;
  350. import java.io.IOException;
  352. import javax.servlet.http.HttpServletRequest;
  354. import org.apache.commons.io.IOUtils;
  355. import org.apache.commons.lang3.StringUtils;
  356. import org.springframework.http.HttpOutputMessage;
  357. import org.springframework.http.converter.HttpMessageNotWritableException;
  358. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  359. import org.springframework.web.context.request.RequestContextHolder;
  360. import org.springframework.web.context.request.ServletRequestAttributes;
  362. import com.fasterxml.jackson.core.JsonEncoding;
  363. import com.fasterxml.jackson.core.JsonProcessingException;
  365. public class CallBackMappingJackson2HttpMessageConvert extends MappingJackson2HttpMessageConverter {
  366.     //做jsonP统一支持标识
  367.     private String callbackName;
  368.     public String getCallbackName() {
  369.         return callbackName;
  370.     }
  371.     public void setCallbackName(String callbackName) {
  372.         this.callbackName = callbackName;
  373.     }
  374.     @Override
  375.     protected void writeInternal(Object object, HttpOutputMessage outputMessage)
  376.             throws IOException, HttpMessageNotWritableException {
  377.         HttpServletRequest request=((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest();
  378.         String callbackParam=request.getParameter(callbackName);
  379.         if(StringUtils.isEmpty(callbackParam)){
  380.             super.writeInternal(object, outputMessage);//调用父类方法直接返回。
  381.         }else{
  382.             JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
  383.             try {
  384.                 String result =callbackParam+"("+super.getObjectMapper().writeValueAsString(object)+");";
  385.                 IOUtils.write(result, outputMessage.getBody(),encoding.getJavaName());
  386.             }
  387.             catch (JsonProcessingException ex) {
  388.                 throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
  389.             }
  390.         }
  392.         super.writeInternal(object, outputMessage);
  393.     }
  395. }

编写controller层

  1. package com.taotao.sso.controller;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Controller;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RequestMethod;
  13. import org.springframework.web.bind.annotation.RequestParam;
  15. import com.taotao.sso.service.UserService;
  16. import com.taotao.sso.util.CookieUtils;
  18. @RequestMapping("service/user")
  19. @Controller
  20. public class UserController {
  21.     @Autowired
  22.     private UserService userService;
  23.     /**
  24.      * 注册
  25.      * @return
  26.      */
  27.     @RequestMapping(value="/register",method=RequestMethod.GET)
  28.     public String register(){
  29.         return "register";
  30.     }
  32.     /**
  33.      * 登录
  34.      * @return
  35.      */
  36.     @RequestMapping(value="/login",method=RequestMethod.GET)
  37.     public String login(){
  38.         return "login";
  39.     }
  41.     @RequestMapping(value="/doLogin",method=RequestMethod.POST)
  42.     public Map<String, Object> doLogin(@RequestParam("username") String userName,
  43.             @RequestParam("password")String password,
  44.             HttpServletRequest request,HttpServletResponse response){
  45.         Map<String, Object> result=new HashMap<>();
  46.         try {
  47.             String token=this.userService.doLogin(userName, password);
  48.             if(token != null && !token.isEmpty()){
  49.                 result.put("status", 200);
  50.                 CookieUtils.setCookie(request,response,"token", token);
  51.             }else{
  52.                 result.put("status", 400);//400参数列表错误。
  53.             }
  54.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.             result.put("status", 500);
  58.         }
  59.         return result;
  60.     }
  61. }

至此sso系统就写完了。

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

发表评论

表情：
评论列表 （有 0 条评论，422人围观）

还没有评论，来说两句吧...

相关阅读

    相关 XXL-SSO 实现SSO单点登录

    一、 概述： 本文旨在使用XXL-SSO开源架构 实现单点登录系统。 XXL-SSO 是一个分布式单点登录框架、只需要登录一次就可以访问所有相互信任的应用系统。 拥有”

    朱雀朱雀/ 0 赞/ 422 阅读

    相关 单点登录SSO的实现原理

    单点登录SSO（Single Sign On）说得简单点就是在一个多系统共存的环境下，用户在一处登录后，就不用在其他系统中登录，也就是用户的一次登录能得到其他所有系统的信任。单

    喜欢ヅ旅行喜欢ヅ旅行/ 0 赞/ 301 阅读