Token机制是sso单点登录的最主要实现机制，最常用的实现机制。

　　Token机制是sso单点登录的最主要实现机制，最常用的实现机制。传统身份认证，一般一个应用服务器，在客户端和服务器关联的时候，在应用服务器上做了一个HttpSession对象保持着客户端和服务器上状态信息存储。

1、传统身份认证。

答：HTTP是一种没有状态的协议，也就是它并不知道是谁是访问应用。这里我们把用户看成是客户端，客户端使用用户名还有密码通过了身份验证，不过下回这个客户端再发送请求时候，还得再验证一下。
　　解决的方法就是，当用户请求登录的时候，如果没有问题，我们在服务端生成一条记录，这个记录里可以说明一下登录的用户是谁，然后把这条记录的 ID 号发送给客户端，客户端收到以后把这个 ID 号存储在 Cookie 里，下次这个用户再向服务端发送请求的时候，可以带着这个 Cookie ，这样服务端会验证一个这个 Cookie 里的信息，看看能不能在服务端这里找到对应的记录，如果可以，说明用户已经通过了身份验证，就把用户请求的数据返回给客户端。
　　上面说的就是 Session，我们需要在服务端存储为登录的用户生成的 Session ，这些 Session 可能会存储在内存，磁盘，或者数据库里。我们可能需要在服务端定期的去清理过期的 Session 。

这种认证中出现的问题是：

　　a）、Session：每次认证用户发起请求时，服务器需要去创建一个记录来存储信息。当越来越多的用户发请求时，内存的开销也会不断增加。
　　b）、可扩展性：在服务端的内存中使用Session存储登录信息，伴随而来的是可扩展性问题。
　　c）、CORS(跨域资源共享)：当我们需要让数据跨多台移动设备上使用时，跨域资源的共享会是一个让人头疼的问题。在使用Ajax抓取另一个域的资源，就可以会出现禁止请求的情况。
　　d）、CSRF(跨站请求伪造)：用户在访问银行网站时，他们很容易受到跨站请求伪造的攻击，并且能够被利用其访问其他的网站。在这些问题中，可扩展性是最突出的。因此我们有必要去寻求一种更有行之有效的方法。

2、Token身份认证。

答：2.1）、使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。大概的流程是这样的：

　　　　a）、客户端使用用户名、密码请求登录。
　　　　b）、服务端收到请求，去验证用户名、密码。
　　　　c）、验证成功后，服务端会签发一个 Token（令牌），再把这个 Token 发送给客户端。
　　　　d）、客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 、Session Storage里。
　　　　e）、客户端每次向服务端请求资源的时候需要带着服务端签发的 Token。
　　　　f）、服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据。

2.2）、使用Token验证的优势：

　　a）、无状态、可扩展。
　　b）、在客户端存储的Tokens是无状态的，并且能够被扩展。基于这种无状态和不存储Session信息，负载负载均衡器能够将用户信息从一个服务传到其他服务器上。
　　c）、安全性。
　　d）、请求中发送token而不再是发送cookie能够防止CSRF(跨站请求伪造)。即使在客户端使用cookie存储token，cookie也仅仅是一个存储机制而不是用于认证。不将信息存储在Session中，让我们少了对session操作。

3、JSON Web Token（JWT）机制。

答：Token在Java中具体实现的方案，JWT（Json数据做web网络层的令牌机制），可以做加密扩展或者签名扩展。

1）、JSON Web Token（JWT）机制。

　　a、JWT是一种紧凑（小而少，只要包含了用户信息即可）且自包含（json数据中包含本次访问简单记录，记录不敏感数据）的，用于在多方传递JSON对象的技术。传递的数据可以使用数字签名增加其安全行。可以使用HMAC加密算法或RSA公钥/私钥加密方式。
　　b、紧凑：数据小，可以通过URL，POST参数，请求头发送。且数据小代表传输速度快。
　　c、自包含：使用payload数据块记录用户必要且不隐私的数据，可以有效的减少数据库访问次数，提高代码性能。
　　d、JWT一般用于处理用户身份验证或数据信息交换。
　　e、用户身份验证：一旦用户登录，每个后续请求都将包含JWT，允许用户访问该令牌允许的路由，服务和资源。单点登录是当今广泛使用JWT的一项功能，因为它的开销
    很小，并且能够轻松地跨不同域使用。
　　f、数据信息交换：JWT是一种非常方便的多方传递数据的载体，因为其可以使用数据签名来保证数据的有效性和安全性。
　　h、官网： http://jwt.io。

2）、JWT数据结构。JWT的数据结构是 ： A.B.C。 由字符点'.'来分隔三部分数据。

2.1）、A：header 头信息。

　　a）、数据结构： {"alg": "加密算法名称", "typ" : "JWT"}。
　　b）、alg是加密算法定义内容，如：HMAC SHA256 或 RSA。
　　c）、typ是token类型，这里固定为JWT。

2.2）、B：payload （有效荷载，可以考虑不传递任何信息）。

　　a）、在payload数据块中一般用于记录实体（通常为用户信息）或其他数据的。主要分为三个部分，分别是：已注册信息（registered claims），公开数据（public claims），私有数据（private claims）。
　　b）、payload中常用信息有：iss（发行者），exp（到期时间），sub（主题），aud（受众）等。前面列举的都是已注册信息。
　　c）、公开数据部分一般都会在JWT注册表中增加定义。避免和已注册信息冲突。
　　d）、公开数据和私有数据可以由程序员任意定义。
　　e）、注意：即使JWT有签名加密机制，但是payload内容都是明文记录，除非记录的是加密数据，否则不排除泄露隐私数据的可能。不推荐在payload中记录任何敏感数据。

2.3）、C：Signature 签名。

　　签名信息。这是一个由开发者提供的信息。是服务器验证的传递的数据是否有效安全的标准。在生成JWT最终数据的之前。先使用header中定义的加密算法，将header和payload进行加密，并使用点进行连接。如：加密后的head.加密后的payload。再使用相同的加密算法，对加密后的数据和签名信息进行加密。得到最终结果。

4、JWT（JSON Web Token）执行流程，如下所示：

5、使用一个简单的项目来验证一下JWT的实现。pom.xml依赖配置，如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.bie</groupId>
    <artifactId>sso-jwt</artifactId>
    <version>1.0</version>
    <packaging>war</packaging>

    <dependencies>
        <!-- spring5.0.6要求Jdk1.8以上版本 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
        <!-- JWT核心依赖 -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- java开发JWT的依赖jar包。 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <!-- 给springmvc提供的响应扩展。@ResponseBody -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.5</version>
        </dependency>
        <!-- jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <!-- jsp -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <!-- 配置Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

JWTSubject作为Subject数据使用。也就是payload中保存的public claims，其中不包含任何敏感数据。建议使用实体类型，或者BO、DTO数据对象。

package com.bie.sso.commons;

/**
 * 作为Subject数据使用。也就是payload中保存的public
 * claims，其中不包含任何敏感数据。开发中建议使用实体类型，或者BO、DTO数据对象。
 * 
 * @author biehl
 *
 */
public class JWTSubject {

    private String username;

    public JWTSubject() {
        super();
    }

    public JWTSubject(String username) {
        super();
        this.username = username;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

}

JWTResult结果对象。可以存放错误编码、正确编码、claims验证过程中payload中的数据。是payload里面的数据对象，是JWT里面的对象。

package com.bie.sso.commons;

import io.jsonwebtoken.Claims;

/**
 * 结果对象。
 * 
 * @author biehl
 *
 */
public class JWTResult {

    /**
     * 错误编码。在JWTUtils中定义的常量， 200为正确。
     */
    private int errCode;

    /**
     * 是否成功，代表结果的状态。
     */
    private boolean success;

    /**
     * 验证过程中payload中的数据。是payload里面的数据对象，是JWT里面的对象。
     */
    private Claims claims;

    public int getErrCode() {
        return errCode;
    }

    public void setErrCode(int errCode) {
        this.errCode = errCode;
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public Claims getClaims() {
        return claims;
    }

    public void setClaims(Claims claims) {
        this.claims = claims;
    }

}

JWTResponseData发送给客户端的数据对象。 商业开发中，一般除特殊请求外，大多数的响应数据都是一个统一类型的数据，统一数据有统一的处理方式，便于开发和维护。

package com.bie.sso.commons;

/***
 * 发送给客户端的数据对象。 商业开发中，一般除特殊请求外，大多数的响应数据都是一个统一类型的数据，统一数据有统一的处理方式，便于开发和维护。
 * 
 * @author biehl
 *
 */
public class JWTResponseData {

    private Integer code;// 返回码，类似HTTP响应码。如：200成功，500服务器错误，404资源不存在等。

    private Object data;// 业务数据

    private String msg;// 返回描述

    private String token;// 身份标识， JWT生成的令牌。

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

}

JWTUtils是JWT的工具。

package com.bie.sso.commons;

import java.util.Date;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.SignatureException;

/**
 * JWT工具
 * 
 * @author biehl
 *
 */
public class JWTUtils {

    // 服务器的key。用于做加解密的key数据，如果可以使用客户端生成的key，当前定义的常量可以不使用。
    private static final String JWT_SECERT = "test_jwt_secert";
    // 做json和java对象之间的相互转换。
    private static final ObjectMapper MAPPER = new ObjectMapper();
    public static final int JWT_ERRCODE_EXPIRE = 1005;// Token过期
    public static final int JWT_ERRCODE_FAIL = 1006;// 验证不通过

    /**
     * 创建密匙key
     * 
     * @return
     */
    public static SecretKey generalKey() {
        try {
            // byte[] encodedKey = Base64.decode(JWT_SECERT);
            // 不管哪种方式最终得到一个byte[]类型的key就行
            byte[] encodedKey = JWT_SECERT.getBytes("UTF-8");
            SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
            return key;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 签发JWT，创建token的方法。
     * 
     * @param id
     *            jwt的唯一身份标识，主要用来作为一次性token，从而回避重放攻击。
     * @param iss
     *            jwt签发者，谁去生成的token信息。
     * @param subject
     *            jwt所面向的用户。payload中记录的public claims公开信息。当前环境中就是用户的登录名。
     * @param ttlMillis
     *            有效期，单位毫秒。
     * @return token token是一次性的。是为一个用户的有效登录周期准备的一个token。用户退出或者超时，token将会失效。
     * 
     * @throws Exception
     */
    public static String createJWT(String id, String iss, String subject, long ttlMillis) {
        // 加密算法。
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        // 当前时间。
        long nowMillis = System.currentTimeMillis();
        // 当前时间的日期对象。
        Date now = new Date(nowMillis);
        // 获取到密匙key。
        SecretKey secretKey = generalKey();
        // 创建JWT的构建器。 就是使用指定的信息和加密算法，生成Token的工具。
        JwtBuilder builder = Jwts.builder().setId(id) // 设置身份标志。就是一个客户端的唯一标记。 如：可以使用用户的主键，客户端的IP，服务器生成的随机数据。
                .setIssuer(iss)

                .setSubject(subject)

                .setIssuedAt(now) // token生成的时间。
                .signWith(signatureAlgorithm, secretKey); // 设定密匙和算法
        // 如果有效期大于等于0，ttlMillis是多长时间，单位是毫秒。
        if (ttlMillis >= 0) {
            long expMillis = nowMillis + ttlMillis; // 当前时间加上有效期就是token的失效时间。
            Date expDate = new Date(expMillis); // token的失效时间。
            builder.setExpiration(expDate);// 设置token的失效时间。
        }
        return builder.compact(); // 生成token
    }

    /**
     * 验证JWT
     * 
     * @param jwtStr
     * @return
     */
    public static JWTResult validateJWT(String jwtStr) {
        // 创建JWTResult对象实例
        JWTResult checkResult = new JWTResult();
        // 创建Claims对象实例
        Claims claims = null;
        try {
            // 解析JWT字符串
            claims = parseJWT(jwtStr);
            // 设定信息
            checkResult.setSuccess(true);
            checkResult.setClaims(claims);
        } catch (ExpiredJwtException e) { // token超时，Token过期
            checkResult.setErrCode(JWT_ERRCODE_EXPIRE);
            checkResult.setSuccess(false);
        } catch (SignatureException e) { // 校验失败，验证不通过
            checkResult.setErrCode(JWT_ERRCODE_FAIL);
            checkResult.setSuccess(false);
        } catch (Exception e) {
            checkResult.setErrCode(JWT_ERRCODE_FAIL);
            checkResult.setSuccess(false);
        }
        return checkResult;
    }

    /**
     * 
     * 解析JWT字符串
     * 
     * @param jwt
     *            就是服务器为客户端生成的签名数据，就是token。
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        // 创建密匙key，通过key校验token
        SecretKey secretKey = generalKey();
        // getBody获取的就是token中记录的payload数据。就是payload中保存的所有的claims。
        return Jwts.parser()

                .setSigningKey(secretKey) // 设置密匙

                .parseClaimsJws(jwt) // 解析的是什么字符串

                .getBody(); // getBody获取的就是token中记录的payload数据。就是payload中保存的所有的claims。
    }

    /**
     * 生成subject信息
     * 
     * @param subObj
     *            - 要转换的对象。
     * @return java对象->JSON字符串出错时返回null
     */
    public static String generalSubject(Object subObj) {
        try {
            return MAPPER.writeValueAsString(subObj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
    }

}

JWTController控制层的业务逻辑，如下所示：

package com.bie.sso.controller;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.bie.sso.commons.JWTResponseData;
import com.bie.sso.commons.JWTResult;
import com.bie.sso.commons.JWTSubject;
import com.bie.sso.commons.JWTUtils;

/**
 * 
 * @author biehl
 *
 */
@Controller
public class JWTController {

    private static final Map<String, String> USERS = new HashMap<>(16);

    static {
        // 初始化10个账号密码信息
        for (int i = 0; i < 10; i++) {
            USERS.put("admin" + i, "password" + 1);
        }
    }

    /**
     * 是否可登录
     * 
     * @param username
     * @param password
     * @return
     */
    public static boolean isLogin(String username, String password) {
        if (null == username || username.trim().length() == 0) {
            return false;
        }
        String obj = USERS.get(username);
        if (null == obj || !obj.equals(password)) {
            return false;
        }
        return true;
    }

    @RequestMapping("/authorization")
    @ResponseBody
    public Object authorization(HttpServletRequest request) {
        // 获取到头部的校验数据
        String token = request.getHeader("Authorization");
        // 验证JWT
        JWTResult result = JWTUtils.validateJWT(token);
        //
        JWTResponseData responseData = new JWTResponseData();
        // 判断是否成功
        if (result.isSuccess()) {
            // 如果成功设置响应码200
            responseData.setCode(200);
            // 将获取到的用户信息进行设置。
            responseData.setData(result.getClaims().getSubject());
            // 重新生成token，就是为了重置token的有效期。
            String newToken = JWTUtils.createJWT(result.getClaims().getId(), result.getClaims().getIssuer(),
                    result.getClaims().getSubject(), 1 * 60 * 1000);
            // 设置新的token的有效期。
            responseData.setToken(newToken);
            return responseData;
        } else {
            // 如果失败设置响应码500
            responseData.setCode(500);
            responseData.setMsg("用户未登录");
            return responseData;
        }
    }

    @RequestMapping("/login")
    @ResponseBody
    public Object login(String username, String password) {
        JWTResponseData responseData = null;
        // 认证用户信息。本案例中访问静态数据。
        if (JWTController.isLogin(username, password)) {
            // 创建一个对象实例，将账号传递进去创建实例对象。
            JWTSubject subject = new JWTSubject(username);
            // 创建签名信息token
            String jwtToken = JWTUtils.createJWT(UUID.randomUUID().toString(), "bie-test-jwt",
                    JWTUtils.generalSubject(subject), 1 * 60 * 1000);
            // 创建相应实例
            responseData = new JWTResponseData();
            responseData.setCode(200);
            responseData.setData(null);
            responseData.setMsg("登录成功");
            // 设置相应的token
            responseData.setToken(jwtToken);
        } else {
            responseData = new JWTResponseData();
            responseData.setCode(500);
            responseData.setData(null);
            responseData.setMsg("登录失败");
            responseData.setToken(null);
        }
        return responseData;
    }

}

登录主界面，可以使用登录，和验证是否登录来测试JWT的使用。登录主界面，如下所示：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript">
    function login() {
        var username = $("#username").val();
        var password = $("#password").val();
        var params = "username=" + username + "&password=" + password;
        $.ajax({
            'url' : '${pageContext.request.contextPath }/login',
            'data' : params,
            'success' : function(data) {
                if (data.code == 200) {
                    var token = data.token;
                    // web storage的查看 - 在浏览器的开发者面板中的application中查看。
                    // local storage - 本地存储的数据。 长期有效的。
                    // session storage - 会话存储的数据。 一次会话有效。
                    var localStorage = window.localStorage; // 浏览器提供的存储空间。 根据key-value存储数据。
                    localStorage.token = token;
                } else {
                    alert(data.msg);
                }
            }
        });
    }

    function setHeader(xhr) { // XmlHttpRequest
        xhr.setRequestHeader("Authorization", window.localStorage.token);
    }

    function testLocalStorage() {
        $.ajax({
            'url' : '${pageContext.request.contextPath}/authorization',
            'success' : function(data) {
                if (data.code == 200) {
                    window.localStorage.token = data.token;
                    alert(data.data);
                } else {
                    alert(data.msg);
                }
            },
            'beforeSend' : setHeader
        });
    }
</script>
</head>
<body>
    <center>
        <table>
            <caption>登录测试</caption>
            <tr>
                <td style="text-align: right; padding-right: 5px">登录名：</td>
                <td style="text-align: left; padding-left: 5px"><input
                    type="text" name="username" id="username" /></td>
            </tr>
            <tr>
                <td style="text-align: right; padding-right: 5px">密码：</td>
                <td style="text-align: left; padding-left: 5px"><input
                    type="text" name="password" id="password" /></td>
            </tr>
            <tr>
                <td style="text-align: right; padding-right: 5px" colspan="2">
                    <input type="button" value="登录" onclick="login();" />
                </td>
            </tr>
        </table>
    </center>
    <input type="button" value="验证是否登录"
        onclick="testLocalStorage();" />
</body>
</html>

可以借助浏览器的帮助理解这些知识点。

注意点1：web storage的查看，在浏览器的开发者面板中的application中查看。

　　a）、local storage：本地存储的数据，长期有效的。
　　b）、session storage：会话存储的数据，一次会话有效。

注意点2：如果对session和cookie不理解的，还是多搜索一下session和cookie的区别，方便自己的理解，然后在搜索一下单点登录的实现过程，网上已经很多介绍了，这篇主要是帮助自己理解JWT的使用，包含生成token，验证token等等知识点。

6、基于JWT机制的单点登录。注意事项，如下所示：

　　1）、使用JWT实现单点登录时，需要注意token时效性。token是保存在客户端的令牌数据，如果永久有效，则有被劫持的可能。token在设计的时候，可以考虑一次性有效或一段时间内有效。如果设置有效时长，则需要考虑是否需要刷新token有效期问题。

　　2）、使用JWT技术生成的token，客户端在保存的时候可以考虑cookie或localStorage。cookie保存方式，可以实现跨域传递数据。localStorage是域私有的本地存储，无法实现跨域。

　　3）、关于webstorage的相关知识点。

　　　　a、webstorage可保存的数据容量为5M。且只能存储字符串数据。
　　　　b、webstorage分为localStorage和sessionStorage。
　　　　c、localStorage的生命周期是永久的，关闭页面或浏览器之后localStorage中的数据也不会消失。localStorage除非主动删除数据，否则数据永远不会消失。
　　　　d、sessionStorage是会话相关的本地存储单元，生命周期是在仅在当前会话下有效。sessionStorage引入了一个“浏览器窗口”的概念，sessionStorage是在同源的窗口中始终存在的数据。只要这个浏览器窗口没有关闭，即使刷新页面或者进入同源另一个页面，数据依然存在。但是sessionStorage在关闭了浏览器窗口后就会被销毁。同时独立的打开同一个窗口同一个页面，sessionStorage也是不一样的。

---

7、Restful接口设计，Rest简述。

　　答：REST（英文：Representational State Transfer，简称REST）描述了一个架构样式的网络系统，比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中，他是 HTTP 规范的主要编写者之一。在目前主流的三种Web服务交互方案中，REST相比于SOAP（Simple Object Access protocol，简单对象访问协议）以及XML-RPC更加简单明了，无论是对URL的处理还是对Payload的编码，REST都倾向于用更加简单轻量的方法设计和实现。值得注意的是REST并没有一个明确的标准，而更像是一种设计的风格。

8、Restful接口设计，Restful简述。

　　答：对应的中文是rest式的，Restful web service是一种常见的rest的应用,是遵守了rest风格的web服务，rest式的web服务是一种ROA(The Resource-Oriented Architecture)(面向资源的架构)。

9、Restful接口设计，Restful特性。

1）、普通架构。

　　每次请求的接口或者地址，都在做描述，例如查询的时候用了query，新增的时候用了save。如：http://127.0.0.1/user/query/1，这个是GET请求，根据用户id查询用户数据。http://127.0.0.1/user/save，这个是POST请求，新增用户。

2）、Restful架构。

　　使用get请求，就是查询.使用post请求，就是新增的请求，意图明显，没有必要做描述，这就是restful。http://127.0.0.1/user/1，这个是GET请求，根据用户id查询用户数据。http://127.0.0.1/user，这个是POST请求，新增用户。

3）、Restful操作方式。幂等性：多次访问，结果资源状态是否相同。安全：访问是否会变更服务器资源状态。

HTTP方法	资源操作	幂等性	是否安全？
GET	查询	是	是
POST	新增	否	否
PUT	修改	是	否
DELETE	删除	是	否

4）、响应状态码。

编码	HTTP方法	响应体内容	描述
200	get/put	资源数据	操作成功
201	post	源数据	创建成功
202	post/put/delete	无	请求已接受
204	delete/put	无	请求已处理，无返回数据
301	get	link 链接	资源已被移除
303	get	link	重定向
304	get	无	资源没有被修改
400	get/post/put/delete	错误提示消息	参数错误（缺少，格式错误等）
401	get/post/put/delete	错误提示消息	未授权
403	get/post/put/delete	错误提示消息	访问受限、授权过期
404	get/post/put/delete	错误提示消息	资源、服务未找到
405	get/post/put/delete	错误提示消息	不允许的HTTP方法
409	get/post/put/delete	错误提示消息	资源冲突或资源被锁定
415	get/post/put/delete	错误提示消息	不支持的数据类型或媒体类型
429	get/post/put/delete	错误提示消息	请求过多被限制
500	get/post/put/delete	错误提示消息	系统错误
501	get/post/put/delete	错误提示消息	接口未实现

 

待续......