DbTemplate

package com.me.dbComponent;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * Created by zgj on 2017/7/27.
 */
public abstract class DbTemplate {

    private <T> T execute(Function<Connection, T> function) {
        Connection connection = getConnection();
        try {
            return function.apply(connection);
        } finally {
            releaseConnection(connection);
        }
    }

    protected void releaseConnection(Connection connection) {
        throw new RuntimeException("the method releaseConnection not implements");
    }

    protected Connection getConnection() {
        throw new RuntimeException("the method getConnection not implements");
    }


    public int insert(String sql, Object... args) {
        return insert(sql, preparedStatement -> setParameter(preparedStatement, args));
    }

    public int insert(String sql, Iterable<?> args) {
        return insert(sql, preparedStatement -> setParameter(preparedStatement, args));
    }

    public int insert(String sql, Map<String, Object> args) {
        return insert(sql, preparedStatement -> setParameter(preparedStatement, args));
    }

    private int insert(String sql, Consumer<PreparedStatement> statementSetter) {
        return execute(connection -> {
           try (PreparedStatement pst = connection.prepareStatement(sql)) {
               connection.setAutoCommit(false);
               if (statementSetter  != null) {
                   statementSetter.accept(pst);
               }
               int count = pst.executeUpdate();
               connection.commit();
               return count;
           } catch (SQLException e) {
               try {
                   connection.rollback();
               } catch (SQLException e1) {
                   throw new RuntimeException("transaction rollback occurred exception", e);
               }
               throw new RuntimeException(e);
           }
        });

    }

    public <T> T queryObject(String sql , Function<ResultSet, T> resultSet, Object... args) {
        return (T)query(sql, preparedStatement -> setParameter(preparedStatement, args), resultSet);
    }

    private <T> T query(String sql, Consumer<PreparedStatement> consumer, Function<ResultSet, T> resultSetExtractor) {
        return execute(connection -> {
            try (PreparedStatement pst = connection.prepareStatement(sql)) {
                if (consumer != null) {
                    consumer.accept(pst);
                }
                try (ResultSet resultSet = pst.executeQuery()) {
                    return resultSetExtractor.apply(resultSet);
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        });

    }

    public <T> T queryObject(String sql, Object... args) {
        return (T)query(sql, preparedStatement -> setParameter(preparedStatement, args), DbTemplate::toOne);
    }

    private <T> List<T> queryList(String sql, Consumer<PreparedStatement> statementConsumer, Function<ResultSet, T> rowMapper) {
        return query(sql, statementConsumer, resultSet -> {
            try {
                int size = getRowSize(resultSet);
                if (size == 0)
                    return Collections.<T>emptyList();
                List<T> list = new ArrayList<>();
                while (resultSet.next()) {
                    T t = rowMapper.apply(resultSet);
                    if (!Objects.isNull(t)) {
                        list.add(t);
                    }
                }
                return list;
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        });
    }

    public <T> List<T> queryList(String sql, Object[] args, Function<ResultSet, T> rowMapper) {
        return queryList(sql, preparedStatement -> setParameter(preparedStatement, args), rowMapper);
    }


    public long queryCount(String sql) {
        return queryCount(sql, "");
    }

    public long queryCount(String sql, Object... args) {
        Number number = queryObject(sql,args);
        return number == null ? 0L : number.longValue();
    }

    public boolean isExist(String sql) {
        return isExist(sql, "");
    }

    public boolean isExist(String sql, Object... args) {
        long count = queryCount(sql, args);
        return count > 0L;
    }

    private static Object toOne(ResultSet resultSet) {
        if (getRowSize(resultSet) > 1) {
            throw new RuntimeException("the result set is more than 1 row");
        }
        try {
            int colAmount = resultSet.getMetaData().getColumnCount();
            if (colAmount == 1 && resultSet.next()) {
                return resultSet.getObject(1);
            } else if (colAmount > 1 && resultSet.next()) {
                Object[] temp = new Object[colAmount];
                for (int i = 0; i < colAmount; i++) {
                    temp[i] = resultSet.getObject(i + 1);
                }
                return temp;
            }
            return null;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    private static int getRowSize(ResultSet resultSet) {
        int rows = 0;
        try {
            if (resultSet.last()) {
                rows = resultSet.getRow();
                resultSet.beforeFirst();
            }
            return rows;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }


    private static void setParameter(PreparedStatement preparedStatement, Object[] args) {
        if (args == null || args.length == 0) {
            return;
        }
        try {
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }

    }

    private static void setParameter(PreparedStatement preparedStatement, Iterable<?> args) {
        if (args == null) {
            return;
        }
        int index = 0;
        try {
            for (Iterator i = args.iterator(); i.hasNext(); ) {
                preparedStatement.setObject(++index, i.next());
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }

    }

    private static void setParameter(PreparedStatement preparedStatement, Map<String, Object> map) {
        if (map == null) {
            return;
        }
        int index = 0;
        try {
            for (String key : map.keySet()) {
                preparedStatement.setObject(++index, map.get(key));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }

    }

}