489
社区成员




目录
JDBC的概念
JDBC的优势
JDBC访问数据库的方式
JDBC在应用程序与数据库之间起到了一个桥梁作用,当应用程序使用JDBC访问特定的数据库时,需要通过不同数据库驱动与不同的数据库进行连接,连接后即可对数据库进行相应的操作。
Driver接口
DriverManager接口
方法名称 |
功能描述 |
registerDriver(Driver driver) |
该方法用于向DriverManager中注册给定的JDBC驱动程序 |
getConnection(String url,String user,String pwd) |
该方法用于建立和数据库的连接,并返回表示连接的Connection对象 |
Connection接口
方法名称 |
功能描述 |
getMetaData() |
用于返回表示数据库元数据的DatabaseMetaData对象 |
createStatement() |
用于创建一个Statement对象并将SQL语句发送到数据库 |
prepareStatement(String sql) |
用于创建一个PreparedStatement对象并将参数化的SQL语句发送到数据库 |
prepareCall(String sql) |
用于创建一个CallableStatement对象来调用数据库存储过程 |
Statement接口
方法名称 |
功能描述 |
execute(String sql) |
用于执行各种SQL语句,该方法返回一个boolean类型的值,如果为true,表示所执行的SQL语句有查询结果,可通过Statement的getResultSet()方法获得查询结果 |
executeUpdate(String sql) |
用于执行SQL中的insert、update和delete语句。该方法返回一个int类型的值,表示数据库中受该SQL语句影响的记录条数 |
executeQuery(String sql) |
用于执行SQL中的select语句,该方法返回一个表示查询结果的ResultSet对象 |
PreparedStatement接口的出现
PreparedStatement接口的介绍
PreparedStatement接口的常用方法
方法名称 |
功能描述 |
executeUpdate() |
在此PreparedStatement对象中执行SQL语句,该语句必须是一个DML语句或者是无返回内容的SQL语句,比如 DDL 语句 |
executeQuery() |
在此PreparedStatement对象中执行SQL查询,该方法返回的是ResultSet对象 |
setInt(int parameterIndex, int x) |
将指定参数设置为给定的int值 |
setFloat(int parameterIndex, float x) |
将指定参数设置为给定的float值 |
setString(int parameterIndex, String x) |
将指定参数设置为给定的String值 |
setDate(int parameterIndex, Date x) |
将指定参数设置为给定的Date值 |
addBatch() |
将一组参数添加到此PreparedStatement对象的批处理命令中 |
setCharacterStream(int parameterIndex, java.io.Reader reader,int length) |
将指定的输入流写入数据库的文本字段 |
setBinaryStream(int parameterIndex, java.io.InputStream x, int length) |
将二进制的输入流数据写入到二进制字段中 |
需要注意的是,setDate()方法可以设置日期内容,但参数Date的类型是java.sql.Date,而不是java.util.Date。在通过setter()方法为SQL语句中的参数赋值时,可以通过参数与SQL类型相匹配的方法(例如,如果参数类型为Integer,那么应该使用setInt()方法),也可以通过setObject()方法设置多种类型的输入参数。通过setter()方法为SQL语句中的参数赋值,具体示例代码如下所示:
String sql = "INSERT INTO users(id,name,email) VALUES(?,?,?)";
PreparedStatement preStmt = conn.prepareStatement(sql);
preStmt.setInt(1, 1); //使用参数与SQL类型相匹配的方法
preStmt.setString(2, "zhangsan"); //使用参数与SQL类型相匹配的方法
preStmt.setObject(3, "zs@sina.com"); //使用setObject()方法设置参数
preStmt.executeUpdate();
ResultSet接口的介绍
next()
方法移动游标到下一行。next()
返回false。ResultSet接口的常用方法
方法名称 |
功能描述 |
getString(int columnIndex) |
用于获取指定字段的String类型的值,参数columnIndex代表字段的索引 |
getString(String columnName) |
用于获取指定字段的String类型的值,参数columnName代表字段的名称 |
getInt(int columnIndex) |
用于获取指定字段的int类型的值,参数columnIndex代表字段的索引 |
getInt(String columnName) |
用于获取指定字段的int类型的值,参数columnName代表字段的名称 |
getDate(int columnIndex) |
用于获取指定字段的Date类型的值,参数columnIndex代表字段的索引 |
getDate(String columnName) |
用于获取指定字段的Date类型的值,参数columnName代表字段的名称 |
方法名称 |
功能描述 |
next() |
将游标从当前位置向下移一行 |
absolute(int row) |
将游标移动到此 ResultSet 对象的指定行 |
afterLast() |
将游标移动到此 ResultSet 对象的末尾,即最后一行之后 |
beforeFirst() |
将游标移动到此 ResultSet 对象的开头,即第一行之前 |
previous() |
将游标移动到此 ResultSet 对象的上一行 |
last() |
将游标移动到此 ResultSet 对象的最后一行 |
ResultSet接口中方法的使用
步骤一:加载并注册数据库驱动
DriverManager.registerDriver(Driver driver);
或
Class.forName("DriverName");
步骤二:通过DriverManager获取数据库连接
Connection conn = DriverManager.getConnection(String url, String user, String pwd);
getConnection()方法有3个参数,它们分别表示连接数据库的URL地址、登录数据库的用户名和密码。以MySQL数据库为例,MySQL 5.5及之前版本,其URL地址的书写格式如下:
jdbc:mysql://hostname:port/databasename
MySQL数据库的时区设定
MySQL 5.6及之后版本的MySQL数据库的时区设定比中国时间早8个小时,需要在URL地址后面指定时区,具体如下所示:
jdbc:mysql://hostname:port/databasename?serverTimezone=GMT%2B8
上面代码中:
步骤三:通过Connection对象获取Statement对象
通过Connection对象获取Statement对象的方式有如下三种:
以创建基本的Statement对象为例,创建方式如下:
Statement stmt = conn.createStatement();
步骤四:使用Statement对象执行SQL语句
所有的Statement对象都有如下三种执行SQL语句的方法:
以executeQuery()方法为例,其使用方式如下:
// 执行SQL语句,获取结果集ResultSet
ResultSet rs = stmt.executeQuery(sql);
步骤五:操作ResultSet结果集
如果执行的SQL语句是查询语句,执行结果将返回一个ResultSet对象,该对象保存了SQL语句查询的结果。程序可以通过操作该ResultSet对象获取查询结果。
// 遍历ResultSet对象,获取查询结果
while (rs.next()) {
// 通过列名或索引获取查询结果的数据
int id = rs.getInt("id");
String name = rs.getString("name");
// 其他操作...
}
步骤六:关闭连接,释放资源
每次操作数据库结束后都要关闭数据库连接,释放资源,包括ResultSet、Statement和Connection等资源。
// 关闭ResultSet对象
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 关闭Statement对象
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
// 关闭Connection对象
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
编写JDBC程序从users表中读取数据,并将结果打印在控制台,具体步骤如下所示。
步骤一:搭建数据库环境
在MySQL中创建一个名称为jdbc的数据库,然后在该数据库中创建一个users表,再向users表中插入3条数据。
步骤二:创建项目环境,导入数据库驱动
在IDEA中创建一个名称为chapter10的Web项目,将下载好的MySQL数据库驱动文件mysql-connector-java-8.0.15-bin.jar复制到项目的lib目录中。加入驱动后的项目结构如下图所示。
创建项目环境,导入数据库驱动
将MySQL的数据库驱动添加到项目的lib目录之后,在IDEA菜单栏单击【File】→【Project Structure】→【libraries 】,进入Project Structure窗口,如下图所示。
在上图中,单击【+】→【Java】,进入【Select Library Files】窗口,选择项目中lib目录下的MySQL的数据库驱动JAR包,将MySQL的数据库驱动发布到项目的类路径下,如下图所示。
在上图中,单击“OK”按钮,返回Project Structure窗口,如下图所示。
在上图中,单击【Apply】→【OK】按钮完成数据驱动的导入。至此,MySQL的数据库驱动就成功发布到项目的类路径下了。
步骤三:编写JDBC程序
在项目chapter10的src目录下,创建一个名称为cn.itcast.jdbc.example的包,在该包中创建类Example01,该类用于读取数据库中的users表,并将读取到的数据输出到控制台。
package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Date;
public class Example01 {
public static void main(String[] args) throws SQLException {
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
try {
// 1. 注册数据库的驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 2.通过DriverManager获取数据库连接
String url = "jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8";
String username = "root";//数据库名称
String password = "root";//数据库密码
conn = DriverManager.getConnection (url, username,
password);
// 3.通过Connection对象获取Statement对象
stmt = conn.createStatement();
// 4.使用Statement执行SQL语句。
String sql = "select * from users";
rs = stmt.executeQuery(sql);
// 5. 操作ResultSet结果集
System.out.println("id | name | password | email | birthday");
while (rs.next()) {
int id = rs.getInt("id"); // 通过列名获取指定字段的值
String name = rs.getString("name");
String psw = rs.getString("password");
String email = rs.getString("email");
Date birthday = rs.getDate("birthday");
System.out.println(id + " | " + name + " | " + psw + " | " + email
+ " | " + birthday);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally{
// 6.回收数据库资源
if(rs!=null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
rs = null;
}
if(stmt!=null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
stmt = null;
}
if(conn!=null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null;
}
}
}
}
步骤四:执行程序,查看结果
控制台的效果如下
实现JDBC程序需要注意的地方—注册驱动
实现JDBC程序需要注意的地方—释放资源
使用Statement对象实现的弊端
解决Statement对象实现的弊端
Statement提供了一个子类PreparedStatement。PreparedStatement对象可以对SQL语句进行预编译,预编译的信息会存储在PreparedStatement对象中。当相同的SQL语句再次执行时,程序会使用PreparedStatement对象中的数据,而不需要对SQL语句再次编译去查询数据库,这样就大大提高了数据的访问效率。
步骤一:
在chapter10项目的cn.itcast.jdbc.example包中创建一个名称为Example02的类,在该类中使用PreparedStatement对象对数据库进行插入数据的操作。
package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement ;
import java.sql.SQLException;
public class Example02 {
public static void main(String[] args) throws SQLException {
Connection conn = null;
PreparedStatement preStmt = null;
try {
// 加载数据库驱动
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8";
String username = "root";
String password = "root";
// 创建应用程序与数据库连接的Connection对象
conn = DriverManager.getConnection(url, username, password);
// 执行的SQL语句
String sql = "INSERT INTO users(name,password,email,birthday)"
+ "VALUES(?,?,?,?)";
// 1.创建执行SQL语句的PreparedStatement对象
preStmt = conn.prepareStatement(sql);
// 2.为SQL语句中的参数赋值
preStmt.setString(1, "zl");
preStmt.setString(2, "123456");
preStmt.setString(3, "zl@sina.com");
preStmt.setString(4, "1989-12-23");
// 3.执行SQL
preStmt.executeUpdate();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally { // 释放资源
if (preStmt != null) {
try {
preStmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
preStmt = null;
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null;
}
}
}
}
Example02.java运行成功后,会在users表中插入一条数据。进入MySQL数据库,使用SELECT语句查看users表,查询结果如下图所示:
解决Statement对象实现的弊端
Statement st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENITIVE,ResultSet.CONCUR_READ_ONLY);
ResultSet rs = st.excuteQuery(sql);
在上述方式中,常量“Result.TYPE_SCROLL_INSENITIVE”表示结果集可滚动,常量“ResultSet.CONCUR_READ_ONLY”表示以只读形式打开结果集。
步骤一:
在chapter10项目的cn.itcast.jdbc.example包中创建一个名称为Example03的类,在该类中使用ResultSet对象取出指定数据的信息。
package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Example03 {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8";
String username = "root";
String password = "root";
//1.获取Connection对象
conn = DriverManager.getConnection(url, username, password);
String sql = "select * from users";
//2.创建Statement对象并设置常量
stmt =conn.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
//3.执行SQL并将获取的数据信息存放在ResultSet中
ResultSet rs = stmt.executeQuery(sql);
//4.取出ResultSet中指定数据的信息
System.out.print("第2条数据的name值为:");
rs.absolute(2); //将指针定位到结果集中第2行数据
System.out.println(rs.getString("name"));
System.out.print("第1条数据的name值为:");
rs.beforeFirst(); //将指针定位到结果集中第1行数据之前
rs.next(); //将指针向后滚动
System.out.println(rs.getString("name"));
System.out.print("第4条数据的name值为:");
rs.afterLast(); //将指针定位到结果集中最后一条数据之后
rs.previous(); //将指针向前滚动
System.out.println(rs.getString("name"));
} catch (Exception e) {
e.printStackTrace();
} finally { // 释放资源
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
stmt = null;
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null;
}
}
}
}
步骤二:
运行结果如下图所示。
思维导图
JDBC连接数据库的缺陷
数据库连接池技术
连接池连接数据库的原理图
连接池连接数据库的原理图的解释
DataSource接口的方法
为了获取数据库连接对象(Connection),JDBC提供了javax.sql.DataSource接口,javax.sql.DataSource接口负责与数据库建立连接,并定义了返回值为Connection对象的方法,具体如下。
注意:上述两个重载的方法,都能用来获取Connection对象。不同的是,第一个方法是通过无参的方式建立与数据库的连接,第二个方法是通过传入登录信息的方式建立与数据库的连接。
DataSource接口的实现类
BasicDataSource
(Apache Commons DBCP)。数据源的解释
DBCP数据库连接池
commons-dbcp2.jar
commons-pool2.jar包
commons-pool2.jar包包含的核心类
BasicDataSource类的常用方法
方法名称 |
功能描述 |
void setDriverClassName(String driverClassName) |
设置连接数据库的驱动名称 |
void setUrl(String url) |
设置连接数据库的路径 |
void setUsername(String username) |
设置数据库的登录账号 |
void setPassword(String password) |
设置数据库的登录密码 |
void setInitialSize(int initialSize) |
设置数据库连接池初始化的连接数目 |
void setMinIdle(int minIdle) |
设置数据库连接池最小闲置连接数目 |
Connection getConnection() |
从连接池中获取一个数据库连接 |
BasicDataSourceFactory工厂类
BasicDataSourceFactory
:创建BasicDataSource对象的工厂类。createDataSource()
:读取配置创建数据源。创建数据源对象—通过BasicDataSource类直接创建数据源对象
在使用BasicDataSource类创建数据源对象时,需要手动给数据源对象设置属性值,然后获取数据库连接对象。
C3P0数据库连接池
ComboPooledDataSource类的常用方法
方法名称 |
功能描述 |
void setDriverClass() |
设置连接数据库的驱动名称 |
void setJdbcUrl() |
设置连接数据库的路径 |
void setUser() |
设置数据库的登录账号 |
void setPassword() |
设置数据库的登录密码 |
void setMaxPoolSize() |
设置数据库连接池最大连接数目 |
void setMinPoolSize() |
设置数据库连接池最小连接数目 |
void setInitialPoolSize() |
设置数据库连接池初始化的连接数目 |
Connection getConnection() |
从数据库连接池中获取一个连接 |
使用C3P0数据库连接池
1. 通过ComboPooledDataSource()构造方法创建数据源对象
步骤一:在chapter11中导入jar包并编写代码
package cn.itcast.chapter11.example;
import java.sql.SQLException;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class Example03 {
public static DataSource ds = null;
// 初始化C3P0数据库连接池
static {
ComboPooledDataSource cpds = new ComboPooledDataSource();
// 设置连接数据库需要的配置信息
try {
cpds.setDriverClass("com.mysql.cj.jdbc.Driver");
cpds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8");
cpds.setUser("root");
cpds.setPassword("123456");
//设置连接池的参数
cpds.setInitialPoolSize(5);
cpds.setMaxPoolSize(15);
ds = cpds;
} catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
public static void main(String[] args) throws SQLException {
// 获取数据库连接对象
System.out.println(ds.getConnection());
}
}
步骤二:运行chapter11项目
2. 通过ComboPooledDataSource(String configName)构造方法创建数据源对象
步骤一:在chapter11项目下创建配置文件
在chapter11项目的src根目录下创建一个c3p0-config.xml文件,用于设置数据库的连接信息和数据源的初始化信息。
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
<property name="jdbcUrl">
jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8
</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="checkoutTimeout">30000</property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
<property name="maxStatements">200</property>
</default-config>
<named-config name="itcast">
<property name="driverClass">com.mysql.cj.jdbc.Driver</property>
<property name="jdbcUrl">
jdbc:mysql://localhost:3306/jdbc?serverTimezone=GMT%2B8
</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">15</property>
</named-config>
</c3p0-config>
步骤二:在chapter11项目下创建Example04类并编写代码
package cn.itcast.chapter11.example;
import java.sql.SQLException;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class Example04 {
public static DataSource ds = null;
// 初始化C3P0数据库连接池
static {
// 使用c3p0-config.xml配置文件中的named-config节点中name属性的值
ComboPooledDataSource cpds = new ComboPooledDataSource("itcast");
ds = cpds;
}
public static void main(String[] args) throws SQLException {
System.out.println(ds.getConnection());
}
}
步骤二:运行Example04类
需要注意的是,在使用ComboPooledDataSource(String configName)方法创建数据源对象时必须遵循以下两点:
(1)配置文件名称必须为c3p0-config.xml或者c3p0.properties,并且位于该项目的src根目录下。
(2)当传入的configName值为空或者不存在时,使用默认配置信息创建数据源。
DBUtils工具的作用
DBUtils的核心类库的三个核心API
由上图可知,DBUtils核心类库主要包括DBUtils类、QueryRunner类和ResultSetHandler接口。DBUtils工具主要通过这三个核心API进行JDBC的所有操作。
DBUtils类的作用
DBUtils类主要提供了加载JDBC驱动、关闭资源等方法,DBUtils类中的方法一般为静态方法,可以直接使用类名进行调用。
DBUtils类的常用方法
方法名称 |
功能描述 |
void close(Connection conn) |
当连接不为NULL时,关闭连接 |
void close(Statement stat) |
当声明不为NULL时,关闭声明 |
void close(ResultSet rs) |
当结果集不为NULL时,关闭结果集 |
void closeQuietly(Connection conn) |
当连接不为NULL时,关闭连接,并隐藏一些在程序中抛出的SQL异常 |
void closeQuietly(Statement stat) |
当声明不为NULL时,关闭声明,并隐藏一些在程序中抛出的SQL异常 |
void closeQuietly(ResultSet rs) |
当结果集不为NULL时,关闭结果集,并隐藏一些在程序中抛出的SQL异常 |
void commitAndCloseQuietly( Connection conn) |
提交连接后关闭连接,并隐藏一些在程序中抛出的SQL异常 |
Boolean loadDriver(String driveClassName) |
装载并注册JDBC驱动程序,如果成功就返回true |
QueryRunner类的作用
QueryRunner类的常用方法
方法名称 |
功能描述 |
Object query(Connection conn,String sql,ResultSetHandler rsh,Object[] params) |
执行查询操作,传入的Connection对象不能为空 |
Object query (String sql, ResultSetHandler rsh,Object[] params) |
执行查询操作 |
Object query (Connection conn,String sql, ResultSetHandler rsh) |
执行一个不需要置换参数的查询操作 |
int update(Connection conn, String sql, ResultSetHandler rsh) |
执行一个更新(插入、删除、更新)操作 |
int update(Connection conn, String sql) |
执行一个不需要置换参数的更新操作 |
int batch(Connection conn,String sql, Object[] []params) |
批量添加、修改、删除 |
int batch(String sql, Object[][] params) |
批量添加、修改、删除 |
ResultSetHandler接口中的常见实现类
ResultSetHandler接口用于处理ResultSet结果集,它可以将结果集中的数据转换为不同的形式。根据结果集中不同的数据类型,ResultSetHandler提供了几种常见的实现类。
ResultSetHandler接口中的方法handle (java.sql.ResultSet rs)
ResultSetHandler接口还提供了一个单独的方法handle (java.sql.ResultSet rs),如果上述实现类没有提供想要的功能,可以自定义一个实现ResultSetHandler接口的类,然后通过重写handle()方法,实现结果集的处理。
BeanHandler和BeanListHandler
类名称 |
相同点 |
不同点 |
BeanHandler |
都要先将结果集封装进JavaBean |
封装单条数据,把结果集的第一条数据的字段放入一个JavaBean中 |
BeanListHandler |
封装多条数据,把每条数据的字段值各放入一个JavaBean中,再把所有JavaBean都放入List集合中 |
ColumnListHandler和ScalarHandler
类名称 |
相同点 |
不同点 |
ColumnListHandler |
都是对指定列的查询结果集进行封装 |
封装指定列的所有数据,将他们放入一个List集合中 |
ScalarHandler |
封装单条列数据,也可以封装类似count、avg、max、min、sum等聚合函数的执行结果 |
注意:ColumnListHandler可以对指定列的所有数据进行封装,ScalarHandler主要针对单行单列的数据进行封装。
使用DBUtils实现增删改查的思路
由于每次操作数据库时,都需要加载数据库驱动、建立数据库连接以及关闭数据库连接,为了避免代码的重复书写,需要建立一个专门用于操作数据库的工具类高效地进行用户信息的增删改查。以下是点分简述的过程:
步骤一:搭建开发环境
在jdbc数据库中创建的user表作为数据表,使用DBUtils工具对user表进行增删改查操作。
步骤二:创建JavaBean
在项目chapter11的目录下,创建一个名为cn.itcast.jdbc.javabean的包,创建User.java,使用User.java作为JavaBean。
package cn.itcast.chapter11.example;
public class User {
private int id;
private String name;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
步骤三:创建C3p0Utils工具类
在项目chapter11的src目录下,创建一个名为cn.itcast.jdbc.utils的包,然后在该包下创建C3p0Utils类,用于创建数据源。
package cn.itcast.jdbc.utils;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3p0Utils {
private static DataSource ds;
static {
ds = new ComboPooledDataSource();
}
public static DataSource getDataSource() {
return ds;
}
}
步骤四:创建InsertDao类,完成插入操作
在项目chapter11的src目录下,创建一个名为cn.itcast.jdbc.dao的包,然后在该包下创建一个InsertDao类,实现对user表插入数据的操作。
package cn.itcast.jdbc.dao;
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import cn.itcast.jdbc.javabean.User;
import cn.itcast.jdbc.utils.C3p0Utils;
public class InsertDao {
public static void main(String[] args)throws SQLException{
// 创建QueryRunner对象
QueryRunner runner = new QueryRunner(C3p0Utils.getDataSource());
String sql = "insert into user (name,password) values ('hello1',123456)";
int num = runner.update(sql);
if (num > 0){
System.out.println("添加成功!");
}else{
System.out.println("添加失败!");
}
}
}
运行结果:
向MySQL数据库发送查询语句:
步骤五:创建UpdateDao类,完成修改操作
在cn.itcast.jdbc.dao包下创建一个UpdateDao类,实现对user表数据的修改操作。
package cn.itcast.jdbc.dao;
import cn.itcast.jdbc.javabean.User;
import cn.itcast.jdbc.utils.C3p0Utils;
import org.apache.commons.dbutils.QueryRunner;
import java.sql.SQLException;
public class UpdateDao {
public static void main(String[] args)throws SQLException {
// 创建QueryRunner对象
QueryRunner runner = new QueryRunner(C3p0Utils.getDataSource());
// 写SQL语句
String sql = "update user set name='hello2',password=111111 where name='hello1'";
// 调用方法
int num = runner.update(sql);
if (num > 0){
System.out.println("修改成功!");
}else{
System.out.println("修改失败!");
}
}
}
运行结果:
向MySQL数据库发送查询语句:
步骤六:创建DeleteDao类,完成删除操作
在cn.itcast.jdbc.dao包下创建一个DeleteDao类,实现对user表数据的删除操作。DeleteDao类的实现如下所示。
package cn.itcast.jdbc.dao;
import cn.itcast.jdbc.utils.C3p0Utils;
import org.apache.commons.dbutils.QueryRunner;
import java.sql.SQLException;
public class DeleteDao {
public static void main(String[] args)throws SQLException {
// 创建QueryRunner对象
QueryRunner runner = new QueryRunner(C3p0Utils.getDataSource());
// 写SQL语句
String sql = "delete from user where name='hello2'";
// 调用方法
int num = runner.update(sql);
if (num > 0){
System.out.println("删除成功!");
}else{
System.out.println("删除失败!");
}
}
}
运行结果:
向MySQL数据库发送查询语句:
步骤七:创建QueryDao类,完成查询操作
1. 在cn.itcast.jdbc.dao包下创建一个QueryDao类,实现对user表中单条数据的查询操作:
package cn.itcast.jdbc.dao;
import cn.itcast.jdbc.javabean.User;
import cn.itcast.jdbc.utils.C3p0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import java.sql.SQLException;
public class QueryDao {
public static void main(String[] args)throws SQLException {
// 创建QueryRunner对象
QueryRunner runner = new QueryRunner(C3p0Utils.getDataSource());
// 写SQL语句
String sql = "select * from user where id=2";
// 调用方法
User user = (User) runner.query(sql,new BeanHandler(User.class));
System.out.println(user.getId()+","+user.getName()+","+user.getPassword());
}
}
运行结果:
2. 查询user表中的全部数据:
package cn.itcast.jdbc.dao;
import cn.itcast.jdbc.javabean.User;
import cn.itcast.jdbc.utils.C3p0Utils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.sql.SQLException;
import java.util.List;
public class QueryDao {
public static void main(String[] args)throws SQLException {
// 创建QueryRunner对象
QueryRunner runner = new QueryRunner(C3p0Utils.getDataSource());
/* // 写SQL语句
String sql = "select * from user where id=2";
// 调用方法
User user = (User) runner.query(sql,new BeanHandler(User.class));
System.out.println(user.getId()+","+user.getName()+","+user.getPassword());*/
// 写SQL语句
String sql = "select * from user";
// 调用方法
List<User> list = (List) runner.query(sql,new BeanListHandler(User.class));
for(User user : list){
System.out.println(user.getId()+","+user.getName()+","+user.getPassword());
}
}
}
运行结果:
需要注意的是:
思维导图