Java 类io.dropwizard.auth.Authorizer 实例源码

/**
 *
 * @param environment The Dropwizard environment
 * @param authorizer A specific authorizer to use instead of the default PermitAllAuthorizer.  See
 * http://www.dropwizard.io/0.9.1/docs/manual/auth.html for more details
 */
public void registerAuthenticator(Environment environment, Authorizer<Peer> authorizer) {
    Preconditions.checkNotNull(environment, "Illegal call to registerAuthenticator with a null Environment object");
    Authenticator<BasicCredentials, Peer> authenticator;
    if (this.cachePolicy != null) {
        authenticator = createCachingAuthenticator(environment.metrics());
    }
    else {
        authenticator = createAuthenticator();
    }
    environment.jersey().register(new AuthDynamicFeature(
        new BasicCredentialAuthFilter.Builder<Peer>()
            .setAuthenticator(authenticator)
            .setAuthorizer(authorizer)
            .setRealm(this.realm)
            .buildAuthFilter()));
    environment.jersey().register(RolesAllowedDynamicFeature.class);
    environment.jersey().register(new AuthValueFactoryProvider.Binder<>(Peer.class));
}

@SuppressWarnings("unchecked")
public ChainedAuthTestResourceConfig() {
    super(true, new MetricRegistry());

    final Authorizer<Principal> authorizer = AuthUtil.getTestAuthorizer(ADMIN_USER, ADMIN_ROLE);
    final AuthFilter<BasicCredentials, Principal> basicAuthFilter = new BasicCredentialAuthFilter.Builder<>()
            .setAuthenticator(AuthUtil.getBasicAuthenticator(ImmutableList.of(ADMIN_USER, ORDINARY_USER)))
            .setAuthorizer(authorizer)
            .buildAuthFilter();

    final AuthFilter<String, Principal> oAuthFilter = new OAuthCredentialAuthFilter.Builder<>()
            .setAuthenticator(AuthUtil.getSingleUserOAuthAuthenticator(BEARER_USER, ADMIN_USER))
            .setPrefix(BEARER_PREFIX)
            .setAuthorizer(authorizer)
            .buildAuthFilter();

    register(new AuthValueFactoryProvider.Binder(Principal.class));
    register(new AuthDynamicFeature(new ChainedAuthFilter<>(buildHandlerList(basicAuthFilter, oAuthFilter))));
    register(RolesAllowedDynamicFeature.class);
    register(AuthResource.class);
}

@Override protected void configure() {

    bind(AuthConfiguration.class).toInstance(authConfiguration);

    bind(ApiKeyCredentials.class).asEagerSingleton();

    bind(new TypeLiteral<Authenticator<String, AuthPrincipal>>() {
    })
        .annotatedWith(Names.named("oauthAppAuthenticator"))
        .to(TokenOAuthAuthenticator.class);

    bind(new TypeLiteral<Authorizer<AuthPrincipal>>() {
    })
        .annotatedWith(Names.named("oauthAppAuthorizer"))
        .to(TokenAuthorizer.class);

    bind(new TypeLiteral<Authenticator<BasicCredentials, AuthPrincipal>>() {
    })
        .annotatedWith(Names.named("basicAppAuthenticator"))
        .to(BasicAuthenticator.class);

    List<String> multipleGroupAccessList = Lists.newArrayList();

    multipleGroupAccessList.addAll(
        Splitter.on(",").splitToList(authConfiguration.multipleGroupAccessList));

    bind(new TypeLiteral<List<String>>() {
    }).annotatedWith(Names.named("multipleGroupAccessList")).toInstance(multipleGroupAccessList);

    bind(AccessControlSupport.class).asEagerSingleton();

    bind(UnauthorizedHandler.class).to(DefaultUnauthorizedHandler.class);

    OkHttpClient.Builder builder = new OkHttpClient.Builder()
        .connectTimeout(authConfiguration.remoteOAuthServer.connectTimeout, TimeUnit.MILLISECONDS)
        .readTimeout(authConfiguration.remoteOAuthServer.connectTimeout, TimeUnit.MILLISECONDS);

    OkHttpClient client = builder.build();

    bind(OkHttpClient.class)
        .annotatedWith(Names.named("OAuthServiceClient"))
        .toInstance(client);

    logger.info("op=configure_oauth,remote_oauth_lookup_url={}",
        authConfiguration.remoteOAuthServer.tokenLookupURI);

    bind(URI.class)
        .annotatedWith(Names.named("OAuthServiceTokenLookupUri"))
        .toInstance(authConfiguration.remoteOAuthServer.tokenLookupURI);
  }

public OAuth2AuthFilter.Builder<C, P, T, A> setAuthorizer(Authorizer<P> authorizer) {
    this.authorizer = authorizer;
    return this;
}

public static Authorizer<Principal> getTestAuthorizer(final String validUser,
                                                      final String validRole) {
    return (principal, role) -> principal != null
            && validUser.equals(principal.getName())
            && validRole.equals(role);
}

/**
 * Return the Authorizer instance that will be used to check the @RolesAllowed annotations.
 * Override this method to provide an instance of a different instance of another class.
 *
 * @return the class.
 */
protected Authorizer createAuthorizer() {
    return new UserAuthorizer();
}

/**
 * Sets the given authorizer
 *
 * @param authorizer an {@link Authorizer}
 * @return the current builder
 */
public AuthFilterBuilder<C, P, T> setAuthorizer(Authorizer<P> authorizer) {
    this.authorizer = authorizer;
    return this;
}