微服务中使用Spring Security + OAuth 2.0 + JWT 搭建认证授权服务

最新推荐文章于 2024-05-21 20:07:23 发布
最新推荐文章于 2024-05-21 20:07:23 发布
阅读量2.7k 收藏 23
点赞数 4
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012373161/article/details/112619667
版权

微服务中使用Spring Security + OAuth 2.0 + JWT 搭建认证授权服务

OAuth 是一种用来规范令牌（Token）发放的授权机制，主要包含了四种授权模式：授权码模式、简化模式、密码模式和客户端模式。关于 OAuth 更多介绍可访问 理解OAuth 2.0 查看。本文主要以 密码模式 来实现用户认证和授权。

搭建项目

项目代码已上传至 Github 。

本例项目以微服务为基础，仅实现认证服务和资源服务，其他如网关、服务管理、配置中心等省略，本文重点是使用 Spring Security + OAuth 2.0 + JWT 实现用户认证授权。

项目结构如下图，认证服务和资源服务分离，认证服务主要是提供令牌和校验令牌服务。

项目结构

父工程 pom.xml 配置如下，主要是指定依赖包的版本：

    <!-- 依赖包版本管理 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.boot.version>2.2.2.RELEASE</spring.boot.version>
        <spring.cloud.version>Hoxton.SR9</spring.cloud.version>
        <spring.cloud.alibaba.version>2.2.1.RELEASE</spring.cloud.alibaba.version>
        <mysql.driver.version>8.0.16</mysql.driver.version>
        <lombok.version>1.16.18</lombok.version>
        <druid.version>1.1.10</druid.version>
    </properties>

    <dependencyManagement>

        <dependencies>

            <!-- spring boot 2.2.2.RELEASE -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- spring cloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Spring Cloud Alibaba -->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- mysql driver -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.driver.version}</version>
            </dependency>

            <!-- lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!-- druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid.version}</version>
            </dependency>

        </dependencies>

    </dependencyManagement>

搭建认证服务

引入依赖

  1. 在 pom.xml 引入以下依赖：
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
        
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-oauth2-jose</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
</dependency>

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

spring-cloud-starter-oauth2 已经包含了 spring-cloud-starter-security、spring-security-oauth2、spring-security-jwt 这3个依赖，只需引入 spring-cloud-starter-oauth2 即可。

  1. 编辑 application.yml，添加数据库连接参数：
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://127.0.0.1:3307/oauth_server?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 1
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      initial-size: 5
      max-active: 50
      max-wait: 60000
      min-idle: 5

准备工作

  1. 新建 UserDTO 类，实现 org.springframework.security.core.userdetails.UserDetails 接口；
/**
 * @author lanweihong 986310747@qq.com
 */
@Data
public class UserDTO implements Serializable, UserDetails {
    private static final long serialVersionUID = 5538522337801286424L;

    private String userName;
    private String password;
    private Set<SimpleGrantedAuthority> authorities;

    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }

    public String getPassword() {
        return this.password;
    }

    public String getUsername() {
        return this.userName;
    }

    public boolean isAccountNonExpired() {
        return true;
    }

    public boolean isAccountNonLocked() {
        return true;
    }

    public boolean isCredentialsNonExpired() {
        return true;
    }

    public boolean isEnabled() {
        return true;
    }
}
  1. 新建类 UserDetailsServiceImpl，实现 org.springframework.security.core.userdetails.UserDetailsService 接口，用于校验用户凭据。
@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    private PasswordEncoder passwordEncoder;

    @Autowired
    public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // TODO 实际开发中，这里请修改从数据库中查询...
        UserDTO user = new UserDTO();
        user.setUserName(username);
        // 密码为 123456 ，且加密
        user.setPassword(passwordEncoder.encode("123456"));
        return user;
    }
}

以上用户配置用于测试，任意用户名，但密码为 123456，实际生产中务必修改为从数据库中读取校验。

配置认证授权服务器

  1. 新建类 Oauth2ServerConfig，继承 org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter 类；在 Oauth2ServerConfig 类上 添加注解 @EnableAuthorizationServer 。

框架提供了几个默认的端点：

  • /oauth/authorize：授权端点
  • /oauth/token：获取令牌端点
  • /oauth/confirm_access：用户确认授权端点
  • /oauth/check_token：校验令牌端点
  • /oauth/error：用于在授权服务器中呈现错误
  • /oauth/token_key：获取 jwt 公钥端点
  1. 继承 AuthorizationServerConfigurerAdapter 类后，我们需要重写以下三个方法扩展实现我们的需求。

  • configure(ClientDetailsServiceConfigurer clients) ：用于定义、初始化客户端信息

  • configure(AuthorizationServerEndpointsConfigurer endpoints)：用于定义授权令牌端点及服务

  • configure(AuthorizationServerSecurityConfigurer security)：用于定义令牌端点的安全约束

配置客户端详细信息

ClientDetailsServiceConfigurer 用于定义 内存 中或 基于JDBC存储实现 的客户端，其重要的几个属性有：

  • clientId：客户端id，必填；
  • clientSecret：客户端密钥；
  • authorizedGrantTypes：客户端授权类型，有 5 种模式： authorization_code、password、client_credentials、implicit、refresh_token；
  • scope：授权范围；
  • accessTokenValiditySeconds：access_token 有效时间，单位为秒，默认为 12 小时；
  • refreshTokenValiditySeconds：refresh_token 有效时间，单位为秒，默认为 30 天；

客户端信息一般保存在 Redis 或 数据库中，本例中客户端信息保存在 MySQL 中；
基于JDBC存储 模式需要创建数据表，官方提供了建表的 SQL 语句，可访问 schema.sql 获取 SQL ；

  1. 使用以下 SQL（适用于MySQL） 来建表：
CREATE TABLE `oauth_client_details`  (
  `client_id` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `resource_ids` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `client_secret` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `scope` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `authorized_grant_types` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `web_server_redirect_uri` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `authorities` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `access_token_validity` int(11) NULL DEFAULT NULL,
  `refresh_token_validity` int(11) NULL DEFAULT NULL,
  `additional_information` varchar(4096) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `autoapprove` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`client_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  1. 添加一条客户端信息用于测试：
INSERT INTO `oauth_client_details` VALUES ('auth-server', NULL, '$2a$10$mcEwJ8qqhk2DYIle6VfhEOZHRdDbCSizAQbIwBR7tTuv9Q7Fca9Gi', 'all', 'password,refresh_token', '', NULL, NULL, NULL, NULL, NULL);

其中密码 123456 使用 BCryptPasswordEncoder 加密，加密后字符为 $2a$10$mcEwJ8qqhk2DYIle6VfhEOZHRdDbCSizAQbIwBR7tTuv9Q7Fca9Gi。

  1. 配置 ClientDetailsServiceConfigurer ，指定客户端信息：
@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    private final DataSource dataSource;
    
    private final PasswordEncoder passwordEncoder;

    @Autowired
    public Oauth2ServerConfig(DataSource dataSource, PasswordEncoder passwordEncoder) {
        this.dataSource = dataSource;
        this.passwordEncoder = passwordEncoder;
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 使用基于 JDBC 存储模式
        JdbcClientDetailsService clientDetailsService = new JdbcClientDetailsService(dataSource);
        // client_secret 加密
        clientDetailsService.setPasswordEncoder(passwordEncoder);
        clients.withClientDetails(clientDetailsService);
    }
}
配置授权令牌端点及服务

配置 AuthorizationServerEndpointsConfigurer 需要指定 AuthenticationManager 及 UserDetailService，尤其是使用密码模式时，必须指定 AuthenticationManager，否则会报 Unsupported grant type: password 错误。

  1. 新建 WebSecurityConfig 类，继承 org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter 类，重写 authenticationManagerBean() 方法，并定义需要用到的 PasswordEncoder；
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                // 支持跨域请求
                .cors()

                .and()
                // 禁用 CSRF
                .csrf().disable()

                .formLogin().disable()
                .httpBasic().disable()
                .logout().disable()

                .authorizeRequests()
                .antMatchers("/oauth/token").permitAll();

                .anyRequest().authenticated();
    }

    /**
     * 重写 authenticationManagerBean()
     * @return
     * @throws Exception
     */
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
  1. 配置 AuthorizationServerEndpointsConfigurer：
@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    private final UserDetailsServiceImpl userDetailsService;

    /**
     * 密码模式 grant_type:password 需指定 AuthenticationManager
     */
    private final AuthenticationManager authenticationManager;


    @Autowired
    public Oauth2ServerConfig(UserDetailsServiceImpl userDetailsService,
                              AuthenticationManager authenticationManager) {
        this.userDetailsService = userDetailsService;
        this.authenticationManager = authenticationManager;
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                // 开启密码模式授权
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService);
    }
}
使用 JWT 作为令牌格式
生成 JWT 密钥对

使用 JDK 的 keytool 工具生成 JKS 密钥对 jwt.jks，并将 jwt.jks 放到 resources 目录下。

定位至 JDK 目录下的 bin 目录，执行以下命令生成密钥对：

keytool -genkey -alias weihong -keyalg RSA -keypass 123456 -keystore jwt.jks -storepass 123456

参数说明：

-genkey 生成密钥

-alias 别名

-keyalg 密钥算法

-keypass 密钥口令

-keystore 生成密钥对的存储路径和名称

-storepass 密钥对口令
定义 token 转换器

在 Oauth2ServerConfig 类中定义 accessTokenConverter() 及 keyPair()：

    /**
     * token 转换器
     * 默认是 uuid 格式，我们在这里指定 token 格式为 jwt
     * 使用非对称加密算法对 token 签名
     * @return
     */
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        // 使用非对称加密算法对 token 签名
        converter.setKeyPair(keyPair());
        return converter;
    }

    @Bean
    public KeyPair keyPair() {
        // 从 classpath 目录下的证书 jwt.jks 中获取秘钥对
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("jwt.jks"), "lanweihong".toCharArray());
        return keyStoreKeyFactory.getKeyPair("weihong", "lanweihong".toCharArray());
    }
指定令牌存储策略为 JWT

配置 AuthorizationServerEndpointsConfigurer 的令牌存储策略为 JWT，指定 accessTokenConverter 为我们定义好的 accessTokenConverter()：

@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    private final UserDetailsServiceImpl userDetailsService;

    /**
     * 密码模式 grant_type:password 需指定 AuthenticationManager
     */
    private final AuthenticationManager authenticationManager;

    @Autowired
    public Oauth2ServerConfig(UserDetailsServiceImpl userDetailsService,
                              AuthenticationManager authenticationManager) {
        this.userDetailsService = userDetailsService;
        this.authenticationManager = authenticationManager;
    }


    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints
                // 开启密码模式授权
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)
                // 指定令牌存储策略
                .accessTokenConverter(accessTokenConverter());
    }

    /**
     * token 转换器
     * 默认是 uuid 格式，我们在这里指定 token 格式为 jwt
     * @return
     */
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        // 使用非对称加密算法对 token 签名
        converter.setKeyPair(keyPair());
        return converter;
    }

    @Bean
    public KeyPair keyPair() {
        // 从 classpath 目录下的证书 jwt.jks 中获取秘钥对
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("jwt.jks"), "lanweihong".toCharArray());
        return keyStoreKeyFactory.getKeyPair("weihong", "lanweihong".toCharArray());
    }

}
扩展 JWT 存储内容

有时候我们需要扩展 JWT 存储的内容，比如存储一些用户数据、权限信息等。我们可以定义 TokenEnhancer 或继承 TokenEnhancer 来实现 JWT 内容增强器：

    @Bean
    public TokenEnhancer tokenEnhancer() {
        return (oAuth2AccessToken, oAuth2Authentication) -> {
            Map<String, Object> map = new HashMap<>(1);
            UserDTO userDTO = (UserDTO) oAuth2Authentication.getPrincipal();
            map.put("userName", userDTO.getUsername());
            // TODO 其他信息可以自行添加
            ((DefaultOAuth2AccessToken) oAuth2AccessToken).setAdditionalInformation(map);
            return oAuth2AccessToken;
        };
    }

配置 AuthorizationServerEndpointsConfigurer JWT 内容增强器：

@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    private final UserDetailsServiceImpl userDetailsService;

    private final AuthenticationManager authenticationManager;

    @Autowired
    public Oauth2ServerConfig(UserDetailsServiceImpl userDetailsService,
                              AuthenticationManager authenticationManager) {
        this.userDetailsService = userDetailsService;
        this.authenticationManager = authenticationManager;
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        List<TokenEnhancer> delegates = new ArrayList<>();

        delegates.add(tokenEnhancer());
        delegates.add(accessTokenConverter());

        // 配置 JWT 内容增强
        enhancerChain.setTokenEnhancers(delegates);

        endpoints
                // 开启密码模式授权
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)
                .accessTokenConverter(accessTokenConverter())
                .tokenEnhancer(enhancerChain);
    }
    
    /**
     * token 转换器
     * 默认是 uuid 格式，我们在这里指定 token 格式为 jwt
     * @return
     */
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        // 使用非对称加密算法对 token 签名
        converter.setKeyPair(keyPair());
        return converter;
    }

    @Bean
    public KeyPair keyPair() {
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("jwt.jks"), "lanweihong".toCharArray());
        return keyStoreKeyFactory.getKeyPair("weihong", "lanweihong".toCharArray());
    }
    
    /**
     * JWT 内容增强器，用于扩展 JWT 内容，可以保存用户数据
     * @return
     */
    @Bean
    public TokenEnhancer tokenEnhancer() {
        return (oAuth2AccessToken, oAuth2Authentication) -> {
            Map<String, Object> map = new HashMap<>(1);
            UserDTO userDTO = (UserDTO) oAuth2Authentication.getPrincipal();
            map.put("userName", userDTO.getUsername());
            // TODO 其他信息可以自行添加
            ((DefaultOAuth2AccessToken) oAuth2AccessToken).setAdditionalInformation(map);
            return oAuth2AccessToken;
        };
    }
}
使用 Redis 存储 token
  1. 在 pom.xml 中添加依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 编辑 application.yml，添加 Redis 连接参数：
spring:
  redis:
    host: localhost
    port: 6379
    password: 1
  1. 添加 token 保存至 redis 的配置:
@Configuration
public class RedisTokenStoreConfig {

    @Resource
    private RedisConnectionFactory connectionFactory;

    @Bean
    public TokenStore redisTokenStore() {
        return new RedisTokenStore(connectionFactory);
    }
}
  1. 在认证服务配置中指定 token 存储方式：
@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    private final UserDetailsServiceImpl userDetailsService;

    /**
     * 密码模式 grant_type:password 需指定 AuthenticationManager
     */
    private final AuthenticationManager authenticationManager;
    
    private final TokenStore tokenStore;

    @Autowired
    public Oauth2ServerConfig(UserDetailsServiceImpl userDetailsService,
                              AuthenticationManager authenticationManager,
                              @Qualifier("redisTokenStore") TokenStore tokenStore) {
        this.userDetailsService = userDetailsService;
        this.authenticationManager = authenticationManager;
        this.tokenStore = tokenStore;
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                // 开启密码模式授权
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)
                // 设置 token 存储方式
                .tokenStore(tokenStore);
    }
}
配置授权令牌安全约束
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                // 允许表单认证
                .allowFormAuthenticationForClients()
                // 开放 /oauth/token_key 获取 token 加密公钥
                .tokenKeyAccess("permitAll()")
                // 开放 /oauth/check_token
                .checkTokenAccess("permitAll()");
    }
认证授权服务配置完整代码

Oauth2ServerConfig：

@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    /**
     * 数据源
     */
    private final DataSource dataSource;

    private final UserDetailsServiceImpl userDetailsService;

    /**
     * 密码模式 grant_type:password 需指定 AuthenticationManager
     */
    private final AuthenticationManager authenticationManager;

    private final PasswordEncoder passwordEncoder;

    private final TokenStore tokenStore;

    @Autowired
    public Oauth2ServerConfig(DataSource dataSource,
                              UserDetailsServiceImpl userDetailsService,
                              AuthenticationManager authenticationManager,
                              PasswordEncoder passwordEncoder,
                              @Qualifier("redisTokenStore") TokenStore tokenStore) {
        this.dataSource = dataSource;
        this.userDetailsService = userDetailsService;
        this.authenticationManager = authenticationManager;
        this.passwordEncoder = passwordEncoder;
        this.tokenStore = tokenStore;
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) {
        security
                // 允许表单认证
                .allowFormAuthenticationForClients()
                // 需通过认证后才能访问 /oauth/token_key 获取 token 加密公钥
                .tokenKeyAccess("permitAll()")
                // 开放 /oauth/check_token
                .checkTokenAccess("permitAll()");
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 使用基于 JDBC 存储模式
        JdbcClientDetailsService clientDetailsService = new JdbcClientDetailsService(dataSource);
        clientDetailsService.setPasswordEncoder(passwordEncoder);
        clients.withClientDetails(clientDetailsService);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        List<TokenEnhancer> delegates = new ArrayList<>();

        delegates.add(tokenEnhancer());
        delegates.add(accessTokenConverter());

        // 配置 JWT 内容增强
        enhancerChain.setTokenEnhancers(delegates);

        endpoints
                // 开启密码模式授权
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService)
                .accessTokenConverter(accessTokenConverter())
                .tokenEnhancer(enhancerChain)
                // 设置 token 存储方式
                .tokenStore(tokenStore);
    }

    /**
     * token 转换器
     * 默认是 uuid 格式，我们在这里指定 token 格式为 jwt
     * @return
     */
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        // 使用非对称加密算法对 token 签名
        converter.setKeyPair(keyPair());
        return converter;
    }

    @Bean
    public KeyPair keyPair() {
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("jwt.jks"), "lanweihong".toCharArray());
        return keyStoreKeyFactory.getKeyPair("weihong", "lanweihong".toCharArray());
    }

    /**
     * JWT 内容增强器，用于扩展 JWT 内容，可以保存用户数据
     * @return
     */
    @Bean
    public TokenEnhancer tokenEnhancer() {
        return (oAuth2AccessToken, oAuth2Authentication) -> {
            Map<String, Object> map = new HashMap<>(1);
            UserDTO userDTO = (UserDTO) oAuth2Authentication.getPrincipal();
            map.put("userName", userDTO.getUsername());
            // TODO 其他信息可以自行添加
            ((DefaultOAuth2AccessToken) oAuth2AccessToken).setAdditionalInformation(map);
            return oAuth2AccessToken;
        };
    }
}

WebSecurityConfig：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                // 支持跨域请求
                .cors()

                .and()
                // 禁用 CSRF
                .csrf().disable()

                .formLogin().disable()
                .httpBasic().disable()
                .logout().disable()

                .authorizeRequests()
                .antMatchers("/oauth/token").permitAll()

                .anyRequest().authenticated();
    }

    /**
     * 重写 authenticationManagerBean()
     * @return
     * @throws Exception
     */
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

测试获取 token

获取 token

运行项目，使用 Postman 访问 /oauth/token 端点，并传参数，参数必须与我们配置的内容一致；

使用Postman测试

成功获取到 token ，格式如下：

{
    "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2MTA1NjkzNDksInVzZXJOYW1lIjoiYWRtaW4iLCJ1c2VyX25hbWUiOiJhZG1pbiIsImp0aSI6IjgzM2VjZDdkLThmMzctNDAxOS04YWQwLTBlODI3ZTM4M2U5YyIsImNsaWVudF9pZCI6Im9hdXRoLXNlcnZlciIsInNjb3BlIjpbImFsbCJdfQ.ke6fWfGMOXhppF-6XXftZJx0w8hSnTKYYwvi_As66Ats9_AFqrHCZiuHA_M5LD2bJzahFC__-IUr_6g6ajx-IlLpSPqs3izgbuOPcTzCivfznGn38W5kYPe1ygQ8mJzN97yAT1QKZGMAT0nr7HR5NSG2MHYPbHuWSHp4KVIf7XQbszmXVPKEeQsv64QZ8O1xe9XtshF4mtZsxfLEGxAZEPSkoyJi-vwH6qKnvVh8EI8zgwTX5cIh6Gj4rcEfDiJYNAiI_NanuNA1wBoI1eD-QYSUQ5XXW1Q4vQAnjQMQwvTZYn1hGdAbeHQrA9hPLw5_Axeq8_meWpNobla_rRYkLQ",
    "token_type": "bearer",
    "refresh_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX25hbWUiOiJhZG1pbiIsInNjb3BlIjpbImFsbCJdLCJhdGkiOiI4MzNlY2Q3ZC04ZjM3LTQwMTktOGFkMC0wZTgyN2UzODNlOWMiLCJleHAiOjE2MTMxMTgxNDksInVzZXJOYW1lIjoiYWRtaW4iLCJqdGkiOiIwMDljZjhmNy05OTE5LTQyODEtYjUxNS02NjM3ZjIyM2MyN2YiLCJjbGllbnRfaWQiOiJvYXV0aC1zZXJ2ZXIifQ.bFMQRXCOz2rvu8QhTOjjlM66Fe3EM5F2wUXI-3dQOxnu2AOCsCJKUZdT0AhsnJkSI5Ewc1jUd7TiUifj9p6CYzIuHtnPORUUE67vt7eiKjpdNdNaUIvXzSoAcx-B5FgYynKslZm5S6WwqQMEb6jFMeg1iN3DphDPbjUMCP2qZevm6fNTT0b7PzxE0POepqqEnyjIS1YOnMnyHkgSAQCtYMAwWATalS4tMFNRb-hbE2MGi-U1j3Z1Mq79x9Uce8ZXjD2a_sCE9x0fqTixO-pRUrQNrIqiX_bZlw96xktnUQy2wCoJiZRxKjZyRhPLxOQPR7FUyd8yFXjCHR_yf5mwYw",
    "expires_in": 43199,
    "scope": "all",
    "userName": "admin",
    "jti": "833ecd7d-8f37-4019-8ad0-0e827e383e9c"
}

将返回的 token 复制到 https://jwt.io/ 解析，发现已正确解析。

JWT解析

校验 token
  1. 使用 Postman 访问 /oauth/check_token 端点，我们试着添加错误的 token ，然后发送请求校验，发现返回错误；

校验错误

  1. 使用 Postman 访问 /oauth/check_token 端点，我们使用正确的 token 校验，成功返回信息；

校验成功

刷新 token

使用 Postman 访问 /oauth/token 端点，其中参数 grant_type 使用 refresh_token，refresh_token 内容为我们从 /oauth/token 获取的 refresh_token（注意不是 access_token）；其他参数请自行配置，可参考如下：

刷新token成功

搭建资源服务

  1. 新建 module ，在 pom.xml 中添加依赖:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
  1. 在 application.yml 中添加 token 校验的相关参数，将 token 校验地址改为认证服务的 token 校验地址：
oauth2:
  resource-id: resource-server
  # token 校验地址
  check-token-url: http://127.0.0.1:8089/oauth/check_token
  client-id: oauth-server
  client-secret: 123456

配置资源服务

  1. 新建 ResourceServerConfig 类，继承 org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter，添加注解 @EnableResourceServer，并配置 token 校验服务；
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Value("${oauth2.check-token-url}")
    private String checkTokenUrl;

    @Value("${oauth2.resource-id}")
    private String resourceId;

    @Value("${oauth2.client-id}")
    private String clientId;

    @Value("${oauth2.client-secret}")
    private String clientSecret;

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

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .requestMatchers(EndpointRequest.toAnyEndpoint()).permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .requestMatchers()
                .antMatchers("/users/**");
    }

    /**
     * 配置 token 校验服务
     * @return
     */
    @Bean
    ResourceServerTokenServices resourceServerTokenServices() {
        RemoteTokenServices remoteTokenServices = new RemoteTokenServices();
        remoteTokenServices.setCheckTokenEndpointUrl(checkTokenUrl);
        remoteTokenServices.setClientId(clientId);
        remoteTokenServices.setClientSecret(clientSecret);
        remoteTokenServices.setAccessTokenConverter(accessTokenConverter());
        return remoteTokenServices;
    }

    @Bean
    public AccessTokenConverter accessTokenConverter() {
        return new DefaultAccessTokenConverter();
    }
}
  1. 添加 Controller
@RestController
public class HomeController {

    @GetMapping("/users")
    public Map<String, Object> test(Authentication authentication) {
        Map<String, Object> data = new HashMap<>(1);
        data.put("user", authentication.getPrincipal());
        return data;
    }
}

测试

使用 Postman 访问 /users ，返回未授权错误：

授权失败

使用 Postman 访问 /users，带上 token 访问，成功请求并获取到用户数据；

授权成功

项目源码地址

https://github.com/lanweihong/spring-securuty-oauth2-jwt

参考：

  1. 理解OAuth 2.0

  2. OAuth 2 Developers Guide

  3. Spring Security OAuth2自定义令牌配置

lanweihong
关注
  • 4
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
微服务统一认证方案 Spring Cloud OAuth2 + JWT
小松de博客
01-06 1623
目录1. 微服务架构下统⼀认证介绍2. 微服务架构下统⼀认证思路2.1 基于 session 的认证⽅式2.2 基于 token 的认证⽅式3. OAuth2 开放授权协议 / 标准3.1 OAuth2 相关介绍3.2 OAuth2 协议⻆⾊和流程3.3 什么情况下需要使⽤ OAuth23.4 OAuth2 颁发 Token授权⽅式4. Spring Cloud OAuth2 + JWT 的实现4.1 Spring Cloud OAuth2 介绍4.2 Spring Cloud OAuth2 构建微服
Spring Cloud 微服务中搭建 OAuth2.0 认证授权服务
javaQQ561487941的博客
12-11 1034
在使用 Spring Cloud 体系来构建微服务的过程中，用户请求是通过网关(ZUUL 或 Spring APIGateway)以 HTTP 协议来传输信息，API 网关将自己注册为 Eureka 服务治理下的应用，同时也从 Eureka 服务中获取所有其他微服务的实例信息。搭建 OAuth2 认证授权服务，并不是给每个微服务调用，而是通过 API 网关进行统一调用来对网关后的微服务做前置过滤，...
Spring Security + OAuth2.0 + JWT
qq_42155347的博客
05-06 3236
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Spring Security是什么？1.认证1.1基于Session认证1.2基于Token认证2.授权3.基于角色访问控制二、OAuth2.0是什么？三、JWT是什么？四、代码实现1.创建Spring Boot项目2.Spring Security实现2.1基本使用2.2 前言 基于Spring Boot项目使用Spring Security+OAuth2.0+JWT搭建用户认证中心。 一、Spring Securi
项目中遇到的一些问题总结（九）—— Spring Security 集成JWT、OAuth2完整验证流程
m0_51431003的博客
05-23 980
如果Token不合法，则拒绝该请求。服务器将Authentication对象中保存的信息转换为JWT Token的Payload部分，使用JwtAccessTokenConverter对象进行转换，同时生成Header和Signature，组成一个完整的JWT Token，返回给客户端。服务器对客户端进行身份认证，并将生成的Access Token保存在JWT Token的Payload部分中，并使用JwtAccessTokenConverter对象进行转换，最终生成一个JWT Token，返回给客户端。
springboot3微服务下结合springsecurity的认证授权实现
最新发布
PleaseBeStrong的博客
05-21 1212
往往是一些字符串类型的关键字，在这里统一定义外部就可以直接调用，方便微服务之间的管理集中式认证管理：通过统一的认证服务器进行登录认证和token的签发刷新，可以简化认证流程，提高安全性和效率。灵活性和可扩展性：各个微服务自行处理权限认证，可以根据各自的业务需求灵活设计权限控制逻辑，便于扩展和维护。适应多种鉴权场景：这种方式可以适应外部应用接入、用户-服务鉴权、服务-服务鉴权等多种鉴权场景。潜在的安全风险：如果各个微服务的权限认证实现不一致或存在缺陷，可能会引入安全风险。性能考虑。
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
04-22
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
SpringSecurity+OAuth2.0+JWT实现用户认证中心
qq_33302985的博客
06-15 2850
随着公司资源，市场，以及深圳部分业务拓展，公司希望将公司所有的用户信息进行整合，搭建一个统一平台，用来支持各业务线的用户授权认证，方便其他子公司授权后获取资源系统的资源，最后经过讨论，决定采用Springsecurity+Oauth2.0+JWT来实现用户认证中心。 Oauth2.0 oauth2.0是一种授权机制，由第三方向资源所有者请求授权，资源所有者同意授权后，第三方去授权服务器获取令牌，资源服务器发放令牌，第三方使用令牌去访问资源服务器的资源。资源服务器校验token无误后开放资源。流程如下图所
Spring Cloud实战 | 第六篇：Spring Cloud Gateway + Spring Security OAuth2 + JWT实现微服务统一认证授权鉴权
竹林幽深
10-07 4139
https://blog.51cto.com/u_12386660/4903483
验证服务：Spring Security + OAuth2.0 + JWT
02-21
更改日志2018.9.1版本升到2.0-SNAPSHOT ，要使用sb1.5.x版本，请切换到TAG 1.0-RELEASE Spring Cloud Security升级到Finchley.RELEASE ，Spring Boot由1.5.X升级到2.0.X。 < dependency> < groupId>org.spring...
Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权
01-23
这个项目“Gateway+Springsecurity+OAuth2.0+JWT 实现分布式统一认证授权”旨在构建一个强大的、分布式的认证与授权系统，以保护微服务架构中的各种服务。下面我们将深入探讨其中涉及的关键技术点。 1. **Gateway**...
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
SpringSecurity+Jwt+Autho2整合(一)
https://juejin.cn/user/4248168663101239/posts
08-08 1164
SpringSecurity+JWT+Autho2整合一. SpringSecurity简介二. SpringSecurity快速入门①. 导入依赖②. 登录页面③. 访问页面④. UserDetailsService详解⑤. UserDetails详解⑥. PasswordEncoder 密码解析器详解⑦. 自定义登录逻辑_修改配置类1. 登录页面配置2. 失败跳转3. 添加控制器的方法4. 设置请求账户和密码的参数名5. 自定义登录成功处理器6. 自定义登录失败处理器7. 访问控制url匹配8. 内置访
springsecurity+oauth2.0分布式认证授权案例 JWT令牌服务配置5
健康平安的活着的专栏
08-29 2117
一 jwt 1.1 jwt？ JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。 1.2 解决问题 当资源服务和授权服务不在一起时资源服务使用RemoteTokenServices 远程请求授权 服务验证token，如果访问量较大将会影响系统的性能 。 解决上边问题： 令牌采用J
OAuth2，jwt，springsecurity之间的区别和联系
qq_56533553的博客
06-24 1697
OAuth 2.0 的核心概念包括资源所有者 (Resource Owner)、客户端 (Client)、授权服务器 (Authorization Server) 和资源服务器 (Resource Server)。Spring Security 可以与 OAuth 2.0 和 JWT 等技术集成，以实现更加灵活和安全的身份验证和授权流程。OAuth 2.0、JWT (JSON Web Token) 和 Spring Security 是安全相关的概念和技术，它们有着不同的功能和用途。
解决swagger-ui加了Oauth2后无法访问的问题
十步杀一人-千里不留行
09-25 9616
两种情况: 1.在客户端需要认证的地方,修改ResourceServerConfig的configure()方法 package com.xuecheng.manage_course.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotatio...
Spring Security+Oauth2+JWT权限认证
分享java知识，一起开卷
06-29 1374
spring security+Oauth2.0+JWT
SpringSecurity OAuth2.0的学习（JWT令牌）
weixin_44012722的博客
05-16 635
SpringSecurity OAuth2.0的学习 首先我们要知道 OAauth（开放授权）是一个开方标准，允许用户授权第三方应用访问他们的微服务应用. OAauth2 包括以下角色 1. 客户端: 通常指 需要通过资源拥有者的授权请求资源服务器的资源，比如Android客户端，WEB端等 2. 资源拥有者： 通常为用户也可以是应用程序，即该资源的拥有者 3. 授权服务器： 用于服务商提供商对资源拥有的身份进行认证，对访问资源惊醒授权。 但是授权服务器就允许随便一个客户端就介入到它的授权服务器吗，它会给
权限管理 springboot集成springSecurity Oauth2 JWT
javajy的博客
11-21 401
认证鉴权
微服务商城系统（十） Spring Security Oauth2 + JWT 用户认证
weixin_41750142的博客
04-01 1864
文章目录一、用户认证分析1、认证 与 授权2、单点登录3、第三方账号登录4、第三方认证 一、用户认证分析      上面流程图 描述了用户要操作的各个微服务，用户查看个人信息 需要访问 用户微服务，下单 需要访问 订单微服务，秒杀抢购商品 需要访问 秒杀微服务。每个服务都需要认证用户的身份，身份认证成功后，需要识别用户的角色，然后授权访问对应的功能，比如管理员 和 普通用户的权限对应的功能 是不一样的。      1、认证 与
spring security+jwt+oauth2.0 pdf
07-13
Spring Security可以与JWT和OAuth 2.0结合使用，以提供更强大的身份验证和授权功能。使用JWT作为身份验证机制，可以在用户登录成功后生成一个JWT令牌，并将其加入到HTTP请求的Header中。服务端可以使用JWT中的信息，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值