文章目录
execute与executeUpdate的区别
相同点
execute
与executeUpdate
的相同点:都可以执行增加,删除,修改
try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8","root", "admin");
Statement s = c.createStatement();) {
String sqlInsert = "insert into Hero values (null,'盖伦',616,100)";
String sqlDelete = "delete from Hero where id = 100";
String sqlUpdate = "update Hero set hp = 300 where id = 100";
// 相同点:都可以执行增加,删除,修改
s.execute(sqlInsert);
s.execute(sqlDelete);
s.execute(sqlUpdate);
s.executeUpdate(sqlInsert);
s.executeUpdate(sqlDelete);
s.executeUpdate(sqlUpdate);
不同点
不同1:
execute
可以执行查询语句
然后通过getResultSet
,把结果集取出来
executeUpdate
不能执行查询语句
不同2:
execute
返回boolean
类型,true
表示执行的是查询语句,false
表示执行的是insert
,delete
,update
等等
executeUpdate
返回的是int
,表示有多少条数据受到了影响
// 不同1:execute可以执行查询语句
// 然后通过getResultSet,把结果集取出来
String sqlSelect = "select * from hero";
s.execute(sqlSelect);
ResultSet rs = s.getResultSet();
while (rs.next()) {
System.out.println(rs.getInt("id"));
}
// executeUpdate不能执行查询语句
// s.executeUpdate(sqlSelect);
// 不同2:
// execute返回boolean类型,true表示执行的是查询语句,false表示执行的是insert,delete,update等等
boolean isSelect = s.execute(sqlSelect);
System.out.println(isSelect);
// executeUpdate返回的是int,表示有多少条数据受到了影响
String sqlUpdate = "update Hero set hp = 300 where id < 100";
int number = s.executeUpdate(sqlUpdate);
System.out.println(number);
特殊操作
获取自增长id
在Statement
通过execute
或者executeUpdate
执行完插入语句后,MySQL
会为新插入的数据分配一个自增长id
,(前提是这个表的id
设置为了自增长,在Mysql
创建表的时候,AUTO_INCREMENT
就表示自增长)
CREATE TABLE hero (
id int(11) AUTO_INCREMENT,
...
}
但是无论是execute
还是executeUpdate
都不会返回这个自增长id是多少。需要通过Statement
的getGeneratedKeys
获取该id
注: 第20行的代码,后面加了个Statement.RETURN_GENERATED_KEYS
参数,以确保会返回自增长ID
。 通常情况下不需要加这个,有的时候需要加,所以先加上,保险一些
PreparedStatement ps = c.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestJDBC {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
String sql = "insert into hero values(null,?,?,?)";
try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8","root", "admin");
PreparedStatement ps = c.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
) {
ps.setString(1, "盖伦");
ps.setFloat(2, 616);
ps.setInt(3, 100);
// 执行插入语句
ps.execute();
// 在执行完插入语句后,MySQL会为新插入的数据分配一个自增长id
// JDBC通过getGeneratedKeys获取该id
ResultSet rs = ps.getGeneratedKeys();
if (rs.next()) {
int id = rs.getInt(1);
System.out.println(id);
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
获取表的元数据
元数据概念:
和数据库服务器相关的数据,比如数据库版本,有哪些表,表有哪些字段,字段类型是什么等等。
package jdbc;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestJDBC {
public static void main(String[] args) throws Exception {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8","root", "admin");) {
// 查看数据库层面的元数据
// 即数据库服务器版本,驱动版本,都有哪些数据库等等
DatabaseMetaData dbmd = c.getMetaData();
// 获取数据库服务器产品名称
System.out.println("数据库产品名称:\t"+dbmd.getDatabaseProductName());
// 获取数据库服务器产品版本号
System.out.println("数据库产品版本:\t"+dbmd.getDatabaseProductVersion());
// 获取数据库服务器用作类别和表名之间的分隔符 如test.user
System.out.println("数据库和表分隔符:\t"+dbmd.getCatalogSeparator());
// 获取驱动版本
System.out.println("驱动版本:\t"+dbmd.getDriverVersion());
System.out.println("可用的数据库列表:");
// 获取数据库名称
ResultSet rs = dbmd.getCatalogs();
while (rs.next()) {
System.out.println("数据库名称:\t"+rs.getString(1));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
练习自增长id
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
String sql = "insert into hero values(null,?,?,?)";
try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8",
"root", "123");
Statement s = c.createStatement();
PreparedStatement ps = c.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
) {
ps.setString(1, "船长");
ps.setFloat(2, 3130f);
ps.setInt(3, 100);
ps.execute();
ResultSet rs = ps.getGeneratedKeys();
int id = -1;
if (rs.next()) {
id = rs.getInt(1);
System.out.println("刚刚插入数据的id是:" + id);
}
int temp = id - 1;
String sql_delete = "delete from hero where id =" + temp;
while (true) {
// 查询上一条数据是否存在
ResultSet rs1 = s.executeQuery("select id from hero where id =" + temp);
if (rs1.next()) {
System.out.println("id = " + temp + "数据存在");
s.execute(sql_delete);
System.out.println("id = " + temp + "该数据已删除");
break;
} else
temp--;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
事物
不使用事务的情况
没有事务的前提下
假设业务操作是:加血,减血各做一次
结束后,英雄的血量不变
而减血的SQL
不小心写错写成了 updata(而非update)
那么最后结果是血量增加了,而非期望的不变
//没有事务的前提下
//假设业务操作时,加血,减血各做一次
//结束后,英雄的血量不变
//加血的SQL
String sql1 = "update hero set hp = hp +1 where id = 22";
s.execute(sql1);
//减血的SQL
//不小心写错写成了 updata(而非update)
String sql2 = "updata hero set hp = hp -1 where id = 22";
s.execute(sql2);
使用事务
在事务中的多个操作,要么都成功,要么都失败
通过 c.setAutoCommit(false);
关闭自动提交
使用 c.commit();
进行手动提交
在22行-35行之间的数据库操作,就处于同一个事务当中,要么都成功,要么都失败
所以,虽然第一条SQL
语句是可以执行的,但是第二条SQL
语句有错误,其结果就是两条SQL
语句都没有被提交。 除非两条SQL
语句都是正确的。
// 有事务的前提下
// 在事务中的多个操作,要么都成功,要么都失败
c.setAutoCommit(false);
// 加血的SQL
String sql1 = "update hero set hp = hp +1 where id = 22";
s.execute(sql1);
// 减血的SQL
// 不小心写错写成了 updata(而非update)
String sql2 = "updata hero set hp = hp -1 where id = 22";
s.execute(sql2);
// 手动提交
c.commit();
MYSQL 表的类型必须是INNODB才支持事务
在Mysql
中,只有当表的类型是INNODB
的时候,才支持事务,所以需要把表的类型设置为INNODB
,否则无法观察到事务.
修改表的类型为INNODB
的SQL
:
alter table hero ENGINE = innodb;
查看表的类型的SQL
show table status from how2java;
不过有个前提,就是当前的MYSQL
服务器本身要支持INNODB
,如果不支持,请看 开启MYSQL INNODB的办法
ORM
ORM=Object Relationship Database Mapping
对象和关系数据库的映射
简单说,一个对象,对应数据库里的一条记录
根据id返回一个Hero对象
Hero.java
package charactor;
public class Hero {
//增加id属性
public int id;
public String name;
public float hp;
public int damage;
}
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import charactor.Hero;
public class TestJDBC {
public static Hero get(int id) {
Hero hero = null;
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8","root", "admin");
Statement s = c.createStatement();) {
String sql = "select * from hero where id = " + id;
ResultSet rs = s.executeQuery(sql);
// 因为id是唯一的,ResultSet最多只能有一条记录
// 所以使用if代替while
if (rs.next()) {
hero = new Hero();
String name = rs.getString(2);
float hp = rs.getFloat("hp");
int damage = rs.getInt(4);
hero.name = name;
hero.hp = hp;
hero.damage = damage;
hero.id = id;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return hero;
}
public static void main(String[] args) {
Hero h = get(22);
System.out.println(h.name);
}
}
练习ROM
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
/**
* 根据ORM的思想,设计其他几个常见的ORM方法:
把一个Hero对象插入到数据库中
public static void add(Hero h)
把这个Hero对象对应的数据删除掉
public static void delete(Hero h)
更新这条Hero对象
public static void update(Hero h)
把所有的Hero数据查询出来,转换为Hero对象后,放在一个集合中返回
public static List<Hero> list();
*/
public class TestJDBC {
//初始化以及数据库连接
@SuppressWarnings("unused")
private static Connection start() throws SQLException{
try {
Class.forName("com.mysql.jdbc.Driver");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Connection c = DriverManager.getConnection(
"jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8",
"root", "admin");
return c;
}
//返回数据库的hero集合
private static List<Hero> list(){
ArrayList<Hero> hList1 = new ArrayList<>();
Hero h = null;
String sqlQuery = "select * from hero";
try( Connection c = start();
Statement s = c.createStatement();
){
ResultSet rs = s.executeQuery(sqlQuery);
while(rs.next()){
h = new Hero();
h.id = rs.getInt(1);
h.name = rs.getString(2);
h.hp = rs.getFloat(3);
h.damage = rs.getInt(4);
hList1.add(h);
}
}catch (SQLException e) {
// TODO: handle exception
e.printStackTrace();
}
return hList1;
}
// 把Hero对象插入到数据库中
public static void add(Hero h){
String sqlinsert = "insert into hero values(?,?,?,?)";
try(
Connection c = start();
PreparedStatement ps = c.prepareStatement(sqlinsert);
){
ps.setInt(1,h.id);
ps.setString(2, h.name);
ps.setFloat(3, h.hp);
ps.setInt(4, h.damage);
ps.execute();
}catch (SQLException e) {
// TODO: handle exception
e.printStackTrace();
}
}
// 根据id查询对应英雄
public static Hero get_hero(int id){
Hero h = null;
String sqlget = "select * from hero where id = "+id+"";
try(
Connection c = start();
Statement s = c.createStatement();
){
ResultSet rs = s.executeQuery(sqlget);
if (rs.next()) {
h = new Hero();
h.id = rs.getInt(1);
h.name = rs.getString(2);
h.hp = rs.getFloat(3);
h.damage = rs.getInt(4);
}
}catch (SQLException e) {
// TODO: handle exception
e.printStackTrace();
}
return h;
}
// 更新英雄信息
private static void update(Hero h) {
String sql = "update hero set name = ? , hp =? , damage = ? where id = ?";
try (
Connection c = start();
PreparedStatement ps = c.prepareStatement(sql);
){
ps.setString(1, h.name);
ps.setFloat(2, h.hp);
ps.setInt(3, h.damage);
ps.setInt(4, h.id);
ps.execute();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 删除英雄
private static void delete(Hero h) {
String sql = "delete from hero where id = ?";
try (
Connection c = start();
PreparedStatement ps = c.prepareStatement(sql);
){
ps.setInt(1, h.id);
ps.execute();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args){
// 查询总数据个数
List<Hero> hlist = list();
System.out.printf("共有%d条数据%n",hlist.size());
// 插入
Hero h = new Hero();
h.id = 10;
h.name = "第"+h.id+"英雄";
h.hp = 580.65f;
h.damage = 120;
System.out.println("添加一条数据");
add(h);
hlist = list();
System.out.printf("数据库中总共有%d条数据\n",hlist.size());
//更新
int id = 6;
//取得第id个英雄的信息
h = get_hero(id);
System.out.printf("英雄id = %d,名字是%s,hp = %f,damage = %d%n",h.id,h.name,h.hp,h.damage);
h.name = "维克托";
update(h);
System.out.printf("删除id = %d的数据%n",h.id);
delete(h);
//最后的结果
hlist = list();
System.out.printf("数据库中总共有%d条数据",hlist.size());
}
}
DAO
DAO = DataAccess Object
数据访问对象
实际上就是运用了练习-ORM中的思路,把数据库相关的操作都封装在这个类里面,其他地方看不到JDBC的代码
DAO接口
package jdbc;
import java.util.List;
import charactor.Hero;
public interface DAO{
//增加
public void add(Hero hero);
//修改
public void update(Hero hero);
//删除
public void delete(int id);
//获取
public Hero get(int id);
//查询
public List<Hero> list();
//分页查询
public List<Hero> list(int start, int count);
}
HeroDAO
设计类HeroDAO
,实现接口DAO
这个HeroDAO
和答案-ORM很接近,做了几个改进:
- 把驱动的初始化放在了构造方法
HeroDAO
里:
public HeroDAO() {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
因为驱动初始化只需要执行一次,所以放在这里更合适,其他方法里也不需要写了,代码更简洁
- 提供了一个
getConnection
方法返回连接
所有的数据库操作都需要事先拿到一个数据库连接Connection
,以前的做法每个方法里都会写一个,如果要改动密码,那么每个地方都需要修改。 通过这种方式,只需要修改这一个地方就可以了。 代码变得更容易维护,而且也更加简洁。
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import charactor.Hero;
public class HeroDAO implements DAO{
public HeroDAO() {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public Connection getConnection() throws SQLException {
return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8", "root",
"admin");
}
public int getTotal() {
int total = 0;
try (Connection c = getConnection(); Statement s = c.createStatement();) {
String sql = "select count(*) from hero";
ResultSet rs = s.executeQuery(sql);
while (rs.next()) {
total = rs.getInt(1);
}
System.out.println("total:" + total);
} catch (SQLException e) {
e.printStackTrace();
}
return total;
}
public void add(Hero hero) {
String sql = "insert into hero values(null,?,?,?)";
try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
ps.setString(1, hero.name);
ps.setFloat(2, hero.hp);
ps.setInt(3, hero.damage);
ps.execute();
ResultSet rs = ps.getGeneratedKeys();
if (rs.next()) {
int id = rs.getInt(1);
hero.id = id;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
public void update(Hero hero) {
String sql = "update hero set name= ?, hp = ? , damage = ? where id = ?";
try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
ps.setString(1, hero.name);
ps.setFloat(2, hero.hp);
ps.setInt(3, hero.damage);
ps.setInt(4, hero.id);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
public void delete(int id) {
try (Connection c = getConnection(); Statement s = c.createStatement();) {
String sql = "delete from hero where id = " + id;
s.execute(sql);
} catch (SQLException e) {
e.printStackTrace();
}
}
public Hero get(int id) {
Hero hero = null;
try (Connection c = getConnection(); Statement s = c.createStatement();) {
String sql = "select * from hero where id = " + id;
ResultSet rs = s.executeQuery(sql);
if (rs.next()) {
hero = new Hero();
String name = rs.getString(2);
float hp = rs.getFloat("hp");
int damage = rs.getInt(4);
hero.name = name;
hero.hp = hp;
hero.damage = damage;
hero.id = id;
}
} catch (SQLException e) {
e.printStackTrace();
}
return hero;
}
public List<Hero> list() {
return list(0, Short.MAX_VALUE);
}
public List<Hero> list(int start, int count) {
List<Hero> heros = new ArrayList<Hero>();
String sql = "select * from hero order by id desc limit ?,? ";
try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
ps.setInt(1, start);
ps.setInt(2, count);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
Hero hero = new Hero();
int id = rs.getInt(1);
String name = rs.getString(2);
float hp = rs.getFloat("hp");
int damage = rs.getInt(4);
hero.id = id;
hero.name = name;
hero.hp = hp;
hero.damage = damage;
heros.add(hero);
}
} catch (SQLException e) {
e.printStackTrace();
}
return heros;
}
}
练习-ItemDAO
设计一个ItemDAO,实现了DAO接口,提供相应的功能实现Item类的ORM
public class Main {
public static void main(String[] args) {
HeroDAO heroDAO=new HeroDAO();
List<Hero> heroList= heroDAO.list(10,5);
Hero hero=heroList.get(0);
System.out.println("数据个数::"+ heroList.size());
System.out.println("id:"+hero.id+" name:"+hero.name+" hp:"+hero.hp+" damage:"+hero.damage);
}
}
class Hero{
String name;
int id;
int damage;
float hp;
String Upname;
int Upid;
int Updamage;
float Uphp;
}
interface DAO{
//增加
public void add(Hero hero);
//修改
public void update(Hero hero);
//删除
public void delete(int id);
//获取
public Hero get(int id);
//查询
public List<Hero> listall();
//分页查询
public List<Hero> list(int start, int count);
}
class HeroDAO implements DAO{
HeroDAO(){
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public Connection getconnection(){
try {
Connection c=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8",
"root", "admin");
return c;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
@Override
public void add(Hero hero) {
String sqll="insert into hero values(null,?,?,?)";
try (Connection connection =getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
ps.setString(1, hero.name);
ps.setFloat(2, hero.hp);
ps.setInt(3, hero.damage);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
@Override
public void update(Hero hero) {
String sqll="update hero set name=?,hp=?,damage=? where id=? and name=? and hp=? and damage=?";
try (Connection connection = getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
Hero hero2=get(hero.id);
if (hero.Upname==null){
ps.setString(1, hero2.name);
}else {
ps.setString(1, hero.Upname);
}
if (hero.Uphp==0){
ps.setFloat(2, hero2.hp);
}else {
ps.setFloat(2, hero.Uphp);
}
if (hero.Updamage == 0) {
ps.setInt(3, hero2.damage);
}else{
ps.setInt(3, hero.Updamage);
}
ps.setString(5, hero.name);
ps.setFloat(6, hero.hp);
ps.setInt(7, hero.damage);
ps.setInt(4, hero.id);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
@Override
public void delete(int id) {
String sqll="delete from hero where id=?";
try (Connection connection =getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
ps.setInt(1, id);
ps.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
@Override
public Hero get(int id) {
Hero hero=new Hero();
String sqll="select * from hero where id=?";
try (Connection connection = getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
ps.setInt(1,id);
ResultSet set=ps.executeQuery();
while(set.next()){
hero.id=set.getInt("id");
hero.name=set.getString("name");
hero.hp=set.getFloat("hp");
hero.damage=set.getInt("damage");
}
} catch (SQLException e) {
e.printStackTrace();
}
return hero;
}
@Override
public List<Hero> listall() {
List<Hero> listhero=new ArrayList<>();
String sqll="select * from hero";
try (Connection connection = getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
ResultSet set=ps.executeQuery();
while(set.next()){
Hero hero=new Hero();
hero.name=set.getString("name");
hero.id=set.getInt("id");
hero.hp=set.getFloat("hp");
hero.damage=set.getInt("damage");
listhero.add(hero);
}
} catch (SQLException e) {
e.printStackTrace();
}
return listhero;
}
@Override
public List<Hero> list(int start, int count) {
List<Hero> listhero=new ArrayList<>();
String sqll="select * from hero limit ?,? ";
try (Connection connection =getconnection();
PreparedStatement ps = connection.prepareStatement(sqll);
) {
ps.setInt(1,start);
ps.setInt(2,count);
ResultSet set=ps.executeQuery();
while(set.next()){
Hero hero=new Hero();
hero.id=set.getInt("id");
hero.name=set.getString("name");
hero.hp=set.getFloat("hp");
hero.damage=set.getInt("damage");
System.out.println(hero.name);
listhero.add(hero);
}
} catch (SQLException e) {
e.printStackTrace();
}
return listhero;
}
}
数据库连接池
与线程池类似的,数据库也有一个数据库连接池。 不过他们的实现思路是不一样的。
本章节讲解了自定义数据库连接池类:ConnectionPool
,虽然不是很完善和健壮,但是足以帮助大家理解ConnectionPool
的基本原理
数据库连接池原理-传统方式
当有多个线程,每个线程都需要连接数据库执行SQL语句的话,那么每个线程都会创建一个连接,并且在使用完毕后,关闭连接。
创建连接和关闭连接的过程也是比较消耗时间的,当多线程并发的时候,系统就会变得很卡顿。
同时,一个数据库同时支持的连接总数也是有限的,如果多线程并发量很大,那么数据库连接的总数就会被消耗光,后续线程发起的数据库连接就会失败。
数据库连接池原理-使用池
与传统方式不同,连接池在使用之前,就会创建好一定数量的连接。
如果有任何线程需要使用连接,那么就从连接池里面借用,而不是自己重新创建. 使用完毕后,又把这个连接归还给连接池供下一次或者其他线程使用。
倘若发生多线程并发情况,连接池里的连接被借用光了,那么其他线程就会临时等待,直到有连接被归还回来,再继续使用。
整个过程,这些连接都不会被关闭,而是不断的被循环使用,从而节约了启动和关闭连接的时间。
ConnectionPool构造方法和初始化
ConnectionPool()
构造方法约定了这个连接池一共有多少连接- 在init() 初始化方法中,创建了size条连接。 注意,这里不能使用
try-with-resource
这种自动关闭连接的方式,因为连接恰恰需要保持不关闭状态,供后续循环使用 getConnection
, 判断是否为空,如果是空的就wait等待,否则就借用一条连接出去returnConnection
, 在使用完毕后,归还这个连接到连接池,并且在归还完毕后,调用notifyAll
,通知那些等待的线程,有新的连接可以借用了。
注:连接池设计用到了多线程的wait和notifyAll,可以在多线程交互章节查阅学习。
package jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class ConnectionPool {
List<Connection> cs = new ArrayList<Connection>();
int size;
public ConnectionPool(int size) {
this.size = size;
init();
}
public void init() {
//这里恰恰不能使用try-with-resource的方式,因为这些连接都需要是"活"的,不要被自动关闭了
try {
Class.forName("com.mysql.jdbc.Driver");
for (int i = 0; i < size; i++) {
Connection c = DriverManager
.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8", "root", "admin");
cs.add(c);
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public synchronized Connection getConnection() {
while (cs.isEmpty()) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Connection c = cs.remove(0);
return c;
}
public synchronized void returnConnection(Connection c) {
cs.add(c);
this.notifyAll();
}
}```
### 测试类
首先初始化一个有3条连接的数据库连接池
然后创建100个线程,每个线程都会从连接池中借用连接,并且在借用之后,归还连接。 拿到连接之后,执行一个耗时1秒的SQL语句。
运行程序,就可以观察到如图所示的效果
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200924110236768.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbl9fbGVl,size_16,color_FFFFFF,t_70#pic_center)
```sql
package jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import jdbc.ConnectionPool;
public class TestConnectionPool {
public static void main(String[] args) {
ConnectionPool cp = new ConnectionPool(3);
for (int i = 0; i < 100; i++) {
new WorkingThread("working thread" + i, cp).start();
}
}
}
class WorkingThread extends Thread {
private ConnectionPool cp;
public WorkingThread(String name, ConnectionPool cp) {
super(name);
this.cp = cp;
}
public void run() {
Connection c = cp.getConnection();
System.out.println(this.getName()+ ":\t 获取了一根连接,并开始工作" );
try (Statement st = c.createStatement()){
//模拟时耗1秒的数据库SQL语句
Thread.sleep(1000);
st.execute("select * from hero");
} catch (SQLException | InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
cp.returnConnection(c);
}
}
练习-数据库连接池
向数据库中插入100条数据,比较传统方式和数据库连接池方式的性能差异
- 使用传统方式创建100个线程,每个线程都会创建新的连接,通过这个连接向数据库插入1条数据,然后关闭这个连接。
- 使用数据库连接池的方式,创建一个有10条连接的连接池,然后创建100个线程,每个线程都会向连接池借用连接,借用到后,向数据库插入1条数据,然后归还这个连接。
通过时间统计,比较这两种方式的性能表现差异。
单次执行: 使用连接池插入数据的时间为:71 不使用连接池插入数据的时间为:86 两个一起执行: 先使用连接池插入数据的时间为:80
后不使用连接池插入数据的时间为:44 反过来: 不使用连接池插入数据-------报错,连接次数资源用完