Spring/spring-data-commons
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Drop support for RxJava 2.

Browse Source 
Closes #2469
This commit is contained in:
Mark Paluch
2021-09-27 14:00:20 +02:00
committed by Jens Schauder
parent 20a1220cd1
commit d4036ec0a9
12 changed files with 14 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
src/main/java/org/springframework/data/repository/reactive/RxJava2CrudRepository.java
View File

@@ -1,202 +0,0 @@
/*
* Copyright 2017-2021 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
*
* https://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.data.repository.reactive;
import io.reactivex.Completable;
import io.reactivex.Flowable;
import io.reactivex.Maybe;
import io.reactivex.Single;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;
/**
* Interface for generic CRUD operations on a repository for a specific type. This repository follows reactive paradigms
* and uses RxJava 2 types.
*
* @author Mark Paluch
* @since 2.0
* @see Maybe
* @see Single
* @see Flowable
* @see Completable
* @deprecated since 2.6, use {@link RxJava3CrudRepository RxJava 3} instead. To be removed with Spring Data 3.0.
*/
@NoRepositoryBean
@Deprecated
public interface RxJava2CrudRepository<T, ID> extends Repository<T, ID> {
/**
* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
* entity instance completely.
*
* @param entity must not be {@literal null}.
* @return {@link Single} emitting the saved entity.
* @throws IllegalArgumentException in case the given {@literal entity} is {@literal null}.
*/
<S extends T> Single<S> save(S entity);
/**
* Saves all given entities.
*
* @param entities must not be {@literal null}.
* @return {@link Flowable} emitting the saved entities.
* @throws IllegalArgumentException in case the given {@link Iterable entities} or one of its entities is
* {@literal null}.
*/
<S extends T> Flowable<S> saveAll(Iterable<S> entities);
/**
* Saves all given entities.
*
* @param entityStream must not be {@literal null}.
* @return {@link Flowable} emitting the saved entities.
* @throws IllegalArgumentException in case the given {@link Flowable entityStream} is {@literal null}.
*/
<S extends T> Flowable<S> saveAll(Flowable<S> entityStream);
/**
* Retrieves an entity by its id.
*
* @param id must not be {@literal null}.
* @return {@link Maybe} emitting the entity with the given id or {@link Maybe#empty()} if none found.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Maybe<T> findById(ID id);
/**
* Retrieves an entity by its id supplied by a {@link Single}.
*
* @param id must not be {@literal null}. Uses the first emitted element to perform the find-query.
* @return {@link Maybe} emitting the entity with the given id or {@link Maybe#empty()} if none found.
* @throws IllegalArgumentException in case the given {@link Single id} is {@literal null}.
*/
Maybe<T> findById(Single<ID> id);
/**
* Returns whether an entity with the given {@literal id} exists.
*
* @param id must not be {@literal null}.
* @return {@link Single} emitting {@literal true} if an entity with the given id exists, {@literal false} otherwise.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Single<Boolean> existsById(ID id);
/**
* Returns whether an entity with the given id, supplied by a {@link Single}, exists.
*
* @param id must not be {@literal null}.
* @return {@link Single} emitting {@literal true} if an entity with the given id exists, {@literal false} otherwise.
* @throws IllegalArgumentException in case the given {@link Single id} is {@literal null}.
*/
Single<Boolean> existsById(Single<ID> id);
/**
* Returns all instances of the type.
*
* @return {@link Flowable} emitting all entities.
*/
Flowable<T> findAll();
/**
* Returns all instances of the type {@code T} with the given IDs.
* <p>
* If some or all ids are not found, no entities are returned for these IDs.
* <p>
* Note that the order of elements in the result is not guaranteed.
*
* @param ids must not be {@literal null} nor contain any {@literal null} values.
* @return {@link Flowable} emitting the found entities. The size can be equal or less than the number of given
* {@literal ids}.
* @throws IllegalArgumentException in case the given {@link Iterable ids} or one of its items is {@literal null}.
*/
Flowable<T> findAllById(Iterable<ID> ids);
/**
* Returns all instances of the type {@code T} with the given IDs supplied by a {@link Flowable}.
* <p>
* If some or all ids are not found, no entities are returned for these IDs.
* <p>
* Note that the order of elements in the result is not guaranteed.
*
* @param idStream must not be {@literal null}.
* @return {@link Flowable} emitting the found entities.
* @throws IllegalArgumentException in case the given {@link Flowable idStream} is {@literal null}.
*/
Flowable<T> findAllById(Flowable<ID> idStream);
/**
* Returns the number of entities available.
*
* @return {@link Single} emitting the number of entities.
*/
Single<Long> count();
/**
* Deletes the entity with the given id.
*
* @param id must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}.
*/
Completable deleteById(ID id);
/**
* Deletes a given entity.
*
* @param entity must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given entity is {@literal null}.
*/
Completable delete(T entity);
/**
* Deletes all instances of the type {@code T} with the given IDs.
*
* @param ids must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@literal ids} or one of its elements is {@literal null}.
* {@literal null}.
* @since 2.5
*/
Completable deleteAllById(Iterable<? extends ID> ids);
/**
* Deletes the given entities.
*
* @param entities must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@link Iterable entities} or one of its entities is
* {@literal null}.
*/
Completable deleteAll(Iterable<? extends T> entities);
/**
* Deletes the given entities supplied by a {@link Flowable}.
*
* @param entityStream must not be {@literal null}.
* @return {@link Completable} signaling when operation has completed.
* @throws IllegalArgumentException in case the given {@link Flowable entityStream} is {@literal null}.
*/
Completable deleteAll(Flowable<? extends T> entityStream);
/**
* Deletes all entities managed by the repository.
*
* @return {@link Completable} signaling when operation has completed.
*/
Completable deleteAll();
}

45
src/main/java/org/springframework/data/repository/reactive/RxJava2SortingRepository.java
View File

@@ -1,45 +0,0 @@
/*
* Copyright 2017-2021 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
*
* https://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.data.repository.reactive;
import io.reactivex.Flowable;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
/**
* Extension of {@link RxJava2CrudRepository} to provide additional methods to retrieve entities using the sorting
* abstraction.
*
* @author Mark Paluch
* @since 2.0
* @see Sort
* @see Flowable
* @see RxJava2CrudRepository
* @deprecated since 2.6, use {@link RxJava3SortingRepository RxJava 3} instead. To be removed with Spring Data 3.0.
*/
@NoRepositoryBean
@Deprecated
public interface RxJava2SortingRepository<T, ID> extends RxJava2CrudRepository<T, ID> {
/**
* Returns all entities sorted by the given options.
*
* @param sort must not be {@literal null}.
* @return all entities sorted by the given options.
*/
Flowable<T> findAll(Sort sort);
}

1
src/main/java/org/springframework/data/repository/reactive/RxJava3SortingRepository.java
View File

@@ -28,7 +28,6 @@ import org.springframework.data.repository.NoRepositoryBean;
* @since 2.4
* @see Sort
* @see Flowable
* @see RxJava2CrudRepository
*/
@NoRepositoryBean
public interface RxJava3SortingRepository<T, ID> extends RxJava3CrudRepository<T, ID> {

86
src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java
View File

@@ -15,8 +15,6 @@
*/
package org.springframework.data.repository.util;
import io.reactivex.Flowable;
import io.reactivex.Maybe;
import kotlinx.coroutines.flow.Flow;
import kotlinx.coroutines.flow.FlowKt;
import kotlinx.coroutines.reactive.ReactiveFlowKt;
@@ -68,14 +66,6 @@ public abstract class ReactiveWrapperConverters {
static {
if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA2)) {
REACTIVE_WRAPPERS.add(RxJava2SingleWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2MaybeWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2ObservableWrapper.INSTANCE);
REACTIVE_WRAPPERS.add(RxJava2FlowableWrapper.INSTANCE);
}
if (ReactiveWrappers.isAvailable(ReactiveLibrary.RXJAVA3)) {
REACTIVE_WRAPPERS.add(RxJava3SingleWrapper.INSTANCE);
@@ -331,82 +321,6 @@ public abstract class ReactiveWrapperConverters {
}
}
// -------------------------------------------------------------------------
// RxJava 2 converters
// -------------------------------------------------------------------------
/**
* Wrapper for RxJava 2's {@link io.reactivex.Single}.
*/
private enum RxJava2SingleWrapper implements ReactiveTypeWrapper<io.reactivex.Single<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Single<?>> getWrapperClass() {
return io.reactivex.Single.class;
}
@Override
public io.reactivex.Single<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Single<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Maybe}.
*/
private enum RxJava2MaybeWrapper implements ReactiveTypeWrapper<Maybe<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Maybe<?>> getWrapperClass() {
return io.reactivex.Maybe.class;
}
@Override
public io.reactivex.Maybe<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Maybe<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Observable}.
*/
private enum RxJava2ObservableWrapper implements ReactiveTypeWrapper<io.reactivex.Observable<?>> {
INSTANCE;
@Override
public Class<? super io.reactivex.Observable<?>> getWrapperClass() {
return io.reactivex.Observable.class;
}
@Override
public io.reactivex.Observable<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Observable<?>) wrapper).map(function::apply);
}
}
/**
* Wrapper for RxJava 2's {@link io.reactivex.Flowable}.
*/
private enum RxJava2FlowableWrapper implements ReactiveTypeWrapper<Flowable<?>> {
INSTANCE;
@Override
public Class<? super Flowable<?>> getWrapperClass() {
return io.reactivex.Flowable.class;
}
@Override
public io.reactivex.Flowable<?> map(Object wrapper, Function<Object, Object> function) {
return ((io.reactivex.Flowable<?>) wrapper).map(function::apply);
}
}
// -------------------------------------------------------------------------
// RxJava 3 converters
// -------------------------------------------------------------------------

19
src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java
View File

@@ -43,11 +43,6 @@ import org.springframework.util.ClassUtils;
* @author Hantsy Bai
* @since 2.0
* @see org.reactivestreams.Publisher
* @see io.reactivex.Single
* @see io.reactivex.Maybe
* @see io.reactivex.Observable
* @see io.reactivex.Completable
* @see io.reactivex.Flowable
* @see io.reactivex.rxjava3.core.Single
* @see io.reactivex.rxjava3.core.Maybe
* @see io.reactivex.rxjava3.core.Observable
@@ -63,10 +58,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 RXJAVA2_PRESENT = ClassUtils.isPresent("io.reactivex.Flowable",
ReactiveWrappers.class.getClassLoader());
private static final boolean RXJAVA3_PRESENT = ClassUtils.isPresent("io.reactivex.rxjava3.core.Flowable",
ReactiveWrappers.class.getClassLoader());
@@ -85,13 +76,7 @@ public abstract class ReactiveWrappers {
*/
public enum ReactiveLibrary {
PROJECT_REACTOR,
/**
* @deprecated since 2.6, use RxJava 3 instead. To be removed with Spring Data 3.0.
*/
@Deprecated
RXJAVA2, RXJAVA3, KOTLIN_COROUTINES;
PROJECT_REACTOR, RXJAVA3, KOTLIN_COROUTINES, MUTINY;
}
/**
@@ -117,8 +102,6 @@ public abstract class ReactiveWrappers {
switch (reactiveLibrary) {
case PROJECT_REACTOR:
return PROJECT_REACTOR_PRESENT;
case RXJAVA2:
return RXJAVA2_PRESENT;
case RXJAVA3:
return RXJAVA3_PRESENT;
case KOTLIN_COROUTINES: