JDBC（Java Data Base Connectivity,java数据库连接）是一种用于运行SQL语句的Java API。能够为多种关系数据库提供统一訪问。它由一组用Java语言编写的类和接口组成。
说白了，它用于直接调用 SQL 命令。
主要步骤：
1.载入JDBC驱动程序
2.建立于数据库的连接
3.创建一个Statement。加入相关參数
4.运行SQL语句
5.处理运行结果
6.关闭JDBC的对象
几个重要的类：
（1）
public class DriverManager extends Object
管理一组 JDBC 驱动程序的基本服务。
主要方法是：
public static Connection getConnection(String url,String user,String password)throws SQLException
试图建立到给定数据库 URL 的连接。DriverManager 试图从已注冊的 JDBC 驱动程序集中选择一个适当的驱动程序。
（2）
public interface PreparedStatement extends Statement
表示预编译的 SQL 语句的对象。 SQL 语句被预编译并存储在PreparedStatement对象中。然后能够使用此对象多次高效地运行该语句。
与Statement接口相比，Statement用于运行静态 SQL 语句并返回它所生成结果的对象。
主要方法是：
1. void setObject(int parameterIndex,Object x) throws SQLException
使用给定对象设置指定參数的值。事实上就是为SQL语句占位符的设定实际參数。
2. intexecuteUpdate() throws SQLException
在此 PreparedStatement 对象中运行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比方 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比方 DDL 语句。
返回：
(1) SQL 数据操作语言 (DML) 语句的行数 (2) 对于无返回内容的 SQL 语句，返回 0
3. ResultSet executeQuery() throws SQLException
在此 PreparedStatement 对象中运行 SQL 查询。并返回该查询生成的 ResultSet 对象。
返回：
包括该查询生成的数据的 ResultSet 对象；不会返回 null
（3）
留意运行executeUpdate()和executeQuery()方法返回的值发现executeQuery()返回的是一个结果集对象。
public interface ResultSet extends Wrapper
表示数据库结果集的数据表，通常通过运行查询数据库的语句生成。
主要方法是：
1. ResultSetMetaData getMetaData() throws SQLException
获取此ResultSet对象的列的编号、类型和属性。
而ResultSetMetaData的主要方法就是 int getColumnCount() 返回此 ResultSet 对象中的列数； String getColumnName(int column) 获取指定列的名称。
2. Object getObject(int columnIndex) throws SQLException
以 Java 编程语言中 Object 的形式获取此 ResultSet 对象的当前行中指定列的值。
实例一：MySql+JDBC
Windows用户能够再http://dev.mysql.com/downloads/windows/installer/下载MySql的自己主动配置安装版
使用Navicat作为MySql的数据库管理工具
另外还须要下载JDBC驱动程序http://dev.mysql.com/downloads/connector/j/，project须要引用里面的jar包
①新建一个工具类JdbcUtils
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
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;
public class JdbcUtils {
// 数据库的登陆账号password
private final String USERNAME = "root";
private final String PASSWORD = "123456";
// JDBC驱动程序
private final String DRIVER = "com.mysql.jdbc.Driver";
// 数据库地址
private final String URL = "jdbc:mysql://localhost:3306/test";
// 三个重要类的对象
private Connection connection;
private PreparedStatement ps;
private ResultSet resultSet;
public JdbcUtils() {
try {
// 步骤1：载入驱动程序
Class.forName(DRIVER);
// 步骤2：建立连接，这里的处理是当实例化这个工具类对象时就完毕这两个步骤
connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
} catch (ClassNotFoundException e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
} catch (SQLException e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
}
}
// 封装的update函数
public int update(String sql, List<Object> params) throws SQLException {
int result = 0;
// 步骤3：创建一个Statement。加入相关參数
ps = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++)
// 注意数据库的下标都是从1開始的，第i个占位符填充params的第i个值
ps.setObject(i + 1, params.get(i));
}
// 步骤4：运行SQL语句，步骤5和6则留给client处理
result = ps.executeUpdate();
return result;
}
// 封装的query函数。返回的是List套个Map，数据库是以键值对的形式存储的
public List<Map<String, Object>> query(String sql, List<Object> params)
throws SQLException {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
// 步骤3：创建一个Statement，加入相关參数
ps = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++)
ps.setObject(i + 1, params.get(i));
}
// 步骤4：运行SQL语句
resultSet = ps.executeQuery();
// 步骤5：处理运行结果
// 获取此ResultSet对象的列的属性
ResultSetMetaData metaData = resultSet.getMetaData();
// 列的长度
int col_len = metaData.getColumnCount();
// 若有下一条记录
while (resultSet.next()) {
// 将该条记录以map形式存储
Map<String, Object> map = new HashMap<String, Object>();
for (int i = 0; i < col_len; i++) {
// 依据列名获得键值并存放在map中
String col_name = metaData.getColumnName(i + 1);
Object col_value = resultSet.getObject(col_name);
map.put(col_name, col_value);
}
// 将该记录加入到list中
list.add(map);
}
// 遍历完resultSet返回list
return list;
}
// 封装步骤6关闭JDBC对象
public void release() {
if (resultSet != null)
try {
resultSet.close();
} catch (SQLException e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
}
if (ps != null)
try {
ps.close();
} catch (SQLException e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
}
if (connection != null)
try {
connection.close();
} catch (SQLException e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
}
}
}
②TestMain类
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class TestMain {
public static void main(String[] args) {
// TODO 自己主动生成的方法存根
JdbcUtils jdbcUtils = new JdbcUtils();
/*运行一:新建表*/
// String sql0 =
// "create table userinfo(id int primary key auto_increment, username varchar(64), password varchar(64))";
// try {
// jdbcUtils.update(sql0, null);
// } catch (SQLException e) {
// // TODO 自己主动生成的 catch 块
// e.printStackTrace();
// }
/*运行二：添加一条记录*/
// String sql = "insert into userinfo (username,password) values(?,?)";
// List<Object> params = new ArrayList<Object>();
// params.add("jack");
// params.add("123456");
// try {
// jdbcUtils.update(sql, params);
// } catch (SQLException e) {
// // TODO 自己主动生成的 catch 块
// e.printStackTrace();
// }
/*运行三：改动一条记录*/
// String sql1 = "update userinfo set username = ? where id = ?";
// List<Object> param1 = new ArrayList<Object>();
// param1.add("tommy");
// param1.add(2);
// try {
// jdbcUtils.update(sql1, param1);
// } catch (SQLException e) {
// // TODO 自己主动生成的 catch 块
// e.printStackTrace();
// }
/*运行四：删除一条记录*/
// String sql2 = "delete from userinfo where username = 'tommy'";
// try {
// jdbcUtils.update(sql2, null);
// } catch (SQLException e) {
// // TODO 自己主动生成的 catch 块
// e.printStackTrace();
// }
/*运行五：查询全部记录*/
// String sql3 = "select * from userinfo";
// try {
// List<Map<String, Object>> list = jdbcUtils.query(sql3, null);
// System.out.println(list);
// } catch (SQLException e) {
// // TODO 自己主动生成的 catch 块
// e.printStackTrace();
// }
}
}
运行步骤一：创建一个新的表（下面说的运行步骤没有说明的话都是指单独运行，其它步骤都凝视掉）
运行步骤二：创建一个表。有三个字段，id是主键
连续运行步骤三两次：添加两条记录
运行步骤四：将第二条记录改动
运行步骤五：删除第二条记录
运行步骤六：查询到一条记录
再次运行步骤一和步骤五：查询到多条记录
实例二：应用反射机制来实现查询数据库记录
①新建一个和数据库字段匹配的类UserInfo
public class UserInfo {
private int id;
private String username;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "UserInfo [id=" + id + ", username=" + username + ", password="
+ password + "]";
}
}
②在JdbcUtils类中加入一个应用反射机制的数据库查询函数
public <T> List<T> queryRef(String sql, List<Object> params, Class<T> cls)
throws Exception {
List<T> list = new ArrayList<>();
ps = connection.prepareStatement(sql);
if (params != null && !params.isEmpty()) {
for (int i = 0; i < params.size(); i++)
ps.setObject(i + 1, params.get(i));
}
resultSet = ps.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int col_len = metaData.getColumnCount();
while (resultSet.next()) {
// 存在记录时，实例化一个对象
T record = cls.newInstance();
for (int i = 0; i < col_len; i++) {
String col_name = metaData.getColumnName(i + 1);
Object col_value = resultSet.getObject(col_name);
// 将列相应的值赋给对象的相应字段
Field field = cls.getDeclaredField(col_name);
field.setAccessible(true);
field.set(record, col_value);
}
// 将这条记录加入到List中
list.add(record);
}
return list;
}③TestMain类，加入一个运行操作
/*运行六：反射机制查询记录*/
String sqlQuery = "select * from userinfo";
try {
List<UserInfo> list = jdbcUtils.queryRef(sqlQuery, null,
UserInfo.class);
System.out.println(list);
} catch (Exception e) {
// TODO 自己主动生成的 catch 块
e.printStackTrace();
} finally {
jdbcUtils.release();
}运行步骤六