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

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

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/application/UserApplication.java

@@ -0,0 +1,53 @@
+package com.baeldung.daopattern.application;
+
+import com.baeldung.daopattern.config.JpaEntityManagerFactory;
+import com.baeldung.daopattern.daos.Dao;
+import com.baeldung.daopattern.daos.JpaUserDao;
+import com.baeldung.daopattern.entities.User;
+import java.util.List;
+import java.util.Optional;
+import javax.persistence.EntityManager;
+import javax.persistence.Persistence;
+
+public class UserApplication {
+    
+    private static JpaUserDao jpaUserDao;
+    
+    public static void main(String[] args) {
+        User user1 = getUser(1);
+        System.out.println(user1);
+        updateUser(user1, new String[]{"John", "john@domain.com"});
+        saveUser(new User("Monica", "monica@domain.com"));
+        deleteUser(getUser(2));
+        getAllUsers().forEach(user -> System.out.println(user.getName()));
+    }
+    
+    private static class JpaUserDaoHolder {
+        private static final JpaUserDao jpaUserDao = new JpaUserDao(new JpaEntityManagerFactory().getEntityManager());
+    }
+    
+    public static Dao getJpaUserDao() {
+        return JpaUserDaoHolder.jpaUserDao;
+    }
+    
+    public static User getUser(long id) {
+        Optional<User> user = getJpaUserDao().get(id);
+        return user.orElseGet(()-> {return new User("non-existing user", "no-email");});
+    }
+    
+    public static List<User> getAllUsers() {
+        return getJpaUserDao().getAll();
+    }
+    
+    public static void updateUser(User user, String[] params){
+        getJpaUserDao().update(user, params);
+    }
+    
+    public static void saveUser(User user) {
+        getJpaUserDao().save(user);
+    }
+    
+    public static void deleteUser(User user) {
+        getJpaUserDao().delete(user);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/config/JpaEntityManagerFactory.java

@@ -0,0 +1,65 @@
+package com.baeldung.daopattern.config;
+
+import com.baeldung.daopattern.entities.User;
+import com.mysql.cj.jdbc.MysqlDataSource;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+import javax.persistence.EntityManager;
+import javax.sql.DataSource;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.spi.PersistenceUnitInfo;
+import org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl;
+import org.hibernate.jpa.boot.internal.PersistenceUnitInfoDescriptor;
+
+public class JpaEntityManagerFactory {
+    
+    private final String DB_URL = "jdbc:mysql://databaseurl";
+    private final String DB_USER_NAME = "username";
+    private final String DB_PASSWORD = "password";
+    
+    public EntityManager getEntityManager() {
+        return getEntityManagerFactory().createEntityManager();
+    }
+    
+    protected EntityManagerFactory getEntityManagerFactory() {
+        PersistenceUnitInfo persistenceUnitInfo = getPersistenceUnitInfo(getClass().getSimpleName());
+        Map<String, Object> configuration = new HashMap<>();
+        return new EntityManagerFactoryBuilderImpl(new PersistenceUnitInfoDescriptor(persistenceUnitInfo), configuration)
+          .build();
+    }
+    
+    protected PersistenceUnitInfoImpl getPersistenceUnitInfo(String name) {
+        return new PersistenceUnitInfoImpl(name, getEntityClassNames(), getProperties());
+    }
+    
+    protected List<String> getEntityClassNames() {
+        return Arrays.asList(getEntities())
+          .stream()
+          .map(Class::getName)
+          .collect(Collectors.toList());
+    }
+    
+    protected Properties getProperties() {
+        Properties properties = new Properties();
+        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
+        properties.put("hibernate.id.new_generator_mappings", false);
+        properties.put("hibernate.connection.datasource", getMysqlDataSource());
+        return properties;
+    }
+    
+    protected Class[] getEntities() {
+        return new Class[]{User.class};
+    }
+    
+    protected DataSource getMysqlDataSource() {
+	MysqlDataSource mysqlDataSource = new MysqlDataSource();
+        mysqlDataSource.setURL(DB_URL);
+	mysqlDataSource.setUser(DB_USER_NAME);
+        mysqlDataSource.setPassword(DB_PASSWORD);
+	return mysqlDataSource;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/config/PersistenceUnitInfoImpl.java

@@ -0,0 +1,130 @@
+package com.baeldung.daopattern.config;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+import javax.sql.DataSource;
+import javax.persistence.SharedCacheMode;
+import javax.persistence.ValidationMode;
+import javax.persistence.spi.ClassTransformer;
+import javax.persistence.spi.PersistenceUnitInfo;
+import javax.persistence.spi.PersistenceUnitTransactionType;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+
+public class PersistenceUnitInfoImpl implements PersistenceUnitInfo {
+    
+    public static final String JPA_VERSION = "2.1";
+    private final String persistenceUnitName;
+    private PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+    private final List<String> managedClassNames;
+    private final List<String> mappingFileNames = new ArrayList<>();
+    private final Properties properties;
+    private DataSource jtaDataSource;
+    private DataSource nonJtaDataSource;
+    
+    public PersistenceUnitInfoImpl(String persistenceUnitName, List<String> managedClassNames, Properties properties) {
+        this.persistenceUnitName = persistenceUnitName;
+        this.managedClassNames = managedClassNames;
+        this.properties = properties;
+    }
+    
+    @Override
+    public String getPersistenceUnitName() {
+        return persistenceUnitName;
+    }
+ 
+    @Override
+    public String getPersistenceProviderClassName() {
+        return HibernatePersistenceProvider.class.getName();
+    }
+ 
+    @Override
+    public PersistenceUnitTransactionType getTransactionType() {
+        return transactionType;
+    }
+ 
+    @Override
+    public DataSource getJtaDataSource() {
+        return jtaDataSource;
+    }
+ 
+    public PersistenceUnitInfoImpl setJtaDataSource(DataSource jtaDataSource) {
+        this.jtaDataSource = jtaDataSource;
+        this.nonJtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.JTA;
+        return this;
+    }
+ 
+    @Override
+    public DataSource getNonJtaDataSource() {
+        return nonJtaDataSource;
+    }
+ 
+    public PersistenceUnitInfoImpl setNonJtaDataSource(DataSource nonJtaDataSource) {
+        this.nonJtaDataSource = nonJtaDataSource;
+        this.jtaDataSource = null;
+        transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
+        return this;
+    }
+ 
+    @Override
+    public List<String> getMappingFileNames() {
+        return mappingFileNames;
+    }
+ 
+    @Override
+    public List<URL> getJarFileUrls() {
+        return Collections.emptyList();
+    }
+ 
+    @Override
+    public URL getPersistenceUnitRootUrl() {
+        return null;
+    }
+ 
+    @Override
+    public List<String> getManagedClassNames() {
+        return managedClassNames;
+    }
+ 
+    @Override
+    public boolean excludeUnlistedClasses() {
+        return false;
+    }
+ 
+    @Override
+    public SharedCacheMode getSharedCacheMode() {
+        return SharedCacheMode.UNSPECIFIED;
+    }
+ 
+    @Override
+    public ValidationMode getValidationMode() {
+        return ValidationMode.AUTO;
+    }
+ 
+    public Properties getProperties() {
+        return properties;
+    }
+ 
+    @Override
+    public String getPersistenceXMLSchemaVersion() {
+        return JPA_VERSION;
+    }
+ 
+    @Override
+    public ClassLoader getClassLoader() {
+        return Thread.currentThread().getContextClassLoader();
+    }
+ 
+    @Override
+    public void addTransformer(ClassTransformer transformer) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+    
+    @Override
+    public ClassLoader getNewTempClassLoader() {
+        return null;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/Dao.java

@@ -0,0 +1,17 @@
+package com.baeldung.daopattern.daos;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface Dao<T> {
+    
+    Optional<T> get(long id);
+    
+    List<T> getAll();
+    
+    void save(T t);
+    
+    void update(T t, String[] params);
+    
+    void delete(T t);   
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/JpaUserDao.java

@@ -0,0 +1,60 @@
+package com.baeldung.daopattern.daos;
+
+import com.baeldung.daopattern.entities.User;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityTransaction;
+import javax.persistence.Query;
+
+public class JpaUserDao implements Dao<User> {
+    
+    private final EntityManager entityManager;
+    
+    public JpaUserDao(EntityManager entityManager) {
+        this.entityManager = entityManager;
+    }
+    
+    @Override
+    public Optional<User> get(long id) {
+        return Optional.ofNullable(entityManager.find(User.class, id));
+    }
+    
+    @Override
+    public List<User> getAll() {
+        Query query = entityManager.createQuery("SELECT e FROM User e");
+        return query.getResultList();
+    }
+    
+    @Override
+    public void save(User user) {
+        executeInsideTransaction(entityManager -> entityManager.persist(user));
+    }
+    
+    @Override
+    public void update(User user, String[] params) {
+        user.setName(Objects.requireNonNull(params[0], "Name cannot be null"));
+        user.setEmail(Objects.requireNonNull(params[1], "Email cannot be null"));
+        executeInsideTransaction(entityManager -> entityManager.merge(user));
+    }
+    
+    @Override 
+    public void delete(User user) {
+        executeInsideTransaction(entityManager -> entityManager.remove(user));
+    }
+    
+    private void executeInsideTransaction(Consumer<EntityManager> action) {
+        final EntityTransaction tx = entityManager.getTransaction();
+        try {
+            tx.begin();
+            action.accept(entityManager);
+            tx.commit(); 
+        }
+        catch (RuntimeException e) {
+            tx.rollback();
+            throw e;
+        }
+    }    
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/daos/UserDao.java

@@ -0,0 +1,44 @@
+package com.baeldung.daopattern.daos;
+
+import com.baeldung.daopattern.entities.User;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+public class UserDao implements Dao<User> {
+    
+    private List<User> users = new ArrayList<>();
+    
+    public UserDao() {
+        users.add(new User("John", "john@domain.com"));
+        users.add(new User("Susan", "susan@domain.com"));
+    }
+    
+    @Override
+    public Optional<User> get(long id) {
+        return Optional.ofNullable(users.get((int) id));
+    }
+    
+    @Override
+    public List<User> getAll() {
+        return users;
+    }
+    
+    @Override
+    public void save(User user) {
+        users.add(user);
+    }
+    
+    @Override
+    public void update(User user, String[] params) {
+        user.setName(Objects.requireNonNull(params[0], "Name cannot be null"));
+        user.setEmail(Objects.requireNonNull(params[1], "Email cannot be null"));
+        users.add(user);
+    }
+    
+    @Override
+    public void delete(User user) {
+        users.remove(user);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/daopattern/entities/User.java

@@ -0,0 +1,45 @@
+package com.baeldung.daopattern.entities;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "users")
+public class User {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private long id;
+    private String name;
+    private String email;
+    
+    public User(){}
+    
+    public User(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+    
+    public long getId() {
+        return id;
+    }
+    
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/Cache.java

@@ -0,0 +1,39 @@
+package com.baeldung.service.locator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class Cache {
+    private List<MessagingService> services;
+
+    public Cache(){
+        services = new ArrayList<MessagingService>();
+    }
+
+    public MessagingService getService(String serviceName){
+
+        for (MessagingService service : services) {
+            if(service.getServiceName().equalsIgnoreCase(serviceName)){
+                System.out.println("Returning cached  " + serviceName + " object");
+                return service;
+            }
+        }
+        return null;
+    }
+
+    public void addService(MessagingService newService){
+        boolean exists = false;
+
+        for (MessagingService service : services) {
+            if(service.getServiceName().equalsIgnoreCase(newService.getServiceName())){
+                exists = true;
+            }
+        }
+        if(!exists){
+            services.add(newService);
+        }
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/EmailService.java

@@ -0,0 +1,15 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class EmailService implements MessagingService {
+
+    public String getMessageBody() {
+        return "email message";
+    }
+
+    public String getServiceName() {
+        return "EmailService";
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/InitialContext.java

@@ -0,0 +1,17 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class InitialContext {
+
+    public Object lookup(String serviceName) {
+
+        if (serviceName.equalsIgnoreCase("EmailService")) {
+            return new EmailService();
+        } else if (serviceName.equalsIgnoreCase("SMSService")) {
+            return new SMSService();
+        }
+        return null;
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/Main.java

@@ -0,0 +1,22 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class Main {
+
+    public static void main(String[] args) {
+
+        MessagingService service = ServiceLocator.getService("EmailService");
+        String email = service.getMessageBody();
+        System.out.println(email);
+
+        service = ServiceLocator.getService("SMSService");
+        String sms = service.getMessageBody();
+        System.out.println(sms);
+
+        service = ServiceLocator.getService("EmailService");
+        String newEmail = service.getMessageBody();
+        System.out.println(newEmail);
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/MessagingService.java

@@ -0,0 +1,8 @@
+package com.baeldung.service.locator;
+
+public interface MessagingService {
+
+    String getMessageBody();
+
+    String getServiceName();
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/SMSService.java

@@ -0,0 +1,15 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class SMSService implements MessagingService {
+
+    public String getMessageBody() {
+        return "sms message";
+    }
+
+    public String getServiceName() {
+        return "SMSService";
+    }
+}

patterns/design-patterns-architectural/src/main/java/com/baeldung/service/locator/ServiceLocator.java

@@ -0,0 +1,27 @@
+package com.baeldung.service.locator;
+
+/**
+ * Created by Gebruiker on 4/20/2018.
+ */
+public class ServiceLocator {
+
+    private static Cache cache;
+
+    static {
+        cache = new Cache();
+    }
+
+    public static MessagingService getService(String serviceName){
+
+        MessagingService service = cache.getService(serviceName);
+
+        if(service != null){
+            return service;
+        }
+
+        InitialContext context = new InitialContext();
+        MessagingService service1 = (MessagingService)context.lookup(serviceName);
+        cache.addService(service1);
+        return service1;
+    }
+}