org.test4j.module.database.enviroment.BaseEnvironment Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of fluent-dbtest Show documentation
fluent database test
There is a newer version: 1.1.2
package org.test4j.module.database.enviroment;

import cn.org.atool.fluent.mybatis.metadata.DbType;
import lombok.Getter;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.test4j.Logger;
import org.test4j.exception.Exceptions;
import org.test4j.functions.EConsumer;
import org.test4j.functions.EFunction;
import org.test4j.module.database.config.DbConfig;
import org.test4j.module.database.enviroment.typesmap.AbstractTypeMap;
import org.test4j.module.database.proxy.DataSourceCreator;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;

public abstract class BaseEnvironment implements DBEnvironment {

    private final Map metas = new HashMap<>();

    private final DataSource dataSource;

    @Getter
    private final DbType dbType;

    protected AbstractTypeMap typeMap;

    protected BaseEnvironment(String dataSourceName) {
        this.dataSource = DataSourceCreator.create(dataSourceName);
        this.dbType = DbConfig.instance().dbType(dataSourceName);
    }

    @Override
    public void commit() {
        this.doIt(connection -> {
            if (!connection.getAutoCommit()) {
                connection.commit();
            }
        });
    }

    @Override
    public void rollback() {
        this.doIt(connection -> {
            if (!connection.getAutoCommit()) {
                connection.rollback();
            }
        });
    }

    @Override
    public void execute(String sql, EConsumer executor) {
        this.doIt(connection -> {
            try (PreparedStatement st = connection.prepareStatement(sql)) {
                executor.accept(st);
            }
        });
    }

    @Override
    public void execute(EFunction stFunction,
                        EConsumer executor) {
        this.doIt(connection -> {
            try (PreparedStatement st = stFunction.apply(connection)) {
                executor.accept(st);
            }
        });
    }

    @Override
    public  R query(EFunction stFunction,
                       EFunction resultFunction) {
        return this.doIt(connection -> {
            try (PreparedStatement st = stFunction.apply(connection)) {
                ResultSet rs = st.executeQuery();
                return resultFunction.apply(rs);
            }
        });
    }

    @Override
    public  R query(String sql, EFunction rsFunction) {
        return this.doIt(connection -> {
            try (PreparedStatement st = connection.prepareStatement(sql)) {
                ResultSet rs = st.executeQuery();
                return rsFunction.apply(rs);
            } catch (Throwable e) {
                throw new RuntimeException("sql:" + sql, e);
            }
        });
    }

    /**
     * 获得数据表的元信息
     *
     * @param table table name
     * @return TableMeta
     */
    @Override
    public TableMeta getTableMetaData(String table) {
        if (metas.get(table) != null) {
            return metas.get(table);
        }
        return this.query("select * from " + table + " where 1!=1",
            rs -> {
                TableMeta meta = new TableMeta(table, rs.getMetaData());
                metas.put(table, meta);
                return meta;
            }
        );
    }

    @Override
    public Object getDefaultValue(String javaType) {
        return this.typeMap.getDefaultValue(javaType);
    }

    @Override
    public Object toObjectValue(String input, String javaType) {
        try {
            return this.typeMap.toObjectByType(input, javaType);
        } catch (Exception e) {
            Logger.info("convert input[" + input + "] to type[" + javaType + "] error, so return input value.\n"
                + e.getMessage());
            return input;
        }
    }

    /**
     * {@inheritDoc} 

     * 

     */
    @Override
    @SuppressWarnings("rawtypes")
    public Object convertToSqlValue(Object value) {
        if (value instanceof Enum) {
            return ((Enum) value).name();
        }
        return value;
    }

    private  R doIt(EFunction function) {
        Connection connection = null;
        try {
            connection = DataSourceUtils.doGetConnection(dataSource);
            return function.apply(connection);
        } catch (Throwable e) {
            throw Exceptions.getUndeclaredThrowableExceptionCaused(e);
        } finally {
            DataSourceUtils.releaseConnection(connection, dataSource);
        }
    }

    private void doIt(EConsumer consumer) {
        Connection connection = null;
        try {
            connection = DataSourceUtils.doGetConnection(dataSource);
            consumer.accept(connection);
        } catch (Throwable e) {
            throw Exceptions.getUndeclaredThrowableExceptionCaused(e);
        } finally {
            DataSourceUtils.releaseConnection(connection, dataSource);
        }
    }
}