通过Java Hipster升级Spring Security OAuth和JUnit测试

最新推荐文章于 2022-11-24 15:46:37 发布

dnc8371

最新推荐文章于 2022-11-24 15:46:37 发布

阅读量283

点赞数

文章标签： python java linux spring 人工智能

“我喜欢编写身份验证和授权代码。” 〜从来没有Java开发人员。 厌倦了一次又一次地建立相同的登录屏幕？尝试使用Okta API进行托管身份验证，授权和多因素身份验证。

使用单元测试和集成测试来验证代码质量是一种很好的方式来表明您对代码的关心。我最近在受欢迎的JHipster开源项目中做了很多工作，以将其升级为使用最新版本的Spring Security。

Spring Security 5.1+将OAuth 2.0和OIDC添加为一流公民，您可以使用其优雅的DSL（又称酷方法链接，又称生成器模式）对其进行配置。自从Rob Winch和工作人员首次启动它以来，我一直有使用它的动力。与他们合作进行非常创新的项目很有趣。 Spring Security使OAuth很棒！

我在2017年秋天向JHipster添加了OAuth 2.0支持。这种经历对我产生了很大的影响。我学到了很多有关Keycloak，Docker Compose以及如何在身份提供者（IdP）之间切换的知识。

我花了最后一个月升级JHipster以使用Spring Security 5.1（Spring Boot 2.1中的默认设置）。在此过程中，我遇到了一些挫折，在Travis CI上摇了摇拳，当我想出解决方案时感到很高兴。在此过程中，我也学到了很多东西。今天，我将与您分享这些经验。

使用OAuth 2.0和OIDC注销

在JHipster中集成了对Keycloak和Okta的支持后不久，该项目收到了很多用户的抱怨，他们无法注销。 JHipster用户熟悉单击注销（检查最新信息）并完全注销。使用默认的Spring Security支持，用户将注销本地应用程序，而不是IdP。

我花了一年的时间，但终于在今年早些时候添加了全球SSO注销。 Keycloak和Okta都要求您将GET请求发送到具有ID令牌和重定向到的URL的端点。因此，我创建了一个LogoutResource来返回这些值。

@RestController
public class LogoutResource {
    private final Logger log = LoggerFactory.getLogger(LogoutResource.class);
    private final UserInfoRestTemplateFactory templateFactory;
    private final String accessTokenUri;

   public LogoutResource(UserInfoRestTemplateFactory templateFactory,
                         @Value("${security.oauth2.client.access-token-uri}") String accessTokenUri) {
       this.templateFactory = templateFactory;
       this.accessTokenUri = accessTokenUri;
   }

    /**
     * POST  /api/logout : logout the current user
     *
     * @return the ResponseEntity with status 200 (OK) and a body with a global logout URL and ID token
     */
    @PostMapping("/api/logout")
    public ResponseEntity<?> logout(HttpServletRequest request, Authentication authentication) {
        log.debug("REST request to logout User : {}", authentication);
        OAuth2RestTemplate oauth2RestTemplate = this.templateFactory.getUserInfoRestTemplate();
        String idToken = (String) oauth2RestTemplate.getAccessToken().getAdditionalInformation().get("id_token");

        String logoutUrl = accessTokenUri.replace("token", "logout");
        Map<String, String> logoutDetails = new HashMap<>();
        logoutDetails.put("logoutUrl", logoutUrl);
        logoutDetails.put("idToken", idToken);
        request.getSession().invalidate();
        return ResponseEntity.ok().body(logoutDetails);
    }
}

Angular客户端调用/api/logout端点并构造IdP注销URL。

this.authServerProvider.logout().subscribe(response => {
  const data = response.body;
  let logoutUrl = data.logoutUrl;
  // if Keycloak, uri has protocol/openid-connect/token
  if (logoutUrl.indexOf('/protocol') > -1) {
    logoutUrl = logoutUrl + '?redirect_uri=' + window.location.origin;
  } else {
    // Okta
    logoutUrl = logoutUrl + '?id_token_hint=' +
    data.idToken + '&post_logout_redirect_uri=' + window.location.origin;
  }
  window.location.href = logoutUrl;
});

测试LogoutResource非常简单。大部分工作涉及模拟UserInfoRestTemplateFactory以便它返回ID令牌。

@RunWith(SpringRunner.class)
@SpringBootTest(classes = JhipsterApp.class)
public class LogoutResourceIntTest {

    @Autowired
    private MappingJackson2HttpMessageConverter jacksonMessageConverter;

    private final static String ID_TOKEN = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" +
        ".eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsIm" +
        "p0aSI6ImQzNWRmMTRkLTA5ZjYtNDhmZi04YTkzLTdjNmYwMzM5MzE1OSIsImlhdCI6MTU0M" +
        "Tk3MTU4MywiZXhwIjoxNTQxOTc1MTgzfQ.QaQOarmV8xEUYV7yvWzX3cUE_4W1luMcWCwpr" +
        "oqqUrg";

    @Value("${security.oauth2.client.access-token-uri}")
    private String accessTokenUri;

    private MockMvc restLogoutMockMvc;

    @Before
    public void before() {
        LogoutResource logoutResource = new LogoutResource(restTemplateFactory(), accessTokenUri);
        this.restLogoutMockMvc = MockMvcBuilders.standaloneSetup(logoutResource)
            .setMessageConverters(jacksonMessageConverter).build();
    }

    @Test
    public void getLogoutInformation() throws Exception {
        String logoutUrl = accessTokenUri.replace("token", "logout");
        restLogoutMockMvc.perform(post("/api/logout"))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$.logoutUrl").value(logoutUrl))
            .andExpect(jsonPath("$.idToken").value(ID_TOKEN));
    }

    private UserInfoRestTemplateFactory restTemplateFactory() {
        UserInfoRestTemplateFactory factory = mock(UserInfoRestTemplateFactory.class);
        Map<String, Object> idToken = new HashMap<>();
        idToken.put("id_token", ID_TOKEN);
        DefaultOAuth2AccessToken token = new DefaultOAuth2AccessToken("my-fun-token");
        token.setAdditionalInformation(idToken);
        when(factory.getUserInfoRestTemplate()).thenReturn(mock(OAuth2RestTemplate.class));
        when(factory.getUserInfoRestTemplate().getAccessToken()).thenReturn(token);
        return factory;
    }
}

我在1月下旬将全局注销支持合并到JHipster的master分支中，并在几周后开始升级Spring Security的OIDC支持。

升级Spring Security的OIDC支持
我从创建问题＃9276开始，以跟踪我的目标，动机和已知问题。

在这一点上，如果您不熟悉Spring Security，您可能想知道：为什么升级到Spring Security的最新版本如此酷？长话短说：它们已经弃用了注释，增加了功能，并使将OAuth 2.0和OIDC集成到您的应用程序中变得更加容易。谢谢，Spring Security团队！

在Spring Boot 2.1+（即Spring Security 5.1+）中，不再建议使用@ EnableOAuth2Sso和@EnableResourceServer。更改的原因可以在2019年1月25日发布的Josh Long的Bootiful Podcast中找到。这是Madhura Bhave的访谈，讨论从21:30开始。

除了将所有Java代码和YAML配置转换为使用最新的Spring Security比特之外，我还决定默认情况下将每个JHipster应用程序都配置为资源服务器。这是JHipster的SecurityConfiguration.java.ejs模板中的逻辑：

@Override
public void configure(HttpSecurity http) throws Exception {
    // @formatter:off
    http
        ...
        <%_ } else if (authenticationType === 'oauth2') { _%>
            <%_ if (['monolith', 'gateway'].includes(applicationType)) { _%>
        .and()
            .oauth2Login()
            <%_ } _%>
        .and()
            .oauth2ResourceServer().jwt();
        <%_ } _%>
        // @formatter:on
  }
}

为了确保实现与OIDC兼容，我用进行观众验证的JwtDecoder bean覆盖了默认的JwtDecoder bean。

@Value("${spring.security.oauth2.client.provider.oidc.issuer-uri}")
private String issuerUri;

@Bean
JwtDecoder jwtDecoder() {
    NimbusJwtDecoderJwkSupport jwtDecoder = (NimbusJwtDecoderJwkSupport)
        JwtDecoders.fromOidcIssuerLocation(issuerUri);

    OAuth2TokenValidator<Jwt> audienceValidator = new AudienceValidator();
    OAuth2TokenValidator<Jwt> withIssuer = JwtValidators.createDefaultWithIssuer(issuerUri);
    OAuth2TokenValidator<Jwt> withAudience = new DelegatingOAuth2TokenValidator<>(withIssuer, audienceValidator);

    jwtDecoder.setJwtValidator(withAudience);

    return jwtDecoder;
}

在所有运行时代码正常工作之后，我开始进行重构测试。测试是重构成功的最可靠指标，尤其是对于像JHipster这样具有26,000个组合的项目而言！

在此过程中，我遇到了许多挑战。由于我学到了很多解决这些挑战的知识，所以我认为对它们进行说明以及如何解决它们会很有趣。

如何模拟具有ID令牌的AuthenticatedPrincipal

我遇到的第一个挑战是更新的LogoutResource 。下面是我将其重构为使用Spring Security的ClientRegistrationRepository之后的代码。

@RestController
public class LogoutResource {
    private ClientRegistration registration;

    public LogoutResource(ClientRegistrationRepository registrations) {
        this.registration = registrations.findByRegistrationId("oidc");
    }

    /**
     * {@code POST  /api/logout} : logout the current user.
     *
     * @param request the {@link HttpServletRequest}.
     * @param idToken the ID token.
     * @return the {@link ResponseEntity} with status {@code 200 (OK)} and a body with a global logout URL and ID token.
     */
    @PostMapping("/api/logout")
    public ResponseEntity<?> logout(HttpServletRequest request,
                                    @AuthenticationPrincipal(expression = "idToken") OidcIdToken idToken) {
        String logoutUrl = this.registration.getProviderDetails()
            .getConfigurationMetadata().get("end_session_endpoint").toString();

        Map<String, String> logoutDetails = new HashMap<>();
        logoutDetails.put("logoutUrl", logoutUrl);
        logoutDetails.put("idToken", idToken.getTokenValue());
        request.getSession().invalidate();
        return ResponseEntity.ok().body(logoutDetails);
    }
}

我试图在LogoutResourceIT.java模拟OAuth2AuthenticationToken ，认为这将导致AuthenticationPrincipal的填充。

@RunWith(SpringRunner.class)
@SpringBootTest(classes = JhipsterApp.class)
public class LogoutResourceIT {

    @Autowired
    private ClientRegistrationRepository registrations;

    @Autowired
    private MappingJackson2HttpMessageConverter jacksonMessageConverter;

    private final static String ID_TOKEN = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" +
        ".eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsIm" +
        "p0aSI6ImQzNWRmMTRkLTA5ZjYtNDhmZi04YTkzLTdjNmYwMzM5MzE1OSIsImlhdCI6MTU0M" +
        "Tk3MTU4MywiZXhwIjoxNTQxOTc1MTgzfQ.QaQOarmV8xEUYV7yvWzX3cUE_4W1luMcWCwpr" +
        "oqqUrg";

    private MockMvc restLogoutMockMvc;

    @Before
    public void before() {
        LogoutResource logoutResource = new LogoutResource(registrations);
        this.restLogoutMockMvc = MockMvcBuilders.standaloneSetup(logoutResource)
            .setMessageConverters(jacksonMessageConverter).build();
    }

    @Test
    public void getLogoutInformation() throws Exception {

        Map<String, Object> claims = new HashMap<>();
        claims.put("groups", "ROLE_USER");
        claims.put("sub", 123);
        OidcIdToken idToken = new OidcIdToken(ID_TOKEN, Instant.now(),
            Instant.now().plusSeconds(60), claims);

        String logoutUrl = this.registrations.findByRegistrationId("oidc").getProviderDetails()
            .getConfigurationMetadata().get("end_session_endpoint").toString();
        restLogoutMockMvc.perform(post("/api/logout")
            .with(authentication(createMockOAuth2AuthenticationToken(idToken))))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$.logoutUrl").value(logoutUrl));
    }

    private OAuth2AuthenticationToken createMockOAuth2AuthenticationToken(OidcIdToken idToken) {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
        OidcUser user = new DefaultOidcUser(authorities, idToken);

        return new OAuth2AuthenticationToken(user, authorities, "oidc");
    }
}

但是，这导致以下错误：

Caused by: java.lang.IllegalArgumentException: tokenValue cannot be empty
    at org.springframework.util.Assert.hasText(Assert.java:284)
    at org.springframework.security.oauth2.core.AbstractOAuth2Token.<init>(AbstractOAuth2Token.java:55)
    at org.springframework.security.oauth2.core.oidc.OidcIdToken.<init>(OidcIdToken.java:53)
    at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.base/java.lang.reflect.Constructor.newInstance(Constructor.java:490)
    at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:172)

我将此问题发布到Stack Overflow上，并且还向Spring Security团队发送了电子邮件。 Joe Grandja对此问题做出了回应。

AuthenticationPrincipalArgumentResolver未在测试中注册。
启用“完整” spring-web-mvc时，它将自动注册，例如@EnableWebMvc 。

但是，在您的@Before ，您具有：

MockMvcBuilders.standaloneSetup() –这不会初始化完整的web-mvc基础结构–只是一个子集。

尝试以下方法：
MockMvcBuilders.webAppContextSetup(this.context) –这将注册AuthenticationPrincipalArgumentResolver并且您的测试应解析OidcIdToken 。

乔是正确的。我将测试更改为以下内容，并通过了测试。 ✅

@RunWith(SpringRunner.class)
@SpringBootTest(classes = JhipsterApp.class)
public class LogoutResourceIT {

    @Autowired
    private ClientRegistrationRepository registrations;

    @Autowired
    private WebApplicationContext context;

    private final static String ID_TOKEN = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" +
        ".eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsIm" +
        "p0aSI6ImQzNWRmMTRkLTA5ZjYtNDhmZi04YTkzLTdjNmYwMzM5MzE1OSIsImlhdCI6MTU0M" +
        "Tk3MTU4MywiZXhwIjoxNTQxOTc1MTgzfQ.QaQOarmV8xEUYV7yvWzX3cUE_4W1luMcWCwpr" +
        "oqqUrg";

    private MockMvc restLogoutMockMvc;

    @Before
    public void before() throws Exception {
        Map<String, Object> claims = new HashMap<>();
        claims.put("groups", "ROLE_USER");
        claims.put("sub", 123);
        OidcIdToken idToken = new OidcIdToken(ID_TOKEN, Instant.now(),
            Instant.now().plusSeconds(60), claims);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken(idToken));
        SecurityContextHolderAwareRequestFilter authInjector = new SecurityContextHolderAwareRequestFilter();
        authInjector.afterPropertiesSet();

        this.restLogoutMockMvc = MockMvcBuilders.webAppContextSetup(this.context).build();
    }

    @Test
    public void getLogoutInformation() throws Exception {
        String logoutUrl = this.registrations.findByRegistrationId("oidc").getProviderDetails()
            .getConfigurationMetadata().get("end_session_endpoint").toString();
        restLogoutMockMvc.perform(post("/api/logout"))
            .andExpect(status().isOk())
            .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
            .andExpect(jsonPath("$.logoutUrl").value(logoutUrl))
            .andExpect(jsonPath("$.idToken").value(ID_TOKEN));
    }

    private OAuth2AuthenticationToken authenticationToken(OidcIdToken idToken) {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
        OidcUser user = new DefaultOidcUser(authorities, idToken);
        return new OAuth2AuthenticationToken(user, authorities, "oidc");
    }
}

正确测试注销功能是一个重要的里程碑。我继续升级JHipster的微服务架构。

如何使用Zuul将OAuth 2.0访问令牌传递给下游微服务

JHipster使用Netflix Zuul代理从网关到下游微服务的请求。我创建了一个AuthorizationHeaderFilter来处理访问令牌传播。

public class AuthorizationHeaderFilter extends ZuulFilter {

    private final AuthorizationHeaderUtil headerUtil;

    public AuthorizationHeaderFilter(AuthorizationHeaderUtil headerUtil) {
        this.headerUtil = headerUtil;
    }

    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }

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

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        Optional<String> authorizationHeader = headerUtil.getAuthorizationHeader();
        authorizationHeader.ifPresent(s -> ctx.addZuulRequestHeader(TokenRelayRequestInterceptor.AUTHORIZATION, s));
        return null;
    }
}

但是，添加它不会导致成功的访问令牌传播。在Jon Ruddell的帮助下，我发现这是因为JHipster有一个LazyInitBeanFactoryPostProcessor导致所有bean都被延迟加载。该ZuulFilterInitializer中包括ZuulFilterInitializer 。将ZuulFilterInitializer为热切加载的bean，可以使一切正常工作。

至此，我一切正常，因此我创建了一个pull请求来升级JHipster的模板。

我知道我签入的内容需要运行Keycloak才能通过集成测试。这是由于OIDC发现以及如何从.well-known/openid-configuration查找端点。

在Spring Boot集成测试中如何处理OIDC发现

我不太担心Keycloak是否需要运行才能通过集成测试。然后，我们的某些Azure和Travis构建开始失败。 JHipster开发人员指出，当Keycloak不运行时，他们会看到类似以下的错误。

Factory method 'clientRegistrationRepository' threw exception; nested exception is
java.lang.IllegalArgumentException: Unable to resolve the OpenID Configuration
with the provided Issuer of "http://localhost:9080/auth/realms/jhipster"

我通过Spring Security的OAuth和OIDC测试进行了一些摸索，并提出了一个解决方案。该修复程序涉及添加一个TestSecurityConfiguration类，该类将覆盖默认的Spring Security设置并模拟Bean，从而不会发生OIDC发现。

@TestConfiguration
public class TestSecurityConfiguration {
    private final ClientRegistration clientRegistration;

    public TestSecurityConfiguration() {
        this.clientRegistration = clientRegistration().build();
    }

    @Bean
    ClientRegistrationRepository clientRegistrationRepository() {
        return new InMemoryClientRegistrationRepository(clientRegistration);
    }

    private ClientRegistration.Builder clientRegistration() {
        Map<String, Object> metadata = new HashMap<>();
        metadata.put("end_session_endpoint", "https://jhipster.org/logout");

        return ClientRegistration.withRegistrationId("oidc")
            .redirectUriTemplate("{baseUrl}/{action}/oauth2/code/{registrationId}")
            .clientAuthenticationMethod(ClientAuthenticationMethod.BASIC)
            .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
            .scope("read:user")
            .authorizationUri("https://jhipster.org/login/oauth/authorize")
            .tokenUri("https://jhipster.org/login/oauth/access_token")
            .jwkSetUri("https://jhipster.org/oauth/jwk")
            .userInfoUri("https://api.jhipster.org/user")
            .providerConfigurationMetadata(metadata)
            .userNameAttributeName("id")
            .clientName("Client Name")
            .clientId("client-id")
            .clientSecret("client-secret");
    }

    @Bean
    JwtDecoder jwtDecoder() {
        return mock(JwtDecoder.class);
    }

    @Bean
    public OAuth2AuthorizedClientService authorizedClientService(ClientRegistrationRepository clientRegistrationRepository) {
        return new InMemoryOAuth2AuthorizedClientService(clientRegistrationRepository);
    }

    @Bean
    public OAuth2AuthorizedClientRepository authorizedClientRepository(OAuth2AuthorizedClientService authorizedClientService) {
        return new AuthenticatedPrincipalOAuth2AuthorizedClientRepository(authorizedClientService);
    }
}

然后，在使用@SpringBootTest类中，我将其配置为配置源。

@SpringBootTest(classes = {MicroApp.class, TestSecurityConfiguration.class})

在使用OAuth 2.0保护的JHipster微服务上运行端到端测试

最终问题很快就浮出水面了。 jhipster-daily-builds （在Azure DevOps上运行）在尝试测试微服务时失败。

Caused by: java.lang.IllegalArgumentException: Unable to resolve the OpenID Configuration
 with the provided Issuer of "http://localhost:9080/auth/realms/jhipster"

我们不包括用于微服务的Keycloak Docker Compose文件，因为我们不希望它们独立运行。它们需要网关才能访问它们，因此它们的OAuth 2.0设置应与您的网关匹配，并且网关项目包含Keycloak文件。

在Azure上运行的端到端测试，其中1）启动微服务，以及2）达到其运行状况终结点以确保其成功启动。为了解决此问题， Pascal Grimaud 禁用了启动/测试微服务。他还创建了一个新问题来改进流程，因此可以使用JHipster的JDL生成完整的微服务堆栈。

升级到Spring Security 5.1及其一流的OIDC支持

我希望这些挑战和修复方法列表对您有所帮助。如果您使用不推荐使用的@EnableOAuth2Sso或@EnableResourceServer ，我建议您尝试升级到Spring Security 5.1。我用来跟踪升级的问题包含显示所有必需的代码更改的链接。

使用JHipster 6生成带有OIDC进行身份验证的Spring Boot + React应用

JHipster 6使用最新和最好的Spring Boot和Spring Security版本。它的前端支持Angular和React。它也支持Vue ，它不是主要生成器的一部分。

如果使用JHipster 6生成应用程序，则本文中提到的所有测试功能都将包含在您的应用程序中。你是怎样做的？我很高兴你问！
首先安装JHipster 6 Beta：

npm install -g generator-jhipster@beta

npm命令是Node.js的一部分。您将需要Node 10.x来安装JHipster并运行有用的命令。

JHipster 6支持Java 8、11和12（感谢Spring Boot 2.1）。我建议使用SDKMAN管理Java SDK ！例如，您可以安装Java 12并将其设置为默认值。

sdk install java 12.0.0-open
sdk default java 12.0.0-open

您可以创建一个使用React和OIDC的JHipster应用，只需几个命令：

mkdir app && cd app

echo "application { config { baseName reactoidc, \
  authenticationType oauth2, clientFramework react } }" >> app.jh

jhipster import-jdl app.jh

下面是显示这些命令结果的终端记录。

必须已配置的OIDC提供程序正在运行，JHipster生成的Spring Boot应用程序才能成功启动。您可以使用Docker Compose启动Keycloak：

docker-compose -f src/main/docker/keycloak.yml up -d

然后使用Maven启动您的应用程序：

./mvnw

启动完成后，打开http://localhost:8080 ，然后单击登录。您将被重定向到Keycloak，您可以在其中输入admin/admin登录。

为什么用Okta代替Keycloak？

Keycloak的效果很好，但这是Okta开发人员博客上的帖子，所以让我向您展示如何使用Okta！为什么要使用Okta？这是一个很好的问题。
Okta是永远在线的身份提供商，为开发人员提供身份验证和授权服务。它还允许您管理用户。我喜欢将其称为“用户作为软件服务”，但是UASS并不是一个很好的缩写。用户管理作为软件服务（UMASS）可以轻松解决。无论如何，这是一项很棒的服务，您应该尝试一下。

注册您的安全Spring Boot应用程序

首先，注册一个免费的Okta开发者帐户（如果已经有一个帐户，则登录）。

登录Okta后，注册您的Spring Boot应用程序。

在顶部菜单中，单击“ 应用程序”
点击添加应用
选择网站，然后单击下一步。
输入名字
将登录重定向URI更改为http://localhost:8080/login/oauth2/code/oidc
点击完成，然后点击编辑，然后添加http://localhost:8080作为注销重定向URI。
点击保存

完成后，您的设置应类似于以下屏幕截图。

在项目的根目录中创建okta.env文件，并将{..}值替换为Okta应用程序中的值：

export SPRING_SECURITY_OAUTH2_CLIENT_PROVIDER_OIDC_ISSUER_URI=https://{yourOktaDomain}/oauth2/default
export SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_ID={clientId}
export SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_SECRET={clientSecret}

在您的.gitignore文件中添加*.env ，这样该文件就不会在GitHub上结束。

创建组并将其作为声明添加到ID令牌

默认情况下，JHipster配置为与两种类型的用户一起使用：管理员和用户。 Keycloak会自动为用户和组配置，但是您需要为Okta组织进行一些一次性配置。

创建一个ROLE_ADMIN和ROLE_USER组（“ 用户” >“ 组” >“ 添加组” ）并将用户添加到其中。您可以使用注册时使用的帐户，也可以创建一个新用户（“ 用户” >“ 添加人” ）。导航到API > 授权服务器 ，然后单击default服务器。点击索赔标签，然后添加索赔 。将其命名为groups ，并将其包含在ID令牌中。将值类型设置为Groups并将过滤器设置为.*的正则表达式。点击创建。

使用以下命令启动您的应用程序：

source okta.env
./mvnw

导航到http://localhost:8080并使用Okta凭据登录。

漂亮的臀部，你不觉得吗？ 🤓

使用JHipster进行更好的Java测试

JHipster为您生成了一个具有开箱即用的良好测试覆盖范围的应用程序。使用自动为您配置的SonarCloud分析代码覆盖率。运行以下命令以在Docker容器中启动Sonar。

docker-compose -f src/main/docker/sonar.yml up -d

然后运行以下Maven命令：

./mvnw -Pprod clean test sonar:sonar -Dsonar.host.url=http://localhost:9001

该过程完成后，导航至http://localhost:9001/projects ，您将看到项目的报告。

代码覆盖率比本报告中显示的要高得多。我们最近更改了许多测试以在集成测试阶段运行，并且还没有弄清楚如何将此数据报告给Sonar。

有关此功能的更多信息，请参见JHipster的代码质量文档。

对JHipster中的JUnit 5的支持也在进行中。

了解有关Spring Security，Spring Boot和JHipster的更多信息

我希望您喜欢我的有关升级JHipster以使用Spring Security 5.1及其出色的OAuth 2.0 + OIDC支持的故事。我真的很喜欢Spring Security团队所做的工作，以简化其配置并使OIDC发现（以及其他功能）正常工作。

我没有为该示例创建GitHub存储库，因为JHipster生成了所有代码，并且不需要修改任何内容。

如果您想了解有关JHipster 6的更多信息，请参阅Java 12和JHipster 6更好，更快，更轻便的Java 。如果您对JHipster的CRUD生成功能和PWA支持感兴趣，我鼓励您查看有关如何使用React，Spring Boot和JHipster构建Photo Gallery PWA的博客文章。

我们还发布了许多有关测试和Spring Security 5.1的文章：

需要更多技术提示吗？在社交网络{ Twitter ， LinkedIn ， Facebook ， YouTube }上关注我们，以便在我们发布新内容时得到通知。
是否有与Okta无关的问题？ 请在我们的开发者论坛上提问。

“通过Java Hipster升级Spring Security OAuth和JUnit测试”最初于2019年4月15日发布在Okta开发人员博客上。

翻译自: https://www.javacodegeeks.com/2019/05/spring-security-oauth-through-java-hipster.html

dnc8371

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
通过Java Hipster升级Spring Security OAuth和JUnit测试

“我喜欢编写身份验证和授权代码。” 〜从来没有Java开发人员。厌倦了一次又一次地建立相同的登录屏幕？尝试使用Okta API进行托管身份验证，授权和多因素身份验证。使用单元测试和集成测试来验证代码质量是一种很好的方式来表明您对代码的关心。我最近在受欢迎的JHipster开源项目中做了很多工作，以将其升级为使用最新版本的Spring Security。 Spring Secu...
复制链接

扫一扫