Java与数据库连接篇—上
Java与数据库连接篇—上
课程内容：
一、什么是JDBC?（What）
JDBC（Java Data Base Connectivity,Java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
Java对外指定一些编程标准，其它数据库服务器厂商按照这个标准，编写对应的实现方案。这样对于Java程序员而言，只需要学习Java的标准即可，不需要了解不同厂商的实现细节。一切操作都是在学习接口开发。按照接口指定的标准完成指定需要完成的业务即可。
二、为什么要使用JDBC?（Why）
- 为了将数据持久的存储、固化到磁盘上我们需要掌握数据库。
- 为了通过Java代码完成对于数据的持久存储我们需要学习JDBC。
- 通过JDBC我们能够以面向接口方式，操作数据库中的数据，更加的方便。
- 本身Java就是跨平台的，通过Java开发的JDBC应用可以在不同的平台上执行。
- JDBC为数据库开发提供了标准的API，所以使用JDBC开发的数据库应用也可以跨数据库(要求全部使用标准的SQL)
JDBC和ODBC的区别和联系:
ODBC:
它使用 C 语言接口,是一组对数据库访问的标准API，这些API通过SQL来完成大部分任务，而且它本身也支持SQL语言，支持用户发来的SQL。ODBC定义了访问数据库API的一组规范，这些API独立于形色各异的DBMS和编程语言。
JDBC:
是Java与数据库的接口规范，JDBC定义了一个支持标准SQL功能的通用低层API，它由Java 语言编写的类和接口组成，旨在让各数据库开发商为Java程序员提供标准的数据库API。
常见JDBC驱动:
- JDBC-ODBC桥(JDBC-ODBC Bridge Driver)
- 最早实现的JDBC驱动程序，旨在快速推广，将JDBC-API映射为ODBC-API。JDK8中已经移除
- JDBC API驱动程序(Anative API partly Java technology-enabled Driver)
- 需要实现本地安装特定的驱动程序，通过转换把Java编写的JDBC-API转换为Native-API，进行数据库操作。
- 纯Java的数据库中间件驱动程序(Pure Java Driver for Database Middleware)
- 不需要安装特定的驱动程序，需要在安装数据库管理系统的服务器端安装中间件(Middleware),中间件负责在存取数据时必要的转换操作。就是将JDBC访问转换为数据库无关的http或者是https协议，再有中间件转换为数据库专用的访问指令。
- 纯Java的JDBC驱动程序(Direct-to-DatabasePureJavaDriver)
- 目前最流行的JDBC驱动，不需要安装任何附加内容，所有存取数据库的操作都直接由JDBC驱动程序来完成，此类驱动程序能将JDBC调用转换成DBMS专用的网络协议，能够自动识别网络协议下的特殊数据库并能直接创建数据连接。
三、 在那些场景下需要使用JDBC(Where)
Java程序员如果想要和数据库打交道就必须要掌握JDBC。
如果你的业务模型中需要将数据持久化存储就必须掌握JDBC。
更多资料添加QQ：1708434248 v:magejava
四、 如何使用JDBC?(How)
1. JDBC所处的处境?
[外链图片转存失败(img-lDgEyDIq-1562727277939)(img_jdbc\1558841462677.png)]
2.编写第一个JDBC程序
1） 连接步骤
1) 手动导入需要连接数据库的jar包
2) 加载驱动
3) 创建连接对象
4) 声明sql语句
5) 创建处理sql语句对象
6) 发送sql语句，接收返回结果
7) 处理结果
8) 关闭资源连接
2) 导入需要的jar包
连接oracle就导入jdbc的jar包，参照附录到安装对应数据库可以在内部找到jar包；
连接mysql就导入mysql-connector的jar包，到官网下载对应版本jar包，或在maven仓库下载jar包。
3) 编写测试代码
@Test
public void searchOne() {
//提升作用域 方便后期关闭资源
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
//3：声明sql语句
String sql = "SELECT * FROM TB_USER WHERE ID = 1";
//4：创建处理对象
stmt = conn.createStatement();
//5：发送sql语句获取结果集(如果是查询操作才存在结果集)
rs = stmt.executeQuery(sql);
//6. 迭代结果集
while(rs.next()) {
//7：分析结果集
System.out.println(rs.getString("name"));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//8：关闭资源
try {
if(rs!=null)
rs.close();
if(stmt!=null)
stmt.close();
if(conn!=null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
4) 分析第一个程序
A. 为什么要加载驱动?
I. 通过Class.forName(“Driver类的路径名”);
II.查看Mysql的Driver类
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
//在初始化的时候，就将当前数据库对象的驱动加载到sql的注册中心中去
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
}
B.获取连接源码
//获取连接就是会将连接信息包装为Properties
public static Connection getConnection(String url,
String user, String password) throws SQLException {
java.util.Properties info = new java.util.Properties();
if (user != null) {
info.put("user", user);
}
if (password != null) {
info.put("password", password);
}
return (getConnection(url, info, Reflection.getCallerClass()));
}
C.常见对象：
| 对象名称 | 获取方式 | 用途 |
|---|---|---|
| DriverManager | 用来管理JDBC驱动的服务类，主要用来获取Connection。 | |
| Connection | DriverManager.getConnection(url,name,pwd); | 代表一个物理连接会话，如果要操作数据库必须先获取数据库连接对象。 |
| Statement | Connection.createStatement(); | 用于执SQL语句的对象。常见的有Statement、PreparedStatement、CallableStatement |
| ResultSet(针对查询) | Statement.executQuery(sql); | 结果集对象，包含了对于访问查询结果的方法。 |
3. 修改操作
3.1测试用例编写
@Test
public void updateNameById() {
//1：声明用户修改的id
Integer id = 1;
//2：声明修改后的名称
String newName= "大锤";
//3：声明连接对象
Connection conn = null;
Statement stmt = null;
try {
//4：加载驱动
Class.forName("com.mysql.jdbc.Driver");
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
stmt = conn.createStatement();
//6：声明sql语句
String sql = "UPDATE TB_USER SET NAME = '"+newName+"'WHERE USERID = "+id;
//7：发送sql语句 接受返回结果
int rows = stmt.executeUpdate(sql);
System.out.println("修改了"+rows+"行记录");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//8：关闭资源
try {
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
3.2 注意事项
1. 修改操作返回的是受影响的行数
2. 加载驱动只需要一次，不需要每次都加载驱动
4. 删除操作
4.1 测试用例编写
public class JDBCTest01 {
Connection conn = null;
Statement stmt = null;
@Before
public void load() {
//1：加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void deleteById() {
try {
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
stmt = conn.createStatement();
//6：声明sql语句
String sql = "DELETE FROM TB_USER WHERE ID = 1";
//7：发送sql语句 接受返回结果
int rows = stmt.executeUpdate(sql);
System.out.println("删除了"+rows+"行记录");
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
4.2 注意事项
* 1:删除操作作为DML语句的一种，返回的也是受影响的行数。
5. 增加操作
5.1 测试用例编写
public class JDBCTest01 {
Connection conn = null;
Statement stmt = null;
@Before
public void load() {
//1：加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void insert() {
try {
User u = new User("wangdachui", "123456",'王大锤', 18, "男");
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
stmt = conn.createStatement();
//6：声明sql语句
String sql = "INSERT INTO TB_USER (UNAME,UPWD,NAME,AGE,GENDER) VALUES ('"+u.getUname()+"','"+u.getUpwd()+"','"+u.getName()+"','"+u.getAge() + "','" + u.getGender() + "')";
//7：发送sql语句 接受返回结果
int rows = stmt.executeUpdate(sql);
System.out.println("增加了"+rows+"行记录");
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
User.java内容如下：
package com.mage.po;
/*
* javabean规范：
* 所有属性私有
* 所有私有属性提供public的setter、getter方法
* 提供至少空构造器
*/
public class User {
private int id;
private String uname;
private String upwd;
private String name;
private String gender;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(int id, String uname, String upwd, String name, String gender, int age) {
super();
this.id = id;
this.uname = uname;
this.upwd = upwd;
this.name = name;
this.gender = gender;
this.age = age;
}
}
更多资料添加QQ：1708434248 v:magejava
5.2 注意事项
删除也是返回受影响的行数
**注意：**对于所有的写操作(增、删、改)，其实主体内容都差不多，主要是sql语句不同，某些参数不同，后期是可以考虑封装起来的。
6. 查询操作
6.1 测试用例编写
public class JDBCTest01 {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
@Before
public void load() {
//1：加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void insert() {
LinkedList<User> list = new LinkedList<User>();
try {
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
stmt = conn.createStatement();
//6：声明sql语句
String sql = "SELECT * FROM TB_USER";
//7：发送sql语句 接受返回结果
rs = stmt.executeQuery(sql);
//8：分析结果集
while(rs.next()) {
User u = new User();
u.setId(rs.getInt("id"));
u.setUname(rs.getString("uname"));
u.setUpwd(rs.getString("upwd"));
u.setName(rs.getString("name"));
u.setAge(rs.getInt("age"));
u.setGender(rs.getString("gender"));
list.add(s);
}
System.out.println(ls);
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(rs!=null) {
rs.close();
}
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
6.2 注意事项
1:对于DQL操作，返回的是结果集ResultSet对象
2:对于ResultSet对象，需要通过.next()方法，查看是否存在其他记录
五、附录
1. Statement对象的问题
1.1 效率问题
- 正常情况下插入：
问题描述：插入100000条数据，通过Statement插入：root
插入数据：1000,用时：2200插入数据：1000,用时：2769
插入数据：1000,用时：2943
public class JDBCTest02 {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
List<User> data = new LinkedList<>();
@Before
public void load() {
try {
//1：加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2：编写测试数据
for(int i = 1;i<100000;i++) {
String uname = "zs"+i;
String upwd = "123";
String name = "张三"+i;
int age = (int)(Math.random()*7+18);
String gender = (int)(Math.random())>0.5?"女":"男";
User u = new User(uname, upwd,name, age, gender);
data.add(u);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void insert() {
try {
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
stmt = conn.createStatement();
//记录时间
long startTime = System.currentTimeMillis();
int rows = 0;
for(int i = 1;i<data.size();i++) {
//6：声明sql语句
String sql = "INSERT INTO TB_User (UNAME,UPWD,NAME,AGE,GENDER) VALUES ('"+
data.get(i).getUname()+"','"+data.get(i).getUpwd()+"','"+ data.get(i).getName()+"','"+ data.get(i).getAge() +"','"+ data.get(i).getGender()+"')";
//7：发送sql语句 接受返回结果
rows += stmt.executeUpdate(sql);
}
//记录时间
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime+"ms,总共受影响的行数是："+rows);
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
结论：
399050ms,总共受影响的行数是：100000
- 通过PreparedStatement插入数据
通过PreparedStatement插入数据
测试用例:
public class JDBCTest03 {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
List<User> data = new LinkedList<User>();
@Before
public void load() {
try {
//1：加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2：编写测试数据
for(int i = 1;i<100000;i++) {
String uname = "zs"+i;
String pwd = "123";
String name = "张三"+i;
int age = (int)(Math.random()*7+18);
String gender = (int)(Math.random())==0?"女":"男";
User u = new User(uname, pwd,name, age, gender);
data.add(u);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void insert() {
int rows = 0;
try {
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note",
"root","root");
//6：声明sql语句
String sql = "INSERT INTO TB_USER(UNAME,UPWD,NAME,AGE,GENDER) VALUES (?,?,?,?,?)";
//7：获取预处理对象
pstmt = conn.prepareStatement(sql);
//记录时间
long startTime = System.currentTimeMillis();
//循环获取到每个对象的内容
for(int i = 0;i<data.size();i++) {
//8：设置绑定变量
pstmt.setString(1,data.get(i).getUname());
pstmt.setString(2,data.get(i).getUpwd());
pstmt.setString(3,data.get(i).getName());
pstmt.setInt(4,data.get(i).getAge());
pstmt.setString(5,data.get(i).getGender());
//9：发送SQL语句 获取结果
rows += pstmt.executeUpdate();
}
//记录时间
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime+"ms,总共受影响的行数是："+rows);
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(pstmt!=null) {
pstmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
结论：
677875ms,总共受影响的行数是：100000
- 通过PreparedStatement批处理以及事务插入数据
通过PreparedStatement批处理插入数据
测试用例:
public class JDBCTest03 {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
List<Student> data = new LinkedList<>();
@Before
public void load() {
try {
//1：加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2：编写测试数据
for(int i = 1;i<100000;i++) {
String name = "用户"+i;
String pwd = "123";
int age = (int)(Math.random()*7+18);
String gender = (int)(Math.random())>0.5?"女":"男";
Student stu = new Student(name, pwd, age, gender);
data.add(stu);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void insert() {
int rows = 0;
try {
//5：获取连接对象
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/note?rewriteBatchedStatements=true",
"root","root");
//6：声明sql语句
String sql = "INSERT INTO TB_USER(UNAME,UPWD,NAMW,AGE,GENDER) VALUES (?,?,?,?,?)";
//7：获取预处理对象
pstmt = conn.prepareStatement(sql);
//记录时间
long startTime = System.currentTimeMillis();
//关闭自动提交事务
conn.setAutoCommit(false);
//循环获取到每个对象的内容
for(int i = 0;i<data.size();i++) {
//8：设置绑定变量
pstmt.setString(1,data.get(i).getUname());
pstmt.setString(2,data.get(i).getUpwd());
pstmt.setString(3,data.get(i).getName());
pstmt.setInt(4,data.get(i).getAge());
pstmt.setString(5,data.get(i).getGender());
//添加到批处理中
pstmt.addBatch();
}
//一起提交到数据库服务器
rows = pstmt.executeBatch().length;
//提交事务
conn.commit();
//记录时间
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime+"ms,总共受影响的行数是："+rows);
} catch (SQLException e) {
try {
//出现异常则回滚事务
conn.rollback();;
e.printStackTrace();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
}
@After
public void close() {
try {
if(pstmt!=null) {
pstmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
结论：
188114ms,总共受影响的行数是：100000
- Tips
- 使用批处理需要增加rewriteBatchedStatements=true
- 将所有批量操作添加到一个事务当中，设置自动提交为false;conn.setAutoCommite(false);
- 如果语句中出现问题，则在异常中对于事务进行回滚。
1.2 SQL注入问题
测试代码：
public class JDBCTest04 {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
public static final String URL = "jdbc:mysql://localhost:3306/note";
public static final String USER_NAME = "root";
public static final String USER_PWD = "root";
//模拟登陆用户
User user = null;
@Before
public void load() {
try {
//1：加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2：模拟用户数据,这里记得在User.java中添加对应构造器
user = new User("'1","' or 1=1");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void queryByUser() {
int rows = 0;
try {
//5：获取连接对象
conn = DriverManager.getConnection(
URL, USER_NAME,USER_PWD);
//6：声明sql语句
String sql = "SELECT * FROM TB_STUDENT WHERE UNAME = "+loginStu.getUname()
+" AND PWD = "+loginStu.getUpwd();
System.out.println(sql);
//7：获取处理对象
stmt = conn.createStatement();
//8：发送sql 获取结果
rs = stmt.executeQuery(sql);
//9：分析结果
while(rs.next()) {
System.out.println("查询到了结果");
}
} catch (SQLException e) {
e.printStackTrace();
}
}
@After
public void close() {
try {
if(stmt!=null) {
stmt.close();
}
if(conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
结论：
- 通过构建sql语句，导致不同的用户名和密码侵入到系统内部，就是SQL注入攻击。
- 为了防止出现这个问题，我们通过预处理对象完成，PreparedStatement。
2. 常见方法总结
| 常见对象 | 对象常见方法 | 作用 |
|---|---|---|
| Connection | Connection.createStatement(); | 创建Statement对象 |
| Connection.preparedStatement(sql); | 创建预处理对象 | |
| Connection.prepareCall(sql) | 创建CallableStatement对象，调用存储过程 | |
| Connection.setAutoCommite(true/false) | 设置事务提交方式，默认情况是自动提交true | |
| Connection.commit(); | 提交事务 | |
| Connection.rollback(); | 回滚事务 | |
| Statement | Statement.executeQuery(sql); | 针对查询操作，获取结果集对象 |
| Statement.executeUpdate(sql); | 针对写(增加、删除、修改)操作，获取受影响的行数 | |
| PreparedStatement | PreparedStatement.executeQuery(); | 针对查询操作，获取结果集对象 |
| PreparedStatement.executeUpdate(); | 针对写(增加、删除、修改)操作，获取受影响的行数 | |
| PreparedStatement.addBatch(); | 添加到批处理中 | |
| PreparedStatement.executeBatch(); | 执行批处理操作 | |
| PreparedStatement.setXXX(index,value); | 设置绑定变量，给指定的占位符index，指定具体的值value，XXX代表value的数据类型。注意index从1开始 | |
| ResultSet | ResultSet.next(); | 查看读操作返回的结果集中是否还存在数据信息 |
| ResultSet.getXXX(index/columnName); | 根据字段的顺序或者是字段名称获取结果集中该字段的值，XXX代表返回数据的类型。index获取列是从0开始 |
3. Statement和PreparedStatement对比
| 区别点 | 对象 | 具体细节 |
|---|---|---|
| 创建方式 | Statement | Connection.createStatement(); 不需要sql |
| PreparedStatement | Connection.preparedStatement(sql);需要sql | |
| 安全 | Statement | 不能防止sql注入 SELECT * FROM TB_USER WHERE UNAME = '1 AND PWD = ’ OR 1=1 |
| PreparedStatement | 可以防止SQL注入 | |
| 效率 | Statement | 不会初始化，没有预处理，每次都是从0开始执行SQ |
| PreparedStatement | 会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率 | |
| 可读性 | Statement | 当多次执行参数不同的语句时，需要不断的拼接字符串，使得阅读变得极为耗时以及费力。 |
| PreparedStatement | 通过SetXXX()；这样的方式，提高了阅读性 | |
| 性能 | Statement | 没有预编译的过程，每次都需要在DB中重新编译一下 |
| PreparedStatement | 语句被db的编译器编译后的执行代码就会被缓存下来， 那么下次调用时只要相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行就可以。 相当于一个函数 ， 对于整个db来说，只有预编译的语句和缓存中匹配，那么任何时候，就可以不需要再次编译从而直接执行。并不是所有的预编译语句都会被缓存起来，数据库本身会用一种策略，频繁使用的语句可能被缓存起来，以保存有更多的空间存储新的预编译语句。 |
3. DBUtiles编写
1) 编写步骤注释
1在src下创建一个.properties文件，编写驱动、链接地址、用户名、密码
2在工具类中通过流的方式读取配置文件信息，获取驱动、链接地址、用户名、密码
3编写获取连接、处理对象的方法
4编写资源连接的方法
2) 具体编码
配置文件DBConfig.properties
database=mysql
#######mysql properties########
mysqlDriver=com.mysql.jdbc.Driver
mysqlUrl=jdbc:mysql://localhost:3306/note
mysqlUsername=root
mysqlPassword=root
#######oracle properties########
oracleDriver=oracle.jdbc.OracleDriver
oracleUrl=jdbc:oracle:thin:@localhost:1521:orcl
oracleUsername=scott
oraclePassword=tiger
编写DBBase接口
public interface DBBase {
public static final String DATABASE_NAME = "database";
public static final String DATABASE_DRIVER = "driver";
public static final String DATABASE_URL = "url";
public static final String DATABASE_USERNAME = "username";
public static final String DATABASE_PASSWORD = "password";
}
编写DBUtils工具类
public class DBUtils {
//声明获取值
private static String database = "";
private static String driver = "";
private static String url = "";
private static String uname = "";
private static String pwd = "";
private static Properties pro = null;
//通过静态代码块将配置文件信息加载进来
static {
try {
//创建配置对象
pro = new Properties();
//获取输入流读取
InputStream is = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("DBConfig.properties");
//读取数据信息
pro.load(is);
//通过方法获取配置文件中的数据信息
database = getValue(DBBase.DATABASE_NAME);
driver = getValue(database+"-"+DBBase.DATABASE_DRIVER);
url = getValue(database+"-"+DBBase.DATABASE_URL);
uname = getValue(database+"-"+DBBase.DATABASE_USERNAME);
pwd = getValue(database+"-"+DBBase.DATABASE_PASSWORD);
//加载驱动
Class.forName(driver);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
System.out.println("驱动类为【"+driver+"】");
}
}
/**
* 获取连接对象
* @return
*/
public static Connection getConn() {
Connection conn = null;
try {
conn = DriverManager.getConnection(url, uname,pwd);
} catch (SQLException e) {
e.printStackTrace();
System.out.println("【"+url+"】【"+uname+"】【"+pwd+"】");
}
return conn;
}
/**
* 创建Statement对象
* @param conn
* @return
*/
public static Statement getState(Connection conn) {
if(conn==null)
throw new RuntimeException("连接为空");
Statement stmt = null;
try {
stmt = conn.createStatement();
} catch (SQLException e) {
e.printStackTrace();
System.out.println("创建Statement对象失败");
}
return stmt;
}
//关闭连接
private static void closeConn(Connection conn) {
if(conn!=null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//关闭资源
private static void closeStmt(Statement stmt) {
if(stmt!=null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//关闭资源
private static void closeRs(ResultSet rs) {
if(rs!=null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//关闭所有资源
public static void closeAll(Connection conn,Statement stmt,ResultSet rs) {
closeRs(rs);
closeStmt(stmt);
closeConn(conn);
}
private static String getValue(String key) {
if("".equals(key)||key==null)
throw new NullPointerException("key值有误");
return pro.getProperty(key);
}
}
总结
1:通过Properties来加载配置文件信息。
2:通过getContextClassLoader().getResourceAsStream()读取相对于项目根目录下的资源文件。(这里的ClassLoader是一个上下文的加载器)。
3:在获取Properties中的值时，通过异常中断去处理了程序
4:通过静态代码块保证加载驱动只需要执行一次
更多资料添加QQ：1708434248 v:magejava