jdbc简单封装类

最新推荐文章于 2022-10-25 20:21:33 发布
最新推荐文章于 2022-10-25 20:21:33 发布
阅读量975 收藏
点赞数 1
分类专栏： JDBC 文章标签： jdbc

实现最简单的JDBC的封装 

只需要三个类 JDBCUtil BaseDaoJdbc BaseDaoJdbcImpl 

1. [代码]JDBC配置文件     

?
1
2
3
4
5
6
7
8
9
#============================#
#===== Database sttings =====#
#============================#
 
#mysql database setting
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/database?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

2. [代码]JDBCUtil     

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
public  class  JDBCUtil {
     
     // 日志接口
     private  static  Logger logger = LoggerFactory.getLogger(JDBCUtil. class );
     
     //JDBC配置属性
     private  static  Properties ps =  new  Properties();
     // 配置文件位置
     private  static  final  String db_setting =  "/config/acs-db.properties" ;
     
     // 初始化JDBC配置文件属性
     static {
         try  {
             if (JDBCUtil. class .getResourceAsStream(db_setting) ==  null ){
                 if (logger.isInfoEnabled())logger.info( "请调用 getInstance(clazz) 方法！ " );
             } else {
             ps.load(JDBCUtil. class .getResourceAsStream(db_setting));
             // 加载JDBC驱动
             Class.forName(ps.getProperty( "jdbc.driver" ));
             if (logger.isInfoEnabled())logger.info( "JDBC驱动启动成功! " +ps.getProperty( "jdbc.driver" ));
             }
             
             
         }  catch  (IOException | ClassNotFoundException e) {
             logger.error(e.getMessage(),e);
         }
         
     }
     private  JDBCUtil(){}
     private  static  JDBCUtil jdbcUtil =  new  JDBCUtil();
     /**
      *
      * getInstance(获取JDBCUtil实例)
      * (注意事项：同项目下调用  – 可选)
      * @return
      * @exception
      * @since  1.0.0
      */
     public  static  JDBCUtil getInstance(){
         return  jdbcUtil;
     }
     /**
      * getInstance(获取JDBCUtil实例)
      * (注意事项：不同项目下调用 – 可选)
      * @param clazz 调用类字节码
      * @return
      * @throws IOException
      * @exception
      * @since  1.0.0
      */
     public  static  JDBCUtil getInstance(Class<?> clazz)  throws  IOException{
         if (clazz.getResourceAsStream(db_setting) ==  null )
             throw  new  RuntimeException( "acs-db.properties is not found " ) ;
         
         ps.load(clazz.getResourceAsStream(db_setting));
         // 加载JDBC驱动
         try  {
             Class.forName(ps.getProperty( "jdbc.driver" ));
             
         }  catch  (ClassNotFoundException e) {
             logger.error(e.getMessage(),e);
         }
         
         return  jdbcUtil;
     }
     /**
      *
      * getConnection(获取数据库连接)
      * (注意事项：-无)
      * @return
      * @exception
      * @since  1.0.0
      */
     public  Connection getConnection(){
         Connection conn =   null ;
         try  {
          conn = DriverManager.getConnection(ps.getProperty( "jdbc.url" ),
                  ps.getProperty( "jdbc.username" ), ps.getProperty( "jdbc.password" ));
         }  catch  (SQLException e) {
             logger.error(e.getMessage(),e);
         }
         return  conn;
     }
     // JDBC BASE DAO
     private  BaseDaoJdbc baseDaoJdbc =  new  BaseDaoJdbcimpl();
     
     /**
      * getBaseDaoJdbc(获取原始的JDBC Dao 层)
      * (注意事项：-无)
      * @return
      * @exception
      * @since  1.0.0
      */
     public  BaseDaoJdbc getBaseDaoJdbc (){
         return  baseDaoJdbc;
     }
     
     /**
      *
      * query(查询方法)
      * (注意事项： – 目前只支持 Map List返回值)
      * @param resultClass 返回类型 如: Map.class
      * @return
      * @throws SQLException
      * @exception
      * @since  1.0.0
      */
     public  <E> E query (String sql,Class<E> resultClass,Object ... obj){
         ResultSet rs = baseDaoJdbc.queryAll(sql, getConnection(), obj);
         try  {
             
             if (resultClass == Map. class ){
                 if (rs.next())  return  (E) getResultMap(rs);
             } else  if (resultClass == List. class ){
                 return  (E) getResultList(rs);
             } else {
                 throw  new  RuntimeException( "" +resultClass + " 该类型目前还没有做扩展!" );
             }
         }  catch  (SQLException e) {
             logger.error(e.getMessage(),e);
         } finally {
             try  {
                 baseDaoJdbc.closeAll(rs, rs.getStatement(), rs.getStatement().getConnection());
             }  catch  (SQLException e) {
                 logger.error(e.getMessage(),e);
             }
             if (logger.isInfoEnabled())logger.info( "关闭数据库连接!" );
         }
         return  null ;
         
     }
     /**
      *
      * executeUpdate(增加、修改、删除 操作)
      * (注意事项：无)
      * @param sql
      * @param obj
      * @return
      * @exception
      * @since  1.0.0
      */
     public  int  executeUpdate(String sql,Object ...obj){
         int  k =  0 ;
         k = getBaseDaoJdbc().executeUpdate(sql, getConnection(), obj);
         return  k;
     }
     
     /*
      * 解析ResultSet 表列数据
      */
     private  Map<String,Object> getResultMap(ResultSet rs)  throws  SQLException{
         Map<String, Object> rawMap =  new  HashMap<String, Object>();
         ResultSetMetaData  rsmd = rs.getMetaData();  // 表对象信息
         int  count = rsmd.getColumnCount();           // 列数
         // 遍历之前需要调用 next()方法
         for  ( int  i =  1 ; i <= count; i++) { 
             String key = rsmd.getColumnLabel(i);
             Object value = rs.getObject(key);
             rawMap.put(key, value);
         }
         return  rawMap;
     }
     /*
      * 解析ResultSet 表数据
      */
     private  List<Map<String,Object>> getResultList(ResultSet rs)  throws  SQLException{
         List<Map<String,Object>> rawList =  new  ArrayList<Map<String,Object>>();
         while (rs.next()){
             Map<String, Object> rawMap = getResultMap(rs);
             rawList.add(rawMap);
         }
         return  rawList;
     }
     
}

3. [代码]BaseDaoJdbc     

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public  interface  BaseDaoJdbc {
     
     /**
      * 关闭所有连接
      * @param conn
      * @param stmt
      * @param rst
      * @return
      */
     public  boolean  closeAll(ResultSet rst,Statement stmt , Connection conn);
     /**
      * 关闭连接对象
      * @param conn
      * @return
      */
     public  boolean  closeConnection(Connection conn);
     /**
      * 关闭执行sql对象
      * @param stmt
      * @return
      */
     public  boolean  closeStatement(Statement stmt);
     /**
      * 关闭结果集
      * @param rst
      * @return
      */
     public  boolean  closeResultSet(ResultSet rst);
     /**
      * 增删改
      * @param sql
      * @param conn
      * @param obj
      * @return
      */
     public  int  executeUpdate(String sql,Connection conn,Object...obj);
     /**
      * 查询所有
      * @param sql
      * @param conn
      * @param obj
      * @return
      */
     public  ResultSet queryAll(String sql,Connection conn, Object... obj);
     
     
}

4. [代码]BaseDaoJdbcImpl     

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
public  class  BaseDaoJdbcimpl  implements  BaseDaoJdbc {
 
     
     public   boolean  closeAll(ResultSet rst,Statement stmt , Connection conn) {
         // TODO 关闭所有连接
         boolean  flag =  false ;
         try  {
             if (rst!= null ){
                 rst.close();
             }
             if (stmt!= null ){
                 stmt.close();
             }
             if (conn!= null &&!conn.isClosed()){
                 conn.close();
                 flag =  true ;
             }
         }  catch  (SQLException e) {
             e.printStackTrace();
         }
         return  flag;
     }
 
     public   boolean  closeConnection(Connection conn) {
         // TODO 关闭Connection对象
         try  {
             if (conn!= null &&!conn.isClosed()){
                 try  {
                     conn.close();
                     return  true ;
                 }  catch  (SQLException e) {
                     e.printStackTrace();
                 }
             }
         }  catch  (SQLException e) {
             e.printStackTrace();
         }
         return  false ;
     }
 
     public   boolean  closeResultSet(ResultSet rst) {
         // TODO 关闭ResultSet对象
         if (rst!= null ){
             try  {
                 rst.close();
               return  true ;
             }  catch  (SQLException e) {
                 e.printStackTrace();
             }
         }
         return  false ;
     }
 
     public   boolean  closeStatement(Statement stmt) {
         // TODO 关闭Statement 对象
         if (stmt!= null ){
             if (stmt  instanceof  PreparedStatement){
                 try  {
                     ((PreparedStatement) stmt).close();
                     
                 }  catch  (SQLException e) {
                     e.printStackTrace();
                 }
             }
         }
         return  false ;
     }
 
 
     
 
     /**
      * 增删改
      * @param sql
      * @param obj
      * @return
      */
     public   int  executeUpdate(String sql,Connection conn,Object...obj){
         int  i =  0  ;
         PreparedStatement psts =  null  ;
         try  {
             psts = conn.prepareStatement(sql) ;
             if (obj!= null  && obj.length> 0 ){
                 for ( int  j= 0 ;j<obj.length;j++){
                     psts.setObject((j+ 1 ), obj[j]) ;
                 }
             }
             i = psts.executeUpdate() ;
         }  catch  (SQLException e) {
             e.printStackTrace();
         } finally {
             closeAll( null , psts, conn);
         }
         return   i ;
     }
     /**
      * 查询所有
      * @param sql
      * @param obj
      * @return ResultSet
      */
 
     public   ResultSet queryAll(String sql,Connection conn, Object... obj) {
         PreparedStatement psts =  null  ;
         ResultSet rs =  null  ;
         try  {
             psts = conn.prepareStatement(sql) ;
             if (obj!= null  && obj.length> 0 ){
                 for ( int  j= 0 ;j<obj.length;j++){
                     psts.setObject((j+ 1 ), obj[j]) ;
                 }
             }
             rs = psts.executeQuery() ;
         }  catch  (SQLException e) {
             e.printStackTrace();
         }
         return   rs ;
         
     }
技术搬砖工
关注
专栏目录
简单封装JDBC
@峰的博客
05-18 5368
一、简要介绍一下自己封装一个jdbc的思路 封装是什么，为什么要封装封装：是面向对象的一种表现形式，主要是面对可相信的对象提供方便，让这类对象具有使用的权利，对其它对象进行拦截，在没有相应权限的情况下是没有使用权利的。 对于一些工具类就是这样的情况，把具体实现的过程封装到类中，只提供你使用的最终接口，只要能实现你的业务就可以，其他的具体操作你没有办法拿到封装就是为了将一团分布的东西集中在一起，所以
JdbcTemplate,自己封装的jdbc小框架
02-26
以自己所掌握的知识，运用一定的设计模式，对JDBC的一般性操作（CRUD）进行封装，支持批量操作，希望对各位童鞋有帮助
java数据库连接(一)--从最简单地jdbc连接说起
热门推荐
雾里看花
01-19 2万+
JDBCJDBC全称"Java DataBase Connectivity"，它是一套面向对象的应用程序接口（API），并且制定了统一的访问各类关系数据库的标准接口，为各个数据库厂商提供了标准的接口实现。通过使用JDBC技术，开发人员可以用纯Java语言和标准的SQL语句编写完整的数据库应用程序，真正地实现软件的跨平台。                     JDBC对多种关系型数据库的驱动
Jdbc简单封装
qq_45455594的博客
01-07 188
1.封装简单的 package com.rimi.servlet_jdbc.util; ​ import com.alibaba.druid.pool.DruidDataSourceFactory; ​ import javax.sql.DataSource; import java.beans.PropertyDescriptor; import java.io.InputStream; import java.lang.reflect.Method; import java.sql.*; impor
JDBC简易封装
zh_tnis的博客
08-22 389
1.JDBC回顾。 根据前边所写的JDBC的代码，我们知道驱动加载、获取连接对象、资源释放是单一的，而statement对象获取、ResultSet结果集的获取、结果集的输出是多变的。 2.加载驱动的封装。 在jdbc连接数据库的过程中，驱动的加载在程序启动的时候就被加载并且执行了一次。这时候我们需要使用到静态关键字static来封装代码。 静态代码块：简单的说，静态代码块就是关键字static修饰的代码块，记住的是，它的特点是随着类的加载，类中的静态代码块也被执行且只执行一次。 static{
最简单的JDBC连接
以书
11-23 455
public class DBHelper { private static String url = "jdbc:mysql://localhost:3306/employeedb"; private static String userName = "root"; private static String passWord = "root"; private static Conne
JDBC简单封装类
01-04
简单的jdbc封装，添加了详细的注视内容。更容易理解。
简单通用JDBC辅助类封装(实例)
09-02
【简单通用JDBC辅助类封装】是Java编程中一种提高代码复用性和简化数据库操作的方法。JDBC（Java Database Connectivity）是Java语言中用来规范客户端程序如何访问数据库的应用程序接口，提供了诸如查询和更新数据库...
java的jdbc简单封装方法
09-03
这篇教程主要讨论的是如何对JDBC进行简单封装，以提高代码的可维护性和复用性。下面我们将详细分析文中提供的封装方法。 1. **配置文件**：在Java应用中，通常会将数据库连接的敏感信息（如驱动、URL、用户名和密码...
简单JDBC封装类
SoL 学习无止境
09-30 2489
为什么要做这个封装类: 以前经常使用Hibernate来操作数据库,但是时间长了以后发现,Hibernate的大多数功能其实我根本就用不上,而且,Hibernate的查询执行效率的确很让人纠结 所以,我又回到了JDBC的怀抱,而我又是个懒人,喜欢一个函数就能直接调用的那种,J
简单JDBC
weixin_43979868的博客
02-10 776
JDBC 前言 ​ Java中万物皆对象，那Java与数据库的关系呢? ​ 数据库中所有的数据都在表中：列名、类型、多行数据 ​ Java中所有的数据都使用对象：属性、类型、多个对象 ​ 通过上面的观察，我们发现一张表正好对应一一个Java类，一 行数据对应一个对象,表中列对应于Java类的属性, 那么这种跟数据库对应的类我们统称为model(pojo, bean等…) 类。 概述 ​ JDBC（Java Data Base Connectivity）：Java数据连接规范，是Java访问数据库的
简单的JDBC
xu123xj123的博客
08-21 114
简单的JDBC小测试 package test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; public class TestJDBC { public static void main(String[] args) { String DB_DRIVER = "com.mysql.cj.jdbc.
最简单的jdbc程序
weixin_34077371的博客
08-15 100
packagecn.ytu.mybatis.jdbc; importjava.sql.Connection; importjava.sql.DriverManager; importjava.sql.PreparedStatement; importjava.sql.ResultSet; importjava.sql.SQLException; importj...
JDBC（最简单方法）
qq_30738155的博客
07-04 199
java连接mysql数据库 1.加载驱动 Class.forName("com.mysql.jdbc.Driver"); 2.获取连接对象 Connection conn =DriverManager.getConnection ("jdbc:mysql://localhost:3306/3-15","root","root"); 3.获取Statement Statement st=conn.createStatement(); 4.查询 ResultSet re = st.executeQuer
JDBC最简单的使用
qq_55931044的博客
10-25 895
JDBC概述JDBC搭建PreparedStatement 和Statement结果处理
JDBC简单地工具类.rar
04-12
本资源"JDBC简单地工具类.rar"包含了一些基础的JDBC代码示例，适合初学者用来了解和学习JDBC的基本用法。 1. **JDBC驱动注册与连接** 在使用JDBC时，首先需要加载并注册对应的数据库驱动，通常通过`Class.forName...
JDBC简单封装
再来一块红烧肉
04-08 263
我们为什么需要将JDBC封装？ 封装加载驱动 封装获取连接对象 封装释放资源
最简单jdbc的使用
qq_43552242的博客
11-29 175
想用较为完善的请看我上篇文章 简要说明 连接数据库时为什么多用PreparedStatement：PreparedStatement不是将参数简单拼凑成sql，而是做了一些预处理，将参数转换为string，两端加单引号，将参数内的一些特殊字符（换行，单双引号，斜杠等）做转义处理，这样就很大限度的避免了sql注入。。 import java.sql.Connection; import java.s...
JDBC及简单封装
mizihigh的博客
08-06 650
JDBC:java 数据库连接,一般分为六个步骤: 1、加载数据库提供商提供的驱动 2、获取数据库连接对象 3、获取处理命令 4、执行sql语句 5、处理执行结果 6、回收资源 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql
最简单的JDBC，你看了吗
农夫的码，没有草原
03-18 295
JDBC 一、概念 1、数据库驱动：程序连接数据库的中介 2、JDBC：简化对数据库的操作，提供了java操作数据库的规范。 二、相关对象或概念解释 DriverManager 加载驱动 //DriverMAnager.registerDriver(new Drinver()); Class.forName("com.mysql.cj.jdbc.Driver"); URL //jdbc:mysql://localhost:3306/study?useUnicode=true&characterEn
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值