`

JDBC粗略封装 crud

    博客分类:
  • Java
阅读更多

 

 

暮然回首,看看jDBC的操作,原来很多的东西都忘记了,数据库的的语句也忘得差不多了,还的捡起来以前的东西,自己粗糙的写了一个封装JDBC的CURD的方法,回顾回顾以前的东西。

 

类名:BasedDaoSupport。主要功能为Dao提供一次分装的接口。

 

注:有几个类是工具类,获得JDBC的链接和独缺配置文件的。

 

Java代码  收藏代码
  1. package cn.edu.lzcc.orderdishes.utils;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.ResultSet;  
  5. import java.sql.SQLException;  
  6. import java.sql.Statement;  
  7.   
  8. import cn.edu.lzcc.orderdishes.exception.ObejectIdException;  
  9. /** 
  10.  *  
  11.  * Project: orderdishes 
  12.  * Package: cn.edu.lzcc.orderdishes.utils 
  13.  * @author  bestupon 
  14.  * Email:   bestupon@foxmail.com 
  15.  * DateTime:Oct 15, 2009 2:06:59 AM 
  16.  * JDBC的数据封装类 
  17.  * 实现了增删改查的基本操作。 
  18.  */  
  19.   
  20. public class BaseDaoSupport {  
  21.     private boolean result=false;  
  22.     Connection conn = DataBaseConnection.getConnection();  
  23.     Statement stmt = DataBaseConnection.createStatement(conn);  
  24.     ResultSet rs = null;  
  25.     /** 
  26.      * 插入增加的方法 
  27.      * @param entityTable 要操作的表的名称 
  28.      * @param propertys 操作的表的属性名称 
  29.      * @param params 增加的值 
  30.      * @return 成功与否 
  31.      * @throws SQLException 
  32.      */  
  33.     public  boolean  addObject(String entityTable,String []propertys,Object[]params) throws SQLException {  
  34.         StringBuffer insertSql =new StringBuffer("");  
  35.         if(null !=entityTable &&!entityTable.equals("")) {  
  36.             insertSql.append("INSERT INTO  ");  
  37.         }else {  
  38.             return result;  
  39.         }  
  40.         if(null !=propertys && propertys.length >=1) {  
  41.             insertSql.append(entityTable.toLowerCase());  
  42.             insertSql.append("  (");  
  43.              for(int i= 0 ; i<propertys.length;i++) {  
  44.                  insertSql.append(propertys[i]);  
  45.                  insertSql.append(",");  
  46.                  if(propertys[i].trim().toLowerCase().equals(entityTable.toLowerCase()+"id") && propertys[i]!=null) {  
  47.                      ObejectIdException oie =  new ObejectIdException("增加方法中的ObjectId的值必须是‘null’值causeby:(主键不能有重复值)");  
  48.                      throw oie;  
  49.                  }  
  50.              }  
  51.              insertSql = new StringBuffer(insertSql.substring(0, insertSql.length()-1));  
  52.              insertSql.append(" )");  
  53.         }  
  54.         if(null !=params) {  
  55.             insertSql.append(" VALUES (");  
  56.              for(int i= 0 ; i<propertys.length;i++) {  
  57.                  if(params[i] != null) {  
  58.                      insertSql.append("'").append(params[i]).append("',");  
  59.                  }else {  
  60.                      insertSql.append(params[i]).append(",");  
  61.                  }  
  62.              }  
  63.              insertSql = new StringBuffer(insertSql.substring(0, insertSql.length()-1));  
  64.              insertSql.append(" ) ;");  
  65.         }  
  66.         System.out.println(insertSql.toString());  
  67.         result =DataBaseConnection.executeUpdate(conn, insertSql.toString())>0 ? true :false;  
  68.         return result;  
  69.     }  
  70.     /** 
  71.      * 删除操作 
  72.      * @param entityTable 
  73.      * @param objectId 
  74.      * @return 
  75.      * @throws SQLException 
  76.      */  
  77.     public  boolean  delObject(String entityTable,String sqlWhere) throws SQLException {  
  78.         StringBuffer deleteSql = new StringBuffer("");   
  79.         deleteSql.append("DELETE FROM  ");  
  80.         deleteSql.append(entityTable.toLowerCase());  
  81.         if(null != sqlWhere && !sqlWhere.equals("") &&sqlWhere.length()>1) {  
  82.             if(sqlWhere.trim().split(" ")[0].toLowerCase().equals("where")){  
  83.                 deleteSql.append(sqlWhere);  
  84.             }else {  
  85.                 deleteSql.append(" WHERE " ).append(sqlWhere);  
  86.             }  
  87.         }  
  88.         System.out.println(deleteSql.toString());  
  89.         result =DataBaseConnection.executeUpdate(conn, deleteSql.toString())>0 ? true :false;  
  90.         return result;  
  91.     }  
  92.     /** 
  93.      * 更新修改的方法 
  94.      * @param entityTable 实体表名称 
  95.      * @param propertys 更新的字段名称 
  96.      * @param params 更新的值 
  97.      * @param sqlWhere 条件语句 
  98.      * @return 返回成功与否 
  99.      * @throws SQLException 
  100.      */  
  101.     public  boolean  modifyObject(String entityTable,String []propertys,Object[]params,String sqlWhere) throws SQLException {  
  102.         StringBuffer updateSql =new StringBuffer("");  
  103.         if(null !=entityTable &&!entityTable.equals("")) {  
  104.             updateSql.append("UPDATE ").append(entityTable.toLowerCase());  
  105.         }else {  
  106.             return result;  
  107.         }  
  108.         if(null !=propertys ) {  
  109.             if(null !=params) {  
  110.                 if(propertys.length == params.length) {  
  111.                     for(int i= 0 ; i<propertys.length;i++) {  
  112.                         updateSql.append("  SET ");  
  113.                         updateSql.append(propertys[i]).append("=").append("'").append(params[i]).append("',");  
  114.                          if(propertys[i].trim().toLowerCase().equals(entityTable.toLowerCase()+"id")) {  
  115.                              ObejectIdException oie =  new ObejectIdException("修改方法中的ObjectId的值不能被更新causeBy(主键唯一性)");  
  116.                              throw oie;  
  117.                          }  
  118.                     }  
  119.                       
  120.                     updateSql = new StringBuffer(updateSql.substring(0, updateSql.length()-1));  
  121.                       
  122.                     if(null != sqlWhere && !sqlWhere.equals("") &&sqlWhere.length()>1) {  
  123.                         if(sqlWhere.trim().split(" ")[0].toLowerCase().equals("where")){  
  124.                             updateSql.append(sqlWhere);  
  125.                         }else {  
  126.                             updateSql.append(" WHERE " ).append(sqlWhere);  
  127.                         }  
  128.                     }  
  129.                 }else{  
  130.                     return result;  
  131.                 }  
  132.             }  
  133.         }  
  134.         result =DataBaseConnection.executeUpdate(conn, updateSql.toString())>0 ? true :false;  
  135.         System.out.println(updateSql.toString());  
  136.         return result;  
  137.     }  
  138.       
  139.     /** 
  140.      * 查询方法 
  141.      * @param entityTable 要操作的表的名称 
  142.      * @param propertys 表中所还有的属性,字段的名称,也就是主要关心的字段的名称 
  143.      * @param sqlWhere 是附加的查询条件,可以含有where 关键字,也可以不含有where关键字均可 
  144.      * @return 查到的ResultSet结果集 
  145.      * @throws SQLException 
  146.      */  
  147.     public  ResultSet  queryObject(String entityTable,Object []propertys,String sqlWhere) throws SQLException {  
  148.         StringBuffer querySql = new StringBuffer("");  
  149.         if(null !=entityTable &&!entityTable.equals("") &&(null == propertys ||propertys.length<1)) {  
  150.             querySql.append("SELECT * FROM ").append(entityTable.toLowerCase());  
  151.         }else if(null !=entityTable &&!entityTable.equals("") &&(null != propertys ||propertys.length>=1)) {  
  152.             if(null !=propertys && propertys.length >=1) {  
  153.                 querySql.append("SELECT  ");  
  154.                  for(int i= 0 ; i<propertys.length;i++) {  
  155.                      querySql.append(propertys[i]).append(",");  
  156.                  }  
  157.                  querySql = new StringBuffer(querySql.substring(0, querySql.length()-1));  
  158.             }  
  159.             querySql.append(" FROM ").append(entityTable.toLowerCase());  
  160.         }  
  161.         if(null != sqlWhere && !sqlWhere.equals("") &&sqlWhere.length()>1) {  
  162.             if(sqlWhere.trim().split(" ")[0].toLowerCase().equals("where")){  
  163.                 querySql.append(sqlWhere);  
  164.             }else {  
  165.                 querySql.append(" WHERE " ).append(sqlWhere);  
  166.             }  
  167.         }  
  168.         System.out.println(querySql);  
  169.         rs = DataBaseConnection.executeQuery(stmt, querySql.toString());  
  170.         return rs ;  
  171.     }  
  172. }  

 

 

 

定义一个Dao接口。如下

 

Java代码  收藏代码
  1. package cn.edu.lzcc.orderdishes.dao;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5.   
  6. public interface FareMenuDao {  
  7.     /** 
  8.      * 增加 
  9.      * @return 
  10.      */  
  11.     public boolean addFareMenu(String entityTable,String []propertys,Object[]params) throws SQLException ;  
  12.     /** 
  13.      * 修改 
  14.      * @param fareMenuId 
  15.      * @return 
  16.      */  
  17.     public boolean modifyFareMenu(String entityTable,String []propertys,Object[]params,String sqlWhere) throws SQLException ;  
  18.     /** 
  19.      * 删除 
  20.      * @param fareMenuId 
  21.      * @return 
  22.      */  
  23.     public boolean delFareMenu(String entityTable,String sqlWhere) throws SQLException ;  
  24.     /** 
  25.      *  
  26.      * @return 
  27.      */  
  28.     public ResultSet queryFareMenu(String entityTable, String []propertys, String sqlWhere) throws SQLException;  
  29. }  

 

 

 

一个Dao的实现如此简单。

 

Java代码  收藏代码
  1. package cn.edu.lzcc.orderdishes.dao.impl;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5.   
  6. import cn.edu.lzcc.orderdishes.dao.FareMenuDao;  
  7. import cn.edu.lzcc.orderdishes.utils.BaseDaoSupport;  
  8.   
  9. public class FareMenuImpl extends BaseDaoSupport implements FareMenuDao {  
  10.   
  11.     public boolean addFareMenu(String entityTable,String []propertys,  
  12.             Object[] params) throws SQLException {  
  13.         return super.addObject(entityTable, propertys, params);  
  14.     }  
  15.   
  16.     public boolean delFareMenu(String entityTable, String sqlWhere) throws SQLException {  
  17.         return super.delObject(entityTable, sqlWhere);  
  18.     }  
  19.   
  20.     public boolean modifyFareMenu(String entityTable, String []propertys,  
  21.             Object[] params,String sqlWhere) throws SQLException {  
  22.         return super.modifyObject(entityTable, propertys, params,sqlWhere);  
  23.     }  
  24.   
  25.     public ResultSet queryFareMenu(String entityTable, String []propertys, String sqlWhere) throws SQLException {  
  26.         return super.queryObject(entityTable, propertys, sqlWhere);  
  27.     }  
  28. }
分享到:
评论

相关推荐

    JDBC CRUD操作的粗略封装DEMO

    本示例“JDBC CRUD操作的粗略封装DEMO”提供了一个基础的JDBC操作数据库的代码实例,旨在简化常见的数据库操作流程。我们可以通过分析这个DEMO来学习如何利用JDBC进行数据处理。 首先,我们需要理解JDBC的基本步骤...

    jdbc封装(实现对实体的增删改查[分页]).zip

    jdbc封装(实现对实体的增删改查[分页]),辅助学习Hibernate 包含三个文件夹,分别是: code-access实现 是用access实现的,本意是access方便,就一个文件,方便部署。但access有好多不支持,就写成这样.主要是可参考Dao...

    jdbc完全封装实现增删改查

    实现完全的对jdbc对象的封装,只需调用则可对数据库进行CRUD操作

    JDBC通用DAO CRUD(不是Hibernate)

    自己写的一个JDBC通用DAO 有几点需要注意: 1.数据库命明目前只支持没下血杠命名(_) 2.表ID字段名取名有2种方式 (1)ID (2)TableName + ID 例如:user表 则取名为 id 或者 userid 因为没有用xml来映射表结构确定哪一个...

    Hibernate与JDBC对于数据库CRUD操作性能示例

    Hibernate与JDBC对于数据库的性能操作对比事例,配置,更多信息资源

    Dapper.Net封装CRUD

    在这个"**Dapper.Net封装CRUD**"的主题中,我们将深入探讨如何利用Dapper进行数据库的基本操作,包括创建、读取、更新和删除(CRUD)。这些是数据库操作中最基础也最常用的部分。 首先,让我们了解Dapper的基本用法...

    jdbc的crud代码

    **JDBC CRUD 操作详解** 在Java编程中,JDBC(Java Database Connectivity)是用于连接数据库的标准接口,它允许开发者通过编写Java代码来执行SQL语句,实现对数据库的增删改查(CRUD)操作。本文将详细介绍如何...

    java jdbc 连接数据库 crud操作

    本教程将深入探讨如何使用Java JDBC进行数据库的CRUD(创建、读取、更新和删除)操作。 首先,要进行JDBC连接,我们需要引入对应的数据库驱动。例如,如果我们使用的是MySQL数据库,需要在项目中添加MySQL的JDBC...

    传智播客JDBC_完成对数据库的CRUD操作.rar

    本教程“传智播客JDBC_完成对数据库的CRUD操作”主要涵盖了如何利用JDBC进行数据库的基本操作,包括创建(Create)、读取(Read)、更新(Update)和删除(Delete)数据。 一、创建(Create) 创建数据通常涉及到...

    JDBC(掌握JDBC的的CRUD、理解JDBC中各个对象的作用、掌握Druid的使用)

    本篇将详细讲解JDBC的CRUD操作、JDBC中各个对象的作用以及Druid数据源的使用。 一、JDBC CRUD操作 1. 创建(Create):在数据库中创建新的数据记录。这通常涉及到执行SQL的INSERT语句。例如: ```java Statement ...

    Struts2-Crud+JdbcDemo最简单的Struts2+jdbc学习曾删改查程序

    这个"Struts2-Crud+JdbcDemo"项目是一个基础的学习示例,涵盖了如何使用Struts2和JDBC进行基本的CRUD(创建、读取、更新和删除)操作。 首先,我们来详细了解一下Struts2的核心概念: 1. **Action类**:在Struts2...

    JDBC封装.rar

    "JDBC封装"是指将常见的数据库操作,如增删改查(CRUD:Create, Read, Update, Delete),进行模块化和抽象化的过程,以便于在代码中重复使用和简化数据库交互。下面将详细介绍JDBC封装的原理、步骤以及它带来的好处...

    jdbc资料(数据库crud操作)

    Apache的DBUtils是一个简单的数据库工具库,它封装了JDBC的一些繁琐操作,如处理结果集、异常处理等,使代码更加简洁、易读。主要特性有: 1. QueryRunner:提供了方便的SQL执行方法,如query()和update(),支持预...

    深入JDBC高级封装

    深入理解JDBC的高级封装对于提升数据库操作的效率和代码的可维护性至关重要。本话题将探讨JDBC的核心机制,以及如何通过ORM(Object-Relational Mapping)框架如Hibernate和EJB(Enterprise JavaBeans)来进一步优化...

    利用享元模式封装数据库CRUD

    本篇文章将深入探讨如何利用享元模式来封装数据库的CRUD(Create、Read、Update、Delete)操作。 首先,我们需要理解享元模式的基本概念。享元模式是一种结构型设计模式,其核心思想是共享对象,通过共享已经存在的...

    Struts+JDBC-Crud曾删改查,用户管理程序

    在"Struts+JDBC-Crud曾删改查,用户管理程序"中,"Crud"代表创建(Create)、读取(Retrieve)、更新(Update)和删除(Delete)这四种基本的数据库操作。这个程序主要是用来管理用户信息,可能包括用户的注册、登录、信息...

    Spring JdbcTemplate调用Oracle存储过程实现CRUD

    使用 Spring JdbcTemplate 调用 Oracle 存储过程实现 CRUD 在本文中,我们将讨论如何使用 Spring JdbcTemplate 调用 Oracle 存储过程来实现 CRUD(Create、Read、Update、Delete)操作。我们将首先编写 Oracle 存储...

    02-SqlHelper对CRUD操作的封装

    在.NET开发中,SqlHelper是经常被用于数据库操作的一个实用工具类,它为CRUD(创建、读取、更新和删除)操作提供了便利的封装。本篇将详细讲解SqlHelper如何实现对数据库的基本操作,并探讨其核心原理和使用场景。 ...

    DB.rar_jdbc封装

    本压缩包“DB.rar_jdbc封装”显然是一个关于如何使用Java JDBC进行数据库连接封装的示例或教程。下面我们将详细探讨JDBC以及如何进行封装。 首先,JDBC是Java平台上的一个接口,它允许Java应用程序与各种数据库进行...

    JDBC数据操作封装

    本篇文章将详细讲解如何利用JDBC进行数据操作封装,包括增删查改(CRUD)的基本操作,以及如何对多条数据进行事务处理,并将结果返回到对象集合和List中。 首先,我们需要理解JDBC的基本步骤: 1. **加载驱动**:...

Global site tag (gtag.js) - Google Analytics