springcloud如何做权限管理（springsecurity）

springcloud如何做权限管理（springsecurity+auth2）？

先看一张脉络图：

现在呢一步一步开始做：

第一步：配置zuul网关

在zuul网关里带上请求头，不做拦截

@Component
@Slf4j
public class AuthFilter extends ZuulFilter {

	/**
     * 具体的过滤逻辑
     * 本例中,检查请求的参数中是否传了token这个参数,如果没传,则请求不被路由到具体的服务实例,
     * 直接返回响应,状态码为401
     * @return
     */
	@Override
	public Object run() {
		//过滤器过滤
		System.out.println("………preHandle……………");

		RequestContext requestContext = RequestContext.getCurrentContext();
		HttpServletRequest request = requestContext.getRequest();
		String header = request.getHeader("Authorization");
		if (null != header && !"".equals(header)) {
			requestContext.addZuulRequestHeader("header", header);

		}
		return null;
	}

	 /**
     * 表示该过滤器是否过滤逻辑,如果是ture,则执行run()方法;如果是false,则不执行run()方法.
     * @return
     */
	@Override
	public boolean shouldFilter() {
		return true;
	}

	/**
     * 过滤顺序,值越小,越早执行该过滤器
     * @return
     */
	@Override
	public int filterOrder() {
		// 过滤的顺序
		return 0;
	}

	/**
     * Zuul有一下四种过滤器
     * "pre":是在请求路由到具体的服务之前执行,这种类型的过滤器可以做安全校验,例如身份校验,参数校验等
     * "routing":它用于将请`在这里插入代码片`求路由到具体的微服务实例,在默认情况下,它使用Http Client进行网络请求
     * "post":它是在请求已被路由到微服务后执行,一般情况下,用作收集统计信息,指标,以及将响应传输到客户端
     * "error":它是在其他过滤器发生错误时执行
     */
	@Override
	public String filterType() {
		return "pre";
	}

}

注意：requestContext.addZuulRequestHeader(“header”, header);这句需要避开敏感词汇，例如Authorization等。

第二步：配置具体微服务（两个微服务都差不多，这里以其中一个为例）

①导包：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

②写一个类WebSecurityConfig放开所有请求，因为导包后所有请求都不通过了。

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.
                authorizeRequests().
                antMatchers("/**").
                permitAll().
                anyRequest().
                authenticated().
                and().
                csrf().
                disable();

    }
}

③写拦截器配置类，放开部分不需要的拦截：

@Configuration
@EnableWebSecurity
public class InterceptorConfig extends WebMvcConfigurationSupport {
    @Autowired
    private JwtInterceptor jwtInterceptor;
    protected void addInterceptors(InterceptorRegistry registry) {
        //注册拦截器要声明拦截器对象和要拦截的请求
        System.out.println("进入InterceptorConfig类的addInterceptors方法！");
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**").
                excludePathPatterns("/**/login/**").
                excludePathPatterns("/**/regist/**").
                excludePathPatterns("/**/captcha/**");
    }
}

④配置拦截器，做真正核心拦截内容

@Component
public class JwtInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtUtil jwtUtil;
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("………preHandle……………");
        //拦截器只是负责把头请求头中包含token的令牌进行一个解析验证。
        if (null == request ||
                null == request.getHeader("header") ||
                !request.getHeader("header").startsWith("Bearer ")) {
            outPutErrorResult(response);
            return false;

        }
        String token = request.getHeader("header").substring(7);
        System.out.println("token:" + token);
        if (StringUtils.isEmpty(token)) {
            outPutErrorResult(response);
            return false;
        }
        try {
            Claims claims = jwtUtil.parseJwt(token);
        } catch (Exception e) {
            e.printStackTrace();
            outPutErrorResult(response);
            return false;
        }

        return true;
    }

    public void outPutErrorResult(HttpServletResponse response) {
        ServletOutputStream output = null;
        try {
            output = response.getOutputStream();
            output.write(("{\"status\":\"error\",\"msg\":\"请登录账号@！\",\"code\":\"500\"}").getBytes());
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != output) {
                try {
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这里需要指出，
Claims claims = jwtUtil.parseJwt(token);
之所以可以这么判断token，是因为这里的token生成方式是采用jjwt方式生成的，所以可以按此方式解析。
参看token生成方法：
导包：

<dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
        </dependency>

  public String createJWT(String id, String subject, String roles) {
        long nowMinius = System.currentTimeMillis();
        JwtBuilder builder = Jwts.
                builder().setId(id).
                setSubject(subject).
                setIssuedAt(new Date()).
                signWith(SignatureAlgorithm.HS256, key).claim("roles", roles);
        if (ttl > 0) {
            builder.setExpiration(new Date(nowMinius + ttl));
        }
        return builder.compact();
    }

    public void setTtl(long ttl) {
        this.ttl = ttl;
    }

    /**
     * 解析JWT
     *
     * @param jwtStr
     * @return
     */
    public Claims parseJwt(String jwtStr) {
        return Jwts.parser().setSigningKey(key).parseClaimsJws(jwtStr).getBody();
    }

第三步：写一个类SecuringRequestInterceptor，在微服务相互调用时带上请求头，要不然会被拦截（每个业务微服务都要写）。

@Component
public class SecuringRequestInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate requestTemplate) {
        获取上一个请求保存的RequestAttributes,能获取到当前的HttpServletRequest
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
        //获取request域
        HttpServletRequest request = attributes.getRequest();
        //获取头部信息
        Enumeration<String> headerNames = request.getHeaderNames();
        //把头部信息里面的信息装进去requestTemplate
        if (headerNames != null) {
            while (headerNames.hasMoreElements()) {
                String name = headerNames.nextElement();
                System.out.println("name:"+name);
                String values = request.getHeader(name);
                System.out.println("values:"+values);
                requestTemplate.header(name, values);
            }
        }
    }
}

到这里基本没问题了，

第四步 再写一个抽象类AbstractController.java方便其他类使用用户名用户id用户角色等内容。（非必须）

 @Autowired
    protected HttpServletRequest request;
    @Autowired
    private JwtUtil jwtUtil;
    
public abstract class AbstractController {

    @Autowired
    protected HttpServletRequest request;
    @Autowired
    private JwtUtil jwtUtil;

    public SysLogUserVo UserInfo(){
        SysLogUserVo svuv = new SysLogUserVo();
        String header = request.getHeader("header");
        String token = header.substring(7);
        try {
            Claims claims = jwtUtil.parseJwt(token);
            svuv.setAccounts(claims.getSubject());
            svuv.setId(Integer.parseInt(claims.getId()));
            svuv.setRole_name((String) claims.get("roles"));

        } catch (Exception e) {
            e.printStackTrace();
        }
        return svuv;
    }
}

其他类想获取用户信息只需继承这个类就可以了