十三.SpringCloud+Security+Oauth2实现微服务授权 - 服务之间授权

1.服务之间授权方案

原理其实很简单，我们的调用关系是客户端(浏览器)调用资源服务器A通过请求头传递Token，资源服务器A通过Feign调用资源服务器B请求是没有Token的，我们只需要编写一个Feign的拦截器，将客户端请求A的请求头中的Token设置到资源服务器A调用资源服务器B的Feign的请求头中即可

2.搭建第二个资源服务器

这里需要搭建第二个资源服务器来演示服务器之间的授权，只需要把security-resource-server 复制一份命名为 security-resource2-server 即可，当然security-resource-server 需要集成Feign去调用security-resource2-server ，这里就省略了，没有思路？？您可以参照 《负载均衡Feign》

这里还要注意一个问题，就是用户如果要能访问到资源服务器A和资源服务器B，那么它应该同时拥有资源服务器A和资源服务器B的访问权限(permisson)，所以不要忘记给用户把需要的权限都配置上

3.Feign的拦截器

为了通用，我们可以搭建一个公共的模块编写Feign的拦截器，谁需要转发Token就只需要依赖它即可 ， 搭建模块 “security-resource-common” ,

3.1.导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3.2.定义Feign的拦截器

RequestInterceptor 是Feign的拦截器接口，提供了apply方法让我们可以通过RequestTemplate 对请求进行自定义，注意：该拦截器类需要给Spirng扫描到

@Component
@Slf4j
public class OAuth2FeignRequestInterceptor implements RequestInterceptor {
   
   

    //请求头中的token
    private final String AUTHORIZATION_HEADER = "Authorization";

    @Override
    public void apply(RequestTemplate requestTemplate) {
   
   
        //requestTemplate:feign底层用来发封装请求的对象

        //1.获取请求对象
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        //2.获取请求头中的Token
        String token = requestAttributes.getRequest().getHeader(AUTHORIZATION_HEADER);
        log.info("Feign拦截器添加请求头：{}",token);

        //3.添加到Feign的请求头
        requestTemplate.header(AUTHORIZATION_HEADER,token);
    }
}
代码挺简单的，通过RequestContextHolder得到请求对象，获取请求头中的Token设置到RequestTemplate 的header中即可

4.修改Hystrix并发策略

4.1.问题描述

理论上来说做了如上配置即可完成Token的转发了，但如果我们集成了Hystrix那么在Feign的拦截器中是没办法获取到请求对象的，这是因为Hystrix默认的隔离策略是线程池，每个请都会被分配到一个新的线程执行，导致请对象无法获取，不知道如何降级？见《Feign开启Hystrix》

4.2.解决方案

解决方案有两种，一是使用信号量隔离，在配置文件中加入如下配置：“hystrix.command.default.execution.isolation.strategy=SEMAPHORE”，解决方案二是修改Hystrix的隔离策略,我们这里使用第二种方式，因为使用信号量隔离会让请求变成单线程执行，官方也不推荐。

如何修改Hystrix的隔离策略呢？原理就是把调用线程A中的请求通过RequestContextHolder获取到，放到新的线程B中的RequestContextHolder中即可 。

4.3.定义Hystrix并发策略配置

@Configuration
public class FeignHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
   
   

    private HystrixConcurrencyStrategy hystrixConcurrencyStrategy;

    public FeignHystrixConcurrencyStrategy() {
   
   
        try {
   
   
            this.hystrixConcurrencyStrategy = HystrixPlugins.getInstance().getConcurrencyStrategy();
            if (this.hystrixConcurrencyStrategy instanceof FeignHystrixConcurrencyStrategy) {
   
   
                return;
            }
            HystrixCommandExecutionHook commandExecutionHook =
                    HystrixPlugins.getInstance().getCommandExecutionHook();
            HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
            HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();
            HystrixPropertiesStrategy propertiesStrategy =
                    HystrixPlugins.getInstance().getPropertiesStrategy();

            HystrixPlugins.reset();
            HystrixPlugins instance = HystrixPlugins.getInstance();
            instance.registerConcurrencyStrategy(this);
            instance.registerCommandExecutionHook(commandExecutionHook);
            instance.registerEventNotifier(eventNotifier);
            instance.registerMetricsPublisher(metricsPublisher);
            instance.registerPropertiesStrategy(propertiesStrategy);
        } catch (Exception e) {
   
   
            System.out.println("策略注册失败");
        }
    }

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
   
   
        //线程A获取请求对象
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //把请求对象放到新的线程中
        return new WrappedCallable<>(callable, requestAttributes);
    }

    @Override
    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                            HystrixProperty<Integer> corePoolSize,
                                            HystrixProperty<Integer> maximumPoolSize,
                                            HystrixProperty<Integer> keepAliveTime,
                                            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
   
   
        return this.hystrixConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
                unit, workQueue);
    }

    @Override
    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                            HystrixThreadPoolProperties threadPoolProperties) {
   
   
        return this.hystrixConcurrencyStrategy.getThreadPool(threadPoolKey, threadPoolProperties);
    }

    @Override
    public BlockingQueue<Runnable> getBlockingQueue(int maxQueueSize) {
   
   
        return this.hystrixConcurrencyStrategy.getBlockingQueue(maxQueueSize);
    }

    @Override
    public <T> HystrixRequestVariable<T> getRequestVariable(HystrixRequestVariableLifecycle<T> rv) {
   
   
        return this.hystrixConcurrencyStrategy.getRequestVariable(rv);
    }

    static class WrappedCallable<T> implements Callable<T> {
   
   
        private final Callable<T> target;
        private final RequestAttributes requestAttributes;

        public WrappedCallable(Callable<T> target, RequestAttributes requestAttributes) {
   
   
            this.target = target;
            this.requestAttributes = requestAttributes;
        }

        @Override
        public T call() throws Exception {
   
   
            try {
   
   
                //把A线程传入过来的请求对象，设置到B线程的RequestContextHolder
                RequestContextHolder.setRequestAttributes(requestAttributes);
                return target.call();
            } finally {
   
   
                RequestContextHolder.resetRequestAttributes();
            }
        }
    }
}

到这里拦截器模块就搭建结束了，你还需要把这个模块依赖到资源服务器中，即给“security-resource-server” 导入依赖 “security-resource-common”，然后启动服务测试。

5.服务之间授权-客户端模式

5.1.问题描述

上面服务之间授权的场景是用户发起的请求需求多个服务完成，然后有了服务之间的授权，有一种场景就是服务之间的调用可能和用户上下文无关。

比如有这样一个场景，由于项目设计的问题，在做微服务重构时导致认证中心AuthServer在做认证时需要调用另外一个微服务SystemServer来加载用来的权限列表，即：用户认证表和用户权限表不在同一个数据库中，当然解决方案也有很多，比如强行把权限和认证表放在一个库，这个不是今天讨论的重点。

现在的问题是SystemServer是做了权限控制的，也就是说客户端向AuthServer提交认证请求获取Token，而AuthServer需要调用SystemServer加载用户的权限才能生成Token,而加载权限又需要先得有一个Token才行，这不就矛盾了么？

这里我要说的解决方案就是给AuthServer添加一个Feign的拦截器，在拦截器中采用客户端模式生成一个临时的Token向SystemServer发起请求加载权限列表然后再为客户端颁发正式的Token

为什么采用客户端模式？因为服务之间是绝对信任的，而且只是需要颁发一个临时的Token而已，和用户上下文无关，这个Token并不是为用户生成的Token，只是服务之间调用需要的临时Token

5.2.Feign的拦截器

这次的拦截器和上一篇文章的拦截器的定义方式一样，只不过上一次是转发用户的Token,而这一次是自己生成一个临时的Token，代码如下：

@Component
@Slf4j
public class OAuth2FeignRequestInterceptor implements RequestInterceptor {
   
   

    private static String TEMPTOKENURL = "http://localhost:3000/oauth/token?client_id=%s&client_secret=%s&grant_type=client_credentials";

    //请求头中的token
    private final String AUTHORIZATION_HEADER = "Authorization";

    @Override
    public void apply(RequestTemplate requestTemplate) {
   
   
        //requestTemplate:feign底层用来发请求的http客户端
        //1.使用客户端模式生成一个临时的Token
        Map<String, String> tokenMap = HttpUtil.sendPost(String.format(TEMPTOKENURL, "temp", "123"));
        ValidUtils.assertNotNull(tokenMap,"服务调用失败[临时Token获取失败]");

        log.info("Feign拦截器添加临时Token到请求头：{}",tokenMap);

        //2.添加到Feign的请求头
        requestTemplate.header(AUTHORIZATION_HEADER,"Bearer "+tokenMap.get("access_token"));
    }
}

5.4.Http工具类

http工具用到了httpclient包

 <dependencies>
     <dependency>
         <groupId>org.apache.httpcomponents</groupId>
         <artifactId>httpclient</artifactId>
         <version>4.5.5</version>
     </dependency>
   <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.59</version>
     </dependency>
 </dependencies>

工具类

public class HttpUtil {
   
   

    //发送Post请求，注意：参数使用？方式带着URL后面
    public static Map<String,String> sendPost(String url) {
   
   
        // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Post请求
        HttpPost httpPost = new HttpPost(url);
        // 响应模型
        CloseableHttpResponse response = null;
        try {
   
   
            // 由客户端执行(发送)Post请求
            response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (responseEntity != null) {
   
   
                return JSON.parseObject(EntityUtils.toString(responseEntity),Map.class);
            }
        } catch (Exception e) {
   
   
            e.printStackTrace();
        } finally {
   
   
            try {
   
   
                // 释放资源
                if (httpClient != null) {
   
   
                    httpClient.close();
                }
                if (response != null) {
   
   
                    response.close();
                }
            } catch (IOException e) {
   
   
                e.printStackTrace();
            }
        }
        return null;
    }
}

总结

到这里就结束了，文章介绍了两种微服务之间的授权方式，一种是和用户上下文有关的请求，通过Feign的拦截器转发用户请求中的Token的给下游微服务，二种是微服务之间调用可能和当前用户上下文无关，我们采用在拦截器中采用客户端模式生成一个Token转发给下游服务的方式，希望对你有所帮助