Drop support for RxJava 1.

Closes #2469

Author: mp911de

pom.xml

@@ -112,20 +112,6 @@
 
 		<!--  RxJava -->
 
-		<dependency>
-			<groupId>io.reactivex</groupId>
-			<artifactId>rxjava</artifactId>
-			<version>${rxjava}</version>
-			<optional>true</optional>
-		</dependency>
-
-		<dependency>
-			<groupId>io.reactivex</groupId>
-			<artifactId>rxjava-reactive-streams</artifactId>
-			<version>${rxjava-reactive-streams}</version>
-			<optional>true</optional>
-		</dependency>
-
 		<dependency>
 			<groupId>io.reactivex.rxjava2</groupId>
 			<artifactId>rxjava</artifactId>

src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java

@@ -22,8 +22,6 @@
 import kotlinx.coroutines.reactive.ReactiveFlowKt;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
-import rx.Observable;
-import rx.Single;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -54,8 +52,6 @@
  * <p>
  * This class discovers reactive wrapper availability and their conversion support based on the class path. Reactive
  * wrapper types might be supported/on the class path but conversion may require additional dependencies.
- * <p>
- * <strong>Note:</strong> As of Spring Data 2.4, support for RxJava 1.x is deprecated in favor of RxJava 2 and 3.
  *
  * @author Mark Paluch
  * @author Oliver Gierke
@@ -72,12 +68,6 @@ public abstract class ReactiveWrapperConverters {
 
 	static {
 
-		if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA1)) {
-
-			REACTIVE_WRAPPERS.add(RxJava1SingleWrapper.INSTANCE);
-			REACTIVE_WRAPPERS.add(RxJava1ObservableWrapper.INSTANCE);
-		}
-
 		if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA2)) {
 
 			REACTIVE_WRAPPERS.add(RxJava2SingleWrapper.INSTANCE);
@@ -341,46 +331,6 @@ public Publisher<?> map(Object wrapper, Function<Object, Object> function) {
 		}
 	}
 
-	// -------------------------------------------------------------------------
-	// RxJava 1 converters
-	// -------------------------------------------------------------------------
-
-	/**
-	 * Wrapper for RxJava 1's {@link Single}.
-	 */
-	private enum RxJava1SingleWrapper implements ReactiveTypeWrapper<Single<?>> {
-
-		INSTANCE;
-
-		@Override
-		public Class<? super Single<?>> getWrapperClass() {
-			return Single.class;
-		}
-
-		@Override
-		public Single<?> map(Object wrapper, Function<Object, Object> function) {
-			return ((Single<?>) wrapper).map(function::apply);
-		}
-	}
-
-	/**
-	 * Wrapper for RxJava 1's {@link Observable}.
-	 */
-	private enum RxJava1ObservableWrapper implements ReactiveTypeWrapper<Observable<?>> {
-
-		INSTANCE;
-
-		@Override
-		public Class<? super Observable<?>> getWrapperClass() {
-			return Observable.class;
-		}
-
-		@Override
-		public Observable<?> map(Object wrapper, Function<Object, Object> function) {
-			return ((Observable<?>) wrapper).map(function::apply);
-		}
-	}
-
 	// -------------------------------------------------------------------------
 	// RxJava 2 converters
 	// -------------------------------------------------------------------------

src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java

@@ -35,8 +35,6 @@
  * <p>
  * Supported types are discovered by their availability on the class path. This class is typically used to determine
  * multiplicity and whether a reactive wrapper type is acceptable for a specific operation.
- * <p>
- * <strong>Note:</strong> As of Spring Data 2.4, support for RxJava 1.x is deprecated in favor of RxJava 2 and 3.
  *
  * @author Mark Paluch
  * @author Christoph Strobl
@@ -45,9 +43,6 @@
  * @author Hantsy Bai
  * @since 2.0
  * @see org.reactivestreams.Publisher
- * @see rx.Single
- * @see rx.Observable
- * @see rx.Completable
  * @see io.reactivex.Single
  * @see io.reactivex.Maybe
  * @see io.reactivex.Observable
@@ -68,12 +63,6 @@ public abstract class ReactiveWrappers {
 	private static final boolean PROJECT_REACTOR_PRESENT = ClassUtils.isPresent("reactor.core.publisher.Flux",
 			ReactiveWrappers.class.getClassLoader());
 
-	@Deprecated
-	private static final boolean RXJAVA1_PRESENT = ClassUtils.isPresent("rx.Observable",
-			ReactiveWrappers.class.getClassLoader())
-			&& ClassUtils.isPresent("rx.RxReactiveStreams",
-			ReactiveWrappers.class.getClassLoader());
-
 	@Deprecated
 	private static final boolean RXJAVA2_PRESENT = ClassUtils.isPresent("io.reactivex.Flowable",
 			ReactiveWrappers.class.getClassLoader());
@@ -98,17 +87,11 @@ public enum ReactiveLibrary {
 
 		PROJECT_REACTOR,
 
-		/**
-		 * @deprecated since 2.4, use RxJava 3 instead. To be removed with Spring Data 3.0.
-		 */
-		@Deprecated
-		RXJAVA1,
-
 		/**
 		 * @deprecated since 2.6, use RxJava 3 instead. To be removed with Spring Data 3.0.
 		 */
 		@Deprecated
-		RXJAVA2, RXJAVA3, KOTLIN_COROUTINES, MUTINY;
+		RXJAVA2, RXJAVA3, KOTLIN_COROUTINES;
 	}
 
 	/**
@@ -134,8 +117,6 @@ public static boolean isAvailable(ReactiveLibrary reactiveLibrary) {
 		switch (reactiveLibrary) {
 			case PROJECT_REACTOR:
 				return PROJECT_REACTOR_PRESENT;
-			case RXJAVA1:
-				return RXJAVA1_PRESENT;
 			case RXJAVA2:
 				return RXJAVA2_PRESENT;
 			case RXJAVA3:

src/test/java/org/springframework/data/repository/core/support/QueryExecutionResultHandlerUnitTests.java

@@ -18,14 +18,14 @@
 import static java.util.Arrays.*;
 import static org.assertj.core.api.Assertions.*;
 
+import io.reactivex.rxjava3.core.Completable;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Single;
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 import lombok.Value;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
-import rx.Completable;
-import rx.Observable;
-import rx.Single;
 
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
@@ -41,6 +41,7 @@
 import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Publisher;
+
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.util.Streamable;
@@ -120,7 +121,7 @@ void convertsRxJavaSingleIntoPublisher() throws Exception {
 		assertThat(result).isInstanceOf(Publisher.class);
 
 		Mono<Entity> mono = Mono.from((Publisher<Entity>) result);
-		assertThat(mono.block()).isEqualTo(entity.toBlocking().value());
+		assertThat(mono.block()).isEqualTo(entity.blockingGet());
 	}
 
 	@Test // DATACMNS-836
@@ -133,7 +134,7 @@ void convertsRxJavaSingleIntoMono() throws Exception {
 		assertThat(result).isInstanceOf(Mono.class);
 
 		Mono<Entity> mono = (Mono<Entity>) result;
-		assertThat(mono.block()).isEqualTo(entity.toBlocking().value());
+		assertThat(mono.block()).isEqualTo(entity.blockingGet());
 	}
 
 	@Test // DATACMNS-836
@@ -146,7 +147,7 @@ void convertsRxJavaSingleIntoFlux() throws Exception {
 		assertThat(result).isInstanceOf(Flux.class);
 
 		Flux<Entity> flux = (Flux<Entity>) result;
-		assertThat(flux.next().block()).isEqualTo(entity.toBlocking().value());
+		assertThat(flux.next().block()).isEqualTo(entity.blockingGet());
 	}
 
 	@Test // DATACMNS-836
@@ -159,7 +160,7 @@ void convertsRxJavaObservableIntoPublisher() throws Exception {
 		assertThat(result).isInstanceOf(Publisher.class);
 
 		Mono<Entity> mono = Mono.from((Publisher<Entity>) result);
-		assertThat(mono.block()).isEqualTo(entity.toBlocking().first());
+		assertThat(mono.block()).isEqualTo(entity.blockingFirst());
 	}
 
 	@Test // DATACMNS-836
@@ -172,7 +173,7 @@ void convertsRxJavaObservableIntoMono() throws Exception {
 		assertThat(result).isInstanceOf(Mono.class);
 
 		Mono<Entity> mono = (Mono<Entity>) result;
-		assertThat(mono.block()).isEqualTo(entity.toBlocking().first());
+		assertThat(mono.block()).isEqualTo(entity.blockingFirst());
 	}
 
 	@Test // DATACMNS-836
@@ -185,7 +186,7 @@ void convertsRxJavaObservableIntoFlux() throws Exception {
 		assertThat(result).isInstanceOf(Flux.class);
 
 		Flux<Entity> flux = (Flux<Entity>) result;
-		assertThat(flux.next().block()).isEqualTo(entity.toBlocking().first());
+		assertThat(flux.next().block()).isEqualTo(entity.blockingFirst());
 	}
 
 	@Test // DATACMNS-836
@@ -198,7 +199,7 @@ void convertsRxJavaObservableIntoSingle() throws Exception {
 		assertThat(result).isInstanceOf(Single.class);
 
 		Single<Entity> single = (Single<Entity>) result;
-		assertThat(single.toBlocking().value()).isEqualTo(entity.toBlocking().first());
+		assertThat(single.blockingGet()).isEqualTo(entity.blockingFirst());
 	}
 
 	@Test // DATACMNS-836
@@ -211,7 +212,7 @@ void convertsRxJavaSingleIntoObservable() throws Exception {
 		assertThat(result).isInstanceOf(Observable.class);
 
 		Observable<Entity> observable = (Observable<Entity>) result;
-		assertThat(observable.toBlocking().first()).isEqualTo(entity.toBlocking().value());
+		assertThat(observable.blockingFirst()).isEqualTo(entity.blockingGet());
 	}
 
 	@Test // DATACMNS-836
@@ -224,7 +225,7 @@ void convertsReactorMonoIntoSingle() throws Exception {
 		assertThat(result).isInstanceOf(Single.class);
 
 		Single<Entity> single = (Single<Entity>) result;
-		assertThat(single.toBlocking().value()).isEqualTo(entity.block());
+		assertThat(single.blockingGet()).isEqualTo(entity.block());
 	}
 
 	@Test // DATACMNS-836
@@ -237,7 +238,7 @@ void convertsReactorMonoIntoCompletable() throws Exception {
 		assertThat(result).isInstanceOf(Completable.class);
 
 		Completable completable = (Completable) result;
-		assertThat(completable.get()).isNull();
+		completable.blockingAwait();
 	}
 
 	@Test // DATACMNS-836
@@ -250,7 +251,7 @@ void convertsReactorMonoIntoCompletableWithException() throws Exception {
 		assertThat(result).isInstanceOf(Completable.class);
 
 		Completable completable = (Completable) result;
-		assertThat(completable.get()).isInstanceOf(InvalidDataAccessApiUsageException.class);
+		assertThatExceptionOfType(InvalidDataAccessApiUsageException.class).isThrownBy(completable::blockingAwait);
 	}
 
 	@Test // DATACMNS-836
@@ -290,7 +291,7 @@ void convertsReactorMonoIntoObservable() throws Exception {
 		assertThat(result).isInstanceOf(Observable.class);
 
 		Observable<Entity> observable = (Observable<Entity>) result;
-		assertThat(observable.toBlocking().first()).isEqualTo(entity.block());
+		assertThat(observable.blockingFirst()).isEqualTo(entity.block());
 	}
 
 	@Test // DATACMNS-836
@@ -303,7 +304,7 @@ void convertsReactorFluxIntoSingle() throws Exception {
 		assertThat(result).isInstanceOf(Single.class);
 
 		Single<Entity> single = (Single<Entity>) result;
-		assertThat(single.toBlocking().value()).isEqualTo(entity.next().block());
+		assertThat(single.blockingGet()).isEqualTo(entity.next().block());
 	}
 
 	@Test // DATACMNS-836
@@ -316,7 +317,7 @@ void convertsReactorFluxIntoObservable() throws Exception {
 		assertThat(result).isInstanceOf(Observable.class);
 
 		Observable<Entity> observable = (Observable<Entity>) result;
-		assertThat(observable.toBlocking().first()).isEqualTo(entity.next().block());
+		assertThat(observable.blockingFirst()).isEqualTo(entity.next().block());
 	}
 
 	@Test // DATACMNS-836

src/test/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformationUnitTests.java

@@ -17,10 +17,8 @@
 
 import static org.assertj.core.api.Assertions.*;
 
-import io.reactivex.Completable;
 import io.reactivex.Flowable;
 import reactor.core.publisher.Flux;
-import rx.Observable;
 
 import java.lang.reflect.Method;
 
@@ -29,7 +27,6 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.reactivestreams.Publisher;
 
-import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.reactive.ReactiveCrudRepository;
 import org.springframework.data.repository.reactive.ReactiveSortingRepository;
@@ -47,26 +44,6 @@ class ReactiveRepositoryInformationUnitTests {
 
 	static final Class<ReactiveJavaInterfaceWithGenerics> BASE_CLASS = ReactiveJavaInterfaceWithGenerics.class;
 
-	@Test // DATACMNS-836
-	void discoversRxJava1MethodWithoutComparingReturnType() throws Exception {
-
-		Method reference = extractTargetMethodFromRepository(RxJava1InterfaceWithGenerics.class, "deleteAll");
-
-		assertThat(reference.getDeclaringClass()).isEqualTo(ReactiveCrudRepository.class);
-		assertThat(reference.getName()).isEqualTo("deleteAll");
-	}
-
-	@Test // DATACMNS-836
-	void discoversRxJava1MethodWithConvertibleArguments() throws Exception {
-
-		Method reference = extractTargetMethodFromRepository(RxJava1InterfaceWithGenerics.class, "saveAll",
-				Observable.class);
-
-		assertThat(reference.getDeclaringClass()).isEqualTo(ReactiveCrudRepository.class);
-		assertThat(reference.getName()).isEqualTo("saveAll");
-		assertThat(reference.getParameterTypes()[0]).isEqualTo(Publisher.class);
-	}
-
 	@Test // DATACMNS-988
 	void discoversRxJava2MethodWithoutComparingReturnType() throws Exception {
 
@@ -136,13 +113,6 @@ private Method extractTargetMethodFromRepository(Class<?> repositoryType, String
 		return composition.findMethod(repositoryType.getMethod(methodName, args)).get();
 	}
 
-	interface RxJava1InterfaceWithGenerics extends Repository<User, String> {
-
-		Observable<User> saveAll(Observable<User> entities);
-
-		Completable deleteAll();
-	}
-
 	interface RxJava2InterfaceWithGenerics extends RxJava2CrudRepository<User, String> {}
 
 	interface ReactiveJavaInterfaceWithGenerics extends ReactiveCrudRepository<User, String> {}