资源服务器授权以及OAuth2对接微服务

/**
 * @Auther: csp1999
 * @Date: 2021/01/26/19:41
 * @Description: 资源授权配置（访问该微服务时，需要校验令牌）
 */
@Configuration
@EnableResourceServer // 开启资源校验服务 ---> 令牌校验
// 开启全局方法安全校验（方法权限控制：不同权限的登录用户，可以访问的方法不同）
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)// 激活方法上的PreAuthorize注解
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "public.key";
    /**
     * 定义JwtTokenStore
     *
     * @param jwtAccessTokenConverter
     * @return
     */
    @Bean
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }
    /**
     * 定义JJwtAccessTokenConverter
     *
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setVerifierKey(getPubKey());
        return converter;
    }
    /**
     * 获取非对称加密的公钥Key
     *
     * @return 公钥 Key
     */
    private String getPubKey() {
        Resource resource = new ClassPathResource(PUBLIC_KEY);
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
            BufferedReader br = new BufferedReader(inputStreamReader);
            return br.lines().collect(Collectors.joining("\n"));
        } catch (IOException ioe) {
            return null;
        }
    }
    /**
     * Http安全配置，对每个到达系统的http请求链接进行校验
     *
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        // 所有请求必须认证通过
        http.authorizeRequests()
                // 下边的路径放行
                // 放行的请求路径不用登陆也可以访问
                .antMatchers(
                        "/user/add","/user/load/*"). // 配置地址放行
                permitAll()
                .anyRequest().
                authenticated();    // 其他地址需要认证授权
    }
}

/**
 * @Auther: csp1999
 * @Date: 2021/01/24/20:17
 * @Description: 全局过滤器: 用于鉴权(获取令牌  + 解析令牌  + 判断令牌是否合法)
 */
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
    // 令牌头
    private static final String AUTHORIZE_TOKEN = "Authorization";
    /**
     * 全局过滤器
     *
     * @param exchange
     * @param chain
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求对象
        ServerHttpRequest request = exchange.getRequest();
        // 2.获取响应对象
        ServerHttpResponse response = exchange.getResponse();
        // 获取请求的URI
        String path = request.getURI().getPath();
        // 3.未登录状态下只放行登录login和搜索search
        if (path.startsWith("/api/user/login") || path.startsWith("/api/brand/search/")) {
            // 直接放行
            return chain.filter(exchange);
        }
        // 4.判断是否为登录的URL 如果不是则权限校验
        // 4.1 从头header中获取令牌数据
        String token = request.getHeaders().getFirst(AUTHORIZE_TOKEN);
        // 如果为true：说明令牌在header中， false：令牌不在header中，将令牌封装入header，再传递给其他微服务
        boolean hasToken = true;
        // 如果header中没有token数据
        if(StringUtils.isEmpty(token)){
            // 4.2 从cookie中中获取令牌数据
            HttpCookie first = request.getCookies().getFirst(AUTHORIZE_TOKEN);
            if(first!=null){
                token=first.getValue();// 就是令牌的数据
            }
            // 令牌不在header中
            hasToken = false;
        }
        // 如果cookie中也没有令牌数据，则从请求参数中获取
        if(StringUtils.isEmpty(token)){
            // 4.3 从请求参数中获取令牌数据
            token= request.getQueryParams().getFirst(AUTHORIZE_TOKEN);
            // 令牌不在header中
            hasToken = false;
        }
        // 如果请求参数中仍然没有token数据
        if(StringUtils.isEmpty(token)){
            // 4.4. 则，结束，响应UNAUTHORIZED状态码405.
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        // 如果得到token数据，则：
        // 5.解析令牌数据(判断解析是否正确,正确就放行,否则就结束)
        try {
            // 1.借助jwt工具类解析token校验令牌
            // Claims claims = JwtUtil.parseJWT(token);
            // 2.借助oautho2校验令牌
            // 如果请求头中没有token：
            if (!hasToken) {
                // token令牌不为空，则判断令牌是否有bearer前缀，如果没有则添加该前缀
                if (!token.startsWith("bearer") && !token.startsWith("Bearer")) {
                    token = "bearer" + token;
                }
                // 如果有前缀，放行
                // 放行之前，将令牌封装到头文件中(这一步是为了方便AUTH2校验令牌)
                request.mutate().header(AUTHORIZE_TOKEN, token);
            }
        } catch (Exception e) {
            e.printStackTrace();
            // 解析失败，响应状态码401
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        // 放行
        return chain.filter(exchange);
    }
    /**
     * 过滤器执行顺序
     *
     * @return
     */
    @Override
    public int getOrder() {
        // 首位
        return 0;
    }
}

/**
 * 查询User全部数据
 *
 * @return
 */
//@PreAuthorize("hasAnyRole('user','admin')")
// 添加权限：只允许管理员admin角色访问，不允许其他角色访问
@PreAuthorize("hasAnyRole('admin')")
@GetMapping
public Result<List<User>> findAll() {
    // 调用UserService实现查询所有User
    List<User> list = userService.findAll();
    return new Result<List<User>>(true, StatusCode.OK, "查询成功", list);
}

/**
 * 客户端信息配置
 *
 * @param clients
 * @throws Exception
 */
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    // 静态客户端信息配置
    /*
    clients.inMemory()
            .withClient("changgou")          // 客户端id
            .secret("changgou")                     // 秘钥
            .redirectUris("http://localhost")       // 重定向地址
            .accessTokenValiditySeconds(3600)       // 访问令牌有效期
            .refreshTokenValiditySeconds(3600)      // 刷新令牌有效期
            .authorizedGrantTypes(
                    "authorization_code",           // 根据授权码生成令牌
                    "client_credentials",           // 客户端认证
                    "refresh_token",                // 刷新令牌
                    "password")                     // 密码方式认证
            .scopes("app");                         // 客户端范围，名称自定义，必填
    */
    // 从数据库中获取上面的数据：
    clients.jdbc(dataSource).clients(clientDetails());// 从数据库加载客户端信息
}

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    //====================================客户端信息认证 开始====================================
    // 取出身份，如果身份为空说明没有认证
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    // 没有认证统一采用httpbasic认证，httpbasic中存储了client_id和client_secret，开始认证client_id和client_secret
    if (authentication == null) {
        ClientDetails clientDetails = clientDetailsService.loadClientByClientId(username);
        if (clientDetails != null) {
            // 秘钥
            String clientSecret = clientDetails.getClientSecret();
            // 1.静态方式
            //return new User(
            //        username, // 客户端id
            //        new BCryptPasswordEncoder().encode(clientSecret), // 客户端密钥->加密操作
            //        AuthorityUtils.commaSeparatedStringToAuthorityList(""));// 权限
            // 2.数据库查找方式
            return new User(
                    username,// 客户端id
                    clientSecret,// 客户端密钥->不需要再加密操作，因为数据库中已经加密
                    AuthorityUtils.commaSeparatedStringToAuthorityList(""));// 权限
        }
    }
    //====================================客户端信息认证 结束====================================
    ...
}

/**
  * 登录方法：
  * 1.密码模式认证-授权方式：grant_type=password
  *
  * @param username 2.账号 szitheima
  * @param password 3.密码 szitheima
  * @return
  */
 @RequestMapping("/login")
 public Result<Map> login(String username, String password) {
     if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
         throw new RuntimeException("用户名/密码不允许为空");
     }
     // 申请令牌：调用loginService的login方法进行登录，并返回生成的令牌数据
     AuthToken authToken = loginService.login(username, password, clientId, clientSecret, GRAND_TYPE);
     // 设置到cookie中
     this.saveCookie(authToken.getAccessToken());
     return new Result<>(true, StatusCode.OK, "令牌生成成功", authToken);
 }
 // 保存token到cookie中
 private void saveCookie(String token) {
     HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
     CookieUtil.addCookie(response, cookieDomain, "/", "Authorization", token, cookieMaxAge, false);
 }

/**
 * @Auther: csp1999
 * @Date: 2021/01/27/14:19
 * @Description: 用户微服务feign客户端接口
 */
@FeignClient(value = "changgou-user")
@RequestMapping(value = "/user")
public interface UserFeign {
    /***
     * 根据ID查询User数据
     * @param id
     * @return
     */
    @GetMapping({
    "/load/{id}"})
    //@GetMapping({"/{id}", "/load/{id}"})不能这样写！
    public Result<User> findById(@PathVariable String id);
}

/***
 * 根据ID查询User数据
 * @param id
 * @return
 */
@GetMapping({
    "/{id}","/load/{id}"})
public Result<User> findById(@PathVariable String id) {
    // 调用UserService实现根据主键查询User
    User user = userService.findById(id);
    return new Result<User>(true, StatusCode.OK, "查询成功", user);
}

/**
 * Http安全配置，对每个到达系统的http请求链接进行校验
 *
 * @param http
 * @throws Exception
 */
@Override
public void configure(HttpSecurity http) throws Exception {
    // 所有请求必须认证通过
    http.authorizeRequests()
            // 下边的路径放行
            // 放行的请求路径不用登陆也可以访问
            .antMatchers(
                    "/user/add","/user/load/*"). // 配置地址放行
            permitAll()
            .anyRequest().
            authenticated();    // 其他地址需要认证授权
}

//====================================用户信息认证 开始====================================
if (StringUtils.isEmpty(username)) {
    return null;
}
// 从数据库加载查询用户信息
Result<com.changgou.user.pojo.User> userResult = userFeign.findById(username);
// 判空
if (userResult == null || userResult.getData() == null) {
    return null;
}
// 根据用户名查询用户信息
//String pwd = new BCryptPasswordEncoder().encode("szitheima");
String pwd = userResult.getData().getPassword();
// 创建User对象
String permissions = "user,admin";// 指定用户的角色身份，普通用户user/admin用户
UserJwt userDetails = new UserJwt(username, pwd, AuthorityUtils.commaSeparatedStringToAuthorityList(permissions));
//====================================用户信息认证 结束====================================

/**
 * 自定义授权认证类
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    ClientDetailsService clientDetailsService;
    @Autowired
    private UserFeign userFeign;
    /**
     * 自定义授权认证
     *
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //====================================客户端信息认证 开始====================================
        // 取出身份，如果身份为空说明没有认证
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        // 没有认证统一采用httpbasic认证，httpbasic中存储了client_id和client_secret，开始认证client_id和client_secret
        if (authentication == null) {
            ClientDetails clientDetails = clientDetailsService.loadClientByClientId(username);
            if (clientDetails != null) {
                // 秘钥
                String clientSecret = clientDetails.getClientSecret();
                // 1.静态方式
                //return new User(
                //        username, // 客户端id
                //        new BCryptPasswordEncoder().encode(clientSecret), // 客户端密钥->加密操作
                //        AuthorityUtils.commaSeparatedStringToAuthorityList(""));// 权限
                // 2.数据库查找方式
                return new User(
                        username,// 客户端id
                        clientSecret,// 客户端密钥->不需要再加密操作，因为数据库中已经加密
                        AuthorityUtils.commaSeparatedStringToAuthorityList(""));// 权限
            }
        }
        //====================================客户端信息认证 结束====================================
        //====================================用户信息认证 开始====================================
        if (StringUtils.isEmpty(username)) {
            return null;
        }
        // 从数据库加载查询用户信息
        Result<com.changgou.user.pojo.User> userResult = userFeign.findById(username);
        // 判空
        if (userResult == null || userResult.getData() == null) {
            return null;
        }
        // 根据用户名查询用户信息
        //String pwd = new BCryptPasswordEncoder().encode("szitheima");
        String pwd = userResult.getData().getPassword();
        // 创建User对象
        String permissions = "user,admin";// 指定用户的角色身份，普通用户user/admin用户
        UserJwt userDetails = new UserJwt(username, pwd, AuthorityUtils.commaSeparatedStringToAuthorityList(permissions));
        //====================================用户信息认证 结束====================================
        //userDetails.setComy(songsi);
        return userDetails;
    }
}

/**
 * @Author: csp1999
 * @Date: 2020/7/6 8:01
 * @Description: OAUTH2 认证授权微服务启动类
 */
@SpringBootApplication
@EnableDiscoveryClient
//@MapperScan(basePackages = "com.changgou.auth.dao")
@EnableFeignClients("com.changgou.user.feign")
public class OAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(OAuthApplication.class, args);
    }
    @Bean(name = "restTemplate")
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}