org.audit4j.handler.db.ConnectionFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of audit4j-db Show documentation
Audit4j - An open-source auditing framework for Java, Spring Integration
The newest version!
/*
 * Copyright (c) 2014-2015 Janith Bandara, This source is a part of
 * Audit4j - An open source auditing framework.
 * http://audit4j.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.audit4j.handler.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

import org.audit4j.core.exception.InitializationException;
import org.audit4j.core.util.Log;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

/**
 * A factory for creating JDBC Connections.
 * 
 * @author Janith Bandara
 */
final class ConnectionFactory {

    /** The Constant SINGLE_CONNECTION. */
    static final String SINGLE_CONNECTION = "single";

    /** The Constant POOLED_CONNECTION. */
    static final String POOLED_CONNECTION = "pooled";

    /** The db_driver. */
    private String driver = "org.hsqldb.jdbcDriver";

    /** The data source class. */
    private String dataSourceClass = "org.hsqldb.jdbc.JDBCDataSource";

    /** The db_url. */
    private String url = "jdbc:hsqldb:hsql://localhost/audit4j";

    /** The jndi data source. */
    private String jndiDataSource;

    /** The db_user. */
    private String user = "audit4juser";

    /** The db_password. */
    private String password = "audit4jpassword";

    /** The connection type. */
    private ConnectionType connectionType;

    /** The ds. */
    private HikariDataSource ds;

    /** The auto commit. */
    private boolean autoCommit = true;

    /** The connection timeout. */
    private Long connectionTimeout;

    /** The idle timeout. */
    private Integer idleTimeout;

    /** The max lifetime. */
    private Integer maxLifetime;

    /** The minimum idle. */
    private Integer minimumIdle;

    /** The maximum pool size. */
    private Integer maximumPoolSize = 100;

    /** The Constant CONNECTION_POOL_NAME. */
    private static final String CONNECTION_POOL_NAME = "Audit4j-DB";

    /**
     * Instantiates a new connection factory.
     */
    private ConnectionFactory() {
    }

    /** The instance. */
    private static ConnectionFactory instance;

    /** The data source. */
    private DataSource dataSource;

    /**
     * Gets the connection.
     * 
     * @return the connection
     */
    Connection getConnection() {
        if (dataSource == null) {
            return getSingleConnection();
        } else {
            return getDataSourceConnection();
        }
    }

    /**
     * Gets the connection.
     * 
     * @return the connection
     */
    Connection getSingleConnection() {
        Connection connection = null;
        try {
            Class.forName(driver);
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            throw new InitializationException("Could not initialize the connection", e);
        } catch (ClassNotFoundException e) {
            throw new InitializationException("Could not find the driver class", e);
        }
        return connection;
    }

    /**
     * Gets the data source connection.
     * 
     * @return the data source connection
     * @since 2.4.0
     */
    Connection getDataSourceConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException ex) {
            throw new InitializationException("Could not obtain the db connection: Cannot get connection", ex);
        }
        return connection;
    }

    /**
     * initialize connection factory. This will created the necessary connection
     * pools and jndi lookups in advance.
     */
    void init() {
        if (dataSource == null) {
            if (connectionType.equals(ConnectionType.POOLED)) {
                HikariConfig config = new HikariConfig();
                config.setMaximumPoolSize(maximumPoolSize);
                config.setDataSourceClassName(dataSourceClass);
                config.addDataSourceProperty("url", url);
                config.addDataSourceProperty("user", user);
                config.addDataSourceProperty("password", password);
                config.setPoolName(CONNECTION_POOL_NAME);
                config.setAutoCommit(autoCommit);
                config.setMaximumPoolSize(maximumPoolSize);
              //  config.setConnectionTestQuery("SELECT 1");
                
                if (connectionTimeout != null) {
                    config.setConnectionTimeout(connectionTimeout);
                }
                if (idleTimeout != null) {
                    config.setIdleTimeout(idleTimeout);
                }
                if (maxLifetime != null) {
                    config.setMaxLifetime(maxLifetime);
                }
                if (minimumIdle != null) {
                    config.setMinimumIdle(minimumIdle);
                }

                ds = new HikariDataSource(config);
                dataSource = ds;

            } else if (connectionType.equals(ConnectionType.JNDI)) {
                if (null == jndiDataSource) {
                    throw new InitializationException("Could not obtain the db connection: jndi data source is null");
                }
                String DATASOURCE_CONTEXT = jndiDataSource;
                try {
                    Context initialContext = new InitialContext();
                    dataSource = (DataSource) initialContext.lookup(DATASOURCE_CONTEXT);
                    if (dataSource == null) {
                        Log.error("Failed to lookup datasource.");
                        throw new InitializationException(
                                "Could not obtain the db connection: Failed to lookup datasource: " + jndiDataSource);
                    }
                } catch (NamingException ex) {
                    throw new InitializationException("Could not obtain the db connection: jndi lookup failed", ex);
                }
            }
        }
    }

    /**
     * Stop.
     */
    void stop() {
        if (ds != null) {
            ds.close();
        }
    }

    /**
     * Sets the driver.
     * 
     * @param driver
     *            the new driver
     */
    void setDriver(String driver) {
        this.driver = driver;
    }

    /**
     * Sets the url.
     * 
     * @param url
     *            the new url
     */
    void setUrl(String url) {
        this.url = url;
    }

    /**
     * Sets the user.
     * 
     * @param user
     *            the new user
     */
    void setUser(String user) {
        this.user = user;
    }

    /**
     * Sets the password.
     * 
     * @param password
     *            the new password
     */
    void setPassword(String password) {
        this.password = password;
    }

    /**
     * Sets the jndi data source.
     * 
     * @param jndiDataSource
     *            the new jndi data source
     */
    public void setJndiDataSource(String jndiDataSource) {
        this.jndiDataSource = jndiDataSource;
    }

    /**
     * Sets the connection type.
     * 
     * @param connectionType
     *            the new connection type
     */
    public void setConnectionType(ConnectionType connectionType) {
        this.connectionType = connectionType;
    }

    /**
     * Sets the data source.
     * 
     * @param dataSource
     *            the new data source
     */
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * Sets the auto commit.
     * 
     * @param autoCommit
     *            the new auto commit
     */
    public void setAutoCommit(boolean autoCommit) {
        this.autoCommit = autoCommit;
    }

    /**
     * Sets the connection timeout.
     * 
     * @param connectionTimeout
     *            the new connection timeout
     */
    public void setConnectionTimeout(Long connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    /**
     * Sets the idle timeout.
     * 
     * @param idleTimeout
     *            the new idle timeout
     */
    public void setIdleTimeout(int idleTimeout) {
        this.idleTimeout = idleTimeout;
    }

    /**
     * Sets the max lifetime.
     * 
     * @param maxLifetime
     *            the new max lifetime
     */
    public void setMaxLifetime(int maxLifetime) {
        this.maxLifetime = maxLifetime;
    }

    /**
     * Sets the minimum idle.
     * 
     * @param minimumIdle
     *            the new minimum idle
     */
    public void setMinimumIdle(int minimumIdle) {
        this.minimumIdle = minimumIdle;
    }

    /**
     * Sets the maximum pool size.
     * 
     * @param maximumPoolSize
     *            the new maximum pool size
     */
    public void setMaximumPoolSize(int maximumPoolSize) {
        this.maximumPoolSize = maximumPoolSize;
    }

    /**
     * Sets the data source class.
     * 
     * @param dataSourceClass
     *            the new data source class
     */
    public void setDataSourceClass(String dataSourceClass) {
        this.dataSourceClass = dataSourceClass;
    }

    /**
     * Gets the single instance of ConnectionFactory.
     * 
     * @return single instance of ConnectionFactory
     */
    static ConnectionFactory getInstance() {
        synchronized (ConnectionFactory.class) {
            if (instance == null) {
                instance = new ConnectionFactory();
            }
        }
        return instance;
    }
}