[关闭]
@File 2019-10-19T07:30:02.000000Z 字数 15404 阅读 125

spring-security oauth2

java

二. 授权服务器的搭建

2.1 依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.security.oauth</groupId>
  7.     <artifactId>spring-security-oauth2</artifactId>
  8.     <version>2.3.6.RELEASE</version>
  9. </dependency>
  11. <dependency>
  12.     <groupId>org.springframework.security.oauth.boot</groupId>
  13.     <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  14.     <version>2.1.9.RELEASE</version>
  15. </dependency>
  17. <dependency>
  18.     <groupId>mysql</groupId>
  19.     <artifactId>mysql-connector-java</artifactId>
  20. </dependency>
  22. <dependency>
  23.     <groupId>com.alibaba</groupId>
  24.     <artifactId>druid-spring-boot-starter</artifactId>
  25.     <version>1.1.17</version>
  26. </dependency>
  28. <dependency>
  29.     <groupId>org.springframework.boot</groupId>
  30.     <artifactId>spring-boot-starter-jdbc</artifactId>
  31. </dependency>

2.2 配置

  1. spring:
  2.   datasource:
  3.     url: jdbc:mysql://mysql:3306/oauth2?useSSL=false&serverTimezone=UTC
  4.     username: root
  5.     password:
  6.     driver-class-name: com.mysql.cj.jdbc.Driver
  7.     druid:
  8.       initial-size: 20
  9.       max-active: 50
  10.       min-idle: 15
  11.       validation-query: 'select 1'
  12.       test-on-borrow: false
  13.       test-on-return: false
  14.       test-while-idle: true
  15.       # psCache, 缓存preparedStatement, 对支持游标的数据库性能有巨大的提升，oracle开启，mysql建议关闭
  16.       pool-prepared-statements: false
  17.       # psCache开启的时候有效
  18.       max-open-prepared-statements: 100
  19.       # 一个连接在被驱逐出连接池的时候，在连接池中最小的空闲时间，单位为毫秒
  20.       min-evictable-idle-time-millis: 30000
  21.       # 距离上次释放空闲连接的时间间隔
  22.       time-between-eviction-runs-millis: 30000

2.3 数据库表的创建

  1. create table oauth_client_details (
  2.   client_id VARCHAR(256) PRIMARY KEY,
  3.   resource_ids VARCHAR(256),
  4.   client_secret VARCHAR(256),
  5.   scope VARCHAR(256),
  6.   authorized_grant_types VARCHAR(256),
  7.   web_server_redirect_uri VARCHAR(256),
  8.   authorities VARCHAR(256),
  9.   access_token_validity INTEGER,
  10.   refresh_token_validity INTEGER,
  11.   additional_information VARCHAR(4096),
  12.   autoapprove VARCHAR(256)
  13. );
  15. create table oauth_client_token (
  16.   token_id VARCHAR(256),
  17.   token blob,
  18.   authentication_id VARCHAR(256) PRIMARY KEY,
  19.   user_name VARCHAR(256),
  20.   client_id VARCHAR(256)
  21. );
  23. create table oauth_access_token (
  24.   token_id VARCHAR(256),
  25.   token blob,
  26.   authentication_id VARCHAR(256) PRIMARY KEY,
  27.   user_name VARCHAR(256),
  28.   client_id VARCHAR(256),
  29.   authentication blob,
  30.   refresh_token VARCHAR(256)
  31. );
  33. create table oauth_refresh_token (
  34.   token_id VARCHAR(256),
  35.   token blob,
  36.   authentication blob
  37. );
  39. create table oauth_code (
  40.   code VARCHAR(256), authentication blob
  41. );
  43. create table oauth_approvals (
  44.     userId VARCHAR(256),
  45.     clientId VARCHAR(256),
  46.     scope VARCHAR(256),
  47.     status VARCHAR(10),
  48.     expiresAt TIMESTAMP,
  49.     lastModifiedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
  50. );

说明：数据库表是依据spring-security的官网，地址为：https://github.com/spring-projects/spring-security-oauth/blob/master/spring-security-oauth2/src/test/resources/schema.sql，但是在创建的时候将所有的字段类型LONGVARBINARY改为BLOB类型。

数据库的说明参考：http://andaily.com/spring-oauth-server/db_table_description.html

2.4 用户登录认证

  1. @Component
  2. public class UserSecurityService implements UserDetailsService {
  4.     private static Logger logger = LoggerFactory.getLogger(UserSecurityService.class);
  6.     @Override
  7.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  8.         logger.info("用户名：" + username);
  10.         return new User(username, "$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga",
  11.                 Arrays.asList(new SimpleGrantedAuthority("ROLE_admin")));
  12.     }
  13. }

2.5 web安全配置

  1. @Configuration
  2. public class WebAuthorizationConfig extends WebSecurityConfigurerAdapter {
  4.     // 密码的加解密
  5.     @Bean
  6.     public PasswordEncoder passwordEncoder() {
  7.         return new BCryptPasswordEncoder();
  8.     }
  10.     @Override
  11.     protected void configure(HttpSecurity http) throws Exception {
  12.         http.formLogin() 
  13.                 .loginPage("/login.html") 
  14.                 .loginProcessingUrl("/authentication/form")
  15.                 .and()
  16.                 .authorizeRequests() 
  17.                 .antMatchers("/login.html").permitAll()
  18.                 .anyRequest()
  19.                 .authenticated()
  20.                 .and()
  21.                 .csrf().disable();
  23.     }
  24. }

2.6 授权服务器配置

  1. @Configuration
  2. @EnableAuthorizationServer
  3. public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
  5.     @Autowired
  6.     private LoginAuthencation loginAuthencation;
  8.     @Autowired
  9.     private PasswordEncoder passwordEncoder;
  11.     @Resource
  12.     private DataSource dataSource;
  14.     // 根据用户的client_id查询用户的授权信息
  15.     @Bean
  16.     public ClientDetailsService clientDetails() {
  17.         return new JdbcClientDetailsService(dataSource);
  18.     }
  20.     //用于将token信息存放在数据库中
  21.     @Bean
  22.     public TokenStore tokenStore() {
  23.         return new JdbcTokenStore(dataSource);
  24.     }
  26.     // authentication_code放入到数据中
  27.     @Bean
  28.     public AuthorizationCodeServices authorizationCodeServices() {
  29.         return new JdbcAuthorizationCodeServices(dataSource);
  30.     }
  32.     @Override
  33.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  34.         // 采用数据库的方式查询用户的授权信息
  35.         clients.withClientDetails(clientDetails());
  37.         /**  供学习使用
  38.         clients.inMemory()
  39.                 // client_id
  40.                 .withClient("client")
  41.                 // client_secret
  42.                 .secret("secret")
  43.                 // 该client允许的授权类型，不同的类型，则获得token的方式不一样。
  44.                 .authorizedGrantTypes("authorization_code")
  45.                 .scopes("all")
  46.                 //回调uri，在authorization_code与implicit授权方式时，用以接收服务器的返回信息
  47.                 .redirectUris("http://localhost:9090/login");
  48.          */
  49.     }
  51.     @Override
  52.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  53.         // 存数据库
  54.         endpoints.tokenStore(tokenStore())
  55.                 .authorizationCodeServices(authorizationCodeServices())
  56.                 .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);
  58.         // 配置tokenServices参数
  59.         DefaultTokenServices tokenServices = new DefaultTokenServices();
  60.         tokenServices.setTokenStore(endpoints.getTokenStore());
  61.         tokenServices.setSupportRefreshToken(false);
  62.         tokenServices.setClientDetailsService(endpoints.getClientDetailsService());
  63.         tokenServices.setTokenEnhancer(endpoints.getTokenEnhancer());
  64.         // token的过期时间为1天
  65.         tokenServices.setAccessTokenValiditySeconds((int)TimeUnit.DAYS.toSeconds(1)); 
  66.         endpoints.tokenServices(tokenServices);
  67.     }
  69.     @Override
  70.     public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
  71.         /**
  72.          * 作用是使用client_id和client_secret来做登录认证，如果是在浏览器的情况下，会让用户
  73.          * 输入用户名和密码
  74.          */
  75.         oauthServer.allowFormAuthenticationForClients();
  76.         oauthServer.checkTokenAccess("isAuthenticated()");
  77.         oauthServer.passwordEncoder(passwordEncoder);
  78.     }
  79. }

2.7 更改默认授权页面

  1. @Controller
  2. @SessionAttributes("authorizationRequest") // 必须配置
  3. public class AuthController {
  5. /**
  6.  * org.springframework.security.oauth2.provider.endpoint.AuthorizationEndpoint 
  7.     默认的授权页面
  8.  */
  9.     @RequestMapping("/oauth/confirm_access")
  10.     public String getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
  11.          AuthorizationRequest authorizationRequest = (AuthorizationRequest) model.get("authorizationRequest");
  13.         System.out.println(authorizationRequest.getScope());
  15.         return "/oauth.html";
  16.     }
  17. }

2.8 获取code

​ 获取授权码的地址：http://127.0.0.1:8080/oauth/authorize?client_id=other_client&response_type=code&redirect_uri=http://localhost:9090/login

​

​ 在浏览器地址栏的重定向地址上可以看到 code值。

2.9 获取access_token

​ 根据上一步获取到的code值获取acccess_token, 请求的地址为：

http://127.0.0.1:8080/oauth/token?client_id=other_client&client_secret=1&grant_type=authorization_code&code=tuvCj9&redirect_uri=http://localhost:9090/login

​ 其中code的值为上一步请求获取到的code的数据，返回内容如下：

2.10 获取额外的信息

​ Oauth2在获取用户额外信息的时候，内部实现上并没有去做，所以需要我们自己去实现，实现的方式就是去重写其代码，思路是从数据库查询到的信息封装到 ClientDetails中，但是内部却没有开放出来，所以需要去找到是在何处查询数据库，根据源代码的追踪，发现查询数据库的操作是在ApprovalStoreUserApprovalHandler这个类中，所以我们需要手动的去修改其源代码，修改的内容如下：

三. 资源服务器的搭建

​ 资源服务器就是用户想要真正获取资源的服务器，我们必须要通过2.9节中获取到的access_token来获取。

3.1依赖

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.1.9.RELEASE</version>
  5. </parent>
  6. <dependencies>
  7.     <dependency>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-web</artifactId>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.springframework.security.oauth</groupId>
  13.         <artifactId>spring-security-oauth2</artifactId>
  14.     <version>2.3.6.RELEASE</version>
  15.     </dependency>
  17.     <dependency>
  18.         <groupId>org.springframework.security.oauth.boot</groupId>
  19.         <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  20.         <version>2.1.9.RELEASE</version>
  21.     </dependency>
  22. </dependencies>

3.2 配置

  1. security:
  2.   oauth2:
  3.     resource:
  4.       # access_token的验证地址
  5.       token-info-uri: http://localhost:8080/oauth/check_token
  7.     client:
  8.       client-id: resources_client
  9.       client-secret: 1

3.3 资源服务账号

​ 我们需要在授权服务器上创建client_id和client_secret，当资源服务器拿到第三方的access_token后需要到授权服务器上验证access_token的来源是否合法。

3.4 资源服务器安全配置

  1. @Configuration
  2. @EnableResourceServer
  3. public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
  5.     @Override
  6.     public void configure(HttpSecurity http) throws Exception {
  7.         http.authorizeRequests() //
  8.                 .antMatchers("/user").access("#oauth2.hasAnyScope('all','read')");
  9.     }
  10. }

3.5 获取资源

通过调用如下接口去获取资源服务器的资源：

http://localhost:8081/user?access_token=92de29ea-df7d-4d35-b585-c740322f9028

四. JWT(Json Web Token)

4.1 传统跨域登录流程

  1. 用户向服务器发送用户名和密码。
  2. 验证服务器后，相关数据（如用户角色，登录时间等）将保存在当前会话中。
  3. 服务器向用户返回session_id，session信息都会写入到用户的Cookie。
  4. 用户的每个后续请求都将通过在Cookie中取出session_id传给服务器。
  5. 服务器收到session_id并对比之前保存的数据，确认用户的身份。

​ 这种模式最大的问题是，没有分布式架构，无法支持横向扩展。如果使用一个服务器，该模式完全没有问题。但是，如果它是服务器群集或面向服务的跨域体系结构的话，则需要一个统一的session数据库库来保存会话数据实现共享，这样负载均衡下的每个服务器才可以正确的验证用户身份。

​ 但是在实际中常见的单点登陆的需求：站点A和站点B提供统一公司的相关服务。现在要求用户只需要登录其中一个网站，然后它就会自动登录到另一个网站。怎么做？

​ 一种解决方案是听过持久化session数据，写入数据库或文件持久层等。收到请求后，验证服务从持久层请求数据。该解决方案的优点在于架构清晰，而缺点是架构修改比较费劲，整个服务的验证逻辑层都需要重写，工作量相对较大。而且由于依赖于持久层的数据库或者问题系统，会有单点风险，如果持久层失败，整个认证体系都会挂掉。

4.2 Jwt

​ 针对如上的问题，另外一种解决方案就是JWT(Json Web Token)，其原则是在服务器验证之后，将生产的一个Json对象返回给用户，格式如下：

  1. {
  2.     "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzEyNDE2NTksInVzZXJfbmFtZSI6ImFhIiwiYXV0aG9yaXRpZXMiOlsiUk9MRV9hZG1pbiJdLCJqdGkiOiJlZTczOTI4OC0zNDMwLTQxMjUtODBhOC1lMDU0Njg5OWQ2ODIiLCJjbGllbnRfaWQiOiJteV9jbGllbnQiLCJzY29wZSI6WyJhbGwiXX0.Ji4xYQJuJRrZeCTTMOb1e2GiOESAyiI9NzbWffKzcJ0",
  3.     "token_type": "bearer",
  4.     "expires_in": 43198,
  5.     "scope": "all",
  6.     "jti": "ee739288-3430-4125-80a8-e0546899d682"
  7. }

4.2.1 Jwt数据结构

​ 如上代码返回的access_token为一个字符串，之间用 . 分隔为为三段，其中第一段为 header(头)，第二段为 payload (负载)，第三段为signature(签名)，如下图所示：

​ 我们可以在 <https://jwt.io/> 在线解析这个JWT token, 如下图所示

header

字段名 描述
alg 算法
typ 令牌类型

payload

字段名 描述
exp 超时时间
jti JWT ID

signature

​ 签名，为了验证发送过来的access_token是否有效，通过如下算法得到：

4.2.2 用法与问题

​ 客户端接收服务器返回的JWT，将其存储在Cookie或localStorage中。此后，客户端将在与服务器交互中都会带JWT。如果将它存储在Cookie中，就可以自动发送，因此一般是将它放入HTTP请求的Header Authorization字段中。当跨域时，也可以将JWT被放置于POST请求的数据主体中。

​ 但是JWT也面临着诸多的问题，如下所示：

  1. JWT默认不加密，但可以加密。生成原始令牌后，可以使用改令牌再次对其进行加密。
  2. 当JWT未加密方法是，一些私密数据无法通过JWT传输。
  3. JWT不仅可用于认证，还可用于信息交换。善用JWT有助于减少服务器请求数据库的次数。
  4. JWT的最大缺点是服务器不保存会话状态，所以在使用期间不可能取消令牌或更改令牌的权限。也就是说，一旦JWT签发，在有效期内将会一直有效。
  5. JWT本身包含认证信息，因此一旦信息泄露，任何人都可以获得令牌的所有权限。为了减少盗用，JWT的有效期不宜设置太长。对于某些重要操作，用户在使用时应该每次都进行进行身份验证。
  6. 为了减少盗用和窃取，JWT不建议使用HTTP协议来传输代码，而是使用加密的HTTPS协议进行传输。

4.3 jwt授权服务器搭建

依赖：

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.1.9.RELEASE</version>
  5. </parent>
  7. <dependencies>
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-web</artifactId>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework.security.oauth</groupId>
  14.         <artifactId>spring-security-oauth2</artifactId>
  15.         <version>2.3.6.RELEASE</version>
  16.     </dependency>
  18.     <dependency>
  19.         <groupId>org.springframework.security.oauth.boot</groupId>
  20.         <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  21.         <version>2.1.9.RELEASE</version>
  22.     </dependency>
  23. </dependencies>

jwt授权服务器

  1. @Configuration
  2. @EnableAuthorizationServer
  3. public class OauthAuthenticationServer extends AuthorizationServerConfigurerAdapter {
  5.     @Autowired
  6.     private PasswordEncoder passwordEncoder;
  8.     @Bean
  9.     public TokenStore tokenStore() {
  10.         return new JwtTokenStore(jwtAccessTokenConverter());
  11.     }
  13.     @Bean
  14.     public JwtAccessTokenConverter jwtAccessTokenConverter() {
  15.         JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
  16.         jwtAccessTokenConverter.setSigningKey("123"); //设置签名
  17.         return jwtAccessTokenConverter;
  18.     }
  20.     // 基于内存的授权码
  21.     @Override
  22.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  23.         clients.inMemory()  //
  24.                 .withClient("my_client") //
  25.                 .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
  26.                 .scopes("all") //
  27.                 .authorizedGrantTypes("authorization_code")
  28.                 .redirectUris("http://localhost:9090/login");
  29.     }
  31.     @Override
  32.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  33.         endpoints.accessTokenConverter(jwtAccessTokenConverter())
  34.                  .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);
  35.     }
  37.     @Override
  38.     public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
  39.         security.allowFormAuthenticationForClients()
  40.                 .passwordEncoder(passwordEncoder);
  41.     }
  42. }

4.4 jwt资源服务器

  1. @Configuration
  2. @EnableResourceServer
  3. public class ReourceServerConfig extends ResourceServerConfigurerAdapter {
  5.     @Bean
  6.     public TokenStore jwtTokenStore() {
  7.         return new JwtTokenStore(jwtAccessTokenConverter());
  8.     }
  10.     @Bean
  11.     public DefaultTokenServices defaultTokenServices() {
  12.         DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
  13.         defaultTokenServices.setTokenStore(jwtTokenStore());
  14.         return defaultTokenServices;
  15.     }
  17.     @Bean
  18.     public JwtAccessTokenConverter jwtAccessTokenConverter() {
  19.         JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
  20.         jwtAccessTokenConverter.setSigningKey("123");
  21.         return jwtAccessTokenConverter;
  22.     }
  24.     @Override
  25.     public void configure(HttpSecurity http) throws Exception {
  26.         http.authorizeRequests()  //
  27.                 .anyRequest() //
  28.                 .authenticated() //
  29.                 .and() //
  30.                 .csrf().disable();
  31.     }
  33.     @Override
  34.     public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
  35.         resources.tokenServices(defaultTokenServices());
  36.     }
  37. }

五. 单点登录

​ 单点登录(Singal Sign On)是很多企业经常使用的一种登录方式，那么何为单点登录呢？为了解决什么样的问题呢？举个例子，在淘宝公司内部，有天猫、淘宝、阿里云、聚划算等众多的产品线，这些产品线是不同的服务器来支撑运行，但是作为用户的我们却可以使用同一套账户名和密码进行登录他几乎所有的产品，登录服务器只有一个，根据登录服务器返回的特定的信息，可以去访问它所有的产品线。着就是所谓的单点登录。

​ 在具体的实现的时候，我们使用JWT的方式来实现单点登录。他的处理流程如下：

5.1 认证服务器

依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.security.oauth</groupId>
  8.         <artifactId>spring-security-oauth2</artifactId>
  9.         <version>2.3.6.RELEASE</version>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.springframework.security.oauth.boot</groupId>
  13.         <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  14.         <version>2.1.9.RELEASE</version>
  15.     </dependency>
  16. </dependencies>

授权服务

  1. @Configuration
  2. @EnableAuthorizationServer
  3. public class SsoAuthorizationConfigServer extends AuthorizationServerConfigurerAdapter {
  4.     @Bean
  5.     public JwtAccessTokenConverter jwtAccessTokenConverter() {
  6.         JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
  7.         jwtAccessTokenConverter.setSigningKey("abcxyz");
  8.         return jwtAccessTokenConverter;
  9.     }
  11.     @Override
  12.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  13.         clients.inMemory()  //
  14.                 .withClient("client-a") //
  15.                 .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
  16.                 .authorizedGrantTypes("authorization_code", "refresh_token")
  17.                 .scopes("all")
  18.                 .redirectUris("http://localhost:8081/clientA/login")
  19.                 .autoApprove(true)
  20.                 .and()
  21.                 .withClient("client-b") //
  22.                 .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
  23.                 .authorizedGrantTypes("authorization_code")
  24.                 .scopes("all")
  25.                 .redirectUris("http://localhost:8082/clientB/login")
  26.                 .autoApprove(true);
  27.     }
  29.     @Override
  30.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  31.         endpoints//.tokenStore(jwtTokenStore())
  32.                  .accessTokenConverter(jwtAccessTokenConverter());
  33.     }
  34. }

5.2 子系统

依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.security.oauth</groupId>
  8.         <artifactId>spring-security-oauth2</artifactId>
  9.         <version>2.3.6.RELEASE</version>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.springframework.boot</groupId>
  13.         <artifactId>spring-boot-starter-security</artifactId>
  14.     </dependency>
  15.     <dependency>
  16.         <groupId>org.springframework.security.oauth.boot</groupId>
  17.         <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  18.         <version>2.1.9.RELEASE</version>
  19.     </dependency>
  20. </dependencies>

配置

  1. server:
  2.   port: 8081
  3.   servlet:
  4.     context-path: /clientA
  7. security:
  8.   oauth2:
  9.     client:
  10.       client-id: client-a
  11.       client-secret: 1
  12.       access-token-uri: http://localhost:7070/auth/oauth/token
  13.       user-authorization-uri: http://localhost:7070/auth/oauth/authorize
  15.     resource:
  16.       jwt:
  17.         key-value: abcxyz

启动类配置

  1. @SpringBootApplication
  2. @EnableOAuth2Sso
  3. public class SsoClientApplicationA {
  4.     public static void main( String[] args ) {
  5.         SpringApplication.run(SsoClientApplicationA.class, args);
  6.     }
  7. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注