当前位置：移动技术网 > IT编程>开发语言>Java > JDBC 编程

JDBC 编程

2019年05月20日 | 移动技术网IT编程 | 我要评论

在java语言中，有一个专门连接数据库的规范（jdbc），专门负责连接数据库进行数据操作。各个数据库提供商会根据这套规范（接口）编写相关的实现类，封装成一个 jar 包供用户下载使用。所以在进行编程时，需要将相应的 jar 包导入到工程文件下的 lib 目录下，并建立依赖。

1 连接数据库并建表

这里我们使用的是 mysql 数据库。

1.1 加载注册驱动

通过下述语句实现注册驱动，原理是这句语句会将 driver.class 这份字节码加载到 jvm 中，然后 jvm 会执行该字节码的静态代码块，mysql 提供的这个驱动包中，driver 的字节码内的静态代码块就完成了驱动对象的创建和注册。

1 //加载注册驱动
2 class.forname("com.mysql.jdbc.driver");

1.2 连接数据库

当我们注册了驱动之后，可以通过 drivermanager 获取与数据库的连接，需要传入三个参数：数据库的地址，登录用户名，登陆密码。注意 connection 和 drivermanager 类都是 java.sql 包下的，dbname 是数据库的名字。

1 //连接数据库
2 connection conn = drivermanager.getconnection(jdbc:mysql://localhost:3306/dbname", "root", "123");

验证已经获取连接，可以在 mysql 控制台，使用命令：show processlist 查看运行进程。

1.3 操作数据库

当得到与数据的连接之后，我们还需要通过该连接获得一个语句对象，该语句对象内包含我们要对数据库执行的操作，也就是 sql 语句。我们执行 sql 语句一般使用语句对象的 executeupdate 和 executequery 方法，前者用于 ddl 和 dml 操作，返回收影响的行数；后者用于执行 dql 操作，返回结果集对象。具体使用方法如下

//语句对象的获得
statement st = conn.createstatement();
//执行语句，这里的语句用于建表
st.executeupdate("create table t_student (id int primary key auto_increment, name varchar(20), age int)")
//释放资源，先进后出，需要处理异常
st.close();
conn.close();

1.4 "贾琏欲执事"

执行一次语句的步骤可以归为“贾（加）琏（连）欲（语）执（执）事（释）”这一句话，合在一起的源码为

public class createtabletest {
   public static void main(string[] args) throws classnotfoundexception, sqlexception {
       class.forname("com.mysql.jdbc.driver");
       connection conn = drivermanager.getconnection("jdbc:mysql://127.0.0.1:3306/jdbc_demo", "root", "1234");
       string sql = "create table t_student (id int primary key auto_increment, name varchar(20), age int)";
       
       statement st = conn.createstatement();
       st.execute(sql);
       
       st.close();
       conn.close();
   }
}

2 dao 层设计

实际开发中，javaweb 开发代码一般分为三层,分层结构是 javaweb 开发中的一种设计思想，这样会让我们开发层次分明，每一层只要完成对应的功能即可，使得项目便于开发和维护。

web层/表现层：主要接受前台浏览器用户的参数，给浏览器响应数据等等
service层/业务成/服务层：主要处理业务功能，日志，权限，事物，等等
dao层/持久层：专门负责和数据库交互，数据处理相关代码

dao ： data access object 数据访问对象

2.1 dao 设计结构

在实际开发中，可以按照下列结构进行设计

马赛克的地方是公司域名倒写加项目名
项目包下的 dao 包内放接口，规范了处理某个数据库需要的方法，名方式以 dao 结尾
dao 包内的 impl 包放具体的实现，命名方式以 daoimpl 结尾
与 dao 包同级的 pojo 包内放用于接收数据库信息的简单普通对象
test 包是用于测试实现类的各个方法
util 包存放工具类
dp.properties 存放了一些数据库连接需要用到的信息。

2.2 代码的重构 - 代码复用

在 1.4 中示范了怎么连接数据库进行一次建表操作，实际上 dao 中的实现类内就是一个个这样的方法，比如常见的增、删、改、查，如果每个方法内都写这样一些列流程，会在后期维护中产生很大麻烦，假如连接密码改了，每个方法都要修改，这显然不现实，所以我们要利用工具类以及配置文档优化代码。

连接数据库

实现类中的方法应该专注于功能的实现，获得连接是该方法需要的一个结果，该方法并不关注这个过程，不应该放在方法内混淆语义。我们可以把连接数据库的代码放在 jdbcutils 这个工具类内，该类的成员都是类成员，然后实现类的方法中直接通过类调用 getconnection() 方法获得连接。同时，注册驱动这个步骤我们只需要执行一次就够了，我们可以把这个步骤放在工具类的静态代码块中，在该类初始化的时候会自动执行一次。

public class jdbcutils {
   
   private static string driverclassname = "com.mysql.jdbc.driver";
   private static string url = "jdbc:mysql://127.0.0.1:3306/jdbc_demo";
   private static string username = "root";
   private static string password = "1234";
   
   static {
       try {
           class.forname(driverclassname);
       } catch (classnotfoundexception e) {
           e.printstacktrace();
       }
   }
   
   public static connection getconnection() throws sqlexception {
       connection conn = drivermanager.getconnection(url, username, password);
       return conn;
   }
}

关闭资源

关闭资源也是一块鸡肋代码，重复且冗长，未重构前每个方法的关闭过程如下

//假设是查询方法，除了关闭连接、语句还要关闭结果集，每次关闭都需要异常处理
/*
connection conn;
preparedstatement ps;
resultset rs;
*/
try {
   //方法需要实现的功能
   return xxx;
} catch (exception e) {
   e.printstacktrace();
} finally {
   //try 代码块中的 return 语句一定会在 finally 执行完后执行，所以关闭系统资源放在 finally 中。先进后出
   try {
       if(rs != null) {
           rs.close();
       }
   } catch (sqlexception e) {
       e.printstacktrace();
   } finally {
       try {
           if(ps != null) {
               ps.close();
           }
       } catch (sqlexception e) {
           e.printstacktrace();
       } finally {
           try {
               if(conn != null) {
                   conn.close();
               }
           } catch (sqlexception e) {
               e.printstacktrace();
           }
       }
   }
}

可以看到这一段关闭资源的方法非常冗长，且每个方法都要关闭一遍。我们可以把这个关闭的流程写进工具类内，实现类的方法只需要调用 jdbcutils.close() 方法即可。

//statement 是 preparedstatement 的父类，这样不管是 statement 或者 preparedstatement 类型的都可以用这个方法关闭
//对于 dml 语句，没有 resultset 对象，可以第三个变量穿 null 即可
public static void close(connection conn, statement s, resultset rs) {
   try {
       if(rs != null) {
           rs.close();
       }
   } catch (exception e) {
       e.printstacktrace();
   } finally {
       try {
           if(s != null) {
               s.close();
           }
       } catch (exception e) {
           e.printstacktrace();
       } finally {
           try {
               if(conn != null) {
                   conn.close();
               }
           } catch (exception e) {
               e.printstacktrace();
           }
       }
   }
}

建立连接需要的信息

把连接需要的这些信息放在代码块中还是不太方便，如果用户修改了账号密码，或者主机地址改变，都需要重新修改代码，这不太满足我们平常应用的要求。所以我们可以把这些信息放在一个 .properties 文件中，java 程序直接去读取这些信息。那以后修改了账户密码，只需要自己打开这个 .properties 文件修改相应的字段即可。

#key=value
driverclassname=com.mysql.jdbc.driver
url=jdbc:mysql://127.0.0.1:3306/jdbc_demo
username=root
password=1234

.properties 内存放了一些键值对，注意等号左右没有空格，结尾也没有标点，# 作为注释

那如何读取这些信息呢？

java 中通过类加载器读取配置文件获得一个输入流，可以通过两种方法获得类加载器

//1.通过某一类的字节码实例可以获取
classloader cl = object.class.getcontextclassloader();
//2.通过当前线程获得
classloader cl = thread.currentthread().getcontextclassloader();

//通过类加载器读取配置文件获得输入流
inputstream in = cl.getresourceasstream("dp.properties");

那如何获得相应的信息呢？

我们可以通过 properties 对象获得相应的信息。properties 类是 map 抽象类下一个专门用于读取配置文件的类，将输入流加载进去，即可通过“key”获得“value”。

properties p = new properties();
p.load(in);
system.out.println(p.getproperty("driverclassname"));

重构后的工具类代码

public class jdbcutils {
   
   private static properties p = new properties();

   static {
       classloader cl = thread.currentthread().getcontextclassloader();
       inputstream in = cl.getresourceasstream("dp.properties");
       try {
           p.load(in);
           class.forname(p.getproperty("driverclassname"));
       } catch (exception e) {
           e.printstacktrace();
       }
   }
   
   public static connection getconnection() throws sqlexception {
       connection conn = drivermanager.getconnection(p.getproperty("url"), p.getproperty("username"), p.getproperty("password"));
       return conn;
   }
   
   public static void close(connection conn, statement s, resultset rs) {
       try {
           if(rs != null) {
               rs.close();
           }
       } catch (exception e) {
           e.printstacktrace();
       } finally {
           try {
               if(s != null) {
                   s.close();
               }
           } catch (exception e) {
               e.printstacktrace();
           } finally {
               try {
                   if(conn != null) {
                       conn.close();
                   }
               } catch (exception e) {
                   e.printstacktrace();
               }
           }
       }
   }
}

2.3 引用连接池，管理连接

按照上面的做法，每次用户进行一次操作，都会建立连接，接着执行完成后销毁连接。虽然每次连接、断开连接用时不长，但当用户数量上来意后，对系统资源的消耗就会变得很高。于是我们引入连接池管理连接。连接池里面拥有一定数量的连接（一般5 - 10个），当通过连接池getconnection 时，连接池提供一个连接供方法使用，当使用完毕后方法执行连接的 close 方法，这个时候并不是直接关闭连接，而是将连接返回给连接池。

在java中,连接池使用 javax.sql.datasource 接口来表示连接池。注意：datasource 仅仅只是一个接口，由各大服务器厂商来实现。常用的 datasource 的实现：

dbcp: spring推荐的
c3p0: hibernate推荐的
druid : （德鲁伊）阿里巴巴开源的,性能最好，速度最快

介绍 druid 使用方法

//需要导入 druid 的 jar 包
//方法一：
//1 创建连接池对象，不能使用 datasource 类型，因为 setxxx 方法时 druiddatasource 类独有的
druiddatasource dds = new druiddatasource();
//2 设置连接数据库的信息
dds.setdriverclassname(p.getproperty("driverclassname"));
dds.seturl(p.getproperty("url"));
dds.setusername(p.getproperty("username"));
dds.setpassword(p.getproperty("password"));
dds.setmaxactive(10);  //最大连接数
connection conn = dds.getconnection();

//方法二
//通过连接池工程获得连接池
//1 通过工厂的静态方法获得连接池，传入上文中的 properties 对象作为参数，工程自动读取配置信息
datasource ds = druiddatasourcefactory.createdatasource(p);
//2 获得连接
connection conn = ds.getconnection();

使用连接池后的工具类

public class jdbcutils {
   
   private static properties p = new properties();

   //用工厂创建连接池对象，工厂底层对 properties 直接读取，只需传入一个 properties 对象
   private static datasource dds;
   static {
       classloader cl = thread.currentthread().getcontextclassloader();
       inputstream in = cl.getresourceasstream("dp.properties");
       try {
           p.load(in);
           dds = druiddatasourcefactory.createdatasource(p);
       } catch (exception e) {
           e.printstacktrace();
       }
   }
   
   public static connection getconnection() throws sqlexception {
       return dds.getconnection();
   }
   
   public static void close(connection conn, statement s, resultset rs) {
       try {
           if(rs != null) {
               rs.close();
           }
       } catch (exception e) {
           e.printstacktrace();
       } finally {
           try {
               if(s != null) {
                   s.close();
               }
           } catch (exception e) {
               e.printstacktrace();
           } finally {
               try {
                   if(conn != null) {
                       conn.close();
                   }
               } catch (exception e) {
                   e.printstacktrace();
               }
           }
       }
   }
}

3 事务

jdbc 中是默认提交事务的，也就是每一条 statement 执行后，自动提交事务。在实际业务中，我们可能需要把多个操作当作一个原子性操作来进行，要么全做，要么全部做。要实现这个要求，我们只需要把自动提交事务给关闭，在通过回滚（rollback）和提交（commit）来完成一次事务。

//银行转账例子
public class transactiontest {
   @test
   public void testname() throws exception {
       connection conn = null;
       statement st = null;
       resultset rs = null;
       try {
           conn = druidutil.getconnection();
           //将事务设置为手动提交
           conn.setautocommit(false);
           
           st = conn.createstatement();
           // 1.检查张无忌的账号余额是否大于等于1000.
           rs = st.executequery("select balance from account where name = '张无忌' and balance >=1000");
           if(!rs.next()) {
               throw new runtimeexception("亲，您的账户余额不够");
           }
           // 余额>=1000:goto 2:
           // 余额 <1000:提示:亲,你的余额不足.
           // 2.在张无忌的账号余额上减少1000.
           st.executeupdate("update account set balance = balance-1000 where name = '张无忌'");
           
           system.out.println(1/0);  //制造异常
           
           // 3.在赵敏的账户余额尚增加1000.
           st.executeupdate("update account set balance = balance+1000 where name = '赵敏'");
           
           //提交事务
           conn.commit();
       } catch (exception e) {
           e.printstacktrace();
           //回滚事务
           conn.rollback();    
       }finally {
           druidutil.close(conn, st, rs);
       }
   }
}
//最终钱不会因为异常而变少

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

《Java核心技术卷1：基础知识》CH14-并发

《Java核心技术卷1：基础知识》CH14-并发 [阅读全文]
vue表单数据AES加密传输

前端用的是vue框架，后端用的是springboot，话不多说，上来直接撸代码。一、前端1. 先安装前端加密JS... [阅读全文]
基于SpringSecurity实现图片验证码登录功能

图片验证码登录验证1.验证码流程详解2.验证码生成3.验证码校验1.验证码流程详解验证码流程图解析：客户端打开登... [阅读全文]
Linux系统下ssh使用总结

转自：https://www.cnblogs.com/kevingrace/p/6110842.html-bas... [阅读全文]
samba服务搭建（Ubuntu12.04）

简单的配置sudo apt-get install samba //安装samba和安装smbclients... [阅读全文]
Java特性

Java语言特性Java是一个简单的、面向对象的、分布式的、解释的、健壮的、安全带、结构中立的、可移植的、高性能... [阅读全文]
Linux运维

Linux运维Linux运维Linux运维一 Linux基础知识Linux简介与安装Linux常用命令Vim编辑... [阅读全文]
Spring中Bean的作用域？单例模式是否是线程安全的？

spring 的 bean 的scopespring容器中管理的bean有五种作用域：1、singleton：单... [阅读全文]
虚拟机对象的创建

读周志明老师《深入理解java虚拟机》笔记2.3.11.对象的创建当java虚拟机遇到一条字节码new指令时，首... [阅读全文]
shiro简单的密码加盐与密码验证

shiro简单的密码加盐与登录验证最近对后台管理框架非常的感兴趣，于是研究了通过什么进行了密码加盐加密的，并如何... [阅读全文]

网友评论


验证码：