Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.config;

import java.io.IOException;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Properties;

import javax.annotation.PreDestroy;
import javax.sql.DataSource;

import com.mysql.cj.jdbc.AbandonedConnectionCleanupThread;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.hibernate.SessionFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.Resource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBuilder;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.spice.profitmandi.dao.repository.dtr.Mongo;

import com.spice.profitmandi.web.config.AppConfig;


@Configuration
@EnableTransactionManagement
@ComponentScan({ "com.spice.profitmandi.*" })
public class WebDBContextConfigure {

        private static final Logger LOGGER = LogManager.getLogger(WebDBContextConfigure.class);

        private static final String HIBERNATE_DRIVER_CLASS = "hibernate.driver.class";
        private static final String HIBERNATE_URL = "hibernate.url";
        private static final String HIBERNATE_USER_NAME = "hibernate.user.name";
        private static final String HIBERNATE_PASSWORD = "hibernate.password";
        private static final String HIBERNATE_DIALECT = "hibernate.dialect";
        private static final String HIBERNATE_SHOW_SQL = "hibernate.show_sql";
        private static final String HIBERNATE_FORMAT_SQL = "hibernate.format_sql";
        private static final String HIBERNATE_JDBC_BATCH_SIZE = "hibernate.jdbc.batch_size";
        private static final String HIBERNATE_ORDER_INSERTS = "hibernate.order_inserts";
        private static final String HIBERNATE_ORDER_UPDATES = "hibernate.order_updates";
        private static final String HIKARI_MAX_POOL_SIZE = "hikari.maximumPoolSize";
        private static final String HIKARI_MIN_IDLE = "hikari.minimumIdle";
        private static final String HIKARI_IDLE_TIMEOUT = "hikari.idleTimeout";
        private static final String HIKARI_MAX_LIFETIME = "hikari.maxLifetime";
        private static final String HIKARI_CONNECTION_TIMEOUT = "hikari.connectionTimeout";

        private Resource resource = AppConfig.getResource();

        private Properties loadAllProperties() {
                Properties properties = new Properties();
                try {
                        Resource sharedRes = AppConfig.getSharedResource();
                        if (sharedRes != null && sharedRes.exists()) {
                                properties.load(sharedRes.getInputStream());
                        }
                        properties.load(resource.getInputStream());
                } catch (IOException e) {
                        LOGGER.error("Failed to load properties", e);
                }
                return properties;
        }

        @Bean(name = "dataSource", destroyMethod = "close")
        public DataSource dataSource() {
                Properties properties = loadAllProperties();

                HikariConfig config = new HikariConfig();
                config.setDriverClassName(properties.getProperty(HIBERNATE_DRIVER_CLASS));
                config.setJdbcUrl(properties.getProperty(HIBERNATE_URL));
                config.setUsername(properties.getProperty(HIBERNATE_USER_NAME));
                config.setPassword(properties.getProperty(HIBERNATE_PASSWORD));
                config.setMaximumPoolSize(Integer.parseInt(properties.getProperty(HIKARI_MAX_POOL_SIZE, "20")));
                config.setMinimumIdle(Integer.parseInt(properties.getProperty(HIKARI_MIN_IDLE, "2")));
                config.setIdleTimeout(Long.parseLong(properties.getProperty(HIKARI_IDLE_TIMEOUT, "30000")));
                config.setMaxLifetime(Long.parseLong(properties.getProperty(HIKARI_MAX_LIFETIME, "1800000")));
                config.setConnectionTimeout(Long.parseLong(properties.getProperty(HIKARI_CONNECTION_TIMEOUT, "30000")));
                config.setPoolName("HikariPool-Web");
                config.setLeakDetectionThreshold(30000);

                LOGGER.info("Initializing HikariDataSource with URL: {}", properties.getProperty(HIBERNATE_URL));
                return new HikariDataSource(config);
        }

        @Bean
        public Properties getHibernateProperties() {
                Properties dbProperties = new Properties();
                Properties properties = loadAllProperties();
                dbProperties.put(HIBERNATE_DIALECT, properties.getProperty(HIBERNATE_DIALECT));
                dbProperties.put(HIBERNATE_SHOW_SQL, properties.getProperty(HIBERNATE_SHOW_SQL));
                dbProperties.put(HIBERNATE_FORMAT_SQL, properties.getProperty(HIBERNATE_FORMAT_SQL));
                dbProperties.put(HIBERNATE_JDBC_BATCH_SIZE, properties.getProperty(HIBERNATE_JDBC_BATCH_SIZE));
                dbProperties.put(HIBERNATE_ORDER_INSERTS, properties.getProperty(HIBERNATE_ORDER_INSERTS, "true"));
                dbProperties.put(HIBERNATE_ORDER_UPDATES, properties.getProperty(HIBERNATE_ORDER_UPDATES, "true"));
                return dbProperties;
        }

        @Primary
        @Bean(name = "sessionFactory")
        public SessionFactory getSessionFactory(DataSource dataSource) {
                LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
                sessionBuilder.addProperties(getHibernateProperties());
                sessionBuilder.scanPackages("com.spice.profitmandi.dao.*");
                LOGGER.info("SessionFactory created");
                return sessionBuilder.buildSessionFactory();
        }

        @Primary
        @Bean(name = "transactionManager")
        public HibernateTransactionManager getTransactionManager(SessionFactory sessionFactory) {
                return new HibernateTransactionManager(sessionFactory);
        }
        
        @Bean(destroyMethod = "close")
        public Mongo mongoClient() {
                Properties properties = loadAllProperties();
                return new Mongo(properties.getProperty("mongo.host"), properties.getProperty("content.mongo.host"));
        }

        /**
         * Cleanup method to prevent memory leaks on shutdown.
         * Deregisters JDBC drivers and stops MySQL cleanup thread.
         */
        @PreDestroy
        public void cleanup() {
                LOGGER.info("WebDBContextConfigure cleanup started...");

                // Stop MySQL AbandonedConnectionCleanupThread
                try {
                        AbandonedConnectionCleanupThread.checkedShutdown();
                        LOGGER.info("MySQL AbandonedConnectionCleanupThread stopped");
                } catch (Exception e) {
                        LOGGER.error("Error stopping MySQL cleanup thread", e);
                }

                // Deregister JDBC drivers loaded by this webapp's classloader
                ClassLoader cl = Thread.currentThread().getContextClassLoader();
                Enumeration<Driver> drivers = DriverManager.getDrivers();
                while (drivers.hasMoreElements()) {
                        Driver driver = drivers.nextElement();
                        if (driver.getClass().getClassLoader() == cl) {
                                try {
                                        DriverManager.deregisterDriver(driver);
                                        LOGGER.info("Deregistered JDBC driver: {}", driver);
                                } catch (SQLException e) {
                                        LOGGER.error("Error deregistering JDBC driver {}", driver, e);
                                }
                        }
                }

                LOGGER.info("WebDBContextConfigure cleanup completed");
        }
}