Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

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,72 @@
+package com.baeldung.config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import converter.ZonedDateTimeReadConverter;
+import converter.ZonedDateTimeWriteConverter;
+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());
+        converters.add(new ZonedDateTimeReadConverter());
+        converters.add(new ZonedDateTimeWriteConverter());
+        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/Action.java

@@ -0,0 +1,51 @@
+package com.baeldung.model;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+import java.time.ZonedDateTime;
+
+@Document
+public class Action {
+
+    @Id
+    private String id;
+
+    private String description;
+    private ZonedDateTime time;
+
+    public Action(String id, String description, ZonedDateTime time) {
+        this.id = id;
+        this.description = description;
+        this.time = time;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public ZonedDateTime getTime() {
+        return time;
+    }
+
+    public void setTime(ZonedDateTime time) {
+        this.time = time;
+    }
+
+    @Override
+    public String toString() {
+        return "Action{id='" + id + "', description='" + description + "', time=" + time + '}';
+    }
+}

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/ActionRepository.java

@@ -0,0 +1,6 @@
+package com.baeldung.repository;
+
+import com.baeldung.model.Action;
+import org.springframework.data.mongodb.repository.MongoRepository;
+
+public interface ActionRepository extends MongoRepository<Action, 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/java/converter/ZonedDateTimeReadConverter.java

@@ -0,0 +1,14 @@
+package converter;
+
+import org.springframework.core.convert.converter.Converter;
+
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.util.Date;
+
+public class ZonedDateTimeReadConverter implements Converter<Date, ZonedDateTime> {
+    @Override
+    public ZonedDateTime convert(Date date) {
+        return date.toInstant().atZone(ZoneOffset.UTC);
+    }
+}

persistence-modules/spring-data-mongodb/src/main/java/converter/ZonedDateTimeWriteConverter.java

@@ -0,0 +1,13 @@
+package converter;
+
+import org.springframework.core.convert.converter.Converter;
+
+import java.time.ZonedDateTime;
+import java.util.Date;
+
+public class ZonedDateTimeWriteConverter implements Converter<ZonedDateTime, Date> {
+    @Override
+    public Date convert(ZonedDateTime zonedDateTime) {
+        return Date.from(zonedDateTime.toInstant());
+    }
+}