jdbcTemplate的Dao层封装

最新推荐文章于 2022-03-20 23:34:20 发布
最新推荐文章于 2022-03-20 23:34:20 发布
阅读量493 收藏
点赞数
文章标签： jdbcTemplate 封装DAO层 
package com.easyrail.base.dao;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.sql.Types;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public abstract class BaseDaoImpl<T>{
    /** 设置一些操作的常量 */
    public static final String SQL_INSERT = "insert";
    public static final String SQL_UPDATE = "update";
    public static final String SQL_DELETE = "delete";

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    private Class<T> entityClass;

    @SuppressWarnings("unchecked")
    public BaseDaoImpl() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        entityClass = (Class<T>) type.getActualTypeArguments()[0];
        System.out.println("Dao实现类是：" + entityClass.getName());
    }

    public void save(T entity) {
        String sql = this.makeSql(SQL_INSERT);
        Object[] args = this.setArgs(entity, SQL_INSERT);
        int[] argTypes = this.setArgTypes(entity, SQL_INSERT);
        jdbcTemplate.update(sql.toString(), args, argTypes);
    }

    public void update(T entity) {
        String sql = this.makeSql(SQL_UPDATE);
        Object[] args = this.setArgs(entity, SQL_UPDATE);
        int[] argTypes = this.setArgTypes(entity, SQL_UPDATE);
        jdbcTemplate.update(sql, args, argTypes);
    }

    public void delete(T entity) {
        String sql = this.makeSql(SQL_DELETE);
        Object[] args = this.setArgs(entity, SQL_DELETE);
        int[] argTypes = this.setArgTypes(entity, SQL_DELETE);
        jdbcTemplate.update(sql, args, argTypes);
    }

    public void delete(Serializable id) {
        String sql = " DELETE FROM " + entityClass.getSimpleName() + " WHERE id=?";
        jdbcTemplate.update(sql, id);
    }

    public void deleteAll() {
        String sql = " TRUNCATE TABLE " + entityClass.getSimpleName();
        jdbcTemplate.execute(sql);
    }

    public T findById(Serializable id) {
        String sql = "SELECT * FROM " + entityClass.getSimpleName() + " WHERE id=?";
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(entityClass);
        return jdbcTemplate.query(sql, rowMapper, id).get(0);
    }

    public List<T> findAll() {
        String sql = "SELECT * FROM " + entityClass.getSimpleName();
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(entityClass);
        return jdbcTemplate.query(sql, rowMapper);
    }

    // 组装SQL
    private String makeSql(String sqlFlag) {
        StringBuffer sql = new StringBuffer();
        Field[] fields = entityClass.getDeclaredFields();
        if (sqlFlag.equals(SQL_INSERT)) {
            sql.append(" INSERT INTO " + entityClass.getSimpleName());
            sql.append("(");
            for (int i = 0; fields != null && i < fields.length; i++) {
                fields[i].setAccessible(true); // 暴力反射
                String column = fields[i].getName();
                sql.append(column).append(",");
            }
            sql = sql.deleteCharAt(sql.length() - 1);
            sql.append(") VALUES (");
            for (int i = 0; fields != null && i < fields.length; i++) {
                sql.append("?,");
            }
            sql = sql.deleteCharAt(sql.length() - 1);
            sql.append(")");
        } else if (sqlFlag.equals(SQL_UPDATE)) {
            sql.append(" UPDATE " + entityClass.getSimpleName() + " SET ");
            for (int i = 0; fields != null && i < fields.length; i++) {
                fields[i].setAccessible(true); // 暴力反射
                String column = fields[i].getName();
                if (column.equals("id")) { // id 代表主键
                    continue;
                }
                sql.append(column).append("=").append("?,");
            }
            sql = sql.deleteCharAt(sql.length() - 1);
            sql.append(" WHERE id=?");
        } else if (sqlFlag.equals(SQL_DELETE)) {
            sql.append(" DELETE FROM " + entityClass.getSimpleName() + " WHERE id=?");
        }
        System.out.println("SQL=" + sql);
        return sql.toString();

    }

    // 设置参数
    private Object[] setArgs(T entity, String sqlFlag) {
        Field[] fields = entityClass.getDeclaredFields();
        if (sqlFlag.equals(SQL_INSERT)) {
            Object[] args = new Object[fields.length];
            for (int i = 0; args != null && i < args.length; i++) {
                try {
                    fields[i].setAccessible(true); // 暴力反射
                    args[i] = fields[i].get(entity);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return args;
        } else if (sqlFlag.equals(SQL_UPDATE)) {
            Object[] tempArr = new Object[fields.length];
            for (int i = 0; tempArr != null && i < tempArr.length; i++) {
                try {
                    fields[i].setAccessible(true); // 暴力反射
                    tempArr[i] = fields[i].get(entity);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            Object[] args = new Object[fields.length];
            System.arraycopy(tempArr, 1, args, 0, tempArr.length - 1); // 数组拷贝
            args[args.length - 1] = tempArr[0];
            return args;
        } else if (sqlFlag.equals(SQL_DELETE)) {
            Object[] args = new Object[1]; // 长度是1
            fields[0].setAccessible(true); // 暴力反射
            try {
                args[0] = fields[0].get(entity);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return args;
        }
        return null;

    }

    // 设置参数类型（写的不全，只是一些常用的）
    private int[] setArgTypes(T entity, String sqlFlag) {
        Field[] fields = entityClass.getDeclaredFields();
        if (sqlFlag.equals(SQL_INSERT)) {
            int[] argTypes = new int[fields.length];
            try {
                for (int i = 0; argTypes != null && i < argTypes.length; i++) {
                    fields[i].setAccessible(true); // 暴力反射
                    if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
                        argTypes[i] = Types.VARCHAR;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
                        argTypes[i] = Types.DECIMAL;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
                        argTypes[i] = Types.INTEGER;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
                        argTypes[i] = Types.DATE;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return argTypes;
        } else if (sqlFlag.equals(SQL_UPDATE)) {
            int[] tempArgTypes = new int[fields.length];
            int[] argTypes = new int[fields.length];
            try {
                for (int i = 0; tempArgTypes != null && i < tempArgTypes.length; i++) {
                    fields[i].setAccessible(true); // 暴力反射
                    if (fields[i].get(entity).getClass().getName().equals("java.lang.String")) {
                        tempArgTypes[i] = Types.VARCHAR;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Double")) {
                        tempArgTypes[i] = Types.DECIMAL;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.lang.Integer")) {
                        tempArgTypes[i] = Types.INTEGER;
                    } else if (fields[i].get(entity).getClass().getName().equals("java.util.Date")) {
                        tempArgTypes[i] = Types.DATE;
                    }
                }
                System.arraycopy(tempArgTypes, 1, argTypes, 0, tempArgTypes.length - 1); // 数组拷贝
                argTypes[argTypes.length - 1] = tempArgTypes[0];

            } catch (Exception e) {
                e.printStackTrace();
            }
            return argTypes;

        } else if (sqlFlag.equals(SQL_DELETE)) {
            int[] argTypes = new int[1]; // 长度是1
            try {
                fields[0].setAccessible(true); // 暴力反射
                if (fields[0].get(entity).getClass().getName().equals("java.lang.String")) {
                    argTypes[0] = Types.VARCHAR;
                } else if (fields[0].get(entity).getClass().getName().equals("java.lang.Integer")) {
                    argTypes[0] = Types.INTEGER;
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
            return argTypes;
        }
        return null;
    }

    private List<T> find(int pageNo, int pageSize, Map<String, String> where, LinkedHashMap<String, String> orderby) {
        // where 与 order by 要写在select * from table 的后面，而不是where rownum<=? )
        // where rn>=?的后面
        StringBuffer sql = new StringBuffer(
                " SELECT * FROM (SELECT t.*,ROWNUM rn FROM (SELECT * FROM " + entityClass.getSimpleName());
        if (where != null && where.size() > 0) {
            sql.append(" WHERE "); // 注意不是where
            for (Map.Entry<String, String> me : where.entrySet()) {
                String columnName = me.getKey();
                String columnValue = me.getValue();
                sql.append(columnName).append(" ").append(columnValue).append(" AND "); // 没有考虑or的情况
            }
            int endIndex = sql.lastIndexOf("AND");
            if (endIndex > 0) {
                sql = new StringBuffer(sql.substring(0, endIndex));
            }
        }
        if (orderby != null && orderby.size() > 0) {
            sql.append(" ORDER BY ");
            for (Map.Entry<String, String> me : orderby.entrySet()) {
                String columnName = me.getKey();
                String columnValue = me.getValue();
                sql.append(columnName).append(" ").append(columnValue).append(",");
            }
            sql = sql.deleteCharAt(sql.length() - 1);
        }
        sql.append(" ) t WHERE ROWNUM<=? ) WHERE rn>=? ");
        System.out.println("SQL=" + sql);
        Object[] args = { pageNo * pageSize, (pageNo - 1) * pageSize + 1 };
        RowMapper<T> rowMapper = BeanPropertyRowMapper.newInstance(entityClass);
        return jdbcTemplate.query(sql.toString(), args, rowMapper);
    }

    private int count(Map<String, String> where) {
        StringBuffer sql = new StringBuffer(" SELECT COUNT(*) FROM " + entityClass.getSimpleName());
        if (where != null && where.size() > 0) {
            sql.append(" WHERE ");
            for (Map.Entry<String, String> me : where.entrySet()) {
                String columnName = me.getKey();
                String columnValue = me.getValue();
                sql.append(columnName).append(" ").append(columnValue).append(" AND "); // 没有考虑or的情况
            }
            int endIndex = sql.lastIndexOf("AND");
            if (endIndex > 0) {
                sql = new StringBuffer(sql.substring(0, endIndex));
            }
        }
        System.out.println("SQL=" + sql);
        return jdbcTemplate.queryForInt(sql.toString());
    }
}

 

ZPHTTT
关注
DAO层封装 2 JDBCTemplate 分页查询、参数包装，简化查询
杨毅的专栏
03-02 1980
JdbcTemplageSupport 继承自 org.springframework.jdbc.core.JdbcTemplate;包括了3组方法：1、传入的参数是List&lt;Object&gt;形式，推荐首选这2个方法public &lt;T&gt; PageResult&lt;T&gt; pagedQuery(String sql, List&lt;Object&gt; sqlArgs,...
Java基于jdbctemplate数据持久层操作封装
CSDN_HELIU的博客
10-22 2207
相关资源分享-下载可直接使用： https://download.csdn.net/download/csdn_heliu/10736181 JdbcTemplate简介： spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。 JdbcTemplate主要提供以下五类方法： execute方法：...
JdbcTemplate通用泛型Dao实现
08-09
NULL 博文链接：https://425826501.iteye.com/blog/2184599
SpringJdbc持久层封装，Spring jdbcTemplate封装，springJdbc泛型Dao，Spring baseDao封装
weixin_33889665的博客
07-06 166
SpringJdbc持久层封装，Spring jdbcTemplate封装，springJdbc泛型Dao，Spring baseDao封装 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&...
Spring框架之使用JdbcTemplate开发Dao层程序
weixin_30547797的博客
03-16 235
简介: JdbcTemplate开发dao层程序 由Spring框架给我们提供,Spring提供的很多操作数据源(关系型数据库,二维表格模型,有明确的行和列(mysql/orcal等) 非关系型数据库(redis.mongodb)NoSQL)消息列(activeMq,jms)的小工具 JdbcTemplate操作关系数据库 RedisTemplate操作redis JmsTt...
JdbcTemplateDao
0与1的世界
09-28 114
package com.hoss.core.dao; import com.hoss.core.exception.HossSqlException; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import java.util.Lis...
java基于jdbctemplate数据持久层操作封装
10-22
- 开发中，通常会基于JdbcTemplate创建一个DAO（Data Access Object）层，将特定的数据库操作封装成方法，便于业务层调用。 - 可以创建一个BaseJdbcDao抽象类，包含基本的增删改查方法，然后让具体的DAO类继承这个...
Spring2.0 DAO框架详解：JdbcTemplate与持久层封装
Spring的持久层封装通过DAO支持、JdbcTemplate和ORM框架的集成，使得数据库操作更加简洁、高效和易于维护，是现代企业级应用开发中的重要工具。学习并掌握这些技术，能够提升开发者在构建可扩展和健壮的应用程序时的...
Spring3 JDBC 通用DAO封装2 dao层终于完成dao层大概上传完整代码
04-12
本篇将围绕“Spring3 JDBC通用DAO封装”这一主题展开，介绍如何实现一个高效的DAO层，并分享相关代码示例。 1. **Spring3 JDBC概述** Spring3 JDBC通过提供JdbcTemplate和SimpleJdbcInsert等工具类，帮助开发者...
Spring JdbcTemplate实现通用的超级dao，比泛型dao更加强大
程序猿开发日志【学习永无止境】
04-12 8335
这两天比较忙，没抽出什么时间，这一停顿居然已经有2个评论了，无疑增添了我的不少动力。 在开始之前，先说下前面实现的通用泛型dao，在第四篇 通用自定义转换到JavaBean的RowMapper实现中，把获取属性的操作也放到了mapRow的方法中，这会导致在每一行数据转换的时候都会获取一遍这个类的所有属性信息，虽然有缓存但总还是只获取一次的好，之前有参考这个实现的朋友可以自行优化一下。
SpringJdbcTemplate封装工具类
06-13
SpringJdbcTemplate封装工具包，包括规范model格式接口，封装SpringJdbcTemplate，实现分页，自适应多种数据库
使用Spring的SimpleJdbcTemplate完成DAO操作
05-24
我的使用Spring的SimpleJdbcTemplate完成DAO操作实例 博文链接：https://zmx.iteye.com/blog/373749
spring的jdbctemplate的crud的基类dao
09-04
本文主要介绍了使用spring的jdbctemplate进行增删改查的基类Dao的简单写法,需要的朋友可以参考下
Spring之JdbcTemplate实现封装
tianjun2012的专栏
07-22 1179
首先配置config.xml com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/mytest1 root 123 insert into tb1 v
Spring baseDao封装，Spring jdbcTemplate封装，springJdbc泛型Dao，SpringJdbc持久层封装
蕃薯耀的博客
07-06 465
t;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt; ©Copyright 蕃薯耀 2017年7月6日 http://fanshuyao.iteye.com/   很久之前弄的Spring Jdbc持久化层的baseDao，现在做个记录。 基本的增、删、查、改、分页、排序都可以用，只是兼容一般，如主键必须是id，并没有深入再封装。   封装基于Spring4+Mysql     package com.lqy
JDBC的封装
FairyKunKun的博客
03-20 1622
解决重复问题 考虑JDBC操作都遵循6步骤 1. 加载驱动 只要加载一次就行了 优先被加载 static代码块 2. 获取连接 封装成一个获取连接的方法 3. 获取SQL执行器 4. 执行SQL 5. 处理结果 6. 关闭资源 封装关闭资源的方法 封装一个工具类 package march.part0320.util; import java.sql.Connection; import j...
jdbcTemplate在Dao中使用
Ting1king的博客
07-26 217
bean.xml: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans
【Spring】JdbcTemplate：DAO模式
wlc19981111的博客
05-15 136
DROP TABLE IF EXISTS `tb_user`; CREATE TABLE `tb_user` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(45) NOT NULL, `age` int(10) unsigned NOT NULL, `sex` varchar(45) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=1.
使用Spring的JdbcTemplate实现DAO
小陆的笔记
08-21 2993
直接使用JDBC操作数据库来实现DAO，相对于使用持久层框架（Hibernate等） ，可以减少映射等带来的性能损失。一般而言，使用JDBC来操作数据库，无非是以下几个步骤：    获取数据源    取得数据库连接    执行SQL语句    处理执行结果和异常    释放数据库连接这些步骤是每次进行数据库操作都必须进行的。很显然，可以使用模板模式来简化设计，将执行SQL语句的部分抽象出来，其它的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值