iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BAEL-5400 - add spring-data-mongodb-2 module (#12340)

Browse Source 
* fix: add spring-data-mongodb-2 module

* fix: missing module in parent pom
This commit is contained in:
lucaCambi77 2022-06-15 03:24:37 +02:00 committed by GitHub
parent 1a1d011466
commit 2095898305
11 changed files with 764 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
persistence-modules/pom.xml
View File

@ -87,6 +87,7 @@
<module>spring-data-jdbc</module>
<module>spring-data-keyvalue</module>
<module>spring-data-mongodb</module>
<module>spring-data-mongodb-2</module>
<module>spring-data-mongodb-reactive</module>
<module>spring-data-neo4j</module>
<module>spring-data-redis</module>

7
persistence-modules/spring-data-mongodb-2/README.md Normal file
View File

@ -0,0 +1,7 @@
=========
## Spring Data MongoDB 2
### Relevant Articles:
- [Return Only Specific Fields for a Query in Spring Data MongoDB](https://www.baeldung.com/mongodb-return-specific-fields)

58
persistence-modules/spring-data-mongodb-2/pom.xml Normal file
View File

@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-data-mongodb-2</artifactId>
<name>spring-data-mongodb-2</name>
<parent>
<groupId>com.baeldung</groupId>
<artifactId>parent-spring-5</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath>../../parent-spring-5</relativePath>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>${org.springframework.data.version}</version>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>${mongodb-driver.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
<exclusions>
<exclusion>
<artifactId>commons-logging</artifactId>
<groupId>commons-logging</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>de.flapdoodle.embed</groupId>
<artifactId>de.flapdoodle.embed.mongo</artifactId>
<version>${embed.mongo.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<org.springframework.data.version>3.0.3.RELEASE</org.springframework.data.version>
<mongodb-driver.version>4.0.5</mongodb-driver.version>
<embed.mongo.version>3.2.6</embed.mongo.version>
</properties>
</project>

46
persistence-modules/spring-data-mongodb-2/src/main/java/com/baeldung/projection/model/InStock.java Normal file
View File

@ -0,0 +1,46 @@
package com.baeldung.projection.model;
import java.util.Objects;
public class InStock {
private String wareHouse;
private Integer quantity;
public InStock(String wareHouse, int quantity) {
this.wareHouse = wareHouse;
this.quantity = quantity;
}
public String getWareHouse() {
return wareHouse;
}
public void setWareHouse(String wareHouse) {
this.wareHouse = wareHouse;
}
public Integer getQuantity() {
return quantity;
}
public void setQuantity(Integer quantity) {
this.quantity = quantity;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
InStock inStock = (InStock) o;
return Objects.equals(wareHouse, inStock.wareHouse) && Objects.equals(quantity, inStock.quantity);
}
@Override
public int hashCode() {
return Objects.hash(wareHouse, quantity);
}
}

71
persistence-modules/spring-data-mongodb-2/src/main/java/com/baeldung/projection/model/Inventory.java Normal file
View File

@ -0,0 +1,71 @@
package com.baeldung.projection.model;
import java.util.List;
import java.util.Objects;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.MongoId;
@Document(collection = "inventory")
public class Inventory {
@Id
private String id;
private String item;
private String status;
private Size size;
private List<InStock> inStock;
public String getId() {
return id;
}
public String getItem() {
return item;
}
public void setItem(String item) {
this.item = item;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Size getSize() {
return size;
}
public void setSize(Size size) {
this.size = size;
}
public List<InStock> getInStock() {
return inStock;
}
public void setInStock(List<InStock> inStock) {
this.inStock = inStock;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Inventory inventory = (Inventory) o;
return Objects.equals(id, inventory.id) && Objects.equals(item, inventory.item) && Objects.equals(status, inventory.status);
}
@Override
public int hashCode() {
return Objects.hash(id, item, status);
}
}

56
persistence-modules/spring-data-mongodb-2/src/main/java/com/baeldung/projection/model/Size.java Normal file
View File

@ -0,0 +1,56 @@
package com.baeldung.projection.model;
import java.util.Objects;
public class Size {
private Double height;
private Double width;
private String uom;
public Size(Double height, Double width, String uom) {
this.height = height;
this.width = width;
this.uom = uom;
}
public Double getHeight() {
return height;
}
public void setHeight(Double height) {
this.height = height;
}
public Double getWidth() {
return width;
}
public void setWidth(Double width) {
this.width = width;
}
public String getUom() {
return uom;
}
public void setUom(String uom) {
this.uom = uom;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Size size = (Size) o;
return Objects.equals(height, size.height) && Objects.equals(width, size.width) && Objects.equals(uom, size.uom);
}
@Override
public int hashCode() {
return Objects.hash(height, width, uom);
}
}

33
persistence-modules/spring-data-mongodb-2/src/main/java/com/baeldung/projection/repository/InventoryRepository.java Normal file
View File

@ -0,0 +1,33 @@
package com.baeldung.projection.repository;
import java.util.List;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import com.baeldung.projection.model.Inventory;
public interface InventoryRepository extends MongoRepository<Inventory, String> {
@Query(value = "{ 'status' : ?0 }", fields = "{ 'item' : 1, 'status' : 1 }")
List<Inventory> findByStatusIncludeItemAndStatusFields(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'item' : 1, 'status' : 1, '_id' : 0 }")
List<Inventory> findByStatusIncludeItemAndStatusExcludeIdFields(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'status' : 0, 'inStock' : 0 }")
List<Inventory> findByStatusIncludeAllButStatusAndStockFields(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'item' : 1, 'status' : 1, 'size.uom': 1 }")
List<Inventory> findByStatusIncludeEmbeddedFields(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'size.uom': 0 }")
List<Inventory> findByStatusExcludeEmbeddedFields(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'item' : 1, 'status' : 1, 'inStock.quantity': 1 }")
List<Inventory> findByStatusIncludeEmbeddedFieldsInArray(String status);
@Query(value = "{ 'status' : ?0 }", fields = "{ 'item' : 1, 'status' : 1, 'inStock': { $slice: -1 } }")
List<Inventory> findByStatusIncludeEmbeddedFieldsLastElementInArray(String status);
}

49
persistence-modules/spring-data-mongodb-2/src/test/java/com/baeldung/projection/AbstractTestProjection.java Normal file
View File

@ -0,0 +1,49 @@
package com.baeldung.projection;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import com.baeldung.projection.model.InStock;
import com.baeldung.projection.model.Inventory;
import com.baeldung.projection.model.Size;
abstract class AbstractTestProjection {
public List<Inventory> getInventories() {
Inventory journal = new Inventory();
journal.setItem("journal");
journal.setStatus("A");
journal.setSize(new Size(14.0, 21.0, "cm"));
journal.setInStock(Collections.singletonList(new InStock("A", 5)));
Inventory notebook = new Inventory();
notebook.setItem("notebook");
notebook.setStatus("A");
notebook.setSize(new Size(8.5, 11.0, "in"));
notebook.setInStock(Collections.singletonList(new InStock("C", 5)));
Inventory paper = new Inventory();
paper.setItem("paper");
paper.setStatus("D");
paper.setSize(new Size(8.5, 11.0, "in"));
paper.setInStock(Collections.singletonList(new InStock("A", 60)));
return Arrays.asList(journal, notebook, paper);
}
abstract void whenIncludeFields_thenOnlyIncludedFieldsAreNotNull();
abstract void whenIncludeFieldsAndExcludeOtherFields_thenOnlyExcludedFieldsAreNull();
abstract void whenIncludeAllButExcludeSomeFields_thenOnlyExcludedFieldsAreNull();
abstract void whenIncludeEmbeddedFields_thenEmbeddedFieldsAreNotNull();
abstract void whenExcludeEmbeddedFields_thenEmbeddedFieldsAreNull();
abstract void whenIncludeEmbeddedFieldsInArray_thenEmbeddedFieldsInArrayAreNotNull();
abstract void whenIncludeEmbeddedFieldsSliceInArray_thenArrayLengthEqualToSlice();
}

223
persistence-modules/spring-data-mongodb-2/src/test/java/com/baeldung/projection/MongoTemplateProjectionUnitTest.java Normal file
View File

@ -0,0 +1,223 @@
package com.baeldung.projection;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.baeldung.projection.config.ProjectionConfig;
import com.baeldung.projection.model.InStock;
import com.baeldung.projection.model.Inventory;
import com.baeldung.projection.model.Size;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = ProjectionConfig.class)
public class MongoTemplateProjectionUnitTest extends AbstractTestProjection {
@Autowired
private MongoTemplate mongoTemplate;
@BeforeEach
void setup() {
List<Inventory> inventoryList = getInventories();
mongoTemplate.insert(inventoryList, Inventory.class);
}
@Test
void whenIncludeFields_thenOnlyIncludedFieldsAreNotNull() {
Query query = new Query();
query.fields()
.include("item")
.include("status");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getId());
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNull(i.getSize());
assertNull(i.getInStock());
});
}
@Test
void whenIncludeFieldsAndExcludeOtherFields_thenOnlyExcludedFieldsAreNull() {
Query query = new Query();
query.fields()
.include("item")
.include("status")
.exclude("_id");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNull(i.getId());
assertNull(i.getSize());
assertNull(i.getInStock());
});
}
@Test
void whenIncludeAllButExcludeSomeFields_thenOnlyExcludedFieldsAreNull() {
Query query = new Query();
query.fields()
.exclude("status")
.exclude("inStock");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNull(i.getInStock());
assertNull(i.getStatus());
});
}
@Test
void whenIncludeEmbeddedFields_thenEmbeddedFieldsAreNotNull() {
Query query = new Query();
query.fields()
.include("item")
.include("status")
.include("size.uom");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNotNull(i.getSize()
.getUom());
assertNull(i.getSize()
.getHeight());
assertNull(i.getSize()
.getWidth());
assertNull(i.getInStock());
});
}
@Test
void whenExcludeEmbeddedFields_thenEmbeddedFieldsAreNull() {
Query query = new Query();
query.fields()
.exclude("size.uom");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNull(i.getSize()
.getUom());
assertNotNull(i.getSize()
.getHeight());
assertNotNull(i.getSize()
.getWidth());
assertNotNull(i.getInStock());
});
}
@Test
void whenIncludeEmbeddedFieldsInArray_thenEmbeddedFieldsInArrayAreNotNull() {
Query query = new Query();
query.fields()
.include("item")
.include("status")
.include("inStock.quantity");
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getInStock());
i.getInStock()
.forEach(stock -> {
assertNull(stock.getWareHouse());
assertNotNull(stock.getQuantity());
});
assertNull(i.getSize());
});
}
@Test
void whenIncludeEmbeddedFieldsSliceInArray_thenArrayLengthEqualToSlice() {
Inventory postcard = new Inventory();
postcard.setItem("postcard");
postcard.setStatus("A");
postcard.setSize(new Size(10.0, 15.25, "cm"));
InStock firstInStock = new InStock("B", 15);
InStock lastInStock = new InStock("C", 35);
postcard.setInStock(Arrays.asList(firstInStock, lastInStock));
mongoTemplate.save(postcard);
Query query = new Query();
query.fields()
.include("item")
.include("status")
.slice("inStock", -1);
List<Inventory> inventoryList = mongoTemplate.find(query, Inventory.class);
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getInStock());
assertEquals(1, i.getInStock()
.size());
assertNull(i.getSize());
});
InStock stock = inventoryList.stream()
.filter(i -> i.getItem()
.equals("postcard"))
.map(i -> i.getInStock()
.get(0))
.findFirst()
.orElse(null);
assertEquals(lastInStock, stock);
}
}

177
persistence-modules/spring-data-mongodb-2/src/test/java/com/baeldung/projection/RepositoryProjectionUnitTest.java Normal file
View File

@ -0,0 +1,177 @@
package com.baeldung.projection;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.baeldung.projection.config.ProjectionConfig;
import com.baeldung.projection.model.InStock;
import com.baeldung.projection.model.Inventory;
import com.baeldung.projection.model.Size;
import com.baeldung.projection.repository.InventoryRepository;
@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = ProjectionConfig.class)
public class RepositoryProjectionUnitTest extends AbstractTestProjection {
@Autowired
private InventoryRepository inventoryRepository;
@BeforeEach
void setup() {
List<Inventory> inventoryList = getInventories();
inventoryRepository.saveAll(inventoryList);
}
@Test
void whenIncludeFields_thenOnlyIncludedFieldsAreNotNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeItemAndStatusFields("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getId());
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNull(i.getSize());
assertNull(i.getInStock());
});
}
@Test
void whenIncludeFieldsAndExcludeOtherFields_thenOnlyExcludedFieldsAreNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeItemAndStatusExcludeIdFields("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNull(i.getId());
assertNull(i.getSize());
assertNull(i.getInStock());
});
}
@Test
void whenIncludeAllButExcludeSomeFields_thenOnlyExcludedFieldsAreNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeAllButStatusAndStockFields("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNull(i.getInStock());
assertNull(i.getStatus());
});
}
@Test
void whenIncludeEmbeddedFields_thenEmbeddedFieldsAreNotNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeEmbeddedFields("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNotNull(i.getSize()
.getUom());
assertNull(i.getSize()
.getHeight());
assertNull(i.getSize()
.getWidth());
assertNull(i.getInStock());
});
}
@Test
void whenExcludeEmbeddedFields_thenEmbeddedFieldsAreNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusExcludeEmbeddedFields("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getSize());
assertNull(i.getSize()
.getUom());
assertNotNull(i.getSize()
.getHeight());
assertNotNull(i.getSize()
.getWidth());
assertNotNull(i.getInStock());
});
}
@Test
void whenIncludeEmbeddedFieldsInArray_thenEmbeddedFieldsInArrayAreNotNull() {
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeEmbeddedFieldsInArray("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getInStock());
i.getInStock()
.forEach(stock -> {
assertNull(stock.getWareHouse());
assertNotNull(stock.getQuantity());
});
assertNull(i.getSize());
});
}
@Test
void whenIncludeEmbeddedFieldsSliceInArray_thenArrayLengthEqualToSlice() {
Inventory postcard = new Inventory();
postcard.setItem("postcard");
postcard.setStatus("A");
postcard.setSize(new Size(10.0, 15.25, "cm"));
InStock firstInStock = new InStock("B", 15);
InStock lastInStock = new InStock("C", 35);
postcard.setInStock(Arrays.asList(firstInStock, lastInStock));
inventoryRepository.save(postcard);
List<Inventory> inventoryList = inventoryRepository.findByStatusIncludeEmbeddedFieldsLastElementInArray("A");
assertTrue(inventoryList.size() > 0);
inventoryList.forEach(i -> {
assertNotNull(i.getItem());
assertNotNull(i.getStatus());
assertNotNull(i.getId());
assertNotNull(i.getInStock());
assertEquals(1, i.getInStock()
.size());
assertNull(i.getSize());
});
InStock stock = inventoryList.stream()
.filter(i -> i.getItem()
.equals("postcard"))
.map(i -> i.getInStock()
.get(0))
.findFirst()
.orElse(null);
assertEquals(lastInStock, stock);
}
}

43
persistence-modules/spring-data-mongodb-2/src/test/java/com/baeldung/projection/config/ProjectionConfig.java Normal file
View File

@ -0,0 +1,43 @@
package com.baeldung.projection.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
import org.springframework.util.SocketUtils;
import com.mongodb.client.MongoClients;
import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodStarter;
import de.flapdoodle.embed.mongo.config.ImmutableMongodConfig;
import de.flapdoodle.embed.mongo.config.MongodConfig;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.runtime.Network;
@Configuration
@ComponentScan(basePackages = "com.baeldung.projection")
@EnableMongoRepositories(basePackages = "com.baeldung.projection.repository")
public class ProjectionConfig {
private static final String CONNECTION_STRING = "mongodb://%s:%d";
private static final String HOST = "localhost";
@Bean
public MongoTemplate mongoTemplate() throws Exception {
int randomPort = SocketUtils.findAvailableTcpPort();
ImmutableMongodConfig mongoDbConfig = MongodConfig.builder()
.version(Version.Main.PRODUCTION)
.net(new Net(HOST, randomPort, Network.localhostIsIPv6()))
.build();
MongodStarter starter = MongodStarter.getDefaultInstance();
MongodExecutable mongodExecutable = starter.prepare(mongoDbConfig);
mongodExecutable.start();
return new MongoTemplate(MongoClients.create(String.format(CONNECTION_STRING, HOST, randomPort)), "mongo_auth");
}
}