Java 类javax.ws.rs.container.ContainerRequestFilter 实例源码

public RequestHandler() {
    // configure the application with the resource
    ResourceConfig config = new ResourceConfig()
            .register(GatewayFeature.class)
            .packages("com.jrestless.aws.examples")
            .register(ApplicationExceptionMapper.class)
            // auto-discovery works, too
            // .register(GlobalExceptionMapper.class)
            .register(new ContainerRequestFilter() {
                @Override
                public void filter(ContainerRequestContext request) throws IOException {
                    LOG.info("baseUri: " + request.getUriInfo().getBaseUri());
                    LOG.info("requestUri: " + request.getUriInfo().getRequestUri());
                }
            });
    init(config);
    start();
}

@Override
protected Application configure() {
    enable(TestProperties.LOG_TRAFFIC);
    ResourceConfig config = new ResourceConfig();
    config.register(LocaleContextFilter.class, 1);
    config.register(new ContainerRequestFilter() {

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException {
            called.incrementAndGet();
            locale = LocaleContextKeeper.getLocale();
        }

    }, 2);
    config.register(TestResource.class);
    return config;
}

public static <F,T> ContainerRequestFilter build(
        final ContainerRequestPredicate predicate,
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestContext, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    final Recorder<ContainerRequestContext> recorder = new BasicRecorder<>(
            predicate,
            extractData,
            transform,
            determineTimestamp,
            writingWorkerManager,
            skipNulls
    );
    return new ContainerRequestFilter() {
        @Override
        public void filter(ContainerRequestContext requestContext) {
            recorder.record(requestContext);
        }
    };
}

@SuppressWarnings("unchecked")
private void registerFilter(final Class<?> c) {
    if (ContainerRequestFilter.class.isAssignableFrom(c)) {
        requestFilters.add((Class<? extends ContainerRequestFilter>) c);
    }

    if (ContainerResponseFilter.class.isAssignableFrom(c)) {
        responseFilters.add((Class<? extends ContainerResponseFilter>) c);
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    context.register(new ContainerRequestFilter() {
        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException {
            if (requestContext.getUriInfo().getPath().endsWith("filtered")) {
                throw new ForbiddenException();
            }
        }
    }, Priorities.AUTHORIZATION);
}

/**
 * Default implementation for the Keycloak auth factory. Please provide your own if you implement
 * your own User's representation.
 *
 * @param configuration the application's configuration
 * @return Keycloak auth factory
 */
protected ContainerRequestFilter createAuthFactory(T configuration) {
    return new KeycloakAuthFilter.Builder<Principal>()
            .setConfig(getKeycloakConfiguration(configuration))
            .setAuthenticator(createAuthenticator(getKeycloakConfiguration(configuration)))
            .setAuthorizer(createAuthorizer())
            .setRealm(getRealm(configuration))
            .buildAuthFilter();
}

protected ContainerRequestFilter getAuthFilter() {
    BasicCredentialAuthFilter.Builder<Principal> builder = new BasicCredentialAuthFilter.Builder<>();
    builder.setAuthorizer(AuthUtil.getTestAuthorizer(ADMIN_USER, ADMIN_ROLE));
    builder.setAuthenticator(AuthUtil.getBasicAuthenticator(ImmutableList.of(ADMIN_USER, ORDINARY_USER)));
    builder.setPrefix(CUSTOM_PREFIX);
    return builder.buildAuthFilter();
}

/**
 * Register JAX-RS application components.
 */
public WSApplication () {

    // Register JAX-RS ContainerRequestFilter. 
    register(ContainerRequestFilter.class);

    //Register Jackson feature for JSON
    register(JacksonFeature.class);

    // Default test factory container
    property(TestProperties.CONTAINER_FACTORY, org.glassfish.jersey.test.grizzly.GrizzlyTestContainerFactory.class);
}

private static <T> boolean isProvider(final Class<T> clazz) {
    return MessageBodyReader.class.isAssignableFrom(clazz) ||
            MessageBodyWriter.class.isAssignableFrom(clazz) ||
            ParamConverter.class.isAssignableFrom(clazz) ||
            ContainerRequestFilter.class.isAssignableFrom(clazz) ||
            ContainerResponseFilter.class.isAssignableFrom(clazz) ||
            ReaderInterceptor.class.isAssignableFrom(clazz) ||
            WriterInterceptor.class.isAssignableFrom(clazz) ||
            ParamConverterProvider.class.isAssignableFrom(clazz) ||
            ContextResolver.class.isAssignableFrom(clazz) ||
            new MetaAnnotatedClass<>(clazz).isAnnotationPresent(Provider.class);
}

public static <F,T> ContainerRequestFilter build(
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestContext, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    return build(ContainerRequestPredicateBuilder.ALWAYS,extractData,transform,determineTimestamp,writingWorkerManager, skipNulls);
}

public static <F,T> ContainerRequestFilter build(
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    return build(extractData,transform,RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP,writingWorkerManager, skipNulls);
}

public static <F,T> ContainerRequestFilter build(
        final ContainerRequestPredicate predicate,
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    return build(predicate,extractData,transform,RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP,writingWorkerManager, skipNulls);
}

public static <F,T> ContainerRequestFilter build(
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestContext, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return build(ContainerRequestPredicateBuilder.ALWAYS,extractData,transform,determineTimestamp,writingWorkerManager, false);
}

public static <F,T> ContainerRequestFilter build(
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return build(extractData,transform,RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP,writingWorkerManager);
}

public static <F,T> ContainerRequestFilter build(
        final ContainerRequestPredicate predicate,
        final Function<ContainerRequestContext, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return build(predicate,extractData,transform,RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP,writingWorkerManager, false);
}

private void runRequestFilters(final MinijaxRequestContext context) throws IOException {
    for (final Class<? extends ContainerRequestFilter> filterClass : requestFilters) {
        final ContainerRequestFilter filter = get(filterClass);
        filter.filter(context);
    }
}

ContainerRequestFilter requestLoggerFilter() {
  return (req) -> LOGGER.info("Request: {}", req.getUriInfo().getRequestUri().getPath());
}

public RegisterAuthDynamicFeature(Class<? extends ContainerRequestFilter> filterClass) {
    this.filterClass = filterClass;
}

private static ContainerRequestFilter createApplicationPathFilter(Application app) {
    ApplicationPathFilter filter = new ApplicationPathFilter();
    filter.setApplication(app);
    return filter;
}

public void addContainerRequestFilter(ContainerRequestFilter requestFilter) {
    jerseyEndpoints.addContainerRequestFilter(requestFilter);
}

public JerseyEndpoints addContainerRequestFilter(ContainerRequestFilter containerRequestFilter) {
    containerRequestFilters.add(containerRequestFilter);
    return this;
}

@Override
public Handler getHandler(final Server server, String context, String applicationName) {
    ResourceConfig rc = new ResourceConfig();

    if (enableSwagger) {
        BeanConfig beanConfig = new BeanConfig();
        beanConfig.setVersion("1.0.0");
        beanConfig.setResourcePackage("");
        beanConfig.setScan(true);
        beanConfig.setBasePath("/");
        beanConfig.setTitle(applicationName);

        Set<String> packages = new HashSet<>();
        packages.add(ApiListingResource.class.getPackage().getName());
        for (Class<?> clazz : allClasses) {
            packages.add(clazz.getPackage().getName());
        }
        rc.packages(packages.toArray(new String[0]));
    }

    rc.registerClasses(allClasses);
    rc.register(HttpMethodOverrideFilter.class);
    rc.register(new JacksonFeature().withMapper(mapper));
    rc.register(MultiPartFeature.class); // adds support for multi-part API requests
    rc.registerInstances(allBinders);
    rc.registerInstances(
        new InjectableBinder(allInjectables),
        new AbstractBinder() {
            @Override
            protected void configure() {
                bind(server).to(Server.class);
            }
        }
    );

    if (supportCORS) {
        rc.register(CorsContainerResponseFilter.class);
    }

    for (ContainerRequestFilter containerRequestFilter : containerRequestFilters) {
        rc.register(containerRequestFilter);
    }

    for (ContainerResponseFilter containerResponseFilter : containerResponseFilters) {
        rc.register(containerResponseFilter);
    }


    ServletHolder servletHolder = new ServletHolder(new ServletContainer(rc));
    ServletContextHandler servletContextHandler = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
    servletContextHandler.setContextPath(context);
    if (!applicationName.isEmpty()) {
        servletContextHandler.setDisplayName(applicationName);
    }
    servletContextHandler.addServlet(servletHolder, "/*");
    servletContextHandler.addFilter(NewRelicRequestFilter.class, "/", EnumSet.of(DispatcherType.REQUEST));

    return servletContextHandler;
}

public static void setAuthenticated(ContainerRequestContext requestContext, ContainerRequestFilter filter) {
    requestContext.setProperty(ContainerRequestContextAuthUtil.AUTHENTICATED, true);
    requestContext.setProperty(ContainerRequestContextAuthUtil.AUTHENTICATED_BY, filter);
}

public static void setDenied(ContainerRequestContext requestContext, ContainerRequestFilter filter) {
    requestContext.setProperty(ContainerRequestContextAuthUtil.DENIED, true);
    requestContext.setProperty(ContainerRequestContextAuthUtil.DENIED_BY, filter);
}

public AuthDynamicFeature(ContainerRequestFilter authFilter) {
    this.authFilter = authFilter;
}

@Override
protected ContainerRequestFilter getAuthFilter() {
    return requestContext -> {
        throw new AssertionError("Authentication must not be performed");
    };
}

protected ContainerRequestFilter getAuthFilter() {
    BasicCredentialAuthFilter.Builder<Principal> builder = new BasicCredentialAuthFilter.Builder<>();
    builder.setAuthorizer(AuthUtil.getTestAuthorizer(ADMIN_USER, ADMIN_ROLE));
    builder.setAuthenticator(AuthUtil.getBasicAuthenticator(ImmutableList.of(ADMIN_USER, ORDINARY_USER)));
    return builder.buildAuthFilter();
}

@BeforeClass
public static void beforeClass() {
    when(mockedValidator.validate(any(Statement.class))).thenReturn(
            new HashSet<ConstraintViolation<Statement>>(0));
    dummySecurityFilter = new ContainerRequestFilter() {

        @Override
        public void filter(ContainerRequestContext containerrequestcontext)
                throws IOException {
            containerrequestcontext
                    .setSecurityContext(new SecurityContext() {

                        @Override
                        public boolean isUserInRole(String s) {
                            return false;
                        }

                        @Override
                        public boolean isSecure() {
                            return false;
                        }

                        @Override
                        public Principal getUserPrincipal() {
                            return new Principal() {

                                @Override
                                public String getName() {
                                    return "larissa";
                                }
                            };
                        }

                        @Override
                        public String getAuthenticationScheme() {
                            return "dummy auth";
                        }
                    });

        }
    };
}

public static LinkedBindingBuilder<ContainerRequestFilter> bindContainerRequestFilter(Binder binder)
{
  Multibinder<ContainerRequestFilter> requestFilterBinder = Multibinder.newSetBinder(binder, ContainerRequestFilter.class);
  return requestFilterBinder.addBinding();
}

/**
 * <p>getContainerRequestFilters.</p>
 *
 * @return a {@link java.lang.Iterable} object.
 */
public Iterable<ContainerRequestFilter> getContainerRequestFilters() {
    return event.getContainerRequestFilters();
}

protected abstract ContainerRequestFilter getAuthFilter();

protected abstract ContainerRequestFilter getAuthFilter();