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);
         }

     }

 }