Java中级/JDBC/2

最新推荐文章于 2021-02-05 23:02:51 发布

fan__lee

最新推荐文章于 2021-02-05 23:02:51 发布

阅读量159

点赞数

分类专栏： JDBC 文章标签： jdbc

本文链接：https://blog.csdn.net/fan__lee/article/details/108762216

版权

JDBC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了JDBC中execute和executeUpdate的区别，包括它们在增删改查操作上的应用。讨论了如何获取自增长ID以及数据库表的元数据。此外，还探讨了事务处理的重要性，演示了在MySQL中不使用和使用事务的场景。最后，展示了ORM思想在DAO设计模式中的应用，以及数据库连接池的概念和基本原理。

摘要由CSDN通过智能技术生成

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=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()){
             
            //模拟时耗１秒的数据库ＳＱＬ语句
            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 反过来：不使用连接池插入数据-------报错，连接次数资源用完

fan__lee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中级/JDBC/2

文章目录execute与executeUpdate的区别相同点不同点execute与executeUpdate的区别相同点execute与executeUpdate的相同点：都可以执行增加，删除，修改 try (Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8","root", "admin"); Sta
复制链接

扫一扫