javax.ws.rs.core.FeatureContext#register()源码实例Demo

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    CacheFor cc = resourceInfo.getResourceClass().getAnnotation(CacheFor.class);
    CacheFor mcc = resourceInfo.getResourceMethod().getAnnotation(CacheFor.class);
    if( mcc!=null ) {
        cc = mcc;
    }
    if (cc!=null) {
        if( cc.value() == 0 ) {
            context.register(NoCacheFilter.class);
        } else if( cc.value() > 0 ) {
            context.register(new CacheFilter("max-age= " + cc.unit().toSeconds(cc.value())));
        }
    } else {
        context.register(NoCacheFilter.class);
    }
}
 

@Override
public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();

    final String jsonFeature = getValue(config.getProperties(), config.getRuntimeType(),
            JSON_FEATURE, ST_JSON_FEATURE, String.class);

    // Do not register our JSON feature if another one is already registered
    if (!ST_JSON_FEATURE.equalsIgnoreCase(jsonFeature)) {
        LOGGER.warn("Skipping registration of: {} as JSON support is already provided by: {}",
                ST_JSON_FEATURE, jsonFeature);
        return false;
    }

    // Prevent other not yet registered JSON features to register themselves
    context.property(getPropertyNameForRuntime(JSON_FEATURE, config.getRuntimeType()),
            ST_JSON_FEATURE);

    if (!config.isRegistered(JacksonSerializerMessageBodyReaderWriter.class)) {
        context.register(SerializationExceptionMapper.class);
        context.register(JacksonSerializerMessageBodyReaderWriter.class);
    }

    return true;
}
 

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    // TODO why it is called twice for the same endpoint
    if (!tracingDisabled(resourceInfo)) {
        log(resourceInfo);
        context.register(new ServerTracingFilter(
            builder.tracer,
            operationName(resourceInfo),
            builder.spanDecorators,
            builder.operationNameBuilder.build(resourceInfo.getResourceClass(), resourceInfo.getResourceMethod()),
            builder.skipPattern != null ? Pattern.compile(builder.skipPattern) : null,
            builder.joinExistingActiveSpan),
            builder.priority);

        if (builder.traceSerialization) {
            context.register(new ServerTracingInterceptor(builder.tracer,
                builder.serializationSpanDecorators), builder.serializationPriority);
        }
    }
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();

    if (!config.isRegistered(EntityFieldsProcessor.class)) {

        // register EntityFilteringFeature
        if (!config.isRegistered(EntityFilteringFeature.class)) {
            context.register(EntityFilteringFeature.class);
        }
        // Entity Processors.
        context.register(EntityFieldsProcessor.class);
        // Scope Resolver.
        context.register(EntityFieldsScopeResolver.class);

        return true;
    }
    return false;
}
 

@Override
public boolean configure(final FeatureContext context) {
	ObjectMapper objectMapper = boot.getObjectMapper();
	ResourceFieldNameTransformer resourceFieldNameTransformer = new ResourceFieldNameTransformer(
			objectMapper.getSerializationConfig());

	PropertiesProvider propertiesProvider = new PropertiesProvider() {

		@Override
		public String getProperty(String key) {
			return (String) context.getConfiguration().getProperty(key);
		}
	};

	boot.setDefaultServiceUrlProvider(new UriInfoServiceUrlProvider());
	boot.setPropertiesProvider(propertiesProvider);
	boot.setResourceFieldNameTransformer(resourceFieldNameTransformer);
	boot.addModule(new JaxrsModule(securityContext));
	boot.boot();

	KatharsisFilter katharsisFilter;
	try {
		RequestContextParameterProviderRegistry parameterProviderRegistry = buildParameterProviderRegistry();

		String webPathPrefix = boot.getWebPathPrefix();
		ResourceRegistry resourceRegistry = boot.getResourceRegistry();
		RequestDispatcher requestDispatcher = boot.getRequestDispatcher();
		katharsisFilter = createKatharsisFilter(resourceRegistry, parameterProviderRegistry, webPathPrefix,
				requestDispatcher);
	}
	catch (Exception e) {
		throw new WebApplicationException(e);
	}
	context.register(katharsisFilter);
	
	registerActionRepositories(context, boot);

	return true;
}
 

@Override
public boolean configure(FeatureContext context) {
    final SecurityFilter filter = new SecurityFilter(providers);
    filter.setAuthorizers(authorizers);
    filter.setClients(clients);
    filter.setMatchers(matchers);
    filter.setMultiProfile(multiProfile);
    filter.setSkipResponse(skipResponse);
    context.register(filter);
    return true;
}
 

public boolean configure(final FeatureContext context) {
    final String disableMoxy = CommonProperties.MOXY_JSON_FEATURE_DISABLE + '.'
            + context.getConfiguration().getRuntimeType().name().toLowerCase();
    context.property(disableMoxy, true);
    context.register(FastJsonProvider.class, MessageBodyReader.class, MessageBodyWriter.class);
    return true;
}
 

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext featureContext) {
  if (authConfiguration.isEnabled()) {
    if (resourceInfo.getResourceMethod().getAnnotation(NoAuth.class) == null
        && resourceInfo.getResourceClass().getAnnotation(NoAuth.class) == null) {
      featureContext.register(requestFilter);
    }
  }
}
 

@Override
public boolean configure(FeatureContext context) {
    if (client == null) {
        client = createClient();
    }

    client.register(RxBodyReader.class);
    context.register(new Binder());

    return true;
}
 

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

    List<Annotation> authzSpecs = new ArrayList<>();
    boolean canRedirect = true;
    for (Class<? extends Annotation> annotationClass : filterAnnotations) {
        // XXX What is the performance of getAnnotation vs getAnnotations?
        Annotation classAuthzSpec = resourceInfo.getResourceClass().getAnnotation(annotationClass);
        Annotation methodAuthzSpec = resourceInfo.getResourceMethod().getAnnotation(annotationClass);

        if (classAuthzSpec != null) authzSpecs.add(classAuthzSpec);
        if (methodAuthzSpec != null) authzSpecs.add(methodAuthzSpec);
        
        if(resourceInfo.getResourceClass().isAnnotationPresent(NoAuthRedirect.class)
        		|| resourceInfo.getResourceMethod().isAnnotationPresent(NoAuthRedirect.class))
        	canRedirect = false;
        if(resourceInfo.getResourceClass().isAnnotationPresent(NoAuthFilter.class)
        		|| resourceInfo.getResourceMethod().isAnnotationPresent(NoAuthFilter.class))
        	return;
    }

    if (!authzSpecs.isEmpty()) {
    	if(canRedirect)
    		context.register(new LoginRedirectFilter(), Priorities.AUTHENTICATION + 1);
        context.register(new AuthorizationFilter(authzSpecs), Priorities.AUTHORIZATION);
    }
}
 

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

/**
 * {@inheritDoc}
 */
@Override
public boolean configure(FeatureContext context) {
    if (!context.getConfiguration().isRegistered(TextMessageBodyWriter.class)) {
        context.register(TextMessageBodyWriter.class);
    }

    if (!context.getConfiguration().isRegistered(CaptchaWriterInterceptor.class)) {
        context.register(CaptchaWriterInterceptor.class);
    }

    if (!context.getConfiguration().isRegistered(PathMessageBodyWriter.class)) {
        context.register(PathMessageBodyWriter.class);
    }

    if (!context.getConfiguration().isRegistered(ContentLengthWriterInterceptor.class)) {
        context.register(ContentLengthWriterInterceptor.class);
    }

    if (!context.getConfiguration().isRegistered(StreamingWriterInterceptor.class)) {
        context.register(StreamingWriterInterceptor.class);
        // streaming process
        context.register(BlobStreamingProcess.class);
        context.register(BytesStreamingProcess.class);
        context.register(ClobStreamingProcess.class);
        context.register(FileStreamingProcess.class);
        context.register(InputStreamingProcess.class);
        context.register(PathStreamingProcess.class);
    }

    return false;
}
 

@Override
public boolean configure(FeatureContext context) {
    if (client == null) {
        client = defaultClient();
    }

    client.register(RxBodyReader.class);
    context.register(new Binder());

    return true;
}
 

protected void registerTransactionFilter(FeatureContext context) {
    context.register(MCRDBTransactionFilter.class);
}
 

@Override
public boolean configure(final FeatureContext context) {
    context.register(new OptionalParamBinder());
    return true;
}
 

@Override
public boolean configure(FeatureContext context) {
	context.register(AwsFeature.class);
	return true;
}
 

@Override
public boolean configure(FeatureContext context) {
    context.register(new BookInfoReader());
    return true;
}
 

@Override
public void configure(FeatureContext context) {
    context.register(KrazoModelProcessor.class);
    context.register(KrazoValidationInterceptor.class);
}
 

@Override
public boolean configure(FeatureContext context) {
	context.register(AwsFeature.class);
	return true;
}
 

@Override
public boolean configure(FeatureContext context) {
    context.register(new SetProxyTimeoutFilter(timeout));
    return true;
}