Refine search
@SuppressWarnings("unchecked") HttpMessageConverterExtractor(Type responseType, List<HttpMessageConverter<?>> messageConverters, Log logger) { Assert.notNull(responseType, "'responseType' must not be null"); Assert.notEmpty(messageConverters, "'messageConverters' must not be empty"); this.responseType = responseType; this.responseClass = (responseType instanceof Class ? (Class<T>) responseType : null); this.messageConverters = messageConverters; this.logger = logger; }
public WebMvcStompWebSocketEndpointRegistration( String[] paths, WebSocketHandler webSocketHandler, TaskScheduler sockJsTaskScheduler) { Assert.notEmpty(paths, "No paths specified"); Assert.notNull(webSocketHandler, "WebSocketHandler must not be null"); this.paths = paths; this.webSocketHandler = webSocketHandler; this.sockJsTaskScheduler = sockJsTaskScheduler; }
/** * Create a {@link ResourceHandlerRegistration} instance. * @param resourceLoader a resource loader for turning a String location * into a {@link Resource} * @param pathPatterns one or more resource URL path patterns */ public ResourceHandlerRegistration(ResourceLoader resourceLoader, String... pathPatterns) { Assert.notNull(resourceLoader, "ResourceLoader is required"); Assert.notEmpty(pathPatterns, "At least one path pattern is required for resource handling"); this.resourceLoader = resourceLoader; this.pathPatterns = pathPatterns; }
public DelegatingWebConnection(WebConnection defaultConnection, List<DelegateWebConnection> connections) { Assert.notNull(defaultConnection, "Default WebConnection must not be null"); Assert.notEmpty(connections, "Connections List must not be empty"); this.connections = connections; this.defaultConnection = defaultConnection; }
@SuppressWarnings("unchecked") HttpMessageConverterExtractor(Type responseType, List<HttpMessageConverter<?>> messageConverters, Log logger) { Assert.notNull(responseType, "'responseType' must not be null"); Assert.notEmpty(messageConverters, "'messageConverters' must not be empty"); this.responseType = responseType; this.responseClass = (responseType instanceof Class ? (Class<T>) responseType : null); this.messageConverters = messageConverters; this.logger = logger; }
/** * Constructor that also accepts a {@link ReactiveAdapterRegistry}. * @param messageReaders readers to convert from the request body * @param adapterRegistry for adapting to other reactive types from Flux and Mono */ protected AbstractMessageReaderArgumentResolver( List<HttpMessageReader<?>> messageReaders, ReactiveAdapterRegistry adapterRegistry) { super(adapterRegistry); Assert.notEmpty(messageReaders, "At least one HttpMessageReader is required"); Assert.notNull(adapterRegistry, "ReactiveAdapterRegistry is required"); this.messageReaders = messageReaders; this.supportedMediaTypes = messageReaders.stream() .flatMap(converter -> converter.getReadableMediaTypes().stream()) .collect(Collectors.toList()); }
@Override public void afterPropertiesSet() throws Exception { Assert.notNull(this.keys, "The 'keys' property must be provided"); Assert.notEmpty(this.keys, "The 'keys' property must not be empty"); Assert.notNull(this.statuses, "The 'statuses' property must be provided"); Assert.notEmpty(this.statuses, "The 'statuses' property must not be empty"); }
/** * Whether this converter should convert messages for which no content type * could be resolved through the configured * {@link org.springframework.messaging.converter.ContentTypeResolver}. * <p>A converter can configured to be strict only when a * {@link #setContentTypeResolver contentTypeResolver} is configured and the * list of {@link #getSupportedMimeTypes() supportedMimeTypes} is not be empty. * <p>When this flag is set to {@code true}, {@link #supportsMimeType(MessageHeaders)} * will return {@code false} if the {@link #setContentTypeResolver contentTypeResolver} * is not defined or if no content-type header is present. */ public void setStrictContentTypeMatch(boolean strictContentTypeMatch) { if (strictContentTypeMatch) { Assert.notEmpty(getSupportedMimeTypes(), "Strict match requires non-empty list of supported mime types"); Assert.notNull(getContentTypeResolver(), "Strict match requires ContentTypeResolver"); } this.strictContentTypeMatch = strictContentTypeMatch; }
/** * Creates a new {@link FacetOperationBuilder} to append a new facet using {@literal operations}. <br /> * {@link FacetOperationBuilder} takes a pipeline of {@link AggregationOperation} to categorize documents into a * single facet. * * @param operations must not be {@literal null} or empty. * @return */ public FacetOperationBuilder and(AggregationOperation... operations) { Assert.notNull(operations, "AggregationOperations must not be null!"); Assert.notEmpty(operations, "AggregationOperations must not be empty!"); return new FacetOperationBuilder(facets, Arrays.asList(operations)); }
/** * Creates a new JPA {@link Metamodel} based {@link MappingContext}. * * @param models must not be {@literal null} or empty. */ public JpaMetamodelMappingContext(Set<Metamodel> models) { Assert.notNull(models, "JPA metamodel must not be null!"); Assert.notEmpty(models, "At least one JPA metamodel must be present!"); this.models = new Metamodels(models); this.persistenceProvider = PersistenceProvider.fromMetamodel(models.iterator().next()); }