SSO-Token,服务器端实现

最近在项目中遇到了一个单点登录的问题，就做了一个研究了下并做了实验，并分享给大家，有意见请指正～～～～

关于SSO的定义等一些相关的问题请自行百度，这里只说实现～～～～～～

首先呢，我做的SSO的实现在验证等操作全部是在服务器端实现的：

思路如下：

1、用户登录后，生成一个16位长度的Token字符串

2、将Token发回到客户端，在服务器端，将生成的Token和用户信息放到一个全局唯一的存储结构中

3、设置Token的过期时间和最后一次操作时间

4、每次用户进行操作时，验证Token是否过期，如过期要求重新登录，否则直接操作，并更新最近一次操作时间

5、后台线程定期检测Token的存储结构，将过期的Token移除

行了，直接来看实现吧：

我们将过期时间间隔，以及Token的字符串长度的设置都在配置文件中：如下SystemComfig.properties

TOKENTIMEOUT=1   设置的Token的过期时间，这里用的1分钟，方便实验，根据系统自行设定即可
TOKEN_BYTE_LEN=12  8--->10; 10--->14; 12--->16 具体的在实验的时候看下就可以了

解析配置文件的类：SystemConfigConstants.java

public class SystemConfigConstants {
	//Token过期时间
	public static final int TOKENTIMEOUT;
	//用于生成的Token长度
	public static final int TOKEN_BYTE_LEN;
	
	/*
	 * 取值过程
	 */
	static{
		//配置文件读取
		InputStream stream = null;
		//读取工具
		Properties properties = null;
		
		try {
			stream = SystemConfigConstants.class.getResourceAsStream("SystemComfig.properties");
			properties = new Properties();
			properties.load(stream);
		} catch (IOException e) {
			e.printStackTrace();
		}

		TOKENTIMEOUT = Integer.parseInt(properties.getProperty("TOKENTIMEOUT"));
		TOKEN_BYTE_LEN = Integer.parseInt(properties.getProperty("TOKEN_BYTE_LEN"));
	}
}

下面就是重点了：

我们需要去生成我们想要的长度的Token字符串，我这里使用的是使用是UUID，因为这个可以保证生成的字符串的不会重复的，但是这个太长了128bit呢，所有觉得太长了

所有我又使用了Base64算法对UUID字符串进行处理，至于UUID是啥，请Google, 所依赖的包：commons-codec-1.10.jar

下面看下具体的实现吧：TokenGenerateUtit.java

public class TokenGenerateUtil {

    //用于外部调用生成Token字符串的静态方法
    public static String getToken(){
        UUID uuid = UUID.randomUUID();
        String token = compressedUUID(uuid);
        //验证是否有相同的Token,为true重新生成
        if(TokenManager.DATA_MAP.containsKey(token)){
            uuid = UUID.randomUUID();
            token = compressedUUID(uuid);
        }
        return token;
    }

    //对UUID进行处理，形成想要的Token长度
    private static String compressedUUID(UUID uuid) {
        byte[] byUuid = new byte[SystemConfigConstants.TOKEN_BYTE_LEN];
        long least = uuid.getLeastSignificantBits();
        long most = uuid.getMostSignificantBits();
        long2bytes(most, byUuid, 0);
        long2bytes(least, byUuid, SystemConfigConstants.TOKEN_BYTE_LEN/2);
        String compressUUID = Base64.encodeBase64URLSafeString(byUuid);
        return compressUUID;
    }

    //长度处理
    private static void long2bytes(long value, byte[] bytes, int offset) {
        for (int i = SystemConfigConstants.TOKEN_BYTE_LEN/2-1; i > -1; i--) {
            bytes[offset++] = (byte) ((value >> 8 * i) & 0xFF);
        }
    }
}

虽然呢UUID可以保证的是唯一的，但是经过Base64处理后，为了不出现重复的情况（在存储结构中，token字符串是作为map的key的，所以不能重复），我在

生成时加了一个检测过程。

下面就是对Token的管理了：先看代码：TokenManager.java

public class TokenManager {

    //计时器,间隔一定的时间执行一次,设置为守护线程设true
    private static final Timer timer = new Timer(true);

    //构造函数私有化防止静态类被实例化  使用这种方式保障全局唯一性
    private TokenManager() {
    }

    //复合结构体，含登录的User和过期时间expried两个成员以及最后一次操作的时间
    private static class Token {
        private String userName;//登录用户名
        private Date expired; //过期时间
        private Date lastOperate; // 最近一次操作的时间
    }

    //令牌存储结构 ConcurrentHashMap：支持同步的HashMap
    public static final Map<String, Token> DATA_MAP = new ConcurrentHashMap<String, Token>();

    /**
     * 令牌有效性验证
     */
    public static boolean validate(String vt) {
        System.out.println("验证Token是否有效.......");
        boolean isValid = true;
        if(DATA_MAP.containsKey(vt)){
            Date expired = DATA_MAP.get(vt).expired;
            Date now = new Date();
            if(now.compareTo(expired) > 0){//已过期
                isValid = false;
                DATA_MAP.remove(vt);//移除
            }
        }else{
            isValid = false;
        }
        return isValid;
    }

    /**
     * 用户授权成功后存入授权信息
     */
    public static void addToken(String vt, String userName) {
        Token token = new Token();

        token.userName = userName;
        token.lastOperate = new Date();
        token.expired = new Date(token.lastOperate.getTime() + SystemConfigConstants.TOKENTIMEOUT * 60 * 1000);

        DATA_MAP.put(vt, token);
    }

    /**
     * 更新最近一次操作的时间
     */
    public static void updateLastOperate(String vt) {
        Token token = DATA_MAP.get(vt);
        token.lastOperate = new Date(new Date().getTime());//更新最近时间
        token.expired = new Date(token.lastOperate.getTime() + SystemConfigConstants.TOKENTIMEOUT * 60 * 1000); //更新过期时间
    }

    /**
     * 计时器实现
     */
    static {
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                for (Entry<String, Token> entiy : DATA_MAP.entrySet()) {
                    String vt = entiy.getKey();
                    Token token = entiy.getValue();

                    Date expired = token.expired;
                    Date now = new Date();
                    //当前时间大于过期时间
                    //当前时间大于过期时间
                    //标识已经过期时间
                    //将token移除
                    if (now.compareTo(expired) > 0) {
                        //已过期，清除
                        DATA_MAP.remove(vt);
                    }
                }
            }
            //第一个为线程启动后间隔多久启动第一次执行，第二个是两次执行的间隔时间
        }, 0 * 1000, 5 * 1000);
    }

    /**
     * 在系统启动时启动管理工具
     */
    public static void init(){ }
}

可以看到有一个Timer以守护线程的方式，运行，对存储结构进行维护，对已经过期的Token移除。

当每次操作的时候，对最近一次操作的时间进行更新，因为对Token过期的检测的线程是有时间间隔的，所以为了保证Token的有效性，每次操作前的Token有效性检测时也会检测一次是否过期。

使用的过程就是前面的思路了。

就到这吧，基本都讲完了，有的实现是把最近一次操作的时间更新和过期性检测放在客户端，觉得没必要，这样可以减少网络交互次数，也方便。

有更好的实现和想法，欢迎一起来讨论下啦，觉得有问题的欢迎指正～～～～～～～～