分佈式電商項目(單體架構-＞分佈式架構)

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

基於CAS的登陸中心(跨域名單點登陸)+Redis+Tomcat集羣(修改SpringBoot的配置文件中的端口模擬)+JWT生成token+基於Redis的分佈式鎖java

1、JWT解析

一、認證流程

首先，前端經過表單發送一個POST請求將用戶名和密碼發到後端(通常是HTTP+SSL)，後端去數據庫中核對信息，覈對成功則將用戶的某些信息看成載荷即JWT Payload，經這個載荷和頭部分別進行Base64編碼拼接後生成簽名，造成一個形如header.payload.signature的JWT(token)。git

後端將JWT字符串做爲登陸成功的結果返回給前端。前端能夠將返回的結果保存在localStorage或sessionStorage上，前端在每次請求時將JWT放入HTTP Header中的Authorization位。(解決XSS和XSRF問題，可經過請求攔截器實現) ，當用戶退出登陸時前端刪除保存的JWT便可。此外，後端還能夠檢查JWT的有效性(檢查簽名是否正確、檢查token是否過時、檢查token的接收方是不是本身等)。github

二、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);

三、JWT的好處

① 輸出是三個點分隔的Base64-URL字符串，能夠在HTML和HTTP環境中輕鬆傳遞這些字符串。算法

② 能夠經過URL、POST參數或者在HTTP Header中發送，數據量小，傳輸速度快。數據庫

③ 負載中包含了全部用戶所須要的信息，避免了屢次查詢數據庫。json

注意：Base64只是一種編碼，它是能夠被翻譯回原來的樣子來的，並非一種加密過程。所以不該該在負載裏面加入任何敏感的數據。後端

四、工具類

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;
	    }
	}

2、基於CAS的單點登陸

一、原理圖

二、實現代碼(不是很妙，用了模板引擎—使用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;
	    }
	}

登陸中心的校驗攔截器：tomcat

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;
	    }
	}

3、基於Redis的原生分佈式鎖

一、Cron表達式

秒分時日月周年(可選)

字段	容許值	容許的特殊字符
秒（Seconds）	0~59的整數	, - * / 四個字符
分（Minutes）	0~59的整數	, - * / 四個字符
小時（Hours）	0~23的整數	, - * / 四個字符
日期（DayofMonth）	1~31的整數（可是你須要考慮你月的天數）	,- * ? / L W C 八個字符
月份（Month）	1~12的整數或者 JAN-DEC	, - * / 四個字符
星期（DayofWeek）	1~7的整數或者 SUN-SAT （1=SUN）	, - * ? / L C # 八個字符
年(可選，留空)（Year）	1970~2099	, - * / 四個字符

二、思想及實現

將到期的時間戳做爲存入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("關閉訂單定時任務關閉");
	    }
	}