一、搭建注册中心

1.1 需求分析

回顾技术方案如下：

分布式系统认证技术方案

1、UAA认证服务负责认证授权。

2、所有请求经过网关到达 微服务 。

3、网关负责 鉴权 客户端以及请求转发。

4、网关将token解析后传递给微服务，微服务进行授权。

1.2 注册中心

所有的微服务的请求都经过网关，网关从认证中心读取微服务的地址，将请求转发至微服务，注册中心采用Eureka。

1、创建 maven 工程，工程结构如下：

注册中心工程结构

2、 pom 依赖如下：

 <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="#34; xmlns:xsi="#34;
         xsi:schemaLocation=" #34;>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.pengjs.book.admin.distributed.security</groupId>
        <artifactId>distributed-security</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.pengjs.book.admin.distributed.security.discovery</groupId>
    <artifactId>distributed-security-discovery</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>distributed-security-discovery</name>
    <description>distributed-security-discovery</description>

    <properties>
        < java .version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId> Spring -boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix- eureka -server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>  

2、配置文件application.yml：

 spring:
  application:
    name: distributed-discovery

server:
  port: 53000
eureka:
  server:
    # 关闭服务自我保护，客户端 心跳检测 15分钟内错误达到80%的服务会开启保护，导致别人还认为是好用的服务
    enable-self-preservation: false
    # 清理间隔（单位毫秒，默认60*1000），5秒将客户端剔除的服务在服务注册中心列表中剔除
    eviction-interval-timer-in-ms: 10000
    # eureka是CAP理论基于AP策略，为了保证一致性，关闭此切换CP，默认不关闭，false关闭
    shouldUseReadOnlyResponseCache: true
  client:
    register-with-eureka: false # false: 不作为一个客户端注册到注册中心
    fetch-registry: false # 为true时，可以启动，但是异常：cannot execute request on any known server
    instance-info-replication-interval-seconds: 10
    service-url:
      defaultZone: {server.port}/eureka/
  instance:
    hostname: ${spring.cloud.client.ip-address}
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance-id:${server.port}}  

3、注册中心启动类

 @SpringBootApplication
@EnableEurekaServer
public class DistributedSecurityDiscoveryApplication {

    public static void main(String[] args) {
        SpringApplication.run(DistributedSecurityDiscoveryApplication.class, args);
    }

}  

二、搭建网关工程

2.1 角色分析

网关整合 OAuth2.0 有 两种思路 ，一种是认证服务器生成jwt令牌，所有请求统一在网关层验证，判断权限等操作；另外一种是由资源服务器处理，网关只做请求转发。

我们选用第一种，把API网关作为OAuth2.0的资源服务器角色，实现接入客户端权限拦截、令牌解析并转发当前登录用户信息（jsonToken）给微服务，这样下游微服务就不需要关心令牌格式解析以及OAuth2.0相关机制了。

API网关在认证授权体系里主要负责两件事：

（1）作为OAuth2.0的 资源服务器 角色，实现接入方权限拦截。

（2）令牌解析并转发当前登录用户信息（明文token）给微服务。

微服务拿到明文token（明文token中包含登录用户的身份和权限信息）后也需要做两件事：

（1）用户授权拦截（看当前用户是否有权限访问资源）。

（2）将用户信息存储进当前线程上下文（有利于后续业务逻辑随时获取当前用户信息）。

2.2 创建工程

网关工程结构如下：

网关工程结构

1、pom依赖

 <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="#34; xmlns:xsi="#34;
    xsi:schemaLocation=" #34;>
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.pengjs.book.admin.distributed.security</groupId>
        <artifactId>distributed-security</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.pengjs.book.admin.distributed.security.gateway</groupId>
    <artifactId>distributed-security-gateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>distributed-security-gateway</name>
    <description>distributed-security-gateway</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.netflix.hystrix</groupId>
            <artifactId>hystrix-javanica</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-jwt</artifactId>
        </dependency>
        <dependency>
            <groupId> javax .interceptor</groupId>
            <artifactId>javax.interceptor-api</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId> fastjson </artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>  

2、配置文件application.yml

 spring:
  application:
    name: gateway-server
  main:
    allow-bean-definition-overriding: true

server:
  port: 53010

logging:
  level:
    root: info
    org:
      springframework: info

zuul:
  retryable: true
  ignored-services: "*"
  add-host-header: true
  sensitive-headers: "*"
  routes:
    uaa-service:
      stripPrefix: false
      path: /uaa/**
    order-service:
      stripPrefix: false
      path: /order/**

eureka:
  client:
    service-url:
      defaultZone: 
  instance:
    preferIpAddress: true
    instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance-id:${server.port}}

management:
  endpoints:
    web:
      exposure:
        include: refresh,health,info,env
feign:
  hystrix:
    enabled: false
  compression:
    request:
      enabled: true
      mime-types[0]: text/xml
      mime-types[1]: application/xml
      mime-types[2]: application/json
      min-request-size: 2048
    response:
      enabled: true  

统一认证服务（UAA）与统一订单服务都是网关下微服务，需要在网关上新增路由配置：

 zuul:
  retryable: true
  ignored-services: "*"
  add-host-header: true
  sensitive-headers: "*"
  routes:
    uaa-service:
      stripPrefix: false
      path: /uaa/**
    order-service:
      stripPrefix: false
      path: /order/**  

上面配置了网关接收的请求url若符合/order/**表达式，则将被转发到order-service（统一订单服务）中。

3、启动类

 @SpringBootApplication
@EnableZuulProxy
@EnableDiscoveryClient
public class DistributedSecurityGatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(DistributedSecurityGatewayApplication.class, args);
    }
}  

三、网关资源服务配置

3.1 配置资源服务

在ResourceServerConfig中定义资源服务资源，主要配置的内容就是定义一些匹配规则，描述某个接入客户端需要什么样的权限才能访问某个微服务：

 @ Configuration 
public class ResourceServerConfig {

    /**
     * 资源列表，与服务端的resourceIds一致
     */
    private static final String RESOURCE_ID = "res1";

    /**
     * 从TokenConfig中注入tokenStore
     */
    @Autowired
    private TokenStore tokenStore;

    /**
     * uaa资源服务配置
     */
    @Configuration
    @EnableResourceServer
    public class UaaServerConfig extends ResourceServerConfigurerAdapter {

        @ Override 
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
            resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
                    .stateless(true);
        }

        @Override
        public void configure(HttpSecurity http) throws Exception {
            // uaa认证全部放行
            http.authorizeRequests()
                    .antMatchers("/uaa/**").permitAll();
        }
    }

    /**
     * order资源服务配置
     */
    @Configuration
    @EnableResourceServer
    public class OrderServerConfig extends ResourceServerConfigurerAdapter {

        @Override
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
            resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
                    .stateless(true);
        }

        @Override
        public void configure(HttpSecurity http) throws Exception {
            // order需要有ROLE_API的scope
            http.authorizeRequests()
                    .antMatchers("/order/**")
                    .access("#oauth2.hasScope('ROLE_API')");
        }

    }

    // 配置其他资源服务。。。

}  

3.2 安全配置

 /**
 * 安全访问控制
 */
@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 安全拦截机制（最重要）
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 网关：所有的请求都放行，只在resource config中拦截
        http.authorizeRequests()
                .antMatchers("/**").permitAll()
                .and().csrf().disable();
    }
}  

四、转发明文token给微服务

通过Zuul过滤器的方式实现，目的是让上下游微服务能够很方便的获取到当前的登录用户信息（明文token）

（1）实现Zuul前置过滤器，完成当前登录用户信息提取，并放入转发到微服务的request中 ：

 /**
 * token传递拦截
 */
public class AuthFilter extends ZuulFilter {

    @Override
    public String filterType() {
        // 请求之前进行拦截
        return "pre";
    }

    @Override
    public int filterOrder() {
        // 最优先，数值越小越优先
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        // 4. 转发给具体的微服务
        RequestContext context = RequestContext.getCurrentContext();
        // 1. 从安全的上下文中获取当前用户对象
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        // 无token直接访问网关内资源的情况，目前只有uaa服务直接暴露
        if (!(authentication instanceof OAuth2Authentication)) {
            // 不解析
            return null;
        }
        OAuth2Authentication oAuth2Authentication = (OAuth2Authentication) authentication;
        Authentication userAuthentication = oAuth2Authentication.getUserAuthentication();
        // 2. 获取当前用户身份信息
        String principals = userAuthentication.getName();

        // 3. 获取当前用户权限信息
        List<String> authorities = new ArrayList<>();
        userAuthentication.getAuthorities().forEach(s -> authorities.add(((GrantedAuthority) s).getAuthority()));
        OAuth2Request oAuth2Request = oAuth2Authentication.getOAuth2Request();
        Map<String, String> requestParameters = oAuth2Request.getRequestParameters();

        // 4. 把身份信息和权限信息中，加入到http的header中
        // 保留原本的基本信息
        Map<String, Object> jsonToken = new HashMap<>(requestParameters);
        if (userAuthentication != null) {
            jsonToken.put("principal", principals);
            jsonToken.put("authorities", authorities);
        }
        // 5. 组装明文token，转发给微服务。放入header，名称json-token
        context.addZuulRequestHeader("json-token", EncryptUtil.encodeUTF8StringBase64(JSON.toJSONString(jsonToken)));
        return null;
    }
}  

（2）将Filter纳入到Spring容器 ：

配置AuthFilter：

 @Configuration
public class ZuulConfig {

    @Bean
    public AuthFilter preFilter() {
        return new AuthFilter();
    }

    @Bean
    public FilterRegistrationBean corsFilter() {
        final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        final CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        config.setMaxAge(18000L);
        source.registerCorsConfiguration("/**", config);
        CorsFilter corsFilter = new CorsFilter(source);
        FilterRegistrationBean bean = new FilterRegistrationBean(corsFilter);
        bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return bean;
    }

}  

五、微服务解析令牌并鉴权

当微服务收到明文token后，该怎么鉴权拦截呢？自己实现一个Filter？自己解析明文token，自己定义一套资源访问策略？

能不能适配Spring Security呢，是不是突然想起了前面我们实现的Spring Security基于token认证的例子。咱们还是拿统一订单服务作为网关下游微服务，对它进行改造，增加 微服务用户鉴权拦截 功能。

（1）增加测试资源

OrderController增加以下endpoint：

 @RestController
public class OrderController {

    /**
     * 流程：当携带token访问这个资源的时候，会通过远程的service去请求地址
     * 校验token是否合法
     * @return
     */
    @GetMapping(value = "/r1")
    // 拥有p1权限方可访问此URL
    @PreAuthorize("hasAnyAuthority('p1')")
    public String r1() {
        // 通过spring security api获取当前登录用户
        UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        // String username = (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        // return username + "访问资源1";
        // return userDto.getUsername() + "访问资源1";
        return JSON.toJSONString(userDto) + "访问资源1";
    }

    @GetMapping(value = "/r2")
    // 拥有p2权限方可访问此URL
    @PreAuthorize("hasAnyAuthority('p2')")
    public String r2() {
        UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        // return userDto.getUsername() + "访问资源2";
        return JSON.toJSONString(userDto) + "访问资源2";
    }

}  

（2）Spring Security配置

开启方法保护，并增加Spring配置策略，除了/login方法不受保护（统一认证要调用），其他的资源全部需要认证才能访问。

 @Configuration
@EnableResourceServer
// 或者是单独配置WebSecurityConfig也可以
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    /**
     * 资源列表，与服务端的resourceIds一致
     */
    private static final String RESOURCE_ID = "res1";

    /**
     * 从TokenConfig中注入tokenStore
     */
    @Autowired
    private TokenStore tokenStore;

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        // 资源id
        resources.resourceId(RESOURCE_ID)
                // 验证令牌的服务
                // .tokenServices(tokenService())
                // 不再使用验证令牌服务，让其自己验证
                .tokenStore(tokenStore)
                .stateless(true);
    }

    /**
     * 资源访问策略
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/**")
                // .access("#oauth2.hasScope('all')") // 所有的请求都必须有scope=all，跟服务端一致
                .access("#oauth2.hasScope('ROLE_ADMIN')") // 所有的请求都必须有scope=ROLE_ADMIN，跟服务端一致
                .and().csrf().disable() // 关闭CSRF
                // 基于token的方式，session就不用再记录了
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

}  

综合以上配置，共定义了三个资源，拥有p1权限才可以访问r1资源，拥有p2权限才可以访问r2资源。

（3）定义Filter拦截token，并形成Spring Security的Authentication对象

 @Component
public class TokenAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("json-token");
        if (null != token) {
            // 1. 解析token
            // 解码
            String json = EncryptUtil.decodeUTF8StringBase64(token);
            // 将token转成json对象
            JSONObject userJson = JSON.parseObject(json);
            // UserDto user = new UserDto();
            // // 用户身份信息
            // user.setUsername(userJson.getString("principal"));
            // uaa那边存的是整个用户的信息，这里就可以直接转为UserDto
            UserDto user = JSON.parseObject(userJson.getString("principal"), UserDto.class);
            // 用户权限
            JSONArray authoritiesArray = userJson.getJSONArray("authorities");
            String[] authorities = authoritiesArray.toArray(new String[authoritiesArray.size()]);

            // 2. 新建并填充authentication（身份信息和权限）
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(user,
                    null, AuthorityUtils.createAuthorityList(authorities));
            // 设置details
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            // 3. 将authentication保存到安全上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        // 过滤器继续往前走
        filterChain.doFilter(request, response);
    }
}  

经过上边的过滤器，资源服务中就可以方便的获取到用户的身份信息：

 UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();  

六、集成测试

本案例测试过程描述：

1、采用OAuth2.0的密码模式从UAA中获取token

2、使用该token通过网关访问订单服务的测试资源

（1）通过网关访问UAA的授权获取令牌，获取token，注意网关端口是53010 ：

通过网关访问UAA的授权获取令牌

（2）通过网关UAA校验token ：

通过网关UAA校验token

（3）带上token访问资源 ：

带上token访问资源

七、扩展用户信息

7.1 需求分析

目前jwt令牌存储了用户身份信息、权限信息，网关将token明文转发给微服务使用，目前用户身份信息锦包含了用户的账户，微服务还需要用户的ID、手机号等重要信息。

在认证阶段DaoAuthenticationProvider会调用UserDetailsService查询用户信息，这里是可以获取到齐全的用户信息的。由于JWT令牌中用户身份信息来源于UserDetails，UserDetails中仅定义了username为用户的身份信息，这里有两个思路，第一是可以扩展UserDetails，使之包含更多的自定义属性，第二也可以扩展username的内容，比如存入json数据内容作为username的内容。相比较而言，方案二比较简单还不用破坏UserDetails的结构，我们采用方案二。

7.2 修改UserDetailsService

从数据库查询到user，将整体的user转成json存入到UserDetails对象中。

     @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 将来连接数据库根据账号查询用户信息
        // 登录账号
        System.out.println("username=" + username);
        UserDto userByUsername = userDao.getUserByUsername(username);
        if (null == userByUsername) {
            // 如果用户查询不到，返回null，返回给provider，由provider来抛异常
            return null;
        }
        // 根据用户的ID查询用户的权限
        List<String> permissions = userDao.findPermissionByUserId(userByUsername.getId());
        String[] permissionArray = new String[permissions.size()];
        permissions.toArray(permissionArray);
        // 将userByUsername转换为json，整体存入到userDetails
        String principal = JSON.toJSONString(userByUsername);
        UserDetails userDetails = User.withUsername(principal).password(userByUsername.getPassword())
                .authorities(permissionArray).build();
        return userDetails;
    }  

7.3 修改资源服务器过滤器

资源服务中的过滤器负责从Header中解析json-token，从中即可拿到网关放入的用户身份信息，代码如下：

 @Component
public class TokenAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("json-token");
        if (null != token) {
            // 1. 解析token
            // 解码
            String json = EncryptUtil.decodeUTF8StringBase64(token);
            // 将token转成json对象
            JSONObject userJson = JSON.parseObject(json);
            // UserDto user = new UserDto();
            // // 用户身份信息
            // user.setUsername(userJson.getString("principal"));
            // uaa那边存的是整个用户的信息，这里就可以直接转为UserDto
            UserDto user = JSON.parseObject(userJson.getString("principal"), UserDto.class);
            // 用户权限
            JSONArray authoritiesArray = userJson.getJSONArray("authorities");
            String[] authorities = authoritiesArray.toArray(new String[authoritiesArray.size()]);

            // 2. 新建并填充authentication（身份信息和权限）
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(user,
                    null, AuthorityUtils.createAuthorityList(authorities));
            // 设置details
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

            // 3. 将authentication保存到安全上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        // 过滤器继续往前走
        filterChain.doFilter(request, response);
    }
}