[BAEL-9538] - Move persistence-related modules into the persistence folder

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/annotation/CascadeSave.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface CascadeSave {
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/MongoConfig.java

@@ -0,0 +1,68 @@
+package com.baeldung.config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.MongoTransactionManager;
+import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
+import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
+import org.springframework.data.mongodb.gridfs.GridFsTemplate;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+
+import com.baeldung.converter.UserWriterConverter;
+import com.baeldung.event.CascadeSaveMongoEventListener;
+import com.baeldung.event.UserCascadeSaveMongoEventListener;
+import com.mongodb.MongoClient;
+
+@Configuration
+@EnableMongoRepositories(basePackages = "com.baeldung.repository")
+public class MongoConfig extends AbstractMongoConfiguration {
+
+    private final List<Converter<?, ?>> converters = new ArrayList<Converter<?, ?>>();
+
+    @Override
+    protected String getDatabaseName() {
+        return "test";
+    }
+
+    @Override
+    public MongoClient mongoClient() {
+        return new MongoClient("127.0.0.1", 27017);
+    }
+
+    @Override
+    public String getMappingBasePackage() {
+        return "com.baeldung";
+    }
+
+    @Bean
+    public UserCascadeSaveMongoEventListener userCascadingMongoEventListener() {
+        return new UserCascadeSaveMongoEventListener();
+    }
+
+    @Bean
+    public CascadeSaveMongoEventListener cascadingMongoEventListener() {
+        return new CascadeSaveMongoEventListener();
+    }
+
+    @Override
+    public MongoCustomConversions customConversions() {
+        converters.add(new UserWriterConverter());
+        return new MongoCustomConversions(converters);
+    }
+
+    @Bean
+    public GridFsTemplate gridFsTemplate() throws Exception {
+        return new GridFsTemplate(mongoDbFactory(), mappingMongoConverter());
+    }
+
+    @Bean
+    MongoTransactionManager transactionManager(MongoDbFactory dbFactory) {
+            return new MongoTransactionManager(dbFactory);
+    }
+    
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/MongoReactiveConfig.java

@@ -0,0 +1,23 @@
+package com.baeldung.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.config.AbstractReactiveMongoConfiguration;
+import org.springframework.data.mongodb.repository.config.EnableReactiveMongoRepositories;
+
+import com.mongodb.reactivestreams.client.MongoClient;
+import com.mongodb.reactivestreams.client.MongoClients;
+
+@Configuration
+@EnableReactiveMongoRepositories(basePackages = "com.baeldung.reactive.repository")
+public class MongoReactiveConfig extends AbstractReactiveMongoConfiguration {
+
+    @Override
+    public MongoClient reactiveMongoClient() {
+        return MongoClients.create();
+    }
+
+    @Override
+    protected String getDatabaseName() {
+        return "reactive";
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/config/SimpleMongoConfig.java

@@ -0,0 +1,24 @@
+package com.baeldung.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+
+import com.mongodb.MongoClient;
+
+@Configuration
+@EnableMongoRepositories(basePackages = "com.baeldung.repository")
+public class SimpleMongoConfig {
+
+    @Bean
+    public MongoClient mongo() throws Exception {
+        return new MongoClient("localhost");
+    }
+
+    @Bean
+    public MongoTemplate mongoTemplate() throws Exception {
+        return new MongoTemplate(mongo(), "test");
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/converter/UserWriterConverter.java

@@ -0,0 +1,26 @@
+package com.baeldung.converter;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import com.baeldung.model.User;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+@Component
+public class UserWriterConverter implements Converter<User, DBObject> {
+
+    @Override
+    public DBObject convert(final User user) {
+        final DBObject dbObject = new BasicDBObject();
+        dbObject.put("name", user.getName());
+        dbObject.put("age", user.getAge());
+        if (user.getEmailAddress() != null) {
+            final DBObject emailDbObject = new BasicDBObject();
+            emailDbObject.put("value", user.getEmailAddress().getValue());
+            dbObject.put("email", emailDbObject);
+        }
+        dbObject.removeField("_class");
+        return dbObject;
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/CascadeCallback.java

@@ -0,0 +1,53 @@
+package com.baeldung.event;
+
+import java.lang.reflect.Field;
+
+import com.baeldung.annotation.CascadeSave;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.util.ReflectionUtils;
+
+public class CascadeCallback implements ReflectionUtils.FieldCallback {
+
+    private Object source;
+    private MongoOperations mongoOperations;
+
+    CascadeCallback(final Object source, final MongoOperations mongoOperations) {
+        this.source = source;
+        this.setMongoOperations(mongoOperations);
+    }
+
+    @Override
+    public void doWith(final Field field) throws IllegalArgumentException, IllegalAccessException {
+        ReflectionUtils.makeAccessible(field);
+
+        if (field.isAnnotationPresent(DBRef.class) && field.isAnnotationPresent(CascadeSave.class)) {
+            final Object fieldValue = field.get(getSource());
+
+            if (fieldValue != null) {
+                final FieldCallback callback = new FieldCallback();
+
+                ReflectionUtils.doWithFields(fieldValue.getClass(), callback);
+
+                getMongoOperations().save(fieldValue);
+            }
+        }
+
+    }
+
+    private Object getSource() {
+        return source;
+    }
+
+    public void setSource(final Object source) {
+        this.source = source;
+    }
+
+    private MongoOperations getMongoOperations() {
+        return mongoOperations;
+    }
+
+    private void setMongoOperations(final MongoOperations mongoOperations) {
+        this.mongoOperations = mongoOperations;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/CascadeSaveMongoEventListener.java

@@ -0,0 +1,19 @@
+package com.baeldung.event;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
+import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
+import org.springframework.util.ReflectionUtils;
+
+public class CascadeSaveMongoEventListener extends AbstractMongoEventListener<Object> {
+
+    @Autowired
+    private MongoOperations mongoOperations;
+
+    @Override
+    public void onBeforeConvert(final BeforeConvertEvent<Object> event) {
+        final Object source = event.getSource();
+        ReflectionUtils.doWithFields(source.getClass(), new CascadeCallback(source, mongoOperations));
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/FieldCallback.java

@@ -0,0 +1,23 @@
+package com.baeldung.event;
+
+import java.lang.reflect.Field;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.util.ReflectionUtils;
+
+public class FieldCallback implements ReflectionUtils.FieldCallback {
+    private boolean idFound;
+
+    @Override
+    public void doWith(final Field field) throws IllegalArgumentException, IllegalAccessException {
+        ReflectionUtils.makeAccessible(field);
+
+        if (field.isAnnotationPresent(Id.class)) {
+            idFound = true;
+        }
+    }
+
+    public boolean isIdFound() {
+        return idFound;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/event/UserCascadeSaveMongoEventListener.java

@@ -0,0 +1,20 @@
+package com.baeldung.event;
+
+import com.baeldung.model.User;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
+import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
+
+public class UserCascadeSaveMongoEventListener extends AbstractMongoEventListener<Object> {
+    @Autowired
+    private MongoOperations mongoOperations;
+
+    @Override
+    public void onBeforeConvert(final BeforeConvertEvent<Object> event) {
+        final Object source = event.getSource();
+        if ((source instanceof User) && (((User) source).getEmailAddress() != null)) {
+            mongoOperations.save(((User) source).getEmailAddress());
+        }
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/model/EmailAddress.java

@@ -0,0 +1,27 @@
+package com.baeldung.model;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+@Document
+public class EmailAddress {
+    @Id
+    private String id;
+    private String value;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(final String id) {
+        this.id = id;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(final String value) {
+        this.value = value;
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/model/User.java

@@ -0,0 +1,93 @@
+package com.baeldung.model;
+
+import com.baeldung.annotation.CascadeSave;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.PersistenceConstructor;
+import org.springframework.data.annotation.Transient;
+import org.springframework.data.mongodb.core.index.CompoundIndex;
+import org.springframework.data.mongodb.core.index.CompoundIndexes;
+import org.springframework.data.mongodb.core.index.IndexDirection;
+import org.springframework.data.mongodb.core.index.Indexed;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.Field;
+
+import com.querydsl.core.annotations.QueryEntity;
+
+@QueryEntity
+@Document
+@CompoundIndexes({ @CompoundIndex(name = "email_age", def = "{'email.id' : 1, 'age': 1}") })
+public class User {
+
+    @Id
+    private String id;
+    @Indexed(direction = IndexDirection.ASCENDING)
+    private String name;
+    @Indexed(direction = IndexDirection.ASCENDING)
+    private Integer age;
+
+    @DBRef
+    @Field("email")
+    @CascadeSave
+    private EmailAddress emailAddress;
+
+    @Transient
+    private Integer yearOfBirth;
+
+    public User() {
+    }
+    
+    public User(String name, Integer age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    @PersistenceConstructor
+    public User(final String name, @Value("#root.age ?: 0") final Integer age, final EmailAddress emailAddress) {
+        this.name = name;
+        this.age = age;
+        this.emailAddress = emailAddress;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(final String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(final Integer age) {
+        this.age = age;
+    }
+
+    public EmailAddress getEmailAddress() {
+        return emailAddress;
+    }
+
+    public void setEmailAddress(final EmailAddress emailAddress) {
+        this.emailAddress = emailAddress;
+    }
+
+    public Integer getYearOfBirth() {
+        return yearOfBirth;
+    }
+
+    public void setYearOfBirth(final Integer yearOfBirth) {
+        this.yearOfBirth = yearOfBirth;
+    }
+
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/reactive/repository/UserRepository.java

@@ -0,0 +1,9 @@
+package com.baeldung.reactive.repository;
+
+import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
+
+import com.baeldung.model.User;
+
+
+public interface UserRepository extends ReactiveMongoRepository<User, String> {
+}

persistence-modules/spring-data-mongodb/src/main/java/com/baeldung/repository/UserRepository.java

@@ -0,0 +1,36 @@
+package com.baeldung.repository;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Query;
+import org.springframework.data.querydsl.QuerydslPredicateExecutor;
+
+import com.baeldung.model.User;
+
+public interface UserRepository extends MongoRepository<User, String>, QuerydslPredicateExecutor<User> {
+    @Query("{ 'name' : ?0 }")
+    List<User> findUsersByName(String name);
+
+    @Query("{ 'age' : { $gt: ?0, $lt: ?1 } }")
+    List<User> findUsersByAgeBetween(int ageGT, int ageLT);
+
+    @Query("{ 'name' : { $regex: ?0 } }")
+    List<User> findUsersByRegexpName(String regexp);
+
+    List<User> findByName(String name);
+
+    List<User> findByNameLikeOrderByAgeAsc(String name);
+
+    List<User> findByAgeBetween(int ageGT, int ageLT);
+
+    List<User> findByNameStartingWith(String regexp);
+
+    List<User> findByNameEndingWith(String regexp);
+
+    @Query(value = "{}", fields = "{name : 1}")
+    List<User> findNameAndId();
+
+    @Query(value = "{}", fields = "{_id : 0}")
+    List<User> findNameAndAgeExcludeId();
+}

persistence-modules/spring-data-mongodb/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?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>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/spring-data-mongodb/src/main/resources/mongoConfig.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+    xmlns:p="http://www.springframework.org/schema/p" xmlns:mongo="http://www.springframework.org/schema/data/mongo"
+    xsi:schemaLocation="
+       http://www.springframework.org/schema/beans 
+       http://www.springframework.org/schema/beans/spring-beans.xsd
+       http://www.springframework.org/schema/data/mongo
+       http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
+       http://www.springframework.org/schema/context 
+       http://www.springframework.org/schema/context/spring-context.xsd"
+>
+    <context:annotation-config/>
+    
+    <mongo:mongo-client id="mongoClient" host="localhost" />
+    
+    <mongo:db-factory id="mongoDbFactory" dbname="test" mongo-ref="mongoClient" />
+    
+    <bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate">
+        <constructor-arg ref="mongoDbFactory" />
+        <constructor-arg ref="mongoConverter" />
+    </bean>
+
+    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
+        <constructor-arg ref="mongoDbFactory"/>
+        <constructor-arg ref="mongoConverter" />
+    </bean>
+
+    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
+
+    <mongo:repositories base-package="com.baeldung.repository" mongo-template-ref="mongoTemplate"/>
+
+    <bean class="com.baeldung.event.CascadeSaveMongoEventListener">
+    </bean>
+
+    <mongo:mapping-converter id="mongoConverter" base-package="com.baeldung.converter">
+        <mongo:custom-converters base-package="org.baeldung.converter"/>
+    </mongo:mapping-converter>
+
+</beans>