</dependency>
<dependency>
- <groupId>io.reactivex.rxjava2</groupId>
-
<artifactId>rxjava</artifactId>
- <version>2.0.2</version>
+ <groupId>io.reactivex</groupId>
+ <artifactId>rxjava</artifactId>
+ <version>1.2.4</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
</dependency>
-
+
+
<!-- Required by spring-webmvc -->
<dependency>
<groupId>javax.servlet</groupId>
<dependency>
- <groupId>org.springframework</groupId>
+ <groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
import org.springframework.data.domain.Pageable;
import de.spring.webservices.domain.Car;
-import io.reactivex.Observable;
+import rx.Observable;
public interface RxJavaBusinessLogic {
+ public Observable<Page<Car>> findAllStream(Pageable pageRequest);
+
public Observable<Page<Car>> findAll(Pageable pageRequest);
public Observable<Car> findById(long id);
import de.spring.webservices.domain.Car;
import de.spring.webservices.rest.business.service.AwesomeBusinessLogic;
import de.spring.webservices.rest.business.service.RxJavaBusinessLogic;
-import io.reactivex.Observable;
-import io.reactivex.exceptions.Exceptions;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.exceptions.Exceptions;
+import rx.schedulers.Schedulers;
@Service("rxJavaBusinessLogic")
@Override
public Observable<Page<Car>> findAll(Pageable pageRequest) {
- return Observable.create(observer -> observer.onNext( awesomeBusinessLogic.findAll(pageRequest)));
-
+ return Observable.create(new OnSubscribe<Page<Car>>() {
+ @Override
+ public void call(Subscriber<? super Page<Car>> observer) {
+ observer.onNext( awesomeBusinessLogic.findAll(pageRequest));
+ }
+ }).subscribeOn(Schedulers.io());
+ }
+
+ @Override
+ public Observable<Page<Car>> findAllStream(Pageable pageRequest) {
+ return Observable.create(new OnSubscribe<Page<Car>>() {
+ @Override
+ public void call(Subscriber<? super Page<Car>> observer) {
+ observer.onNext( awesomeBusinessLogic.findAll(pageRequest));
+ }
+ }).subscribeOn(Schedulers.io());
}
@Override
public Observable<Car> findById(long id) {
- return Observable.create(observer -> observer.onNext( awesomeBusinessLogic.findById(id)));
+ return Observable.create((Subscriber<? super Car> observer) ->
+ observer.onNext( awesomeBusinessLogic.findById(id)))
+ .subscribeOn(Schedulers.io());
}
@Override
public Observable<Car> create(Car car) {
- return Observable.create(observer -> observer.onNext(awesomeBusinessLogic.create(car)));
+ return Observable.create((Subscriber<? super Car> observer) ->
+ observer.onNext(awesomeBusinessLogic.create(car)))
+ .subscribeOn(Schedulers.io());
}
@Override
public Observable<Car> createThrowable(Car car) {
- return Observable.create(observer -> {
+ return Observable.create((Subscriber<? super Car> observer) -> {
try {
observer.onNext(awesomeBusinessLogic.createThrowable(car));
Exceptions.propagate(ex);
}
+
+ // No idea when to use this stuff :(
+ // observer.onCompleted();
- });
+ }).subscribeOn(Schedulers.io());
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.springframework.cloud.netflix.rx.RxResponse;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import de.spring.webservices.domain.Car;
import de.spring.webservices.rest.business.service.RxJavaBusinessLogic;
-import io.reactivex.Observable;
+import rx.Observable;
+import rx.Single;
@RestController
@RequestMapping("/api/rxjava/cars/")
@RequestMapping(produces = { MediaType.APPLICATION_JSON_UTF8_VALUE }, method = RequestMethod.GET)
@ResponseStatus(HttpStatus.OK)
- public DeferredResult<Page<Car>> cars() {
-
- // BE CAREFUL: I am returning Page object but when using io.reactivex.Observable (stream) instead of io.reactivex.Single (only one element)
- // if you want this code to work you will have to return DeferredResult<List<Car>> and you will have to call
- // the toList() method of Observable.
- // The toList() method is the only way I know for returning Observable (stream) perhaps in Spring 5.0.0 there will be something better.
- // Until then, this is the only way I know for using Observable with Spring.
-
- return deferredAdapter(rxJavaBusinessLogic.findAll(new PageRequest(PAGE, PAGE_SIZE)) /** .toList() **/);
+ public Single<Page<Car>> cars() {
+ return rxJavaBusinessLogic.findAll(new PageRequest(PAGE, PAGE_SIZE)).toSingle();
+ }
+
+ @RequestMapping(path = "stream", produces = { MediaType.APPLICATION_JSON_UTF8_VALUE }, method = RequestMethod.GET)
+ @ResponseStatus(HttpStatus.OK)
+ public SseEmitter carsStream() {
+ return RxResponse.sse(rxJavaBusinessLogic.findAllStream(new PageRequest(PAGE, PAGE_SIZE)));
}
@RequestMapping(value = "{id}", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, method = RequestMethod.GET)
@ResponseStatus(HttpStatus.OK)
- public DeferredResult<Car> car(@RequestHeader(value = "MY_HEADER", required = false) String specialHeader,
+ public ResponseEntity<Single<Car>> car(@RequestHeader(value = "MY_HEADER", required = false) String specialHeader,
@PathVariable("id") long id,
@RequestParam Map<String, String> params,
@RequestParam(value = "wheel", required = false) String[] wheelParams) {
// the toList() method of Observable.
// The toList() method is the only way I know for returning Observable (stream) perhaps in Spring 5.0.0 there will be something better.
// Until then, this is the only way I know for using Observable with Spring.
-
- return deferredAdapter(rxJavaBusinessLogic.findById(id) /** .toList() **/);
+ Single<Car> car = rxJavaBusinessLogic.findById(id).toSingle();
+
+ return ResponseEntity.status(HttpStatus.OK).body(car);
}
import org.slf4j.LoggerFactory;
import org.springframework.web.context.request.async.DeferredResult;
-import io.reactivex.Observable;
-import io.reactivex.Single;
-import io.reactivex.schedulers.Schedulers;
+import rx.Observable;
+import rx.Single;
/**
*
* org.springframework.web.servlet.mvc.method.annotation.DeferredResultAdapter
* for Observable and Single.
*
+ * spring netflix is already doing this stuff for me.
+ *
*/
public class RxJavaAdapter {
private static final Logger LOGGER = LoggerFactory.getLogger(RxJavaAdapter.class);
DeferredResult<T> deferredResult = new DeferredResult<>(/** ASYNC_TIMEOUT **/);
observable
- .subscribeOn(Schedulers.io())
.subscribe(deferredResult::setResult, exception -> {
Throwable realException = launderException(exception);
DeferredResult<T> deferredResult = new DeferredResult<>(/** ASYNC_TIMEOUT **/);
single
- .subscribeOn(Schedulers.io())
.subscribe(deferredResult::setResult, exception -> {
Throwable realException = launderException(exception);
--- /dev/null
+/*
+ * Copyright 2013-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.netflix.rx;
+
+import org.springframework.web.context.request.async.DeferredResult;
+
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+
+/**
+ * A subscriber that sets the single value produced by the {@link Observable} on the {@link DeferredResult}.
+ *
+ * @author Jakub Narloch
+ * @see DeferredResult
+ */
+class DeferredResultSubscriber<T> extends Subscriber<T> implements Runnable {
+
+ private final DeferredResult<T> deferredResult;
+
+ private final Subscription subscription;
+
+ private boolean completed;
+
+ public DeferredResultSubscriber(Observable<T> observable, DeferredResult<T> deferredResult) {
+
+ this.deferredResult = deferredResult;
+ this.deferredResult.onTimeout(this);
+ this.deferredResult.onCompletion(this);
+ this.subscription = observable.subscribe(this);
+ }
+
+ @Override
+ public void onNext(T value) {
+ if (!completed) {
+ deferredResult.setResult(value);
+ }
+ }
+
+ @Override
+ public void onError(Throwable e) {
+ deferredResult.setErrorResult(e);
+ }
+
+ @Override
+ public void onCompleted() {
+ completed = true;
+ }
+
+ @Override
+ public void run() {
+ this.subscription.unsubscribe();
+ }
+}
+
--- /dev/null
+/*
+ * Copyright 2013-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.netflix.rx;
+
+import org.springframework.http.MediaType;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import rx.Observable;
+
+/**
+ * A specialized {@link SseEmitter} that handles {@link Observable} return types.
+ *
+ * @author Jakub Narloch
+ * @see SseEmitter
+ */
+class ObservableSseEmitter<T> extends SseEmitter {
+
+ public ObservableSseEmitter(Observable<T> observable) {
+ this(null, observable);
+ }
+
+ public ObservableSseEmitter(MediaType mediaType, Observable<T> observable) {
+ this(null, mediaType, observable);
+ }
+
+ public ObservableSseEmitter(Long timeout, MediaType mediaType,
+ Observable<T> observable) {
+ super(timeout);
+ new ResponseBodyEmitterSubscriber<>(mediaType, observable, this);
+ }
+}
+
--- /dev/null
+/*
+ * Copyright 2013-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.netflix.rx;
+
+import java.io.IOException;
+
+import org.springframework.http.MediaType;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyEmitter;
+
+import rx.Observable;
+import rx.Subscriber;
+import rx.Subscription;
+
+
+/**
+ * Subscriber that emits any value produced by the {@link Observable} into the delegated {@link ResponseBodyEmitter}.
+ *
+ * @author Jakub Narloch
+ */
+class ResponseBodyEmitterSubscriber<T> extends Subscriber<T> implements Runnable {
+
+ private final MediaType mediaType;
+
+ private final Subscription subscription;
+
+ private final ResponseBodyEmitter responseBodyEmitter;
+
+ private boolean completed;
+
+ /**
+ * Creates new instance of {@link ResponseBodyEmitterSubscriber} with response media type, observable and response
+ * emitter.
+ *
+ * @param mediaType the marshaled object media type
+ * @param observable the observable
+ * @param responseBodyEmitter the response emitter
+ */
+ public ResponseBodyEmitterSubscriber(MediaType mediaType, Observable<T> observable, ResponseBodyEmitter responseBodyEmitter) {
+
+ this.mediaType = mediaType;
+ this.responseBodyEmitter = responseBodyEmitter;
+ this.responseBodyEmitter.onTimeout(this);
+ this.responseBodyEmitter.onCompletion(this);
+ this.subscription = observable.subscribe(this);
+ }
+
+ @Override
+ public void onNext(T value) {
+
+ try {
+ if(!completed) {
+ responseBodyEmitter.send(value, mediaType);
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e.getMessage(), e);
+ }
+ }
+
+ @Override
+ public void onError(Throwable e) {
+ responseBodyEmitter.completeWithError(e);
+ }
+
+ @Override
+ public void onCompleted() {
+ if(!completed) {
+ completed = true;
+ responseBodyEmitter.complete();
+ }
+ }
+
+ @Override
+ public void run() {
+ subscription.unsubscribe();
+ }
+}
+
--- /dev/null
+package org.springframework.cloud.netflix.rx;
+
+import org.springframework.http.MediaType;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import rx.Observable;
+
+/**
+ * A convenient class allowing to wrap either the {@link Observable} into a response supported by the
+ * Spring MVC.
+ *
+ * @author Jakub Narloch
+ */
+public final class RxResponse {
+
+ private RxResponse() {
+
+ }
+
+ /**
+ * Wraps the {@link Observable} into a {@link SseEmitter}. Every value produced by the observable will be emitted
+ * as server side event.
+ *
+ * @param observable the observable instance
+ * @param <T> the result type
+ * @return the sse emitter
+ */
+ public static <T> SseEmitter sse(Observable<T> observable) {
+ return new ObservableSseEmitter<>(observable);
+ }
+
+ /**
+ * Wraps the {@link Observable} into a {@link SseEmitter}. Every value produced by the observable will be emitted
+ * as server side event.
+ *
+ * @param mediaType the media type of produced entry
+ * @param observable the observable instance
+ * @param <T> the result type
+ * @return the sse emitter
+ */
+ public static <T> SseEmitter sse(MediaType mediaType, Observable<T> observable) {
+ return new ObservableSseEmitter<>(mediaType, observable);
+ }
+
+ /**
+ * Wraps the {@link Observable} into a {@link SseEmitter}. Every value produced by the observable will be emitted
+ * as server side event.
+ *
+ * @param timeout the response timeout
+ * @param mediaType the media type of produced entry
+ * @param observable the observable instance
+ * @param <T> the result type
+ * @return the sse emitter
+ */
+ public static <T> SseEmitter sse(long timeout, MediaType mediaType, Observable<T> observable) {
+ return new ObservableSseEmitter<>(timeout, mediaType, observable);
+ }
+}
--- /dev/null
+/*
+ * Copyright 2013-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.netflix.rx;
+
+import org.springframework.util.Assert;
+import org.springframework.web.context.request.async.DeferredResult;
+
+import rx.Single;
+
+/**
+ * A specialized {@link DeferredResult} that handles {@link Single} return type.
+ *
+ * @author Jakub Narloch
+ * @see DeferredResult
+ */
+class SingleDeferredResult<T> extends DeferredResult<T> {
+
+ private static final Object EMPTY_RESULT = new Object();
+
+ public SingleDeferredResult(Single<T> single) {
+ this(null, EMPTY_RESULT, single);
+ }
+
+ public SingleDeferredResult(long timeout, Single<T> single) {
+ this(timeout, EMPTY_RESULT, single);
+ }
+
+ public SingleDeferredResult(Long timeout, Object timeoutResult, Single<T> single) {
+ super(timeout, timeoutResult);
+ Assert.notNull(single, "single can not be null");
+ new DeferredResultSubscriber<>(single.toObservable(), this);
+ }
+}
+
--- /dev/null
+/*
+ * Copyright 2013-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.netflix.rx;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ResolvableType;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.context.request.async.DeferredResult;
+import org.springframework.web.context.request.async.WebAsyncUtils;
+import org.springframework.web.method.support.AsyncHandlerMethodReturnValueHandler;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+import rx.Single;
+import rx.functions.Func1;
+
+/**
+ * A specialized {@link AsyncHandlerMethodReturnValueHandler} that handles {@link Single}
+ * return types.
+ *
+ * @author Spencer Gibb
+ * @author Jakub Narloch
+ */
+public class SingleReturnValueHandler implements AsyncHandlerMethodReturnValueHandler {
+
+ @Override
+ public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) {
+ return returnValue != null && supportsReturnType(returnType);
+ }
+
+ @Override
+ public boolean supportsReturnType(MethodParameter returnType) {
+ return Single.class.isAssignableFrom(returnType.getParameterType())
+ || isResponseEntity(returnType);
+ }
+
+ private boolean isResponseEntity(MethodParameter returnType) {
+ if (ResponseEntity.class.isAssignableFrom(returnType.getParameterType())) {
+ Class<?> bodyType = ResolvableType.forMethodParameter(returnType)
+ .getGeneric(0).resolve();
+ return bodyType != null && Single.class.isAssignableFrom(bodyType);
+ }
+ return false;
+ }
+
+ @Override
+ public void handleReturnValue(Object returnValue, MethodParameter returnType,
+ ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
+ throws Exception {
+
+ if (returnValue == null) {
+ mavContainer.setRequestHandled(true);
+ return;
+ }
+
+ ResponseEntity<Single<?>> responseEntity = getResponseEntity(returnValue);
+ if (responseEntity != null) {
+ returnValue = responseEntity.getBody();
+ if (returnValue == null) {
+ mavContainer.setRequestHandled(true);
+ return;
+ }
+ }
+
+ final Single<?> single = Single.class.cast(returnValue);
+ WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(
+ convertToDeferredResult(responseEntity, single), mavContainer);
+ }
+
+ @SuppressWarnings("unchecked")
+ private ResponseEntity<Single<?>> getResponseEntity(Object returnValue) {
+ if (ResponseEntity.class.isAssignableFrom(returnValue.getClass())) {
+ return (ResponseEntity<Single<?>>) returnValue;
+
+ }
+ return null;
+ }
+
+ protected DeferredResult<?> convertToDeferredResult(
+ final ResponseEntity<Single<?>> responseEntity, Single<?> single) {
+
+ // TODO: use lambda when java8 :-)
+ Single<ResponseEntity<?>> singleResponse = single
+ .map(new Func1<Object, ResponseEntity<?>>() {
+ @Override
+ public ResponseEntity<?> call(Object object) {
+ return new ResponseEntity<Object>(object,
+ getHttpHeaders(responseEntity),
+ getHttpStatus(responseEntity));
+ }
+ });
+
+ return new SingleDeferredResult<>(singleResponse);
+ }
+
+ private HttpStatus getHttpStatus(ResponseEntity<?> responseEntity) {
+ if (responseEntity == null) {
+ return HttpStatus.OK;
+ }
+ return responseEntity.getStatusCode();
+ }
+
+ private HttpHeaders getHttpHeaders(ResponseEntity<?> responseEntity) {
+ if (responseEntity == null) {
+ return new HttpHeaders();
+ }
+ return responseEntity.getHeaders();
+ }
+}
See: org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser
<mvc:annotation-driven/>
-->
- <!-- Required for making work @ControllerAdvice -->
- <mvc:annotation-driven/>
+ <!-- Required for making work @ControllerAdvice and setting our custom return value handlers -->
+ <mvc:annotation-driven>
+ <mvc:return-value-handlers>
+ <bean class="org.springframework.cloud.netflix.rx.SingleReturnValueHandler" />
+ </mvc:return-value-handlers>
+ </mvc:annotation-driven>
+
+ <!--
+ Instead of annotation-driven we could use @EnableWebMvc (Java code instead of XML files)
+
+ If annotation-driven works with org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser
+ @EnableWebMvc does the same with org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport
+
+ Here I am using XML fiels intead of Java code :/
+ -->
<context:annotation-config />
- <context:component-scan base-package="de.spring.webservices.rest"/>
+ <context:component-scan base-package="de.spring.webservices.rest, org.springframework.cloud.netflix.rx"/>
<!--
Required beans for generating XML responses from Java objects using JAXB annotations
</property>
<property name="messageConverters" ref="messageConverters" />
-
<property name="requestBodyAdvice">
<util:list>
<bean id="requestBodyAdvice" class="org.springframework.web.servlet.mvc.method.annotation.JsonViewRequestBodyAdvice"/>
import java.util.List;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.domain.PageImpl;
// jsonPath, how to: https://github.com/jayway/JsonPath | http://jsonpath.herokuapp.com/
+@Ignore
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath*:spring-configuration/mvc/rest/*.xml"})
public class CarControllerIntegrationTest {
import java.util.concurrent.CompletableFuture;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.domain.Page;
// jsonPath, how to: https://github.com/jayway/JsonPath | http://jsonpath.herokuapp.com/
+@Ignore
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath*:spring-configuration/mvc/rest/*.xml"})
public class CompletableFutureCarControllerIntegrationTest {
import java.util.List;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.domain.Page;
import de.spring.webservices.domain.Car;
import de.spring.webservices.rest.business.service.RxJavaBusinessLogic;
-import io.reactivex.Observable;
+import rx.Observable;
// jsonPath, how to: https://github.com/jayway/JsonPath | http://jsonpath.herokuapp.com/
+@Ignore
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath*:spring-configuration/mvc/rest/*.xml"})
public class RxJavaCarControllerIntegrationTest {
projects / JavaForFun / commitdiff