JDBC数据库连接技术

1.JDBC 概念

java database conactivity

java 数据库连接技术 程序员

使用java语言操作数据的技术

使用框架操作数据库:

mybatis、hibernate

2.JDBC 简介

SUN 公司为了简化和统一对数据库的操作制定了JDBC 的接口规范。 然后由各大数据库厂商 提供 java连接数据库的驱动程序。

JDBC规范中，涉及到两个包 一个是 java.sql javax.sql

3.连接数据的URL

用来定位数据库的位置的

主协议:子协议:[]://主机:端口号/数据库名

jdbc:oracle:thin:@localhost:1521/xe

jdbc:mysql://localhost:3306/emp

4.JDBC 连接数据库的步骤

4.1 加载驱动

有两种手段 但是推荐使用第二种反射的方式

4.2 获取数据库连接

DriverManager.getConnection(….);

4.3 获取sql的执行环境 Statement

4.4 执行sql

insert delete update 只要不报异常 基本上执行成功了

select 就会获得结果集 要进行遍历

DDL (create table drop table alter table) 基本不用

4.5 关闭资源

连接 执行环境 结果集

5.如何导入jar包

项目上右键 —— buildpath —- configbuild path —— add

library —– user library — - new library —– add External jars —- 一路完成 确定

6.使用JDBC 做了一个更新操作

6.1 加载驱动

Class.forName(“oracle.jdbc.OracleDriver”);

6.2 获取数据库连接

Connection conn = DriverManager.getConnection(url,username,password);

6.3 获取sql 的执行环境 Statement

Statement st = conn.createStatement();

6.4 执行sql 语句 dml操作推荐使用 executeUpdate select操作推荐 executeQuery

int rows = st.executeUpdate(sql语句);

6.5 释放资源 从小到大释放 st 和 conn

if(st != null){

try{

st.close();

}catch(SQLException e){

e.printStackTrace();

}finally{

st = null;

}

}

1. 元数据

主要是描述数据属性的信息，记录表中数据的类型 字段名字 字段的个数

create   table     myUser(
id     number     primary  key,
name  varchar2(30),
password   varchar2(30)
);

insert into myUser values(1,’kobe’,’123’);

insert into myUser values(2,’tmac’,’456’);

commit;

2.滚动结果集

st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_READ_ONLY); 可以随机访问数据 而不是按照顺序访问

3.PreparedStatement

相对于Statement优势:

可以避免sql注入问题 ’ or ‘a’=’a

避免sql缓冲溢出

提前预编译 提高了执行的效率

简化了sql的拼接 避免sql语法错误

5. 批处理

5.1 使用 Statement 一次执行多个sql 可以是不同的操作 st.addBatch(sql3); int[] results = st.executeBatch();

5.2 使用 PreparedStatement

一次执行多个sql 每次执行的sql语句相同 只是值不同

“insert into myUser values(myuser_id_seq.nextval,?,?)”

addBatch();

executeBatch();

6.JDBC中的事务

JDBC 中事务默认是 自动提交的 把事务改为手动提交之后 如果不主动断开连接 事务是不会提交的 但是主动关闭会

提交事务 但是不能寄希望于这里。我们需要明确的提交 或者 回滚 conn.commit()

或者 conn.rollback()。

1.事务的四个隔离级别

conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); 可以通过 Connection 点的方式 获取对应的常量

Connection.TRANSACTION_READ_UNCOMMITED 读未提交

Connection.TRANSACTION_READ_COMMITED 读提交

Connection.TRANSACTION_REPEATABLE_READ 可重复读

Connection.TRANSACTION_SERIALIZABLE 序列化

这四个隔离级别 是为了解决三个问题

脏读

一个事务 读取到了 另外一个事务没有提交的数据

不可重复读

一个事务在开始时 读取了一份数据 然后操作的过程中 这个事务影响的数据

被另外一个事务修改了并做了修改的提交，这个时候再次读取这份时 数据就

发生了改变。

幻读

一个事务在开始时 对表中的所有数据进行了统计 然后操作的过程中 表中的数据发生了

增 删 这样统计的数据就发生了改变。

2.连接池

2.1 为什么要有连接池

频繁的获取 和 关闭连接 是非常消耗资源的 连接池的连接的关闭 只是把连接放回了连接池

2.2 使用连接池来获取连接

BasicDataSource datasource = new BasicDataSource(); // 设置数据源的参数

datasource.setDriverClassName(“oracle.jdbc.OracleDriver”);

datasource.setUrl(“jdbc:oracle:thin:@127.0.0.1:1521:xe”);

datasource.setUsername(“system”);

datasource.setPassword(“abc123”);

// 最大空闲数

datasource.setMaxIdle(5);

// 最小空闲数

datasource.setMinIdle(1);

// 最大活动连接 最大连接数据

datasource.setMaxActive(15);

// 初始化数量

datasource.setInitialSize(2);

两种连接池比较

c3p0与dbcp区别：

dbcp没有自动的去回收空闲连接的功能

c3p0有自动回收空闲连接功能

两者主要是对数据连接的处理方式不同！

C3P0提供最大空闲时间，DBCP提供最大连接数。

加载驱动代码：

db.properties

driverClassName=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:xe
username=system
password=abc123

JDBCUtilProperties

package com.x.util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JDBCUtilProperties {
public  static   String   driverClassName;
public  static   String   url;
public  static   String   username;
public  static   String   password;
static {
try {
// 读取 db.properties  文件
InputStream  inputStream = JDBCUtilProperties.class.getClassLoader().
getResourceAsStream("com/xdl/util/db.properties");
/* Properties  就是一个key value 结构  */
Properties  pro = new Properties();
try {
pro.load(inputStream);
driverClassName = pro.getProperty("driverClassName");
url = pro.g
f29c
etProperty("url");
username = pro.getProperty("username");
password = pro.getProperty("password");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Class.forName(driverClassName);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/* 获取数据库 连接的方法  */
public  static  Connection   getConnection(){
Connection  conn  = null;
try {
conn = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return  conn;
}
/* 释放资源的方法  */
public  static  void  releaseResource(Connection conn,Statement st,ResultSet rs){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
rs = null;
}
}
if(st != null){
try {
st.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
st = null;
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
conn = null;
}
}
}
}

测试

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import com.x.util.JDBCUtilProperties;

public class Demo4 {
public static void main(String[] args) {
// 1.使用工具类获取连接
Connection  conn = JDBCUtilProperties.getConnection();
// 2.获取执行环境
try {
Statement   st  = conn.createStatement();
// 3.执行sql
ResultSet rs = st.executeQuery
("select  id,first_name name,salary from s_emp");
// 遍历结果集
while(rs.next()) {
System.out.println(rs.getInt(1)+":"+rs.getString(2)+":"+rs.getDouble(3));
System.out.println(rs.getInt("id")+":"+rs.getString("name")+":"
+rs.getDouble("salary"));
System.out.println(rs.getInt("ID")+":"+rs.getString("NAME")+":"
+rs.getDouble("salary"));
}
//4.程序结束  释放资源
JDBCUtilProperties.releaseResource(conn, st, rs);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

批处理

使用Statement 做批处理

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;

import com.xdl.util.JDBCUtilProperties;

public class Demo5 {
/* 使用Statement  做批处理  */
public static  void   test1(){
String  sql1="insert  into myUser values(myuser_id_seq.nextval,'testgg','xyy')";
String  sql2="delete from myUser where id < 22";
String  sql3="update  myUser set password = '123' where id > 2";
//1.获取连接
Connection conn = null;
Statement  st = null;
conn = JDBCUtilProperties.getConnection();
//2. 获取执行环境
try {
st = conn.createStatement();
st.addBatch(sql1);
st.addBatch(sql2);
st.addBatch(sql3);
int[]  results = st.executeBatch();
for(int i : results){
System.out.println("执行的结果是 成功了:"+ i +"条");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
JDBCUtilProperties.releaseResource(conn, st, null);
}

}
public static void test2(){
String  sql = "insert into myUser values(myUser_id_seq.nextval,?,?)";
String  names[] = {"test1","test2","test3","test4","test5"};
String  password[] = {"1","2","3","4","5"};
Connection  conn  =  null;
PreparedStatement  ps = null;
conn = JDBCUtilProperties.getConnection();
try {
ps = conn.prepareStatement(sql);
for(int i=0;i<names.length;i++){
ps.setString(1, names[i]);
ps.setString(2, password[i]);
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
JDBCUtilProperties.releaseResource(conn, ps, null);
}

}
public static void main(String[] args) {
//test1();
test2();
}

}

}
public class Demo7 {
/* 转账的案例
create  table   bankAccount(
id   number  primary key,
name  varchar2(30),
money   number);
insert  into  bankAccount values(1,'mengge',10000000);
insert  into  bankAccount values(2,'canglaoshi',10000000);
commit;
*/

public  static void   test3(){
// 1.获取连接
Connection   conn  = null;
PreparedStatement   ps = null;
PreparedStatement   ps2 = null;
conn = JDBCUtilProperties.getConnection();
try {
conn.setAutoCommit(false);
double  m = 1000000;
ps = conn.prepareStatement
("update bankaccount set money=money-? where id=1 and name='mengge'");
ps.setDouble(1, m);
int rows = ps.executeUpdate();
ps2 = conn.prepareStatement
("update bankaccount set money=money+? where id=2 and name='lianglaoshi'");
ps2.setDouble(1, m);
int rows2 = ps2.executeUpdate();
if(rows == 1 && rows2 == 1 ){
System.out.println("转账成功");
conn.commit();
}else{
System.out.println("转账失败");
conn.rollback();
}

} catch (SQLException e) {
// TODO Auto-generated catch block
try {
conn.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
}finally {
JDBCUtilProperties.releaseResource(conn, ps, null);
JDBCUtilProperties.releaseResource(conn, ps2, null);
}
}
public static void main(String[] args) {
//test1();
//test2();
test3();
}
}
}

public class Demo6 {
/* 测试jdbc 默认的自动提交的事务 */
public  static  void  test1(){
Connection   conn = null;
PreparedStatement  ps = null;
conn =  JDBCUtilProperties.getConnection();
try {
ps = conn.prepareStatement
("insert into myUser values(myuser_id_seq.nextval,?,?)");
ps.setString(1, "test99");
ps.setString(2, "888888");
ps.executeUpdate();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
JDBCUtilProperties.releaseResource(conn, ps, null);
}
}
/* 改变jdbc 默认的自动提交的事务  改为手动提交 */
public  static  void  test2(){
Connection   conn = null;
PreparedStatement  ps = null;
conn =  JDBCUtilProperties.getConnection();
try {
// 改为手工提交
conn.setAutoCommit(false);
ps = conn.prepareStatement
("insert into myUser values(myuser_id_seq.nextval,?,?)");
ps.setString(1, "test101");
ps.setString(2, "11111111");
ps.executeUpdate();
System.out.println("好好看着  有没有提交");
conn.commit();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
JDBCUtilProperties.releaseResource(conn, ps, null);
}
}

“`