vue前后分离session实现_关于前后端分离（springboot、vue、cas实现SSO）

A、传统意义来讲，前后端不分离的项目进行集成cas，很简单，很方便，不再赘述，简单描述如下：

a1、后台服务集成CAS，主要就是引入jar包依赖，集成CAS过滤器并制定其order优先级高

a2、此时后台服务就会很轻松的集成了CAS实现所谓的SSO

B、但是现在项目都是前后端分离，对于前后端分离有一个难点，就是如何集成，如果后台模式不变，依然集成CAS，追加CAS过滤器，那么前端服务拿到后台的重定向(CAS校验不通过，重定向到CAS服务配置的登录页面)如何处理？跨域？临时解决方案：

b1、需要去掉后台集成的CAS过滤器，

b2、前端配置拦截器，没有登录的话需要去请求CAS服务器，并声明需要拿到jwt，并将jwt作为cookie写入本地

b3、前端将拿到的jwt去请求后台，携带cookie jwt

b4、后端自己写的那个过滤器去校验jwt是否合法，不合法响应接口生成json标记为重定向，此处重定向不是用response.sendRedirect(...)，而是将声明重定向，前端拿到该重定向标记去请求CAS服务器拿jwt，重回上述B2步骤，如果后台校验成功则正常chain.doFilter(...)即可

b5、如此就是前后端分离的SSO，后台是Springboot，前端是Vue，SSO服务是独立的CAS服务器

备注：关于前后端分离的文章，在网上翻了遍，也没有找到合适的，最终还是摸索中前进，找到了替代方案，这个方案感觉差点意思，但是偷梁换柱实现了简单的SSO，众大佬有好的方案一起成长。

过滤器代码如下：

```

import com.alibaba.fastjson.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.http.ResponseEntity;

import org.springframework.util.StringUtils;

import org.springframework.web.client.RestTemplate;

import javax.servlet.FilterConfig;

import javax.servlet.*;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.validation.constraints.NotNull;

import java.io.IOException;

import java.net.URLDecoder;

import java.util.Enumeration;

/**

* Created with IntelliJ IDEA 2019.

* Project:SmartES

* User: WANG PO

* Date: 2019-07-02 18:30:23

* Version:1.0.0

* Description: 过滤器

*

* @author wangpo

*/

public class LocalUserInfoFilterimplements Filter {

Loggerlogger = LoggerFactory.getLogger(LocalUserInfoFilter.class);

@Override

public void init(FilterConfig filterConfig)throws ServletException {

}

@Override

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {

HttpServletRequestrequest_= (HttpServletRequest) request;

HttpServletResponseresponse_= (HttpServletResponse) response;

HttpSession session = request_.getSession();

Enumeration attributeNames = session.getAttributeNames();

while (attributeNames.hasMoreElements()) {

System.err.println("session " + attributeNames.nextElement());

}

//增加校验

String jwt = loadJWTOrUrl(request_, "jwt");

ResponseEntity responseEntity =null;

if (!StringUtils.isEmpty(jwt)) {

JSONObject jsonObject =new JSONObject();

logger.warn("前端获取到jwt={}", jwt);

String decode = URLDecoder.decode(jwt, "UTF-8");

logger.warn("转码后的获取到decode={}", decode);

String[] split = decode.split("&");

jsonObject.put("token", split[0]);

try {

try {

responseEntity =new RestTemplate().postForEntity("http:/xxxxxxxx.com/api-token-verify/", jsonObject, String.class);

System.err.println("responseEntity.getStatusCode().value():" + responseEntity.getStatusCode().value());

}catch (Exception e) {

logger.warn("appear  error  {}", e.getMessage());

jsonObject =new JSONObject();

//此处的状态码为了前端控制重定向而不是采取服务器重定向

jsonObject.put("sso_status", "302");

response_.getWriter().write(jsonObject.toJSONString());

logger.warn("手动重定向------------------------------");

return;

}

}catch (Exception e) {

e.printStackTrace();

}

}else {

response_.reset();

JSONObject jsonObject =new JSONObject();

//此处的状态码为了前端控制重定向而不是采取服务器重定向

jsonObject.put("sso_status", "302");

response_.getWriter().write(jsonObject.toJSONString());

logger.warn("手动重定向------------------------------");

return;

}

//校验jwt如果校验失败则直接进行重定向

chain.doFilter(request_, response_);

}

/**

* 优先从header中获取jwt，如果没有则从cookie中获取jwt

* @param request_

* @return

*/

private StringloadJWTOrUrl(HttpServletRequestrequest_, @NotNull(message ="key not empty when try loadJWTOrUrl") String key) {

String jwt = request_.getHeader(key);

if (!StringUtils.isEmpty(jwt)) {

return jwt;

}

Cookie[] cookies = request_.getCookies();

if (cookies !=null) {

for (Cookie cookie : cookies) {

String name = cookie.getName();

String value = cookie.getValue();

if (key.equalsIgnoreCase(name)) {

return value;

}

}

}

return null;

}

@Override

public void destroy() {

}

}

```

个人过滤器代码：

```

import org.jasig.cas.client.session.SingleSignOutFilter;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

/**

* Created with IntelliJ IDEA 2019.

* Project:SmartES

* User: WANG PO

* Date: 2019-07-02 18:30:23

* Version:1.0.0

* Description: 过滤器配置

*

* @author wangpo

*/

@Configuration

public class FilterConfig {

/**

* 注册自身过滤器

* @return

*/

@Bean

public FilterRegistrationBeanregistrationBean() {

FilterRegistrationBean registrationBean =new FilterRegistrationBean();

registrationBean.setFilter(new LocalUserInfoFilter());

registrationBean.addUrlPatterns("/*");

registrationBean.setName("localUserInfoFilter");

registrationBean.setOrder(1);

return registrationBean;

}

}

```