分布式電商專案(單體架構-＞分布式架構)

前后端的代碼都在GitHub上，https://github.com/xiguanlezz/E-Commerce2

基于CAS的登錄中心(跨域名單點登錄)+Redis+Tomcat集群(修改SpringBoot的組態檔中的埠模擬)+JWT生成token+基于Redis的分布式鎖

一、JWT決議

1、認證流程

首先，前端通過表單發送一個POST請求將用戶名和密碼發到后端(一般是HTTP+SSL)，后端去資料庫中核對資訊，核對成功則將用戶的某些資訊當作載荷即JWT Payload，經這個載荷和頭部分別進行Base64編碼拼接后生成簽名，形成一個形如header.payload.signature的JWT(token)，

后端將JWT字串作為登錄成功的結果回傳給前端，前端可以將回傳的結果保存在localStorage或sessionStorage上，前端在每次請求時將JWT放入HTTP Header中的Authorization位，(解決XSS和XSRF問題，可通過請求攔截器實作) ，當用戶退出登錄時前端洗掉保存的JWT即可，此外，后端還可以檢查JWT的有效性(檢查簽名是否正確、檢查token是否過期、檢查token的接收方是否是自己等)，

2、JWT結構

• Header：令牌的型別(即JWT)和所使用的簽名演算法(非對稱加密)，例如HMAC、SHA256或RSA，它會使用Base64編碼組成JWT結構的第一部分，

	{
	  "alg": "HS256",
	  "typ": "JWT"
	}

• Payload：包含有關物體(通常是用戶)和其他資料的宣告，它會使用Base64編碼組成JWT結構的第二部分，

	{
	  "username": "admin",
	  "role": "1"
	}

• Signature：使用編碼后的Header和Payload以及我們提供的一個密鑰，然后使用Header中指定的簽名演算法(非對稱加密)進行簽名，簽名的作用是保證JWT沒有被篡改過，還能保證生成簽名的服務器是安全的(使用私鑰加密，公鑰解密)，

	SHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload),secret);

3、JWT的好處

① 輸出是三個點分隔的Base64-URL字串，可以在HTML和HTTP環境中輕松傳遞這些字串，

② 可以通過URL、POST引數或者在HTTP Header中發送，資料量小，傳輸速度快，

③ 負載中包含了所有用戶所需要的資訊，避免了多次查詢資料庫，

注意：Base64只是一種編碼，它是可以被翻譯回原來的樣子來的，并不是一種加密程序，因此不應該在負載里面加入任何敏感的資料，

4、工具類

	public class JWTUtil {
	    private final static String secretKey = "23223232"; //私鑰
	    private final static long expireTime = 1000 * 60 * 30;  //設定token的過期時間為30分鐘
	
	    public static String getToken(User user) {
	        JWTCreator.Builder builder = JWT.create();
	        assert user != null;
	        builder.withClaim("id", user.getId());
	        builder.withClaim("username", user.getUsername());
	        builder.withClaim("email", user.getEmail());
	        builder.withClaim("phone", user.getPhone());
	        builder.withClaim("role", user.getRole());
	
	        long nowTimeMillis = System.currentTimeMillis();
	        if (expireTime > 0) {
	            nowTimeMillis += expireTime;
	        }
	        String token = builder
	                .withExpiresAt(new Date(nowTimeMillis))
	                .sign(Algorithm.HMAC256(secretKey));
	        return token;
	    }
	
	    public static void verify(String token) {
	        JWT.require(Algorithm.HMAC256(secretKey)).build().verify(token);
	    }
	
	    public static String getPayload(String token) {
	        DecodedJWT verify = JWT.require(Algorithm.HMAC256(secretKey)).build().verify(token);
	        assert verify != null;
	        String payload = verify.getPayload();
	        return payload;
	    }
	}

二、基于CAS的單點登錄

1、原理圖

2、實作代碼(不是很妙，用了模板引擎—使用MVVM架構可能正常點)

登錄攔截器(實作了兩種方式，一種是session，另一種是token)：

	@Order(1)
	public class LoginInterceptor implements HandlerInterceptor {
	    @Autowired
	    private StringRedisTemplate stringRedisTemplate;
	
	    @Override
	    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
	        String requestURL = httpServletRequest.getRequestURL().toString();
	
	        String loginToken = CookieUtil.readLoginToken(httpServletRequest);
	        if (StringUtils.isBlank(loginToken)) {
	            //判斷是否是cas之后的請求即請求中是否帶有ticket
	            String ticket = httpServletRequest.getParameter("ticket");
	            if (StringUtils.isNotBlank(ticket)) {
	                //使用token的方式----------------start---------------------
	//                JWTUtil.verify(ticket);
	                //使用token的方式----------------end---------------------
	
	                //使用session的方式----------------start---------------------
	                String userJson = stringRedisTemplate.opsForValue().get(ticket);
	                User user = JsonUtil.jsonToObject(userJson, User.class);
	                if (user != null) {
	                    CookieUtil.writeLoginToken(httpServletResponse, ticket);
	                    //寫完cookie后原地跳轉登錄請求
	                    httpServletResponse.sendRedirect(PropertiesUtil.getProperty("login.url", "http://www.mmall.com:8080/user/login.do"));
	                    return false;
	                }
	                //使用session的方式----------------end---------------------
	            }
	        } else {
	            //判斷cookie資訊是否有效
	
	            //使用token的方式----------------start---------------------
	//            JWTUtil.verify(loginToken);
	            //使用token的方式----------------end---------------------
	
	            //使用session的方式----------------start---------------------
	            String userJson = stringRedisTemplate.opsForValue().get(loginToken);
	            User user = JsonUtil.jsonToObject(userJson, User.class);
	            if (user != null) {
	                //MVVM架構中都是前端路由, 后端只負責提供資料
	                httpServletResponse.sendRedirect(PropertiesUtil.getProperty("index.url", "http://www.mmall.com"));
	                return false;
	            }
	            //使用session的方式----------------end---------------------
	        }
	        if (requestURL.contains("login")) {
	            httpServletResponse.reset();    //這里要添加reset，否則會報例外
	            httpServletResponse.setCharacterEncoding("UTF-8");  //這里要設定編碼, 否則會亂碼
	            String loginCenterURL = PropertiesUtil.getProperty("login.center.url", "http://login.mmall.com:8888/check");
	            httpServletResponse.sendRedirect(loginCenterURL + "?originalURL=" + PropertiesUtil.getProperty("login.url", "http://www.mmall.com:8080/user/login.do"));
	        }
	        return false;
	    }
	}

登錄中心的校驗攔截器：

	public class CheckInterceptor implements HandlerInterceptor {
	    @Autowired
	    private StringRedisTemplate stringRedisTemplate;
	    @Autowired
	    private ObjectMapper objectMapper;
	
	    @Override
	    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler) throws Exception {
	        String originalURL = httpServletRequest.getParameter("originalURL");
	        String loginToken = CookieUtil.readLoginToken(httpServletRequest);
	
	        if (StringUtils.isNotBlank(loginToken)) {
	            //使用token的方式----------------start---------------------
	//                JWTUtil.verify(loginToken);
	            //使用token的方式----------------end---------------------
	
	            //使用session的方式----------------start---------------------
	            String userJson = stringRedisTemplate.opsForValue().get(loginToken);
	            User user = objectMapper.readValue(userJson, User.class);
	            assert StringUtils.isNotBlank(originalURL);
	            if (user != null) {
	                httpServletResponse.reset();    //這里要添加reset，否則會報例外
	                httpServletResponse.setCharacterEncoding("UTF-8");  //這里要設定編碼, 否則會亂碼
	                httpServletResponse.sendRedirect(originalURL);
	                return false;
	            }
	            //使用session的方式----------------end---------------------
	        }
	        return true;
	    }
	}

三、基于Redis的原生分布式鎖

1、Cron運算式

秒 分 時 日 月 周 年(可選)

2、思想及實作

將到期的時間戳作為存入Redis的value值，setex這一原子操作可以實作分布式鎖，但是如果實作的時候沒有在原子操作上面加上過期時間的話，這會產生死鎖問題，此時需要使用雙重檢查鎖的思想，從Redis中根據key取出相應的value，根據現在的時間戳和value值的關系來決定是否可以獲得分布式鎖，

	@Component
	public class CloseOrderTask {
	    @Autowired
	    private IOrderService iOrderService;
	    @Autowired
	    private StringRedisTemplate stringRedisTemplate;

	    @Scheduled(cron = "0 */1 * * * ?")
	    public void closeOrderTaskV2() {
	        log.info("關閉訂單定時任務啟動");
	        long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout", "5000"));
	        Boolean flag = stringRedisTemplate.opsForValue()
	                .setIfAbsent(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,    //key
	                        String.valueOf(System.currentTimeMillis() + lockTimeout));   //過期的時間戳作為value
	        if (BooleanUtils.isTrue(flag)) {
	            log.info("{}獲取到了分布式鎖: {}", Thread.currentThread().getName(), Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
	            iOrderService.closeOrder(Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour", "2")));
	        } else {
	            //這里需要用雙重檢測鎖防分布式鎖產生死鎖
	            String formerLockValueStr = stringRedisTemplate.opsForValue().get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
	            assert formerLockValueStr != null;
	            long formerLockValue = Long.parseLong(formerLockValueStr);
	            if (System.currentTimeMillis() > formerLockValue) {   //說明之前的鎖已經過期, 可重新獲得鎖
	                String latterLockValueStr = stringRedisTemplate.opsForValue()
	                        .getAndSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,
	                                String.valueOf(System.currentTimeMillis() + lockTimeout));
	                if (latterLockValueStr == null  //呼叫getAndSet函式的時候鎖已經過期, 并且被洗掉了
	                        || StringUtils.equals(formerLockValueStr, latterLockValueStr)) {    //相等表明確實是這個tomcat行程獲取到了分布式鎖
	                    log.info("{}獲取到了分布式鎖: {}", Thread.currentThread().getName(), Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
	                    iOrderService.closeOrder(Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour", "2")));
	                } else {
	                    log.info("沒有獲取到分布式鎖: {}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
	                }
	            } else {
	                log.info("沒有獲取到分布式鎖: {}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
	            }
	        }
	        log.info("關閉訂單定時任務關閉");
	    }
	}