java8 lambda表达式 编写jdbc基类

最新推荐文章于 2023-09-24 20:32:04 发布
最新推荐文章于 2023-09-24 20:32:04 发布
阅读量792 收藏 1
点赞数
分类专栏： java 文章标签： java jdbc lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoping_1988/article/details/78095990
版权

支持lambda表达式的接口类

@FunctionalInterface
public interface ResultSetHandler <T> {
    T handle(ResultSet rs) throws Exception;
}

jdbc基类

其中doQuery方法支持lamda表达式参数传入，这样就把基本的jdbc处理步骤封装在一个方法里了

import com.alibaba.fastjson.JSON;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.sql.*;
import java.sql.Date;
import java.util.*;

public abstract class BaseJdbcDao<T> {

    private static final Logger logger = LoggerFactory.getLogger(BaseJdbcDao.class);

    private Class<T> entityClass;

    public BaseJdbcDao() {
        Type genType = getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        entityClass = (Class) params[0];
    }

    public abstract Connection getConnection() throws Exception;
    public abstract void closeConnection(Connection connection) throws Exception;

    /**
     * map转对象
     * @param orgin
     * @param target
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws InstantiationException
     */
    protected  <T> List<T> populateData(List<Map<String, Object>> orgin, Class<T> target) throws IllegalAccessException, InvocationTargetException, InstantiationException {
        if (CollectionUtils.isEmpty(orgin)) {
            return Collections.emptyList();
        }
        try {
            List<T> objs = new ArrayList<>(orgin.size());
            T obj = null;
            for (Map<String, Object> map : orgin) {
                obj = target.newInstance();
                BeanUtils.populate(obj, map);
                objs.add(obj);
            }
            return objs;
        } catch (Exception e) {
            logger.error("populate error!", e);
            throw e;
        }
    }

    /**
     * map转对象
     * @param orgin
     * @param target
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     * @throws InstantiationException
     */
    protected  <T> T populateData(Map<String, Object> orgin, Class<T> target) throws IllegalAccessException, InvocationTargetException, InstantiationException {
        if (orgin == null) {
            return null;
        }
        try {
            T obj = target.newInstance();
            BeanUtils.populate(obj, orgin);
            return obj;
        } catch (Exception e) {
            logger.error("populate error!", e);
            throw e;
        }
    }

    /**
     * 判断class是不是基本数据类型,String,Integer,Long,Float,Double
     * @param clazz
     * @return
     */
    protected boolean isBasicClassType(Class<?> clazz) {
        return String.class == clazz || Integer.class == clazz || Long.class == clazz || Float.class == clazz || Double.class == clazz || Date.class == clazz;
    }

    /**
     * 查询单条记录,
     * @param <T>
     * @param clazz class的属性必须是小写
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected <T> T getObjectBySQL(Class<T> clazz, String sql, Object ... params) throws Exception {
        if (isBasicClassType(clazz)) {
            return this.doQuery(sql, rs -> {
                if (rs.next()) {
                    return this.getBasicClassType(clazz, rs);
                }
                return null;
            }, params);
        }
        return this.populateData(this.getMapBySQL(sql, params), clazz);
    }

    /**
     * 查询一条记录,class的属性必须是小写
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected T getObjectBySQL(String sql, Object ... params) throws Exception {
        return this.getObjectBySQL(this.entityClass, sql, params);
    }

    /**
     * 查询一个list, class中的属性必须都是小写的
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected List<T> getListBySQL(String sql, Object ... params) throws Exception {
        return this.getListBySQL(this.entityClass, sql, params);
    }

    /**
     *
     * @param clazz
     * @param rs
     * @return
     * @throws Exception
     */
    private <T> T getBasicClassType(Class<T> clazz, ResultSet rs) throws Exception {
        if (String.class == clazz) {
            return (T)rs.getString(1);
        } else if (Integer.class == clazz) {
            return (T)Integer.valueOf(rs.getInt(1));
        } else if (Long.class == clazz) {
            return (T)Long.valueOf(rs.getLong(1));
        } else if (Float.class == clazz) {
            return (T)Float.valueOf(rs.getFloat(1));
        } else if (Double.class == clazz) {
            return (T)Double.valueOf(rs.getDouble(1));
        } else if (Date.class == clazz) {
            return (T)rs.getDate(1);
        }
        return null;
    }

    /**
     * 查询一个list
     * @param clazz, class中的属性必须都是小写的
     * @param sql
     * @param params
     * @param <T>
     * @return
     * @throws Exception
     */
    protected <T> List<T> getListBySQL(Class<T> clazz, String sql, Object ... params) throws Exception {
        if (isBasicClassType(clazz)) {
            return this.doQuery(sql, rs -> {
                List<T> result = new ArrayList<>();
                while (rs.next()) {
                    result.add(this.getBasicClassType(clazz, rs));
                }
                return result;
            }, params);
        }
        return this.populateData(this.getListMapBySQL(sql, params), clazz);
    }

    /**
     * 查询一个list,返回的map中的key都是小写
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected List<Map<String, Object>> getListMapBySQL(String sql, Object ... params) throws Exception {
        return this.doQuery(sql, rs -> {
            ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等
            int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数
            List<String> columns = new ArrayList<>();
            for (int i = 1; i <= columnCount; i++) {
                columns.add(md.getColumnLabel(i));
            }
            List<Map<String, Object>> result = new ArrayList<>();
            Map<String, Object> rowData = null;
            while (rs.next()) {
                rowData = new LinkedHashMap<>(columnCount);
                for (String column : columns) {
                    rowData.put(column.toLowerCase(), rs.getObject(column));
                }
                result.add(rowData);
            }
            return result;
        }, params);
    }

    /**
     * 查询一条记录,返回的map中的key都是小写
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected Map<String, Object> getMapBySQL(String sql, Object ... params) throws Exception {
        return this.doQuery(sql, rs -> {
            if (rs.next()) {
                ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等
                int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数
                List<String> columns = new ArrayList<>();
                for (int i = 1; i <= columnCount; i++) {
                    columns.add(md.getColumnLabel(i));
                }
                Map<String, Object> rowData = new HashMap<>(columnCount);
                for (String column : columns) {
                    rowData.put(column.toLowerCase(), rs.getObject(column));
                }
                return rowData;
            }
            return Collections.EMPTY_MAP;
        }, params);
    }

    /**
     * 查询总记录数
     * @param sql
     * @param params
     * @return
     * @throws Exception
     */
    protected int getCountBySQL(String sql, Object ... params) throws Exception {
        return this.doQuery(sql, rs -> {
            if (rs.next()) {
                return rs.getInt(1);
            }
            return 0;
        }, params);
    }

    /**
     * 执行sql查询
     * @param sql
     * @param handler
     * @param params
     * @param <T>
     * @return
     * @throws Exception
     */
    protected  <T> T doQuery(String sql, ResultSetHandler<T> handler, Object ... params) throws Exception {
        logger.debug(sql);
        logger.debug("parameters:{}", JSON.toJSONString(params));
        Connection conn = null;
        PreparedStatement stat = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            stat = conn.prepareStatement(sql);
            if(params != null) {
                for(int e = 0; e < params.length; ++e) {
                    this.setParameters(stat, params[e], e + 1);
                }
            }
            rs = stat.executeQuery();
            return handler.handle(rs);
        } catch (Exception e) {
            logger.error("errorSQL:{}", sql);
            logger.error("parameters:{}", JSON.toJSONString(params));
            logger.error("",e);
            throw e;
        } finally {
            closeResultSet(rs);
            closeStatement(stat);
            closeConnection(conn);
        }
    }

    /**
     *
     * @param ps
     * @param value
     * @param columnIndex
     * @return
     * @throws Exception
     */
    protected void setParameters(PreparedStatement ps, Object value, int columnIndex) throws Exception{
        if(value != null){
            Class<?> valueType = value.getClass();
            if (valueType.equals(String.class)) {
                ps.setString(columnIndex, value.toString());
            } else if(valueType.equals(int.class) || valueType.equals(Integer.class)) {
                ps.setInt(columnIndex, Integer.parseInt(value.toString(), 10));
            } else if(valueType.equals(long.class) || valueType.equals(Long.class)) {
                ps.setLong(columnIndex, Long.parseLong(value.toString()));
            } else if(valueType.equals(short.class) || valueType.equals(Short.class)) {
                ps.setShort(columnIndex, Short.parseShort(value.toString()));
            } else if(valueType.equals(java.util.Date.class)) {
                ps.setTimestamp(columnIndex, new java.sql.Timestamp(((java.util.Date)value).getTime()));
            } else if(valueType.equals(boolean.class) || valueType.equals(Boolean.class)) {
                ps.setBoolean(columnIndex, Boolean.parseBoolean(value.toString()));
            } else if(valueType.equals(double.class) || valueType.equals(Double.class)) {
                ps.setDouble(columnIndex, Double.parseDouble(value.toString()));
            } else if(valueType.equals(float.class) || valueType.equals(Float.class)) {
                ps.setFloat(columnIndex, Float.parseFloat(value.toString()));
            } else if(valueType.equals(byte.class) || valueType.equals(Byte.class)) {
                ps.setByte(columnIndex, Byte.parseByte(value.toString()));
            } else if(valueType.equals(byte[].class) || valueType.equals(Byte[].class)) {
                ps.setBytes(columnIndex, (byte[])value);
            } else if(valueType.equals(BigDecimal.class)) {
                ps.setBigDecimal(columnIndex, new BigDecimal(value.toString()));
            } else if(valueType.equals(Timestamp.class)) {
                ps.setTimestamp(columnIndex, (Timestamp)value);
            } else if(valueType.equals(java.sql.Date.class)) {
                ps.setTimestamp(columnIndex, new java.sql.Timestamp(((java.sql.Date)value).getTime()));
            } else {
                ps.setObject(columnIndex, value);
            }
        } else {
            ps.setObject(columnIndex, null);
        }
    }


    /**
     * 关闭statement
     * 
     * @param stmt
     */
    protected void closeStatement(Statement stmt){
        if(stmt!=null){
            try{
                stmt.close();
            }catch(Exception ex){
                logger.error(ex.getMessage(),ex);
            }
        }
    }

    /**
     * 关闭resultSet
     * 
     * @param rs
     */
    protected void closeResultSet(ResultSet rs){
        if(rs!=null){
            try{
                rs.close();
            }catch(Exception ex){
                logger.error(ex.getMessage(),ex);
            }
        }
    }
}
xiaoping_1988
关注
专栏目录
[Java 8 & Spring JDBC] 使用Spring JDBC和Lambda表达式简化DAO
不忘初心，好好沉淀
07-09 7292
使用Spring JDBC和Lambda表达式简化DAO 如果你需要向数据库中插入一条Item记录，那么会有类似下面的代码： Item对应的实体类型为： public class Item { public int name; public BigDecimal price; } public void create(Item item) throws IOExcept
Java
02-16
14. **Lambda表达式**：Java 8引入了Lambda表达式，简化了函数式编程，使代码更加简洁。 15. **Stream API**：Java 8引入的Stream API，用于处理集合数据，提供了一种声明式编程风格，使代码更易读且高效。 16. **...
Java8学习之旅2---基于Lambda的JDBC编程
weixin_34040079的博客
08-06 95
Java8的Lambda表达式确实是一个很好的特性。可是在哪些场合下使用。事实上还是须要细致考虑的。我们当然不能为了使用而使用，而是须要找到切实实用的场合。在JDBC编程中，比如查询语句，首先须要进行查询參数绑定，其次是处理返回的结果集，这两步操作是每一个查询都不同的，而获取JDBC连接，准备PreparedStatement，以及释放资源则都是全然同样的，这就是一个Lambda表达式应用...
JdbcTemplate RowMapper lambda表达式使用
weixin_42756198的博客
01-18 1894
JdbcTemplate RowMapper lambda表达式使用 教程由来： 由于准备写一个json工具包，但是需要有数据测试，就使用了JdbcTemplate的query来查询数据，本来使用BeanPropertyRowMapper作为封装参数，如下： public List&lt;Emp&gt; findAll(){ List&lt;Emp&gt; query = jdbcTem...
用 Java 8 lambda 优化 JDBC
zhangxin09的专栏
07-27 331
首先创建一个函数接口 ResultSetProcessor ： @FunctionalInterface public interface ResultSetProcessor { public void process(ResultSet resultSet, long currentRow) throws SQLException; } 下面做个简单查询案例，使用这个接口遍历 public static void select(Connection connection, String sql
Java：学习Java
02-09
自Java 8起，引入了lambda表达式和Stream API，使得代码更加简洁、易读，尤其在处理集合时，能实现复杂的操作。 15. **模块化系统（Java 9+）** Java 9引入了模块化系统（Project Jigsaw），帮助构建和部署大型、...
Java面试常见问题从基础到进阶
10-20
Redis作为缓存系统，消息队列如RabbitMQ、Kafka用于异步通信，分布式追踪系统Zipkin、Jaeger用于监控服务间的调用，Java在大数据处理中的应用，以及Lambda表达式和函数式编程在Java 8及以后版本的角色。 JVM调优和...
JAVA核心知识点整理.rar
最新发布
03-21
这份文档可能还深入讨论了每个主题的细节，例如接口、构造函数、枚举、 Lambda表达式、Stream API、模块化系统（Java 9及以上）以及并发编程的最佳实践。对于Java初学者或有经验的开发者来说，这些都是不可或缺的...
Java goes from getting started to mastering..zip
06-16
11. **Java 8及以后版本的新特性**：Lambda表达式、Stream API、Optional类、日期时间API等新特性，使Java的编写更加简洁和高效。 12. **测试与调试**：JUnit是Java的单元测试框架，Maven和Gradle是常见的构建工具...
lambda-jdbc-sample:示例Java编写的AWS Lambda函数可通过JDBC连接到数据库
05-24
用于测试来自AWS Lambda函数的JDBC连接的示例项目
用Java 8 lambda优化JDBC
Chung
07-27 154
首先创建一个函数接口ResultSetProcessor ： @FunctionalInterfacepublic interface ResultSetProcessor {     public void process(ResultSet resultSet,                         long currentRow)                       ...
Java8——Java数据库编程（JDBC）
小金是个小菜鸡
06-21 670
JDBC简介： 数据库操作属于Java的服务范围；服务的最大特点：所有的操作部分几乎都是固定的流程；也就是说服务几乎没有技术含量，属于应用部分，代码的流程是固定的； JDBC：Java数据库连接技术，即：是由Java提供的一组与平台无关的数据库操作标准（是一组接口的组成），数据库属于资源操作，所以最后操作一定要关闭数据库！ JDBC技术范畴里实际上规定了4种Java数据库操作的形式： JDBC-ODBC：桥接技术（100%不用）； |- 在Windows中有ODBC技术，ODBC指的是...
Java语言08之JDBC
solololo的博客
09-24 131
存储过程预先存储在MySQL服务器上，需要执行的时候，客户端只需要向服务器端发出调用存储过程的命令，服务器端就可以把预先存储好的这一系列SQL语句全部执行。在SSC中，key为SQL语句，value为对应的执行计划。其实是因为SQL语句在程序运行前已经进行了预编译，在程序运行时第一次操作数据库之前，SQL语句已经被数据库解析、优化和编译，因此，PreparedStatement类的本质就是缓存执行计划，跳过SQL语句的编译过程并重用执行计划，以达到减轻数据库的负担、提高访问数据库的速度的目的。
JdbcTemplate 易被 Java 8 Lambda 带入的坑
weixin_34138521的博客
03-05 309
Spring 的 JdbcTemplate 为我们操作数据库提...
java 8 jdbc_java8_api_jdbc
weixin_32760485的博客
02-15 110
jdbc-1jdbc的概念驱动的分类连接oracle数据库与任何表格数据源交互代码编写步骤加载驱动Class.forNameDriverManager.registerDriver使用DriverManager.getConnection得到连接(Connection接口的实例)jdbc-2Connection接口Statement接口完成数据的增加，修改与删除封装获取数据库连接代码为一个公共静态...
Java入门（八）JDBC
ACGkaka的博客
12-02 214
目录一、JDBC概述、怎样使用JDBC、初步封装二、连接池技术、优化Statement对象（使用PreparedStatement）三、批量处理、结果集元数据、事务、返回自增主键、JDBC操作分页 ????：哈喽~☀️欢迎加入程序????大家庭，快点开始✒️自己的黑客帝国吧 ~???????? 内容简述：JDBC概述、封装JDBCUtils工具类、Statement、PreparedStatement、批处理、事务、返回自增主键、JDBC操作分页。 一、JDBC概述、怎样使用JDBC、初步封装 JDB
java 8 jdbc_初学Java8：通过JDBC实现简易人力资源管理系统
weixin_39523280的博客
02-21 225
1，人力资源管理系统，实现查询、添加、修改、删除的功能。同时设计登录界面，实现注册、登录，修改密码的功能。通过登录进入人力资源管理系统。2，能实现将输入的数据保存到数据库,并实现对数据的查询，修改，删除。3，在数据库设计两张表，分别是员工表t_staff(列包括id、姓名、性别、年龄)，用户表t_user(列包括id、用户名、密码)，3，异常处理，未实现数据有效性验证。(上次已实现，这次主要练习目...
java 8 jdbc_用Java 8 lambda优化JDBC
weixin_32365483的博客
02-15 211
用Java 8 lambda优化JDBC本教程源码下载github首先创建一个函数接口ResultSetProcessor：@FunctionalInterfacepublic interface ResultSetProcessor {public void process(ResultSet resultSet,long currentRow)throws SQLException;}下面...
Java8 Lambda表达式详解与实战应用
"Java8中的Lambda表达式教程深入解析" Java8的Lambda表达式是一种简洁且强大的特性，它允许程序员在代码中直接传递函数或操作，而无需创建完整的类或匿名内部类。这一改变使得Java语言更加灵活，提高了代码的可读性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值