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

@Test
public void testExtensionWithoutAName() {
    Dictionary<String, Object> properties = new Hashtable<>();

    properties.put(JAX_RS_EXTENSION, true);

    ServiceRegistration<ContainerResponseFilter> registration =
        bundleContext.registerService(
            ContainerResponseFilter.class, new TestFilter(), properties);

    try {
        RuntimeDTO runtimeDTO = _runtime.getRuntimeDTO();

        assertEquals(
            (long)registration.getReference().getProperty("service.id"),
            runtimeDTO.defaultApplication.extensionDTOs[0].serviceId);
    }
    finally {
        registration.unregister();
    }

}

public ControllerAdminApiApplication(String consoleWebPath) {
    super();
    CONSOLE_WEB_PATH = consoleWebPath;
    if (!CONSOLE_WEB_PATH.endsWith("/")) {
      CONSOLE_WEB_PATH += "/";
    }
    packages(RESOURCE_PACKAGE);
    // TODO See ControllerResponseFilter
//    register(new LoggingFeature());
    register(JacksonFeature.class);
    register(MultiPartFeature.class);
    registerClasses(io.swagger.jaxrs.listing.ApiListingResource.class);
    registerClasses(io.swagger.jaxrs.listing.SwaggerSerializers.class);
    register(new ContainerResponseFilter() {
      @Override
      public void filter(ContainerRequestContext containerRequestContext,
          ContainerResponseContext containerResponseContext)
          throws IOException {
        containerResponseContext.getHeaders().add("Access-Control-Allow-Origin", "*");
      }
    });
    // property("jersey.config.server.tracing.type", "ALL");
    // property("jersey.config.server.tracing.threshold", "VERBOSE");
  }

public AdminApiApplication(ServerInstance instance) {
  this.serverInstance = instance;
  packages(RESOURCE_PACKAGE);
  register(new AbstractBinder() {
    @Override
    protected void configure() {
      bind(serverInstance).to(ServerInstance.class);
    }
  });

  register(JacksonFeature.class);

  registerClasses(io.swagger.jaxrs.listing.ApiListingResource.class);
  registerClasses(io.swagger.jaxrs.listing.SwaggerSerializers.class);
  register(new ContainerResponseFilter() {
    @Override
    public void filter(ContainerRequestContext containerRequestContext,
        ContainerResponseContext containerResponseContext)
        throws IOException {
      containerResponseContext.getHeaders().add("Access-Control-Allow-Origin", "*");
    }
  });

}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final ContainerResponsePredicate predicate,
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestAndResponse, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    final Recorder<ContainerRequestAndResponse> recorder = new BasicRecorder<>(
            predicate,
            extractData,
            transform,
            determineTimestamp,
            writingWorkerManager,
            skipNulls);
    return buildResponseFilter(recorder);
}

@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);
    }
}

private void runResponseFilters(final MinijaxRequestContext context, final Response response) throws IOException {
    final ContainerResponseContext responseContext = (ContainerResponseContext) response;
    for (final Class<? extends ContainerResponseFilter> filterClass : responseFilters) {
        final ContainerResponseFilter filter = get(filterClass);
        filter.filter(context, responseContext);
    }
}

@Reference(
    cardinality = MULTIPLE, policyOption = GREEDY,
    target = "(liferay.apio.architect.container.response.filter=true)"
)
public void setContainerResponseFilter(
    ServiceReference<ContainerResponseFilter> serviceReference,
    ContainerResponseFilter containerResponseFilter) {

    _containerResponseFilters.add(containerResponseFilter);
}

@SuppressWarnings("unused")
public <T> void unsetContainerResponseFilter(
    ServiceReference<ContainerResponseFilter> serviceReference,
    ContainerResponseFilter containerResponseFilter) {

    _containerResponseFilters.remove(containerResponseFilter);
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {

    Method resourceMethod = resourceInfo.getResourceMethod();
    if (resourceMethod.getReturnType() != Optional.class) {
        return;
    }

    Type returnType = resourceMethod.getGenericReturnType();
    if ((returnType instanceof ParameterizedType) == false) {
        return;
    }

    ParameterizedType pt = (ParameterizedType) returnType;
    if (pt.getActualTypeArguments()[0] != UIResponse.class) {
        return;
    }

    context.register(new ContainerResponseFilter() {

        @Override
        public void filter(ContainerRequestContext requestContext,
                ContainerResponseContext responseContext) throws IOException {
            if (responseContext.hasEntity() == false) {
                return;
            }
            Optional<?> opt = (Optional<?>) responseContext.getEntity();
            responseContext.setEntity(opt.orElse(null));
            responseContext.setStatusInfo(
                    opt.map(a -> responseContext.getStatusInfo()).orElse(Status.NOT_FOUND));
        }
    });
}

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> ContainerResponseFilter buildResponseFilter(
        final Recorder<ContainerRequestAndResponse> recorder)
{
    return new ContainerResponseFilter() {
        @Override
        public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
            recorder.record(new ContainerRequestAndResponse(requestContext, responseContext));
        }
    };
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestAndResponse, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager,
        boolean skipNulls)
{
    return buildResponseFilter(ContainerResponsePredicateBuilder.ALWAYS, extractData, transform, determineTimestamp, writingWorkerManager, skipNulls);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    return buildResponseFilter(extractData, transform, RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP_CRAR, writingWorkerManager, skipNulls);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final ContainerResponsePredicate predicate,
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager,
        final boolean skipNulls)
{
    return buildResponseFilter(predicate, extractData, transform, RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP_CRAR, writingWorkerManager, skipNulls);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
    final ContainerResponsePredicate predicate,
    final Function<ContainerRequestAndResponse, F> extractData,
    final Function<F,T> transform,
    final Function<ContainerRequestAndResponse, DateTime> determineTimestamp,
    final WritingWorkerManager<T> writingWorkerManager)
{
    return buildResponseFilter(predicate, extractData, transform, determineTimestamp, writingWorkerManager, false);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final Function<ContainerRequestAndResponse, DateTime> determineTimestamp,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return buildResponseFilter(ContainerResponsePredicateBuilder.ALWAYS, extractData, transform, determineTimestamp, writingWorkerManager, false);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return buildResponseFilter(extractData, transform, RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP_CRAR, writingWorkerManager, false);
}

public static <F,T> ContainerResponseFilter buildResponseFilter(
        final ContainerResponsePredicate predicate,
        final Function<ContainerRequestAndResponse, F> extractData,
        final Function<F,T> transform,
        final WritingWorkerManager<T> writingWorkerManager)
{
    return buildResponseFilter(predicate, extractData, transform, RecorderFilterFactory.EXTRACT_REQUEST_TIMESTAMP_CRAR, writingWorkerManager, false);
}

@Override
public ContainerResponseFilter[] getResponseFilters() {

    return responseFilters;
}

@Override
public void setResponseFilters(final ContainerResponseFilter[] responseFilters) {

    this.responseFilters = responseFilters;
}

ContainerResponseFilter xPoweredByFilter() {
  return (req, res) -> res.getHeaders().add("X-Powered-By", "UnitTest-Webserver (1.0-SNAPSHOT)");
}

private ServiceRegistration<?> registerExtension(
    String name, Object... keyValues) {

    TestFilter testFilter = new TestFilter();

    Dictionary<String, Object> properties = new Hashtable<>();

    properties.put(JAX_RS_EXTENSION, true);
    properties.put(JAX_RS_NAME, name);

    for (int i = 0; i < keyValues.length; i = i + 2) {
        properties.put(keyValues[i].toString(), keyValues[i + 1]);
    }

    ServiceRegistration<ContainerResponseFilter> serviceRegistration =
        bundleContext.registerService(
            ContainerResponseFilter.class, testFilter, properties);

    _registrations.add(serviceRegistration);

    return serviceRegistration;
}

public JerseyEndpoints addContainerResponseFilter(ContainerResponseFilter containerResponseFilter) {
    containerResponseFilters.add(containerResponseFilter);
    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 RestResourceApplication() {

        packages("com.porterhead.resource", "com.porterhead.user.resource",
        "com.porterhead.sample");

        register(RequestContextFilter.class);

        ApplicationContext rootCtx = ContextLoader.getCurrentWebApplicationContext();
        ContainerResponseFilter filter = rootCtx.getBean(JerseyCrossOriginResourceSharingFilter.class);
        register(filter);

        register(GenericExceptionMapper.class);
        register(AccessDeniedExceptionMapper.class);

        register(JacksonFeature.class);

    }

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