北京吸脂手术价格,必兆棋牌,beacon时槽
jdbc核心技术
讲师：宋红康
微博：尚硅谷-宋红康
持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、xml数据文件中。
jdo (java data object )技术
第三方o/r工具，如hibernate, mybatis 等
jdbc是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。 ————面向接口编程
补充：odbc(open database connectivity，开放式数据库连接)，是微软在windows平台下推出的。使用者在程序中只需要调用odbc api，由 odbc 驱动程序将调用转换成为对特定的数据库的调用请求。
java.sql.driver 接口是所有 jdbc 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。
在驱动jar上右键-->build path-->add to build path
注意：如果是dynamic web project（动态的web项目）话，则是把驱动jar放到webcontent（有的开发工具叫webroot）目录中的web-inf目录中的lib目录下即可
加载驱动：加载 jdbc 驱动需调用 class 类的静态方法 forname()，向其传递要加载的 jdbc 驱动的类名
使用drivermanager.registerdriver(com.mysql.jdbc.driver)来注册驱动
通常不用显式调用 drivermanager 类的 registerdriver() 方法来注册驱动程序类的实例，因为 driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 drivermanager.registerdriver() 方法来注册自身的一个实例。下图是mysql的driver实现类的源码：
jdbc url 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 url 选择正确的驱动程序，从而建立到数据库的连接。
举例：
几种常用数据库的 jdbc url
mysql的连接url编写方式：
oracle 9i的连接url编写方式：
sqlserver的连接url编写方式：
jdbc:sqlserver://主机名称:sqlserver服务端口号:databasename=数据库名称
jdbc:sqlserver://localhost:1433:databasename=atguigu
我要评论 @test
public void testconnection1() {
try {
//1.提供java.sql.driver接口实现类的对象
driver driver = null;
driver = new com.mysql.jdbc.driver();
//2.提供url，指明具体操作的数据
string url = "jdbc:mysql://localhost:3306/test";
//3.提供properties的对象，指明用户名和密码
properties info = new properties();
info.setproperty("user", "root");
info.setproperty("password", "abc123");
//4.调用driver的connect()，获取连接
connection conn = driver.connect(url, info);
system.out.println(conn);
} catch (sqlexception e) {
e.printstacktrace();
}
}
说明：上述代码中显式出现了第三方数据库的api
@test
public void testconnection2() {
try {
//1.实例化driver
string classname = "com.mysql.jdbc.driver";
class clazz = class.forname(classname);
driver driver = (driver) clazz.newinstance();
//2.提供url，指明具体操作的数据
string url = "jdbc:mysql://localhost:3306/test";
//3.提供properties的对象，指明用户名和密码
properties info = new properties();
info.setproperty("user", "root");
info.setproperty("password", "abc123");
//4.调用driver的connect()，获取连接
connection conn = driver.connect(url, info);
system.out.println(conn);
} catch (exception e) {
e.printstacktrace();
}
}
说明：相较于方式一，这里使用反射实例化driver，不在代码中体现第三方数据库的api。体现了面向接口编程思想。
@test
public void testconnection3() {
try {
//1.数据库连接的4个基本要素：
string url = "jdbc:mysql://localhost:3306/test";
string user = "root";
string password = "abc123";
string drivername = "com.mysql.jdbc.driver";
//2.实例化driver
class clazz = class.forname(drivername);
driver driver = (driver) clazz.newinstance();
//3.注册驱动
drivermanager.registerdriver(driver);
//4.获取连接
connection conn = drivermanager.getconnection(url, user, password);
system.out.println(conn);
} catch (exception e) {
e.printstacktrace();
}
}
说明：使用drivermanager实现数据库的连接。体会获取连接必要的4个基本要素。
@test
public void testconnection4() {
try {
//1.数据库连接的4个基本要素：
string url = "jdbc:mysql://localhost:3306/test";
string user = "root";
string password = "abc123";
string drivername = "com.mysql.jdbc.driver";
//2.加载驱动 （①实例化driver ②注册驱动）
class.forname(drivername);
//driver driver = (driver) clazz.newinstance();
//3.注册驱动
//drivermanager.registerdriver(driver);
/*
可以注释掉上述代码的原因，是因为在mysql的driver类中声明有：
static {
try {
drivermanager.registerdriver(new driver());
} catch (sqlexception var1) {
throw new runtimeexception("can't register driver!");
}
}
*/
//3.获取连接
connection conn = drivermanager.getconnection(url, user, password);
system.out.println(conn);
} catch (exception e) {
e.printstacktrace();
}
}
说明：不必显式的注册驱动了。因为在drivermanager的源码中已经存在静态代码块，实现了驱动的注册。
@test
public void testconnection5() throws exception {
//1.加载配置文件
inputstream is = connectiontest.class.getclassloader().getresourceasstream("jdbc.properties");
properties pros = new properties();
pros.load(is);
//2.读取配置信息
string user = pros.getproperty("user");
string password = pros.getproperty("password");
string url = pros.getproperty("url");
string driverclass = pros.getproperty("driverclass");
//3.加载驱动
class.forname(driverclass);
//4.获取连接
connection conn = drivermanager.getconnection(url,user,password);
system.out.println(conn);
}
其中，配置文件声明在工程的src目录下：【jdbc.properties】
user=root password=abc123 url=jdbc:mysql://localhost:3306/test driverclass=com.mysql.jdbc.driver
说明：使用配置文件的方式保存配置信息，在代码中加载配置文件
使用配置文件的好处：
①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码
②如果修改了配置信息，省去重新编译的过程。
数据库连接被用于向数据库服务器发送命令和 sql 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个socket连接。
通过调用 connection 对象的 createstatement() 方法创建该对象。该对象用于执行静态的 sql 语句，并且返回执行结果。
statement 接口中定义了下列方法用于执行 sql 语句：
int excuteupdate(string sql)：执行更新操作insert、update、delete resultset executequery(string sql)：执行查询操作select
但是使用statement操作数据表存在弊端：
sql 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 sql 语句段或命令(如：select user, password from user_table where user='a' or 1 = ' and password = ' or '1' = '1') ，从而利用系统的 sql 引擎完成恶意行为的做法。
对于 java 而言，要防范 sql 注入，只要用 preparedstatement(从statement扩展而来) 取代 statement 就可以了。
代码演示：
public class statementtest {
// 使用statement的弊端：需要拼写sql语句，并且存在sql注入的问题
@test
public void testlogin() {
scanner scan = new scanner(system.in);
system.out.print("用户名：");
string username = scan.nextline();
system.out.print("密 码：");
string password = scan.nextline();
// select user,password from user_table where user = '1' or ' and password = '='1' or '1' = '1';
string sql = "select user,password from user_table where user = '" + username + "' and password = '" + password
+ "'";
user user = get(sql, user.class);
if (user != null) {
system.out.println("登陆成功!");
} else {
system.out.println("用户名或密码错误！");
}
}
// 使用statement实现对数据表的查询操作
public <t> t get(string sql, class<t> clazz) {
t t = null;
connection conn = null;
statement st = null;
resultset rs = null;
try {
// 1.加载配置文件
inputstream is = statementtest.class.getclassloader().getresourceasstream("jdbc.properties");
properties pros = new properties();
pros.load(is);
// 2.读取配置信息
string user = pros.getproperty("user");
string password = pros.getproperty("password");
string url = pros.getproperty("url");
string driverclass = pros.getproperty("driverclass");
// 3.加载驱动
class.forname(driverclass);
// 4.获取连接
conn = drivermanager.getconnection(url, user, password);
st = conn.createstatement();
rs = st.executequery(sql);
// 获取结果集的元数据
resultsetmetadata rsmd = rs.getmetadata();
// 获取结果集的列数
int columncount = rsmd.getcolumncount();
if (rs.next()) {
t = clazz.newinstance();
for (int i = 0; i < columncount; i++) {
// //1. 获取列的名称
// string columnname = rsmd.getcolumnname(i+1);
// 1. 获取列的别名
string columnname = rsmd.getcolumnlabel(i + 1);
// 2. 根据列名获取对应数据表中的数据
object columnval = rs.getobject(columnname);
// 3. 将数据表中得到的数据，封装进对象
field field = clazz.getdeclaredfield(columnname);
field.setaccessible(true);
field.set(t, columnval);
}
return t;
}
} catch (exception e) {
e.printstacktrace();
} finally {
// 关闭资源
if (rs != null) {
try {
rs.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
if (st != null) {
try {
st.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
if (conn != null) {
try {
conn.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
return null;
}
}
综上：
可以通过调用 connection 对象的 preparedstatement(string sql) 方法获取 preparedstatement 对象
preparedstatement 接口是 statement 的子接口，它表示一条预编译过的 sql 语句
preparedstatement 对象所代表的 sql 语句中的参数用问号(?)来表示，调用 preparedstatement 对象的 setxxx() 方法来设置这些参数. setxxx() 方法有两个参数，第一个参数是要设置的 sql 语句中的参数的索引(从 1 开始)，第二个是设置的 sql 语句中的参数的值
代码的可读性和可维护性。
preparedstatement 可以防止 sql 注入
| java类型 | sql类型 |
|---|---|
| boolean | bit |
| byte | tinyint |
| short | smallint |
| int | integer |
| long | bigint |
| string | char,varchar,longvarchar |
| byte array | binary , var binary |
| java.sql.date | date |
| java.sql.time | time |
| java.sql.timestamp | timestamp |
//通用的增、删、改操作（体现一：增、删、改 ； 体现二：针对于不同的表）
public void update(string sql,object ... args){
connection conn = null;
preparedstatement ps = null;
try {
//1.获取数据库的连接
conn = jdbcutils.getconnection();
//2.获取preparedstatement的实例 (或：预编译sql语句)
ps = conn.preparestatement(sql);
//3.填充占位符
for(int i = 0;i < args.length;i++){
ps.setobject(i + 1, args[i]);
}
//4.执行sql语句
ps.execute();
} catch (exception e) {
e.printstacktrace();
}finally{
//5.关闭资源
jdbcutils.closeresource(conn, ps);
}
}
// 通用的针对于不同表的查询:返回一个对象 (version 1.0)
public <t> t getinstance(class<t> clazz, string sql, object... args) {
connection conn = null;
preparedstatement ps = null;
resultset rs = null;
try {
// 1.获取数据库连接
conn = jdbcutils.getconnection();
// 2.预编译sql语句，得到preparedstatement对象
ps = conn.preparestatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setobject(i + 1, args[i]);
}
// 4.执行executequery(),得到结果集：resultset
rs = ps.executequery();
// 5.得到结果集的元数据：resultsetmetadata
resultsetmetadata rsmd = rs.getmetadata();
// 6.1通过resultsetmetadata得到columncount,columnlabel；通过resultset得到列值
int columncount = rsmd.getcolumncount();
if (rs.next()) {
t t = clazz.newinstance();
for (int i = 0; i < columncount; i++) {// 遍历每一个列
// 获取列值
object columnval = rs.getobject(i + 1);
// 获取列的别名:列的别名，使用类的属性名充当
string columnlabel = rsmd.getcolumnlabel(i + 1);
// 6.2使用反射，给对象的相应属性赋值
field field = clazz.getdeclaredfield(columnlabel);
field.setaccessible(true);
field.set(t, columnval);
}
return t;
}
} catch (exception e) {
e.printstacktrace();
} finally {
// 7.关闭资源
jdbcutils.closeresource(conn, ps, rs);
}
return null;
}
说明：使用preparedstatement实现的查询操作可以替换statement实现的查询操作，解决statement拼串和sql注入问题。
查询需要调用preparedstatement 的 executequery() 方法，查询结果是一个resultset 对象
resultset 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
当指针指向一行时, 可以通过调用 getxxx(int index) 或 getxxx(int columnname) 获取每一列的值。
boolean next()
…
可用于获取关于 resultset 对象中列的类型和属性信息的对象
getcolumncount()：返回当前 resultset 对象中的列数。
isnullable(int column)：指示指定列中的值是否可以为 null。
isautoincrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。
问题1：得到结果集后, 如何知道该结果集中有哪些列 ？ 列名是什么？
需要使用一个描述 resultset 的对象， 即 resultsetmetadata
问题2：关于resultsetmetadata
面向接口编程的思想
sql是需要结合列名和表的属性名来写。注意起别名。
练习题1：从控制台向数据库的表customers中插入一条数据，表结构如下：
练习题2：创立数据库表 examstudent，表结构如下：
向数据表中添加如下数据：
代码实现1：插入一个新的student 信息
请输入考生的详细信息
type:
idcard:
examcard:
studentname:
location:
grade:
信息录入成功!
代码实现2：在 eclipse中建立 java 程序：输入身份证号或准考证号可以查询到学生的基本信息。结果如下：
代码实现3：完成学生信息的删除功能
插入blob类型的数据必须使用preparedstatement，因为blob类型的数据无法使用字符串拼接写的。
mysql的四种blob类型(除了在存储的最大信息量上不同外，他们是等同的)
//获取连接
connection conn = jdbcutils.getconnection();
string sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
preparedstatement ps = conn.preparestatement(sql);
// 填充占位符
ps.setstring(1, "徐海强");
ps.setstring(2, "xhq@126.com");
ps.setdate(3, new date(new java.util.date().gettime()));
// 操作blob类型的变量
fileinputstream fis = new fileinputstream("xhq.png");
ps.setblob(4, fis);
//执行
ps.execute();
fis.close();
jdbcutils.closeresource(conn, ps);
connection conn = jdbcutils.getconnection();
string sql = "update customers set photo = ? where id = ?";
preparedstatement ps = conn.preparestatement(sql);
// 填充占位符
// 操作blob类型的变量
fileinputstream fis = new fileinputstream("coffee.png");
ps.setblob(1, fis);
ps.setint(2, 25);
ps.execute();
fis.close();
jdbcutils.closeresource(conn, ps);
string sql = "select id, name, email, birth, photo from customer where id = ?";
conn = getconnection();
ps = conn.preparestatement(sql);
ps.setint(1, 8);
rs = ps.executequery();
if(rs.next()){
integer id = rs.getint(1);
string name = rs.getstring(2);
string email = rs.getstring(3);
date birth = rs.getdate(4);
customer cust = new customer(id, name, email, birth);
system.out.println(cust);
//读取blob类型的字段
blob photo = rs.getblob(5);
inputstream is = photo.getbinarystream();
outputstream os = new fileoutputstream("c.jpg");
byte [] buffer = new byte[1024];
int len = 0;
while((len = is.read(buffer)) != -1){
os.write(buffer, 0, len);
}
jdbcutils.closeresource(conn, ps, rs);
if(is != null){
is.close();
}
if(os != null){
os.close();
}
}
当需要成批插入或者更新记录时，可以采用java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率
jdbc的批量处理语句包括下面三个方法：
通常我们会遇到两种批量执行sql语句的情况：
举例：向数据表中插入20000条数据
create table goods( id int primary key auto_increment, name varchar(20) );
connection conn = jdbcutils.getconnection();
statement st = conn.createstatement();
for(int i = 1;i <= 20000;i++){
string sql = "insert into goods(name) values('name_' + "+ i +")";
st.executeupdate(sql);
}
long start = system.currenttimemillis();
connection conn = jdbcutils.getconnection();
string sql = "insert into goods(name)values(?)";
preparedstatement ps = conn.preparestatement(sql);
for(int i = 1;i <= 20000;i++){
ps.setstring(1, "name_" + i);
ps.executeupdate();
}
long end = system.currenttimemillis();
system.out.println("花费的时间为：" + (end - start));//82340
jdbcutils.closeresource(conn, ps);
/*
* 修改1： 使用 addbatch() / executebatch() / clearbatch()
* 修改2：mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
* ?rewritebatchedstatements=true 写在配置文件的url后面
* 修改3：使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
*
*/
@test
public void testinsert1() throws exception{
long start = system.currenttimemillis();
connection conn = jdbcutils.getconnection();
string sql = "insert into goods(name)values(?)";
preparedstatement ps = conn.preparestatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setstring(1, "name_" + i);
//1.“攒”sql
ps.addbatch();
if(i % 500 == 0){
//2.执行
ps.executebatch();
//3.清空
ps.clearbatch();
}
}
long end = system.currenttimemillis();
system.out.println("花费的时间为：" + (end - start));//20000条：625 //1000000条:14733
jdbcutils.closeresource(conn, ps);
}
/*
* 层次四：在层次三的基础上操作
* 使用connection 的 setautocommit(false) / commit()
*/
@test
public void testinsert2() throws exception{
long start = system.currenttimemillis();
connection conn = jdbcutils.getconnection();
//1.设置为不自动提交数据
conn.setautocommit(false);
string sql = "insert into goods(name)values(?)";
preparedstatement ps = conn.preparestatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setstring(1, "name_" + i);
//1.“攒”sql
ps.addbatch();
if(i % 500 == 0){
//2.执行
ps.executebatch();
//3.清空
ps.clearbatch();
}
}
//2.提交数据
conn.commit();
long end = system.currenttimemillis();
system.out.println("花费的时间为：" + (end - start));//1000000条:4978
jdbcutils.closeresource(conn, ps);
}
事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。
jdbc程序中为了让多个 sql 语句作为一个事务执行：
若此时 connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setautocommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。
【案例：用户aa向用户bb转账100】
public void testjdbctransaction() {
connection conn = null;
try {
// 1.获取数据库连接
conn = jdbcutils.getconnection();
// 2.开启事务
conn.setautocommit(false);
// 3.进行数据库操作
string sql1 = "update user_table set balance = balance - 100 where user = ?";
update(conn, sql1, "aa");
// 模拟网络异常
//system.out.println(10 / 0);
string sql2 = "update user_table set balance = balance + 100 where user = ?";
update(conn, sql2, "bb");
// 4.若没有异常，则提交事务
conn.commit();
} catch (exception e) {
e.printstacktrace();
// 5.若有异常，则回滚事务
try {
conn.rollback();
} catch (sqlexception e1) {
e1.printstacktrace();
}
} finally {
try {
//6.恢复每次dml操作的自动提交功能
conn.setautocommit(true);
} catch (sqlexception e) {
e.printstacktrace();
}
//7.关闭连接
jdbcutils.closeresource(conn, null, null);
}
}
其中，对数据库操作的方法为：
//使用事务以后的通用的增删改操作（version 2.0）
public void update(connection conn ,string sql, object... args) {
preparedstatement ps = null;
try {
// 1.获取preparedstatement的实例 (或：预编译sql语句)
ps = conn.preparestatement(sql);
// 2.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setobject(i + 1, args[i]);
}
// 3.执行sql语句
ps.execute();
} catch (exception e) {
e.printstacktrace();
} finally {
// 4.关闭资源
jdbcutils.closeresource(null, ps);
}
}
原子性（atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
一致性（consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
隔离性（isolation）
事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
数据库提供的4种事务隔离级别：
oracle 支持的 2 种事务隔离级别：read commited, serializable。 oracle 默认的事务隔离级别为: read commited 。
mysql 支持 4 种事务隔离级别。mysql 默认的事务隔离级别为: repeatable read。
每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别。
查看当前的隔离级别:
select @@tx_isolation;
设置当前 mysql 连接的隔离级别:
set transaction isolation level read committed;
设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed;
补充操作：
创建mysql数据库用户：
create user tom identified by 'abc123';
授予权限
#授予通过网络方式登录的tom用户，对所有库所有表的全部权限，密码设为abc123. grant all privileges on *.* to tom@'%' identified by 'abc123'; #给tom用户使用本地命令行方式，授予atguigudb这个库下的所有表的插删改查的权限。 grant select,insert,delete,update on atguigudb.* to tom@localhost identified by 'abc123';
package com.atguigu.bookstore.dao;
import java.lang.reflect.parameterizedtype;
import java.lang.reflect.type;
import java.sql.connection;
import java.sql.sqlexception;
import java.util.list;
import org.apache.commons.dbutils.queryrunner;
import org.apache.commons.dbutils.handlers.beanhandler;
import org.apache.commons.dbutils.handlers.beanlisthandler;
import org.apache.commons.dbutils.handlers.scalarhandler;
/**
* 定义一个用来被继承的对数据库进行基本操作的dao
*
* @author hanyanbing
*
* @param <t>
*/
public abstract class basedao<t> {
private queryrunner queryrunner = new queryrunner();
// 定义一个变量来接收泛型的类型
private class<t> type;
// 获取t的class对象，获取泛型的类型，泛型是在被子类继承时才确定
public basedao() {
// 获取子类的类型
class clazz = this.getclass();
// 获取父类的类型
// getgenericsuperclass()用来获取当前类的父类的类型
// parameterizedtype表示的是带泛型的类型
parameterizedtype parameterizedtype = (parameterizedtype) clazz.getgenericsuperclass();
// 获取具体的泛型类型 getactualtypearguments获取具体的泛型的类型
// 这个方法会返回一个type的数组
type[] types = parameterizedtype.getactualtypearguments();
// 获取具体的泛型的类型·
this.type = (class<t>) types[0];
}
/**
* 通用的增删改操作
*
* @param sql
* @param params
* @return
*/
public int update(connection conn,string sql, object... params) {
int count = 0;
try {
count = queryrunner.update(conn, sql, params);
} catch (sqlexception e) {
e.printstacktrace();
}
return count;
}
/**
* 获取一个对象
*
* @param sql
* @param params
* @return
*/
public t getbean(connection conn,string sql, object... params) {
t t = null;
try {
t = queryrunner.query(conn, sql, new beanhandler<t>(type), params);
} catch (sqlexception e) {
e.printstacktrace();
}
return t;
}
/**
* 获取所有对象
*
* @param sql
* @param params
* @return
*/
public list<t> getbeanlist(connection conn,string sql, object... params) {
list<t> list = null;
try {
list = queryrunner.query(conn, sql, new beanlisthandler<t>(type), params);
} catch (sqlexception e) {
e.printstacktrace();
}
return list;
}
/**
* 获取一个但一值得方法，专门用来执行像 select count(*)...这样的sql语句
*
* @param sql
* @param params
* @return
*/
public object getvalue(connection conn,string sql, object... params) {
object count = null;
try {
// 调用queryrunner的query方法获取一个单一的值
count = queryrunner.query(conn, sql, new scalarhandler<>(), params);
} catch (sqlexception e) {
e.printstacktrace();
}
return count;
}
}
package com.atguigu.bookstore.dao;
import java.sql.connection;
import java.util.list;
import com.atguigu.bookstore.beans.book;
import com.atguigu.bookstore.beans.page;
public interface bookdao {
/**
* 从数据库中查询出所有的记录
*
* @return
*/
list<book> getbooks(connection conn);
/**
* 向数据库中插入一条记录
*
* @param book
*/
void savebook(connection conn,book book);
/**
* 从数据库中根据图书的id删除一条记录
*
* @param bookid
*/
void deletebookbyid(connection conn,string bookid);
/**
* 根据图书的id从数据库中查询出一条记录
*
* @param bookid
* @return
*/
book getbookbyid(connection conn,string bookid);
/**
* 根据图书的id从数据库中更新一条记录
*
* @param book
*/
void updatebook(connection conn,book book);
/**
* 获取带分页的图书信息
*
* @param page：是只包含了用户输入的pageno属性的page对象
* @return 返回的page对象是包含了所有属性的page对象
*/
page<book> getpagebooks(connection conn,page<book> page);
/**
* 获取带分页和价格范围的图书信息
*
* @param page：是只包含了用户输入的pageno属性的page对象
* @return 返回的page对象是包含了所有属性的page对象
*/
page<book> getpagebooksbyprice(connection conn,page<book> page, double minprice, double maxprice);
}
package com.atguigu.bookstore.dao;
import java.sql.connection;
import com.atguigu.bookstore.beans.user;
public interface userdao {
/**
* 根据user对象中的用户名和密码从数据库中获取一条记录
*
* @param user
* @return user 数据库中有记录 null 数据库中无此记录
*/
user getuser(connection conn,user user);
/**
* 根据user对象中的用户名从数据库中获取一条记录
*
* @param user
* @return true 数据库中有记录 false 数据库中无此记录
*/
boolean checkusername(connection conn,user user);
/**
* 向数据库中插入user对象
*
* @param user
*/
void saveuser(connection conn,user user);
}
package com.atguigu.bookstore.dao.impl;
import java.sql.connection;
import java.util.list;
import com.atguigu.bookstore.beans.book;
import com.atguigu.bookstore.beans.page;
import com.atguigu.bookstore.dao.basedao;
import com.atguigu.bookstore.dao.bookdao;
public class bookdaoimpl extends basedao<book> implements bookdao {
@override
public list<book> getbooks(connection conn) {
// 调用basedao中得到一个list的方法
list<book> beanlist = null;
// 写sql语句
string sql = "select id,title,author,price,sales,stock,img_path imgpath from books";
beanlist = getbeanlist(conn,sql);
return beanlist;
}
@override
public void savebook(connection conn,book book) {
// 写sql语句
string sql = "insert into books(title,author,price,sales,stock,img_path) values(?,?,?,?,?,?)";
// 调用basedao中通用的增删改的方法
update(conn,sql, book.gettitle(), book.getauthor(), book.getprice(), book.getsales(), book.getstock(),book.getimgpath());
}
@override
public void deletebookbyid(connection conn,string bookid) {
// 写sql语句
string sql = "delete from books where id = ?";
// 调用basedao中通用增删改的方法
update(conn,sql, bookid);
}
@override
public book getbookbyid(connection conn,string bookid) {
// 调用basedao中获取一个对象的方法
book book = null;
// 写sql语句
string sql = "select id,title,author,price,sales,stock,img_path imgpath from books where id = ?";
book = getbean(conn,sql, bookid);
return book;
}
@override
public void updatebook(connection conn,book book) {
// 写sql语句
string sql = "update books set title = ? , author = ? , price = ? , sales = ? , stock = ? where id = ?";
// 调用basedao中通用的增删改的方法
update(conn,sql, book.gettitle(), book.getauthor(), book.getprice(), book.getsales(), book.getstock(), book.getid());
}
@override
public page<book> getpagebooks(connection conn,page<book> page) {
// 获取数据库中图书的总记录数
string sql = "select count(*) from books";
// 调用basedao中获取一个单一值的方法
long totalrecord = (long) getvalue(conn,sql);
// 将总记录数设置都page对象中
page.settotalrecord((int) totalrecord);
// 获取当前页中的记录存放的list
string sql2 = "select id,title,author,price,sales,stock,img_path imgpath from books limit ?,?";
// 调用basedao中获取一个集合的方法
list<book> beanlist = getbeanlist(conn,sql2, (page.getpageno() - 1) * page.page_size, page.page_size);
// 将这个list设置到page对象中
page.setlist(beanlist);
return page;
}
@override
public page<book> getpagebooksbyprice(connection conn,page<book> page, double minprice, double maxprice) {
// 获取数据库中图书的总记录数
string sql = "select count(*) from books where price between ? and ?";
// 调用basedao中获取一个单一值的方法
long totalrecord = (long) getvalue(conn,sql,minprice,maxprice);
// 将总记录数设置都page对象中
page.settotalrecord((int) totalrecord);
// 获取当前页中的记录存放的list
string sql2 = "select id,title,author,price,sales,stock,img_path imgpath from books where price between ? and ? limit ?,?";
// 调用basedao中获取一个集合的方法
list<book> beanlist = getbeanlist(conn,sql2, minprice , maxprice , (page.getpageno() - 1) * page.page_size, page.page_size);
// 将这个list设置到page对象中
page.setlist(beanlist);
return page;
}
}
package com.atguigu.bookstore.dao.impl;
import java.sql.connection;
import com.atguigu.bookstore.beans.user;
import com.atguigu.bookstore.dao.basedao;
import com.atguigu.bookstore.dao.userdao;
public class userdaoimpl extends basedao<user> implements userdao {
@override
public user getuser(connection conn,user user) {
// 调用basedao中获取一个对象的方法
user bean = null;
// 写sql语句
string sql = "select id,username,password,email from users where username = ? and password = ?";
bean = getbean(conn,sql, user.getusername(), user.getpassword());
return bean;
}
@override
public boolean checkusername(connection conn,user user) {
// 调用basedao中获取一个对象的方法
user bean = null;
// 写sql语句
string sql = "select id,username,password,email from users where username = ?";
bean = getbean(conn,sql, user.getusername());
return bean != null;
}
@override
public void saveuser(connection conn,user user) {
//写sql语句
string sql = "insert into users(username,password,email) values(?,?,?)";
//调用basedao中通用的增删改的方法
update(conn,sql, user.getusername(),user.getpassword(),user.getemail());
}
}
package com.atguigu.bookstore.beans;
/**
* 图书类
* @author songhongkang
*
*/
public class book {
private integer id;
private string title; // 书名
private string author; // 作者
private double price; // 价格
private integer sales; // 销量
private integer stock; // 库存
private string imgpath = "static/img/default.jpg"; // 封面图片的路径
//构造器，get()，set()，tostring()方法略
}
package com.atguigu.bookstore.beans;
import java.util.list;
/**
* 页码类
* @author songhongkang
*
*/
public class page<t> {
private list<t> list; // 每页查到的记录存放的集合
public static final int page_size = 4; // 每页显示的记录数
private int pageno; // 当前页
// private int totalpageno; // 总页数，通过计算得到
private int totalrecord; // 总记录数，通过查询数据库得到
package com.atguigu.bookstore.beans;
/**
* 用户类
* @author songhongkang
*
*/
public class user {
private integer id;
private string username;
private string password;
private string email;
数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
数据库连接池技术的优点
1. 资源重用
由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
2. 更快的系统反应速度
数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间
3. 新的资源分配手段
对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
4. 统一的连接管理，避免数据库连接泄漏
在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露
//使用c3p0数据库连接池的方式，获取数据库的连接：不推荐
public static connection getconnection1() throws exception{
combopooleddatasource cpds = new combopooleddatasource();
cpds.setdriverclass("com.mysql.jdbc.driver");
cpds.setjdbcurl("jdbc:mysql://localhost:3306/test");
cpds.setuser("root");
cpds.setpassword("abc123");
// cpds.setmaxpoolsize(100);
connection conn = cpds.getconnection();
return conn;
}
//使用c3p0数据库连接池的配置文件方式，获取数据库的连接：推荐
private static datasource cpds = new combopooleddatasource("helloc3p0");
public static connection getconnection2() throws sqlexception{
connection conn = cpds.getconnection();
return conn;
}
其中，src下的配置文件为：【c3p0-config.xml】
<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
<named-config name="helloc3p0">
<!-- 获取连接的4个基本信息 -->
<property name="user">root</property>
<property name="password">abc123</property>
<property name="jdbcurl">jdbc:mysql:///test</property>
<property name="driverclass">com.mysql.jdbc.driver</property>
<!-- 涉及到数据库连接池的管理的相关属性的设置 -->
<!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
<property name="acquireincrement">5</property>
<!-- 初始化数据库连接池时连接的数量 -->
<property name="initialpoolsize">5</property>
<!-- 数据库连接池中的最小的数据库连接数 -->
<property name="minpoolsize">5</property>
<!-- 数据库连接池中的最大的数据库连接数 -->
<property name="maxpoolsize">10</property>
<!-- c3p0 数据库连接池可以维护的 statement 的个数 -->
<property name="maxstatements">20</property>
<!-- 每个连接同时可以使用的 statement 对象的个数 -->
<property name="maxstatementsperconnection">5</property>
</named-config>
</c3p0-config>
| 属性 | 默认值 | 说明 |
|---|---|---|
| initialsize | 0 | 连接池启动时创建的初始化连接数量 |
| maxactive | 8 | 连接池中可同时连接的最大的连接数 |
| maxidle | 8 | 连接池中最大的空闲的连接数，超过的空闲连接将被释放，如果设置为负数表示不限制 |
| minidle | 0 | 连接池中最小的空闲的连接数，低于这个数量会被创建新的连接。该参数越接近maxidle，性能越好，因为连接的创建和销毁，都是需要消耗资源的；但是不能太大。 |
| maxwait | 无限制 | 最大等待时间，当没有可用连接时，连接池等待连接释放的最大时间，超过该时间限制会抛出异常，如果设置-1表示无限等待 |
| poolpreparedstatements | false | 开启池的statement是否prepared |
| maxopenpreparedstatements | 无限制 | 开启池的prepared 后的同时最大连接数 |
| minevictableidletimemillis | 连接池中连接，在时间段内一直空闲， 被逐出连接池的时间 | |
| removeabandonedtimeout | 300 | 超过时间限制，回收没有用(废弃)的连接 |
| removeabandoned | false | 超过removeabandonedtimeout时间后，是否进 行没用连接（废弃）的回收 |
public static connection getconnection3() throws exception {
basicdatasource source = new basicdatasource();
source.setdriverclassname("com.mysql.jdbc.driver");
source.seturl("jdbc:mysql:///test");
source.setusername("root");
source.setpassword("abc123");
//
source.setinitialsize(10);
connection conn = source.getconnection();
return conn;
}
//使用dbcp数据库连接池的配置文件方式，获取数据库的连接：推荐
private static datasource source = null;
static{
try {
properties pros = new properties();
inputstream is = dbcptest.class.getclassloader().getresourceasstream("dbcp.properties");
pros.load(is);
//根据提供的basicdatasourcefactory创建对应的datasource对象
source = basicdatasourcefactory.createdatasource(pros);
} catch (exception e) {
e.printstacktrace();
}
}
public static connection getconnection4() throws exception {
connection conn = source.getconnection();
return conn;
}
其中，src下的配置文件为：【dbcp.properties】
driverclassname=com.mysql.jdbc.driver url=jdbc:mysql://localhost:3306/test?rewritebatchedstatements=true&useserverprepstmts=false username=root password=abc123 initialsize=10 #...
druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了c3p0、dbcp、proxool等db池的优点，同时加入了日志监控，可以很好的监控db池连接和sql的执行情况，可以说是针对监控而生的db连接池，可以说是目前最好的连接池之一。
package com.atguigu.druid;
import java.sql.connection;
import java.util.properties;
import javax.sql.datasource;
import com.alibaba.druid.pool.druiddatasourcefactory;
public class testdruid {
public static void main(string[] args) throws exception {
properties pro = new properties(); pro.load(testdruid.class.getclassloader().getresourceasstream("druid.properties"));
datasource ds = druiddatasourcefactory.createdatasource(pro);
connection conn = ds.getconnection();
system.out.println(conn);
}
}
其中，src下的配置文件为：【druid.properties】
url=jdbc:mysql://localhost:3306/test?rewritebatchedstatements=true username=root password=123456 driverclassname=com.mysql.jdbc.driver initialsize=10 maxactive=20 maxwait=1000 filters=wall
| 配置 | 缺省 | 说明 |
|---|---|---|
| name | 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是：”datasource-” + system.identityhashcode(this) | |
| url | 连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto | |
| username | 连接数据库的用户名 | |
| password | 连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用configfilter。详细看这里：https://github.com/alibaba/druid/wiki/%e4%bd%bf%e7%94%a8configfilter | |
| driverclassname | 根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbtype，然后选择相应的driverclassname(建议配置下) | |
| initialsize | 0 | 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getconnection时 |
| maxactive | 8 | 最大连接池数量 |
| maxidle | 8 | 已经不再使用，配置了也没效果 |
| minidle | 最小连接池数量 | |
| maxwait | 获取连接时最大等待时间，单位毫秒。配置了maxwait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useunfairlock属性为true使用非公平锁。 | |
| poolpreparedstatements | false | 是否缓存preparedstatement，也就是pscache。pscache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。 |
| maxopenpreparedstatements | -1 | 要启用pscache，必须配置大于0，当大于0时，poolpreparedstatements自动触发修改为true。在druid中，不会存在oracle下pscache占用内存过多的问题，可以把这个数值配置大一些，比如说100 |
| validationquery | 用来检测连接是否有效的sql，要求是一个查询语句。如果validationquery为null，testonborrow、testonreturn、testwhileidle都不会其作用。 | |
| testonborrow | true | 申请连接时执行validationquery检测连接是否有效，做了这个配置会降低性能。 |
| testonreturn | false | 归还连接时执行validationquery检测连接是否有效，做了这个配置会降低性能 |
| testwhileidle | false | 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timebetweenevictionrunsmillis，执行validationquery检测连接是否有效。 |
| timebetweenevictionrunsmillis | 有两个含义： 1)destroy线程会检测连接的间隔时间2)testwhileidle的判断依据，详细看testwhileidle属性的说明 | |
| numtestsperevictionrun | 不再使用，一个druiddatasource只支持一个evictionrun | |
| minevictableidletimemillis | ||
| connectioninitsqls | 物理连接初始化的时候执行的sql | |
| exceptionsorter | 根据dbtype自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接 | |
| filters | 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall | |
| proxyfilters | 类型是list，如果同时配置了filters和proxyfilters，是组合关系，并非替换关系 |
commons-dbutils 是 apache 组织提供的一个开源 jdbc工具类库，它是对jdbc的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
api包说明：
该类简单化了sql查询，它与resultsethandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
测试
// 测试添加
@test
public void testinsert() throws exception {
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
string sql = "insert into customers(name,email,birth)values(?,?,?)";
int count = runner.update(conn, sql, "何成飞", "he@qq.com", "1992-09-08");
system.out.println("添加了" + count + "条记录");
jdbcutils.closeresource(conn, null);
}
// 测试删除
@test
public void testdelete() throws exception {
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
string sql = "delete from customers where id < ?";
int count = runner.update(conn, sql,3);
system.out.println("删除了" + count + "条记录");
jdbcutils.closeresource(conn, null);
}
该接口用于处理 java.sql.resultset，将数据按要求转换为另一种形式。
resultsethandler 接口提供了一个单独的方法：object handle (java.sql.resultset .rs)。
接口的主要实现类：
测试
/*
* 测试查询:查询一条记录
*
* 使用resultsethandler的实现类：beanhandler
*/
@test
public void testqueryinstance() throws exception{
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
string sql = "select id,name,email,birth from customers where id = ?";
//
beanhandler<customer> handler = new beanhandler<>(customer.class);
customer customer = runner.query(conn, sql, handler, 23);
system.out.println(customer);
jdbcutils.closeresource(conn, null);
}
/*
* 测试查询:查询多条记录构成的集合
*
* 使用resultsethandler的实现类：beanlisthandler
*/
@test
public void testquerylist() throws exception{
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
string sql = "select id,name,email,birth from customers where id < ?";
//
beanlisthandler<customer> handler = new beanlisthandler<>(customer.class);
list<customer> list = runner.query(conn, sql, handler, 23);
list.foreach(system.out::println);
jdbcutils.closeresource(conn, null);
}
/*
* 自定义resultsethandler的实现类
*/
@test
public void testqueryinstance1() throws exception{
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
string sql = "select id,name,email,birth from customers where id = ?";
resultsethandler<customer> handler = new resultsethandler<customer>() {
@override
public customer handle(resultset rs) throws sqlexception {
system.out.println("handle");
// return new customer(1,"tom","tom@126.com",new date(123323432l));
if(rs.next()){
int id = rs.getint("id");
string name = rs.getstring("name");
string email = rs.getstring("email");
date birth = rs.getdate("birth");
return new customer(id, name, email, birth);
}
return null;
}
};
customer customer = runner.query(conn, sql, handler, 23);
system.out.println(customer);
jdbcutils.closeresource(conn, null);
}
/*
* 如何查询类似于最大的，最小的，平均的，总和，个数相关的数据，
* 使用scalarhandler
*
*/
@test
public void testqueryvalue() throws exception{
queryrunner runner = new queryrunner();
connection conn = jdbcutils.getconnection3();
//测试一：
// string sql = "select count(*) from customers where id < ?";
// scalarhandler handler = new scalarhandler();
// long count = (long) runner.query(conn, sql, handler, 20);
// system.out.println(count);
//测试二：
string sql = "select max(birth) from customers";
scalarhandler handler = new scalarhandler();
date birth = (date) runner.query(conn, sql, handler);
system.out.println(birth);
jdbcutils.closeresource(conn, null);
}
总结
@test
public void testupdatewithtx() {
connection conn = null;
try {
//1.获取连接的操作（
//① 手写的连接：jdbcutils.getconnection();
//② 使用数据库连接池：c3p0;dbcp;druid
//2.对数据表进行一系列crud操作
//① 使用preparedstatement实现通用的增删改、查询操作（version 1.0 \ version 2.0)
//version2.0的增删改public void update(connection conn,string sql,object ... args){}
//version2.0的查询 public <t> t getinstance(connection conn,class<t> clazz,string sql,object ... args){}
//② 使用dbutils提供的jar包中提供的queryrunner类
//提交数据
conn.commit();
} catch (exception e) {
e.printstacktrace();
try {
//回滚数据
conn.rollback();
} catch (sqlexception e1) {
e1.printstacktrace();
}
}finally{
//3.关闭连接等操作
//① jdbcutils.closeresource();
//② 使用dbutils提供的jar包中提供的dbutils类提供了关闭的相关操作
}
}
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
网友评论