mindol1004/spring-boot-rest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

JAVA-14288 Rename spring-5-reactive-modules to spring-reactive-modules (#12659)

Browse Source 
* JAVA-14288 Rename spring-5-reactive-modules to spring-reactive-modules

* JAVA-14288 Remove failing module

* JAVA-14288 Revert commenting spring-cloud-openfeign-2 module
This commit is contained in:
anuragkumawat
2022-09-02 21:50:42 +05:30
committed by GitHub
parent 18f456b179
commit d429f0f064
303 changed files with 12 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/ReactiveCouchbaseApplication.java Normal file
View File

@@ -0,0 +1,13 @@
package com.baeldung.couchbase;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
@SpringBootApplication(exclude = MongoAutoConfiguration.class)
public class ReactiveCouchbaseApplication {
public static void main(String[] args) {
SpringApplication.run(ReactiveCouchbaseApplication.class, args);
}
}

43
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/configuration/CouchbaseProperties.java Normal file
View File

@@ -0,0 +1,43 @@
package com.baeldung.couchbase.configuration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import java.util.Collections;
import java.util.List;
@Configuration
@PropertySource("classpath:couchbase.properties")
public class CouchbaseProperties {
private final List<String> bootstrapHosts;
private final String bucketName;
private final String bucketPassword;
private final int port;
public CouchbaseProperties(@Value("${spring.couchbase.bootstrap-hosts}") final List<String> bootstrapHosts, @Value("${spring.couchbase.bucket.name}") final String bucketName, @Value("${spring.couchbase.bucket.password}") final String bucketPassword,
@Value("${spring.couchbase.port}") final int port) {
this.bootstrapHosts = Collections.unmodifiableList(bootstrapHosts);
this.bucketName = bucketName;
this.bucketPassword = bucketPassword;
this.port = port;
}
public List<String> getBootstrapHosts() {
return bootstrapHosts;
}
public String getBucketName() {
return bucketName;
}
public String getBucketPassword() {
return bucketPassword;
}
public int getPort() {
return port;
}
}

15
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/configuration/N1QLReactiveCouchbaseConfiguration.java Normal file
View File

@@ -0,0 +1,15 @@
package com.baeldung.couchbase.configuration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.couchbase.repository.config.EnableReactiveCouchbaseRepositories;
@Configuration
@EnableReactiveCouchbaseRepositories("com.baeldung.couchbase.domain.repository.n1ql")
@Primary
public class N1QLReactiveCouchbaseConfiguration extends ReactiveCouchbaseConfiguration {
public N1QLReactiveCouchbaseConfiguration(CouchbaseProperties couchbaseProperties) {
super(couchbaseProperties);
}
}

48
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/configuration/ReactiveCouchbaseConfiguration.java Normal file
View File

@@ -0,0 +1,48 @@
package com.baeldung.couchbase.configuration;
import com.couchbase.client.java.env.CouchbaseEnvironment;
import com.couchbase.client.java.env.DefaultCouchbaseEnvironment;
import org.springframework.context.annotation.Bean;
import org.springframework.data.couchbase.config.AbstractReactiveCouchbaseConfiguration;
import org.springframework.data.couchbase.config.BeanNames;
import org.springframework.data.couchbase.repository.support.IndexManager;
import java.util.List;
public abstract class ReactiveCouchbaseConfiguration extends AbstractReactiveCouchbaseConfiguration {
private CouchbaseProperties couchbaseProperties;
public ReactiveCouchbaseConfiguration(final CouchbaseProperties couchbaseProperties) {
this.couchbaseProperties = couchbaseProperties;
}
@Override
protected List<String> getBootstrapHosts() {
return couchbaseProperties.getBootstrapHosts();
}
@Override
protected String getBucketName() {
return couchbaseProperties.getBucketName();
}
@Override
protected String getBucketPassword() {
return couchbaseProperties.getBucketPassword();
}
@Override
public CouchbaseEnvironment couchbaseEnvironment() {
return DefaultCouchbaseEnvironment
.builder()
.bootstrapHttpDirectPort(couchbaseProperties.getPort())
.build();
}
@Bean(name = BeanNames.COUCHBASE_INDEX_MANAGER)
public IndexManager couchbaseIndexManager() {
return new IndexManager(true, true, false);
}
}

13
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/configuration/ViewReactiveCouchbaseConfiguration.java Normal file
View File

@@ -0,0 +1,13 @@
package com.baeldung.couchbase.configuration;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.repository.config.EnableReactiveCouchbaseRepositories;
@Configuration
@EnableReactiveCouchbaseRepositories("com.baeldung.couchbase.domain.repository.view")
public class ViewReactiveCouchbaseConfiguration extends ReactiveCouchbaseConfiguration {
public ViewReactiveCouchbaseConfiguration(CouchbaseProperties couchbaseProperties) {
super(couchbaseProperties);
}
}

43
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/domain/Person.java Normal file
View File

@@ -0,0 +1,43 @@
package com.baeldung.couchbase.domain;
import org.springframework.data.annotation.Id;
import org.springframework.data.couchbase.core.mapping.Document;
import java.util.Objects;
import java.util.UUID;
@Document
public class Person {
@Id private UUID id;
private String firstName;
public Person(final UUID id, final String firstName) {
this.id = id;
this.firstName = firstName;
}
private Person() {
}
public UUID getId() {
return id;
}
public String getFirstName() {
return firstName;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(id, person.id) && Objects.equals(firstName, person.firstName);
}
@Override
public int hashCode() {
return Objects.hash(id, firstName);
}
}

16
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLPersonRepository.java Normal file
View File

@@ -0,0 +1,16 @@
package com.baeldung.couchbase.domain.repository.n1ql;
import com.baeldung.couchbase.domain.Person;
import org.springframework.data.couchbase.core.query.N1qlPrimaryIndexed;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import java.util.UUID;
@Repository
@N1qlPrimaryIndexed
public interface N1QLPersonRepository extends ReactiveCrudRepository<Person, UUID> {
Flux<Person> findAllByFirstName(final String firstName);
}

13
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLSortingPersonRepository.java Normal file
View File

@@ -0,0 +1,13 @@
package com.baeldung.couchbase.domain.repository.n1ql;
import com.baeldung.couchbase.domain.Person;
import org.springframework.data.couchbase.core.query.N1qlPrimaryIndexed;
import org.springframework.data.repository.reactive.ReactiveSortingRepository;
import org.springframework.stereotype.Repository;
import java.util.UUID;
@Repository
@N1qlPrimaryIndexed
public interface N1QLSortingPersonRepository extends ReactiveSortingRepository<Person, UUID> {
}

20
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/couchbase/domain/repository/view/ViewPersonRepository.java Normal file
View File

@@ -0,0 +1,20 @@
package com.baeldung.couchbase.domain.repository.view;
import com.baeldung.couchbase.domain.Person;
import org.springframework.data.couchbase.core.query.View;
import org.springframework.data.couchbase.core.query.ViewIndexed;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import java.util.UUID;
@Repository
@ViewIndexed(designDoc = ViewPersonRepository.DESIGN_DOCUMENT)
public interface ViewPersonRepository extends ReactiveCrudRepository<Person, UUID> {
String DESIGN_DOCUMENT = "person";
@View(designDocument = ViewPersonRepository.DESIGN_DOCUMENT)
Flux<Person> findByFirstName(String firstName);
}

15
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/r2dbc/R2dbcApplication.java Normal file
View File

@@ -0,0 +1,15 @@
package com.baeldung.r2dbc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@ComponentScan(basePackages = "com.baeldung.r2dbc")
public class R2dbcApplication {
public static void main(String[] args) {
SpringApplication.run(R2dbcApplication.class, args);
}
}

21
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/r2dbc/configuration/R2DBCConfiguration.java Normal file
View File

@@ -0,0 +1,21 @@
package com.baeldung.r2dbc.configuration;
import io.r2dbc.h2.H2ConnectionConfiguration;
import io.r2dbc.h2.H2ConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
@Configuration
@EnableR2dbcRepositories(basePackages = "com.baeldung.r2dbc.repository")
public class R2DBCConfiguration extends AbstractR2dbcConfiguration {
@Bean
public H2ConnectionFactory connectionFactory() {
return new H2ConnectionFactory(
H2ConnectionConfiguration.builder()
.url("mem:testdb;DB_CLOSE_DELAY=-1;TRACE_LEVEL_FILE=4")
.username("sa")
.build());
}
}

18
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/r2dbc/model/Player.java Normal file
View File

@@ -0,0 +1,18 @@
package com.baeldung.r2dbc.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Table
public class Player {
@Id
Integer id;
String name;
Integer age;
}

17
spring-reactive-modules/spring-5-data-reactive/src/main/java/com/baeldung/r2dbc/repository/PlayerRepository.java Normal file
View File

@@ -0,0 +1,17 @@
package com.baeldung.r2dbc.repository;
import org.springframework.data.r2dbc.repository.Query;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import com.baeldung.r2dbc.model.Player;
import reactor.core.publisher.Flux;
public interface PlayerRepository extends ReactiveCrudRepository<Player, Integer> {
@Query("select id, name, age from player where name = $1")
Flux<Player> findAllByName(String name);
@Query("select * from player where age = $1")
Flux<Player> findByAge(int age);
}

4
spring-reactive-modules/spring-5-data-reactive/src/main/resources/couchbase.properties Normal file
View File

@@ -0,0 +1,4 @@
spring.couchbase.bucket.name=default
spring.couchbase.bootstrap-hosts=localhost
spring.couchbase.port=8091
spring.couchbase.bucket.password=123456

13
spring-reactive-modules/spring-5-data-reactive/src/main/resources/logback.xml Normal file
View File

@@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
</pattern>
</encoder>
</appender>
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>

17
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/SpringContextTest.java Normal file
View File

@@ -0,0 +1,17 @@
package com.baeldung;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.baeldung.r2dbc.R2dbcApplication;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = R2dbcApplication.class)
public class SpringContextTest {
@Test
public void whenSpringContextIsBootstrapped_thenNoExceptions() {
}
}

54
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/CouchbaseMockConfiguration.java Normal file
View File

@@ -0,0 +1,54 @@
package com.baeldung.couchbase.domain.repository;
import com.baeldung.couchbase.configuration.CouchbaseProperties;
import com.couchbase.mock.Bucket;
import com.couchbase.mock.BucketConfiguration;
import com.couchbase.mock.CouchbaseMock;
import org.springframework.boot.test.context.TestConfiguration;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.Collections;
@TestConfiguration
public class CouchbaseMockConfiguration {
private CouchbaseMock couchbaseMock;
public CouchbaseMockConfiguration(final CouchbaseProperties couchbaseProperties) {
final BucketConfiguration bucketConfiguration = new BucketConfiguration();
bucketConfiguration.numNodes = 1;
bucketConfiguration.numReplicas = 1;
bucketConfiguration.numVBuckets = 1024;
bucketConfiguration.name = couchbaseProperties.getBucketName();
bucketConfiguration.type = Bucket.BucketType.COUCHBASE;
bucketConfiguration.password = couchbaseProperties.getBucketPassword();
try {
couchbaseMock = new CouchbaseMock(couchbaseProperties.getPort(), Collections.singletonList(bucketConfiguration));
} catch (final IOException ex) {
throw new UncheckedIOException(ex);
}
}
@PostConstruct
public void postConstruct() {
try {
couchbaseMock.start();
} catch (final IOException ex) {
throw new UncheckedIOException(ex);
}
try {
couchbaseMock.waitForStartup();
} catch (final InterruptedException ex) {
throw new RuntimeException(ex);
}
}
@PreDestroy
public void preDestroy() {
couchbaseMock.stop();
}
}

55
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLPersonRepositoryLiveTest.java Normal file
View File

@@ -0,0 +1,55 @@
package com.baeldung.couchbase.domain.repository.n1ql;
import com.baeldung.couchbase.domain.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import reactor.core.publisher.Flux;
import reactor.test.StepVerifier;
import java.util.UUID;
@RunWith(SpringRunner.class)
@SpringBootTest(properties = {"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration"})
public class N1QLPersonRepositoryLiveTest {
@Autowired private N1QLPersonRepository personRepository;
@Test
public void shouldFindAll_byLastName() {
//Given
final String firstName = "John";
final Person matchingPerson = new Person(UUID.randomUUID(), firstName);
final Person nonMatchingPerson = new Person(UUID.randomUUID(), "NotJohn");
wrap(() -> {
personRepository
.save(matchingPerson)
.subscribe();
personRepository
.save(nonMatchingPerson)
.subscribe();
//When
final Flux<Person> allByFirstName = personRepository.findAllByFirstName(firstName);
//Then
StepVerifier
.create(allByFirstName)
.expectNext(matchingPerson)
.verifyComplete();
}, matchingPerson, nonMatchingPerson);
}
private void wrap(final Runnable runnable, final Person... people) {
try {
runnable.run();
} finally {
for (final Person person : people) {
personRepository
.delete(person)
.subscribe();
}
}
}
}

60
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLSortingPersonRepositoryLiveTest.java Normal file
View File

@@ -0,0 +1,60 @@
package com.baeldung.couchbase.domain.repository.n1ql;
import com.baeldung.couchbase.domain.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;
import reactor.core.publisher.Flux;
import reactor.test.StepVerifier;
import java.util.UUID;
@RunWith(SpringRunner.class)
@SpringBootTest(properties = {"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration"})
public class N1QLSortingPersonRepositoryLiveTest {
@Autowired private N1QLSortingPersonRepository personRepository;
@Test
public void shouldFindAll_sortedByFirstName() {
//Given
final Person firstPerson = new Person(UUID.randomUUID(), "John");
final Person secondPerson = new Person(UUID.randomUUID(), "Mikki");
wrap(() -> {
personRepository
.save(firstPerson)
.subscribe();
personRepository
.save(secondPerson)
.subscribe();
//When
final Flux<Person> allByFirstName = personRepository.findAll(Sort.by(Sort.Direction.DESC, "firstName"));
//Then
StepVerifier
.create(allByFirstName)
.expectNextMatches(person -> person
.getFirstName()
.equals(secondPerson.getFirstName()))
.expectNextMatches(person -> person
.getFirstName()
.equals(firstPerson.getFirstName()))
.verifyComplete();
}, firstPerson, secondPerson);
}
//workaround for deleteAll()
private void wrap(final Runnable runnable, final Person... people) {
try {
runnable.run();
} finally {
for (final Person person : people) {
personRepository
.delete(person)
.subscribe();
}
}
}
}

81
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/view/ViewPersonRepositoryIntegrationTest.java Normal file
View File

@@ -0,0 +1,81 @@
package com.baeldung.couchbase.domain.repository.view;
import com.baeldung.couchbase.configuration.CouchbaseProperties;
import com.baeldung.couchbase.configuration.ViewReactiveCouchbaseConfiguration;
import com.baeldung.couchbase.domain.Person;
import com.baeldung.couchbase.domain.repository.CouchbaseMockConfiguration;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import java.util.UUID;
@RunWith(SpringRunner.class)
@SpringBootTest(properties = { "spring.couchbase.port=10010", "spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration" },
classes = { CouchbaseMockConfiguration.class, ViewReactiveCouchbaseConfiguration.class, CouchbaseProperties.class })
public class ViewPersonRepositoryIntegrationTest {
@Autowired private ViewPersonRepository personRepository;
@Test
public void shouldSavePerson_findById_thenDeleteIt() {
//Given
final UUID id = UUID.randomUUID();
final Person person = new Person(id, "John");
wrap(() -> {
personRepository
.save(person)
.subscribe();
//When
final Mono<Person> byId = personRepository.findById(id);
//Then
StepVerifier
.create(byId)
.expectNextMatches(result -> result
.getId()
.equals(id))
.expectComplete()
.verify();
}, person);
}
@Test
public void shouldFindAll_thenDeleteIt() {
//Given
final Person person = new Person(UUID.randomUUID(), "John");
final Person secondPerson = new Person(UUID.randomUUID(), "Mikki");
wrap(() -> {
personRepository
.save(person)
.subscribe();
personRepository
.save(secondPerson)
.subscribe();
//When
final Flux<Person> all = personRepository.findAll();
//Then
StepVerifier
.create(all)
.expectNextCount(2)
.verifyComplete();
}, person, secondPerson);
}
private void wrap(final Runnable runnable, final Person... people) {
try {
runnable.run();
} finally {
for (final Person person : people) {
personRepository
.delete(person)
.subscribe();
}
}
}
}

124
spring-reactive-modules/spring-5-data-reactive/src/test/java/com/baeldung/r2dbc/R2dbcApplicationIntegrationTest.java Normal file
View File

@@ -0,0 +1,124 @@
package com.baeldung.r2dbc;
import com.baeldung.r2dbc.model.Player;
import com.baeldung.r2dbc.repository.PlayerRepository;
import io.r2dbc.h2.H2ConnectionFactory;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.test.context.junit4.SpringRunner;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Hooks;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import java.util.Arrays;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class R2dbcApplicationIntegrationTest {
@Autowired
PlayerRepository playerRepository;
@Autowired
DatabaseClient client;
@Autowired
H2ConnectionFactory factory;
@Before
public void setup() {
Hooks.onOperatorDebug();
List<String> statements = Arrays.asList(//
"DROP TABLE IF EXISTS player;",
"CREATE table player (id INT AUTO_INCREMENT NOT NULL, name VARCHAR2, age INT NOT NULL);");
statements.forEach(it -> client.execute(it) //
.fetch() //
.rowsUpdated() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete());
}
@Test
public void whenDeleteAll_then0IsExpected() {
playerRepository.deleteAll()
.as(StepVerifier::create)
.expectNextCount(0)
.verifyComplete();
}
@Test
public void whenInsert6_then6AreExpected() {
insertPlayers();
playerRepository.findAll()
.as(StepVerifier::create)
.expectNextCount(6)
.verifyComplete();
}
@Test
public void whenSearchForCR7_then1IsExpected() {
insertPlayers();
playerRepository.findAllByName("CR7")
.as(StepVerifier::create)
.expectNextCount(1)
.verifyComplete();
}
@Test
public void whenSearchFor32YearsOld_then2AreExpected() {
insertPlayers();
playerRepository.findByAge(32)
.as(StepVerifier::create)
.expectNextCount(2)
.verifyComplete();
}
@Test
public void whenBatchHas2Operations_then2AreExpected() {
Mono.from(factory.create())
.flatMapMany(connection -> Flux.from(connection
.createBatch()
.add("select * from player")
.add("select * from player")
.execute()))
.as(StepVerifier::create)
.expectNextCount(2)
.verifyComplete();
}
private void insertPlayers() {
List<Player> players = Arrays.asList(
new Player(null, "Kaka", 37),
new Player(null, "Messi", 32),
new Player(null, "Mbappé", 20),
new Player(null, "CR7", 34),
new Player(null, "Lewandowski", 30),
new Player(null, "Cavani", 32)
);
playerRepository.saveAll(players).subscribe();
}
}