一、连接mysql数据库
步骤：
1、启动 MySQL ：以管理员身份打开 cmd 命令行，输入 net start mysql
2、在 MySQL 创建一张表，用于后面的操作。我这里创建了一张 user 表，有id、name、password三个字段。
3、导入jar包
(1)创建新项目，在项目下创建lib包，用于存放所需要的jar包
(2)拷贝 mysql 驱动包 mysql-connector-j-8.0.31.jar 到 lib 目录下。右键jar包，点击 添加为库。
添加后 jar 包旁出现一个小三角，可以点开查看里面的内容，此时导入成功。
mysql 驱动 jar 包下载：
官网：https://dev.mysql.com/downloads/
CSDN：mysql-connector-j-8.0.31-Java文档类资源-CSDN文库
4、创建类 Demo01.java,用于编写数据库连接的代码
5、注册驱动
Class.forName("com.mysql.cj.jdbc.Driver"); 6、获取数据库连接对象
方法1：
private static final String URL = "jdbc:mysql://localhost:3306/db1";
private static final String USER = "root";
private static final String PASSWORD = "root";
... ...
Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);方法2：
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");方法3：
Properties p = new Properties();
p.setProperty("user","root");
p.setProperty("password","root")
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);【注意】需要填写3个参数，分别是数据库连接URL、用户名、密码，需要填写你自己的。
其中URL的构成：
jdbc:mysql:// localhost:3306 / db1
协议 IP地址 端口 要连接的数据库名称7、获取执行SQL语句的对象
Statement stat = conn.createStatement();8、执行SQL语句
增删改：executeUpdate
stat.executeUpdate("insert into user value(1,'admin','root')");
stat.executeUpdate("update user set name = 'sunny' where id = 1");
stat.executeUpdate("delete from user where id = 1");查：executeQuery
ResultSet rs = stat.executeQuery("select * from user");
while (rs.next()){
int id = rs.getInt("id");
String name = rs.getString("name");
String password = rs.getString("password");
System.out.println("id="+id+",name="+name+",password="+password);
}方法解析：
- rs.next —— 判断结果集是否有下一条记录，返回boolean类型。
- rs.getInt —— 可以传入String或者int类型的参数，String类型的参数为数据表的对应列名，int类型的参数则为数据表的对应列数，推荐传入String类型。返回int类型的数据。
- rs. getString —— 可以传入String或者int类型的参数，String类型的参数为数据表的对应列名，int类型的参数则为数据表的对应列数，推荐传入String类型。返回String类型的数据。
9、释放连接
rs.close();
stat.close();
conn.close();完整代码：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class Demo01 {
private static final String URL = "jdbc:mysql://localhost:3306/db1";
private static final String USER = "root";
private static final String PASSWORD = "root";
public static void main(String[] args) throws Exception {
// 注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 获取数据库连接对象
// 方法1
Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
// 方法2
/*Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1?user=root&password=root");*/
// 方法3
/*
Properties p = new Properties();
p.setProperty("user","root");
p.setProperty("password","root")
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", p);
*/
// 获取执行SQL语句的对象
Statement stat = conn.createStatement();
// 执行SQL语句
stat.executeUpdate("insert into user value(1,'admin','root')");
stat.executeUpdate("update user set name = 'sunny' where id = 1");
stat.executeUpdate("delete from user where id = 1");
ResultSet rs = stat.executeQuery("select * from user");
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
String password = rs.getString("password");
System.out.println("id=" + id + ",name=" + name + ",password=" + password);
}
// 释放连接
rs.close();
stat.close();
conn.close();
}
}
二、编写使用工具类
观察上面的代码我们可以发现，除了执行SQL的语句有所不同外，其他代码的格式基本上都是固定的。我们可以编写一个工具类，提供 获取数据库连接对象、关闭数据库相关资源 等相关方法。
1、编写工具类 JdbcUtils.java
创建 Utils 文件夹，将代码相关的工具类都放到里面。编写JdbcUtils.java，代码首先运行静态代码块类的语句，获得数据库连接对象。
import java.sql.*;
public class JdbcUtils {
private static final String driver = "com.mysql.cj.jdbc.Driver";
private static final String url = "jdbc:mysql://localhost:3306/db1";
private static final String name = "root";
private static final String password = "root";
private static final Connection conn;
static {
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, name, password);
} catch (ClassNotFoundException | SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 获取数据库连接对象
* @return 数据库连接对象
*/
public static Connection getConnect() {
return conn;
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param ps sql语句执行对象
* @param rs 查询结果集
*/
public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
if (conn != null) conn.close();
if (ps != null) ps.close();
if (rs != null) rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param ps sql语句执行对象
*/
public static void close(Connection conn, PreparedStatement ps) {
close(conn, ps, null);
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param rs 查询结果集
*/
public static void close(Connection conn, ResultSet rs) {
close(conn, null, rs);
}
}
2、解耦代码
分析工具类，可以发现关于数据库连接的相关参数，如 driver、url、user、password 等均写在代码中，程序的耦合性较高。可以将变量写在 .properties文件中，程序通过读取文件的方式获得相关信息。
首先创建 jdbc.properties 资源包，以 “ 键=值 ” 的形式写入相关参数。
jdbc.properties
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db1
name=root
password=rootJdbcUtils.java
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
private static final String driver;
private static final String url;
private static final String name;
private static final String password;
static {
try {
Properties p = new Properties();
p.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
driver = p.getProperty("driver");
url = p.getProperty("url");
name = p.getProperty("name");
password = p.getProperty("password");
Class.forName(driver);
} catch (ClassNotFoundException | IOException e) {
throw new RuntimeException(e);
}
}
/**
* 获取数据库连接对象
* @return 数据库连接对象
* @throws Exception 获取失败
*/
public static Connection getConnect() throws Exception {
return DriverManager.getConnection(url, name, password);
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param ps sql语句执行对象
* @param rs 查询结果集
*/
public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
if (conn != null) conn.close();
if (ps != null) ps.close();
if (rs != null) rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param ps sql语句执行对象
*/
public static void close(Connection conn, PreparedStatement ps) {
close(conn, ps, null);
}
/**
* 关闭数据库相关资源
* @param conn 数据库连接对象
* @param rs 查询结果集
*/
public static void close(Connection conn, ResultSet rs) {
close(conn, null, rs);
}
}
3、使用工具类
import Utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
public class JdbcUtilsDemo {
public static void main(String[] args) throws Exception {
query();
}
public static void query() throws Exception {
Connection conn = JdbcUtils.getConnect();
Statement stat = conn.createStatement();
ResultSet rs = stat.executeQuery("select * from user");
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
String password = rs.getString("password");
System.out.println("id=" + id + ",name=" + name + ",password=" + password);
}
JdbcUtils.close(conn, rs);
}
}
三、使用数据库连接池
数据库连接池是存储数据库连接对象的容器，你可以想象成一个已经提前 装好数个连接对象的池子。当你需要 连接对象 时，可以直接从池子获取，用完归还即可。这样当程序在运行的时候，不用自己去创建数据库连接对象，从而提高了运行效率。常用的JDBC连接池有C3P0、Druid。
1、简单的数据库连接池
编写一个简陋的 数据库连接池，用于理解原理。
import Utils.JdbcUtils;
import java.sql.Connection;
import java.util.LinkedList;
public class SimpleConnectPool {
private static LinkedList<Connection> pool = new LinkedList<>();
static {
try {
for (int i = 1; i <= 5; i++) {
// 获取数据库连接对象
Connection conn = JdbcUtils.getConnect();
// 将连接对象放到 pool 中
pool.add(conn);
}
} catch (Exception e) {
System.out.println("数据库连接池初始化失败!");
}
}
// 提供 获取数据库连接对象 的方法（pool删除）
public static synchronized Connection getConnect(){
if(pool.size() > 0){
return pool.removeFirst();
}
throw new RuntimeException("数据库连接池中 对象已用完");
}
// 提供 归还数据库连接对象 的方法（pool添加）
public static void close(Connection conn){
pool.addLast(conn);
}
}
使用该连接池
import java.sql.Connection;
public class SimpleConnectPoolDemo {
public static void main(String[] args) {
for (int i = 1; i <= 6; i++) {
Connection conn = SimpleConnectPool.getConnect();
System.out.printf("第" + i + "次获取:" + conn+"\n");
if (i == 3) {
SimpleConnectPool.close(conn);
System.out.printf("第" + i + "次归还:" + conn+"\n");
}
}
}
}
2、使用 C3P0 数据库连接池
步骤：
（1）导入jar包。导入方式和mysql驱动包的导入一样，注意这次除了要导入一个jar包外，还需要导入一个 xml 配置文件，即如下2个文件。
C3P0下载：c3p0-0.9.5.2-Java文档类资源-CSDN文库
（2）编写 c3p0-config.xml 配置文件。打开 c3p0-config.xml ，将里面与数据库连接相关的4个参数修改为自己的。C3P0会根据这个配置文件中的参数连接你的mysql数据库。
【注意】该配置文件需放在 src 目录下。
<?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/db1</property>
<property name="user">root</property>
<property name="password">root</property>
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">10</property>
<property name="checkoutTimeout">3000</property>
</default-config>
<named-config name="otherc3p0">
</named-config>
</c3p0-config>（3）创建 C3P0Demo1 类，编写相关代码。
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo1 {
public static void main(String[] args) throws SQLException {
// 创建数据库连接池对象
DataSource dataSource = new ComboPooledDataSource();
// 获取数据库连接对象
Connection conn = dataSource.getConnection();
System.out.println(conn);
// 归还连接
conn.close();
}
}（4）你也可以不编写 c3p0-config.xml 配置文件，直接在代码中设置数据库连接相关参数。创建 C3P0Demo2 类，编写相关代码。
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;
public class C3P0Demo2 {
public static void main(String[] args) throws PropertyVetoException, SQLException {
// 创建数据库连接池对象
ComboPooledDataSource dataSource = new ComboPooledDataSource();
// 配置参数信息
dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1");
dataSource.setUser("root");
dataSource.setPassword("root");
// 获取数据库连接对象
Connection conn = dataSource.getConnection();
System.out.println(conn);
// 归还连接
conn.close();
}
}3、使用 Druid 数据库连接池
步骤：
（1）导入jar包。导入方式和mysql驱动包的导入一样，注意这次除了要导入一个jar包外，还需要导入一个 properties 配置文件，即如下2个文件。
Druid下载：druid-1.0.9-Java文档类资源-CSDN文库
(2)编写 druid.properties 配置文件。打开 druid.properties ，将里面与数据库连接相关的参数修改为自己的。Druid会根据这个配置文件中的参数连接你的mysql数据库。
【注意】该配置文件需放在 src 目录下。
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db1
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
filters=stat
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
validationQuery=SELECT 1
testWhileIdle=true
testOnBorrow=false
testOnReturn=false
poolPreparedStatements=false
maxPoolPreparedStatementPerConnectionSize=200（3）创建 DruidDemo1 类，编写相关代码。
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.util.Properties;
public class DruidDemo1 {
public static void main(String[] args) throws Exception {
// 创建数据库连接池对象
Properties p = new Properties();
p.load(DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
// 获取数据库连接对象
Connection conn = dataSource.getConnection();
System.out.println(conn);
// 归还连接
conn.close();
}
}
（4）同样的，你也可以不编写 druid.properties 配置文件，直接在代码中设置数据库连接相关参数。创建 DruidDemo2 类，编写相关代码。
import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
public class DruidDemo2 {
public static void main(String[] args) throws Exception {
// 创建数据库连接池对象
DruidDataSource dataSource = new DruidDataSource();
// 配置参数信息
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/db1");
dataSource.setUsername("root");
dataSource.setPassword("root");
// 获取数据库连接对象
Connection conn = dataSource.getConnection();
System.out.println(conn);
// 归还连接
conn.close();
}
}4、编写 Druid 工具类
当然，你可以像上面的 JdbcUtils 一样编写 Druid 的工具类。工具类代码放在 Utils 目录下。我这里使用的是编写配置文件的方式，配置文件不用改变。
package Utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class DruidUtils {
public static DataSource dataSource;
static {
try {
Properties p = new Properties();
p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
dataSource = DruidDataSourceFactory.createDataSource(p);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 获取数据库连接池对象的方法
public static DataSource getDataSource() {
return dataSource;
}
// 获取数据库连接对象的方法
public static Connection getConnection() throws Exception {
return dataSource.getConnection();
}
// 归还数据库连接对象的方法
public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
// 归还数据库连接对象
if (conn != null) conn.close();
// 释放sql语句执行对象
if (ps != null) ps.close();
// 释放查询结果集
if (rs != null) rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
使用：
package Pool;
import Utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class DruidUtilsDemo3 {
public static void main(String[] args) throws Exception {
// 获取数据库连接对象
Connection conn = DruidUtils.getConnection();
// 获取执行sql语句执行对象
PreparedStatement ps = conn.prepareStatement("select * from user");
// 执行sql语句,获得结果集
ResultSet rs = ps.executeQuery();
// 解析结果集
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
String password = rs.getString("password");
System.out.println("id=" + id + ",name=" + name + ",password=" + password);
}
// 归还连接,释放sql语句执行对象、结果集
DruidUtils.close(conn,ps,rs);
}
}四、使用JavaTemplate
JavaTemplate是由Spring框架对JDBC进行封装的基于ORM思想的工具类，他可以帮助我们简化代码。
1.ORM 对象关系映射思想（Object Relational Mapping）
以我们浏览网站为例，当我们向网站的服务器发送请求（例如登录操作），服务器会收到我们请求相关的信息（例如登录的用户名、密码）。ORM的思想是先将这些信息封装到一个名为user的类中，这个类中的字段比如id,name,password等，会和数据库中表的列名一一对应。通过JDBC的解封装、反射等技术，将数据传递给数据库以及返回给服务器。
2、简单使用
步骤：
（1）导入jar包。需要导入5个包，包名如下：
JavaTemplate下载：JdbcTemplate-Java文档类资源-CSDN文库
（2）创建 User 类，类中的字段 和 你的数据库里面的表 一一对应。这段代码推荐使用工具自动生成，尽量不要自己写。
public class User {
private int id;
private String name;
private String password;
public User() {
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setPassword(String password) {
this.password = password;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public String getPassword() {
return password;
}
@Override
public String toString() {
return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
}
}
【注意】不要忘记无参构造！不要忘记漏了setXXX()、getXXX()方法！
（3）创建 JdbcTemplateDemo 类，编写相关代码
（4）创建数据库连接池对象（C3P0或者Druid）
C3P0:
DataSource dataSource = new ComboPooledDataSource();Druid:
Properties p = new Properties();
p.load(JdbcTemplateDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(p);（5）创建JdbcTemplate对象，将数据库连接池对象封装到JdbcTemplate对象
方式1：通过JdbcTemplate的有参构造赋值
JdbcTemplate jt = new JdbcTemplate(dataSource);方式2：通过JdbcTemplate的setDataSource方法赋值
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);(6)执行 sql 语句
增删改：
User user = new User(1,"admin","1234");
jt.update("insert into user value (?,?,?)",user.getId(),user.getName(),user.getPassword());
jt.update("update user set name = ? where id = ?", user.getName(), user.getId());
jt.update("delete from user where id = ?", user.getId());查：
- 查询一条数据
int id = 1; // 仅为简单示范
User user = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
System.out.println(user);- 查询多条记录
List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
for (User a : users) System.out.println(a);- 查询一个数据 : 查询 id=1 的 name 值
int id = 1; // 仅为简单示范
String name = jt.queryForObject("select name from user where id = ?", String.class, id);
System.out.println(name);- 查询一个数据 : 查询表中有多少条记录
int count = jt.queryForObject("select count(*) from user",int.class);
System.out.println(count);(7)所有代码：
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.util.List;
public class JdbcTemplateDemo {
public static void main(String[] args) throws Exception {
// 1.创建数据库连接池对象
/* C3P0 */
DataSource dataSource = new ComboPooledDataSource();
/* Druid */
/*
Properties p = new Properties();
p.load(JdbcTemplateDemo.class.getClassLoader().getResourceAsStream("druid.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(p);
*/
// 2.创建 JdbcTemplate 对象,将数据库连接池封装到 JdbcTemplate 对象
/* 方法一 : 提供有参构造赋值 */
// JdbcTemplate jt = new JdbcTemplate(dataSource);
/* 方法二 : 通过setDataSource赋值 */
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(dataSource);
// 3.执行 sql 语句
/* 增删改 */
User user1 = new User(1,"admin","1234"); // 仅为简单示范
jt.update("insert into user value (?,?,?)", user1.getId(), user1.getName(),user1.getPassword());
jt.update("update user set name = ? where id = ?", user1.getName(), user1.getId());
jt.update("delete from user where id = ?", user1.getId());
/* 查 */
// 查询一条数据
int id = 1; // 仅为简单示范
User user2 = jt.queryForObject("select * from user where id = ?",new BeanPropertyRowMapper<>(User.class),id);
System.out.println(user2);
// 查询多条记录
List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
for (User a : users) System.out.println(a);
// 查询一个数据 : 查询 id=1 的 name 值
String name = jt.queryForObject("select name from user where id = ?", String.class, 1);
System.out.println(name);
// 查询一个数据 : 查询表中有多少条记录
int count = jt.queryForObject("select count(*) from user",int.class);
System.out.println(count);
}
}public class User {
private int id;
private String name;
private String password;
public User() {
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setPassword(String password) {
this.password = password;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public String getPassword() {
return password;
}
@Override
public String toString() {
return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
}
}3、实际项目中的使用
项目结构：
（1）UserDao类
import java.util.List;
public interface UserDao {
// 添加用户
void add(User user);
// 修改用户
void update(User user);
// 删除用户
void delete(int id);
// 查询所有
List<User> findAll();
// 查询一条数据
User findById(int id);
}（2）UserDaoImpl 类
import Utils.DruidUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
public class UserDaoImpl implements UserDao {
// 创建 JdbcTemplate 对象
private final JdbcTemplate jt = new JdbcTemplate(DruidUtils.getDataSource());
@Override
public void add(User user) {
jt.update("insert into user values(?,?,?)", user.getId(), user.getName(), user.getPassword());
}
@Override
public void update(User user) {
jt.update("update user set name = ?,password = ? where id = ?", user.getName(), user.getPassword(), user.getId());
}
@Override
public void delete(int id) {
jt.update("delete from user where id = ?", id);
}
@Override
public List<User> findAll() {
List<User> users = jt.query("select * from user", new BeanPropertyRowMapper<>(User.class));
return users;
}
@Override
public User findById(int id) {
User user = jt.queryForObject("select * from user where id = ?", new BeanPropertyRowMapper<>(User.class), id);
return user;
}
}（3）User 类
import java.io.Serializable;
public class User implements Serializable {
private int id;
private String name;
private String password;
public User() {
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setPassword(String password) {
this.password = password;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public String getPassword() {
return password;
}
@Override
public String toString() {
return "User{" + "id=" + id + ", name='" + name + '\'' + ", password='" + password + '\'' + '}';
}
}
（4）DruidUtils 类
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class DruidUtils {
public static DataSource dataSource;
static {
try {
Properties p = new Properties();
p.load(DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
dataSource = DruidDataSourceFactory.createDataSource(p);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 获取数据库连接池对象的方法
public static DataSource getDataSource() {
return dataSource;
}
// 获取数据库连接对象的方法
public static Connection getConnection() throws Exception {
return dataSource.getConnection();
}
// 归还数据库连接对象的方法
public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
try {
// 归还数据库连接对象
if (conn != null) conn.close();
// 释放sql语句执行对象
if (ps != null) ps.close();
// 释放查询结果集
if (rs != null) rs.close();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
（5）UserTest 类
import org.junit.Test;
import java.util.List;
public class UserTest {
// 创建 Dao 对象
private final UserDao userDao = new UserDaoImpl();
@Test
public void add() {
User user = new User(1, "ketty", "eee");
userDao.add(user);
}
@Test
public void update() {
User user = new User(1, "hello", "root");
userDao.update(user);
}
@Test
public void delete() {
userDao.delete(1);
}
@Test
public void findAll() {
List<User> users = userDao.findAll();
for (User a : users) {
System.out.println(a);
}
}
@Test
public void findById() {
User user = userDao.findById(1);
System.out.println(user);
}UserTest 类中使用了 JUnit 的 @Test ，以便更快进行测试。你也可以在main方法中进行测试。
