JDBC基础知识

理论：

1.Driver接口：

Java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现

在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现

加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名

DriverManager 类是驱动程序管理器类，负责管理驱动程序

通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例

DriverManager 类的 getConnection() 方法建立到数据库的连接的到数据库的connection对象

2.Statement

通过调用 Connection 对象的 createStatement 方法创建该对象

该对象用于执行静态的 SQL 语句，并且返回执行结果

Statement 接口中定义了下列方法用于执行 SQL 语句：

ResultSet excuteQuery(String sql)

int excuteUpdate(String sql)

 

 

 

 

 

 

 

 

PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXXX() 方法来设置这些参数. setXXX() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

/**

 * 执行 SQL 语句, 使用 PreparedStatement  （代码可读，防止sql注入）

 * @param sql

 * @param args: 填写 SQL 占位符的可变参数

 */

public static void update(String sql, Object ... args){

Connection connection = null;

PreparedStatement preparedStatement = null;

try {

connection = JDBCTools.getConnection();

preparedStatement = connection.prepareStatement(sql);

for(int i = 0; i < args.length; i++){

preparedStatement.setObject(i + 1, args[i]);

}

preparedStatement.executeUpdate();

} catch (Exception e) {

e.printStackTrace();

} finally{

JDBCTools.releaseDB(null, preparedStatement, connection);

}

}

利用JDBC元元素编写通用的jdbc查询方法：

package com.atguigu.jdbc;

 

import java.lang.reflect.InvocationTargetException;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

 

import org.apache.commons.beanutils.BeanUtils;

 

public class DAO {

 

// INSERT, UPDATE, DELETE 操作都可以包含在其中

public void update(String sql, Object... args) {

Connection connection = null;

PreparedStatement preparedStatement = null;

 

try {

connection = JDBCTools.getConnection();

preparedStatement = connection.prepareStatement(sql);

 

for (int i = 0; i < args.length; i++) {

preparedStatement.setObject(i + 1, args[i]);

}

 

preparedStatement.executeUpdate();

} catch (Exception e) {

e.printStackTrace();

} finally {

JDBCTools.releaseDB(null, preparedStatement, connection);

}

}

 

// 查询一条记录, 返回对应的对象

public <T> T get(Class<T> clazz, String sql, Object... args) {

List<T> result = getForList(clazz, sql, args);

if(result.size() > 0){

return result.get(0);

}

return null;

}

 

/**

 * 传入 SQL 语句和 Class 对象, 返回 SQL 语句查询到的记录对应的 Class 类的对象的集合

 * @param clazz: 对象的类型

 * @param sql: SQL 语句

 * @param args: 填充 SQL 语句的占位符的可变参数.

 * @return

 */

public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {

 

List<T> list = new ArrayList<>();

 

Connection connection = null;

PreparedStatement preparedStatement = null;

ResultSet resultSet = null;

 

try {

//1. 得到结果集

connection = JDBCTools.getConnection();

preparedStatement = connection.prepareStatement(sql);

 

for (int i = 0; i < args.length; i++) {

preparedStatement.setObject(i + 1, args[i]);

}

 

resultSet = preparedStatement.executeQuery();

//2. 处理结果集, 得到 Map 的 List, 其中一个 Map 对象

//就是一条记录. Map 的 key 为 reusltSet 中列的别名, Map 的 value

//为列的值.

List<Map<String, Object>> values =

handleResultSetToMapList(resultSet);

//3. 把 Map 的 List 转为 clazz 对应的 List

//其中 Map 的 key 即为 clazz 对应的对象的 propertyName,

//而 Map 的 value 即为 clazz 对应的对象的 propertyValue

list = transfterMapListToBeanList(clazz, values);

 

} catch (Exception e) {

e.printStackTrace();

} finally {

JDBCTools.releaseDB(resultSet, preparedStatement, connection);

}

 

return list;

}

 

public <T> List<T> transfterMapListToBeanList(Class<T> clazz,

List<Map<String, Object>> values) throws InstantiationException,

IllegalAccessException, InvocationTargetException {

 

List<T> result = new ArrayList<>();

 

T bean = null;

 

if (values.size() > 0) {

for (Map<String, Object> m : values) {

bean = clazz.newInstance();

for (Map.Entry<String, Object> entry : m.entrySet()) {

String propertyName = entry.getKey();

Object value = entry.getValue();

 

BeanUtils.setProperty(bean, propertyName, value);

}

// 13. 把 Object 对象放入到 list 中.

result.add(bean);

}

}

 

return result;

}

 

/**

 * 处理结果集, 得到 Map 的一个 List, 其中一个 Map 对象对应一条记录

 *

 * @param resultSet

 * @return

 * @throws SQLException

 */

public List<Map<String, Object>> handleResultSetToMapList(

ResultSet resultSet) throws SQLException {

// 5. 准备一个 List<Map<String, Object>>:

// 键: 存放列的别名, 值: 存放列的值. 其中一个 Map 对象对应着一条记录

List<Map<String, Object>> values = new ArrayList<>();

 

List<String> columnLabels = getColumnLabels(resultSet);

Map<String, Object> map = null;

 

// 7. 处理 ResultSet, 使用 while 循环

while (resultSet.next()) {

map = new HashMap<>();

 

for (String columnLabel : columnLabels) {

Object value = resultSet.getObject(columnLabel);

map.put(columnLabel, value);

}

 

// 11. 把一条记录的一个 Map 对象放入 5 准备的 List 中

values.add(map);

}

return values;

}

 

/**

 * 获取结果集的 ColumnLabel 对应的 List

 *

 * @param rs

 * @return

 * @throws SQLException

 */

private List<String> getColumnLabels(ResultSet rs) throws SQLException {

List<String> labels = new ArrayList<>();

 

ResultSetMetaData rsmd = rs.getMetaData();

for (int i = 0; i < rsmd.getColumnCount(); i++) {

labels.add(rsmd.getColumnLabel(i + 1));

}

 

return labels;

}

 

// 返回某条记录的某一个字段的值 或 一个统计的值(一共有多少条记录等.)

public <E> E getForValue(String sql, Object... args) {

//1. 得到结果集: 该结果集应该只有一行, 且只有一列

Connection connection = null;

PreparedStatement preparedStatement = null;

ResultSet resultSet = null;

 

try {

//1. 得到结果集

connection = JDBCTools.getConnection();

preparedStatement = connection.prepareStatement(sql);

 

for (int i = 0; i < args.length; i++) {

preparedStatement.setObject(i + 1, args[i]);

}

 

resultSet = preparedStatement.executeQuery();

if(resultSet.next()){

return (E) resultSet.getObject(1);

}

} catch(Exception ex){

ex.printStackTrace();

} finally{

JDBCTools.releaseDB(resultSet, preparedStatement, connection);

}

//2. 取得结果

return null;

}

 

}

得到生成的主键：

使用prepareStatment的getGeneratedKeys方法得到Resultset结果集

Connection.prepareStatment(sql,Statement.RETURN_GENERATED_KEYS)

ResultSet rs=prepareStatement.getGeneratedKeys

 

数据库中Bob类型

InputStream is= picture.getBinaryStream();(picture 为BLOB对象)

OutputStream os= new FileOutputStream();

Byte[] b= new Byte[1024];

int len;

While((len=is.read(b))!=-1){

   os.write(b,0,len);

}

 

 

 

 

数据库事务：

原子性（最小个体，同时发生） 一致性 （），隔离性（isolation），持久性

 

Oracle和mysql

Oracle不是自动提交，mysql是自动提交。

· 修改表的数据：

Oracle数据库在使用表的数据操作时，需要用sql语句来执行，比如：select * from table for update;这样你才能对数据进行修改，修改完了之后记得点击提交事务按钮。MySql中修改或添加数据就简单得多了，直接就可以设置数据，点击refresh保存就好。、

oracle中事务从上一个commit或rollback开始；

但是MySQL中事务的开始必须要有START TRANSACTION;

或者setAutoCommit(false)这才标志着一个事物的开始，否则使用rollback是无法回滚数据的。

 

· 主键：

MySql一般使用自动增长类型，在创建表的时候只要指定表的主键为auto increment，插入记录时就不需要再为主键添加记录了，主键会自动增长。Oracle中没有自动增长，主键一般使用序列，插入记录时将序列号的下一值付给该字段即可，只是ORM框架只是需要native主键生成策略即可。

· 单引号的处理：

MySql里可以使用双引号来包起字符串，Oracle里要使用单引号包起字符串。

· 分页查询：

　　这个应该是两者最明显的区别了，很多人都知道MySql中分页很简单，因为他有专门的关键字limit来实现分页查询；但是Oracle里面没有这种关键字来实现分页查询的，所以它实现起来就比MySql要繁琐得多了，在每个结果集中只有一个rownum字段标明它的位置，并且只能用rownum<=某个数，不能用rownum>=某个数，因为ROWNUM是伪列，在使用时所以需要为ROWNUM取一个别名，变成逻辑列，然后来操作。

 

· 事务隔离级别：connection.setTransactionIsolation();

脏读（某线程回滚） 幻读（插入行 ）  不可重复读（更新某字段）

Oracle支持两种隔离级别：READ COMMITED, SERIALIZABLE. Oracle 默认的事务隔离级别为: READ COMMITED

Mysql支持四种事务隔离级别： Mysql 默认的事务隔离级别为: REPEATABLE READ

 

 

JDBC批量处理

 

 

 

 

 

理论

 

 

JDBC(java database connection)

/**

 * 1. 获取连接的方法. 通过读取配置文件从数据库服务器获取一个连接.

 *

 * @return

 * @throws Exception

 */

public static Connection getConnection() throws Exception {

// 1. 准备连接数据库的 4 个字符串.

// 1). 创建 Properties 对象

Properties properties = new Properties();

 

// 2). 获取 jdbc.properties 对应的输入流

InputStream in = JDBCTools.class.getClassLoader().getResourceAsStream(

"jdbc.properties");

 

// 3). 加载 2） 对应的输入流

properties.load(in);

 

// 4). 具体决定 user, password 等4 个字符串.

String user = properties.getProperty("user");

String password = properties.getProperty("password");

String jdbcUrl = properties.getProperty("jdbcUrl");

String driver = properties.getProperty("driver");

 

// 2. 加载数据库驱动程序(对应的 Driver 实现类中有注册驱动的静态代码块.)

Class.forName(driver);

 

// 3. 通过 DriverManager 的 getConnection() 方法获取数据库连接.

return DriverManager.getConnection(jdbcUrl, user, password);

}