1 简介和基础使用 1.1 简介
JDBC：是sun发布的一个java程序和数据库之间通信的规范（接口）
各大数据库厂商去实现JDBC规范（实现类），将这些实现类打成压缩包 ， 就是所谓的jar包
比如：
1.2 创建连接
url：防止中文乱码 ， 加上参数=true&=utf-8 。url的标准格式为：jdbc:mysql://ip:端口号/数据库名称?参数列表
public class Demo01 {public static void main(String[] args) throws ClassNotFoundException, SQLException {//1.添加jar包//2.加载驱动Class.forName("com.mysql.jdbc.Driver");//3.通过驱动管理器获取连接对象//3-1 准备urlString url = "jdbc:mysql://localhost:3306/fruitdb";//3-2 准备用户名String usr = "root";//3-3 准备密码String pwd = "root";Connection connection = DriverManager.getConnection(url,usr,pwd);System.out.println("conn = "+connection);}}
1.3 添加数据
先建立连接之后 ， 得到对象 ， 这个对象相当于建立了一条连接数据库和java之间的马路，通过对象得到预处理对象 ， 这个对象相当于马路上的一辆车，用于运送真实的数据 。
在SQL语句中，使用?当做占位符，再通过预处理对象的set方法为占位符填充内容
最后，记得关闭连接，先关闭预处理对象 ， 再关闭连接对象
public class Demo02 {public static void main(String[] args) throws ClassNotFoundException, SQLException {//1.加载驱动Class.forName("com.mysql.jdbc.Driver");//2.通过驱动管理器获取连接对象//2-1 准备url//url表示和数据库通信的地址，如果需要带参数 ， 则需要使用？进行连接//如果使用多个参数,多个参数之间使用&连接String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf-8";//2-2 准备用户名String usr = "root";//2-3 准备密码String pwd = "root";Connection connection = DriverManager.getConnection(url,usr,pwd);//3. 编写SQL语句//id，fname,price,fcount,remarkString sql = "insert into t_fruit value(0,?,?,?,?)";//4.创建预处理对象PreparedStatement psmt = connection.prepareStatement(sql);//5.填充参数psmt.setString(1,"榴莲");psmt.setInt(2,15);psmt.setInt(3,100);psmt.setString(4,"榴莲是一种神奇的水果");//6.执行更新（增删改） ， 返回影响行数int i = psmt.executeUpdate();System.out.println(i>0?"添加成功！":"添加失败");//7.释放资源psmt.close();connection.close();}}
1.4 更新和删除数据
和添加数据步骤都一样，最后都是预处理对象调用方法并返回影响行数 。因此更新与修改和添加的不同就是SQL语句和预处理设置SQL中的占位符的值而已 。
更新：
Fruit fruit = new Fruit(33, "猕猴桃", "猕猴桃啊猕猴桃");Class.forName("com.mysql.jdbc.Driver");String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf8";Connection connection = DriverManager.getConnection(url, "root", "root");String sql = "update t_fruit set fname=?,remark = ? where fid = ?";PreparedStatement psmt = connection.prepareStatement(sql);psmt.setString(1, fruit.getFname());psmt.setString(2, fruit.getRemark());psmt.setInt(3,fruit.getFid());int i = psmt.executeUpdate();System.out.println(i>0?"修改成功":"修改失败");psmt.close();connection.close();
删除：
Class.forName("com.mysql.jdbc.Driver");String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf8";Connection connection = DriverManager.getConnection(url, "root", "root");String sql = "delete from t_fruit where fid = ?";PreparedStatement psmt = connection.prepareStatement(sql);psmt.setInt(1,33);int i = psmt.executeUpdate();System.out.println(i>0?"删除成功":"删除失败");psmt.close();connection.close();
1.5 增删更新总结 1.5.1 步骤： 加载驱动通过驱动获取连接对象，连接对象相当于连接java与数据库之间的一条马路编写SQL语句 ， 语句中使用占位符创建数据预处理对象，数据预处理对象相当于马路上运送SQL语句的小车填充预处理数据对象的参数执行更新参数，对于增删查都是执行对象的方法 ， 返回影响行数关闭资源，关闭对象和对象 1.6 查询
查询与增删改的不同之处在于：
例如：查询所有数据
//1.加载驱动Class.forName("com.mysql.jdbc.Driver");String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf8";//2.获取连接对象Connection connection = DriverManager.getConnection(url, "root", "root");//3.编写SQL语句String sql = "select * from t_fruit";//4.创建预处理命令对象PreparedStatement psmt = connection.prepareStatement(sql);//5.填充参数，这里没有，略//6.执行查询，返回结果集ResultSet res = psmt.executeQuery();List
查询指定的一条记录：
Class.forName("com.mysql.jdbc.Driver");String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf8";Connection connection = DriverManager.getConnection(url, "root", "root");//编写SQL语句String sql = "select * from t_fruit where fid = ?";//创建预处理命令对象PreparedStatement psmt = connection.prepareStatement(sql);//填充参数psmt.setInt(1,2);//由于fid是主键，所以可以不使用列表 ， 这里改一下//执行查询，返回结果集ResultSet res = psmt.executeQuery();//判断下一行是否有数据，并且指针指到下一行if(res.next()){//表示当前行第一列的数据，因为这一列是int类型的数据，所以使用getIntint fid = res.getInt(1);//也可以通过结果集的列名String fname = res.getString("fname");int price = res.getInt(3);int fcount = res.getInt("fcount");String remark = res.getString("remark");Fruit fruit = new Fruit(fid,fname,price,fcount,remark);System.out.println(fruit);}//释放资源res.close();psmt.close();connection.close();
查询总记录条数：
Class.forName("com.mysql.jdbc.Driver");String url = "jdbc:mysql://localhost:3306/fruitdb?useSSL=false&useUnicode=true&characterEncoding=utf8";Connection connection = DriverManager.getConnection(url, "root", "root");//编写SQL语句String sql = "select count(*) from t_fruit";//创建预处理命令对象PreparedStatement psmt = connection.prepareStatement(sql);//执行查询 ， 返回结果集//这里返回的是一个一行一列的数据ResultSet res = psmt.executeQuery();//判断下一行是否有数据，并且指针指到下一行if(res.next()){int count = res.getInt(1);System.out.println("总记录条数："+count);}//释放资源res.close();psmt.close();connection.close();
1.7 查询总结 1.7.1 查询与增删改的不同之处在于：1.7.2 步骤： 加载驱动通过驱动获取连接对象 ， 连接对象相当于连接java与数据库之间的一条马路编写SQL语句 ， 语句中使用占位符创建数据预处理对象，数据预处理对象相当于马路上运送SQL语句的小车填充预处理数据对象的参数执行更新参数，执行方法返回结果集关闭资源，关闭对象、对象和对象 1.8 批处理
如果一次性添加大量数据，若每一条数据都单独执行一次方法，那么效率很低下，所以可以采用批处理的方法来提高处理的效率 。
批处理操作的步骤：
如果执行批处理任务，需要在添加一个参数： ents=true将数据加入一个批次：psmt.();执行批处理：int[] batch = psmt.();如果继续进行处理 ， 需要进行clear：psmt.clear();
package com.zylai.jdbc01;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.SQLException;import java.util.Arrays;/*** @Author: Zhao YunLai* @Date: 2022/06/21/12:54* @Description: 添加*/public class DemoAddBatch {public static void main(String[] args) throws ClassNotFoundException, SQLException {//1.加载驱动Class.forName("com.mysql.jdbc.Driver");//2.通过驱动管理器获取连接对象//批处理操作一//如果执行批处理任务，需要添加一个参数： rewriteBatchedStatements=trueString url = "jdbc:mysql://localhost:3306/fruitdb?rewriteBatchedStatements=true&useSSL=false&useUnicode=true&characterEncoding=utf-8";//2-2 准备用户名String usr = "root";//2-3 准备密码String pwd = "root";Connection connection = DriverManager.getConnection(url,usr,pwd);//3. 编写SQL语句String sql = "insert into t_fruit value(0,?,?,?,?)";//4.创建预处理对象PreparedStatement psmt = connection.prepareStatement(sql);//5.填充参数for (int i = 0; i < 1000; i++) {psmt.setString(1,"榴莲"+i);psmt.setInt(2,15);psmt.setInt(3,100);psmt.setString(4,"榴莲是一种神奇的水果"+i);//批处理操作二：将数据加入一个批次psmt.addBatch();//每一百个处理一次，分批次处理，每次执行完要记得清空一下队列if(i%100==0){psmt.executeBatch();//记得clear一下psmt.clearBatch();}}//批处理操作三int[] batch = psmt.executeBatch();System.out.println(Arrays.toString(batch));//7.释放资源psmt.close();connection.close();}}
2 工程 2.1 需求概述和整体框架
以实现一个水果库存系统为例 ， 这个系统需要提供水果的增删改查操作
=================欢迎使用水果库存系统=====================1.查看水果库存列表2.添加水果库存信息3.查看特定水果库存信息4.水果下架5.退出======================================================
整体框架如下图 ， 在里面写调用DAO层的方法 ， 在dao里面写持久层方法 ， 提供接口及其实现类，pojo写实体类 ， view是客户端视图操作 。
2.2 最初版本 2.2.1 pojo
pojo包下的Fruit类
package com.zylai.fruit01.pojo;/*** @Author: Zhao YunLai* @Date: 2022/06/21/17:33* @Description:*/public class Fruit {private Integer fid;private String fname;private Integer price;private Integer fcount;private String remark;public Fruit(){}public Fruit(Integer fid, String fname, String remark) {this.fid = fid;this.fname = fname;this.remark = remark;}public Fruit(Integer fid, String fname, Integer price, Integer fcount, String remark) {this.fid = fid;this.fname = fname;this.price = price;this.fcount = fcount;this.remark = remark;}@Overridepublic String toString() {return fid+"\t\t"+fname+"\t\t"+price+"\t\t"+fcount+"\t\t"+remark;}public Integer getFid() {return fid;}public void setFid(Integer fid) {this.fid = fid;}public String getFname() {return fname;}public void setFname(String fname) {this.fname = fname;}public Integer getPrice() {return price;}public void setPrice(Integer price) {this.price = price;}public Integer getFcount() {return fcount;}public void setFcount(Integer fcount) {this.fcount = fcount;}public String getRemark() {return remark;}public void setRemark(String remark) {this.remark = remark;}}
2.2.2 dao
接口
package com.zylai.fruit01.dao;import com.zylai.fruit01.pojo.Fruit;import java.util.List;/*** @Author: Zhao YunLai* @Date: 2022/06/21/18:02* @Description:*/public interface FruitDAO {//查询库存列表List
实现类
注意到这个实现类存在着大量的代码冗余，之后的优化主要对这个类进行优化
package com.zylai.fruit01.dao.impl;import com.zylai.fruit01.dao.FruitDAO;import com.zylai.fruit01.pojo.Fruit;import java.sql.*;import java.util.ArrayList;import java.util.List;/*** @Author: Zhao YunLai* @Date: 2022/06/21/18:05* @Description:*/public class FruitDAOImpl implements FruitDAO {private final String DRIVER = "com.mysql.jdbc.Driver";private final String URL = "jdbc:mysql://localhost:3306/fruitdb?useUnicode=true&characterEncoding=utf-8&useSSL=false";private final String USER = "root";private final String PWD = "root";//查询所有的库存信息@Overridepublic List
2.2.3
处理请求层，由于业务比较简单，所以一些业务都在里面进行
package com.zylai.fruit01.controller;import com.zylai.fruit01.dao.FruitDAO;import com.zylai.fruit01.dao.impl.FruitDAOImpl;import com.zylai.fruit01.pojo.Fruit;import java.util.List;import java.util.Scanner;/*** @Author: Zhao YunLai* @Date: 2022/06/21/17:35* @Description:*/public class Menu {Scanner input = new Scanner(System.in);private FruitDAO fruitDAO = new FruitDAOImpl();public int showMainMenu(){System.out.println("=================欢迎使用水果库存系统=====================");System.out.println("1.查看水果库存列表");System.out.println("2.添加水果库存信息");System.out.println("3.查看特定水果库存信息");System.out.println("4.水果下架");System.out.println("5.退出");System.out.println("======================================================");System.out.print("请选择：");int res = input.nextInt();while(true){if(res<1||res>5){System.out.println("请在1~5当中进行选择！");System.out.print("请选择：");res = input.nextInt();}else{break;}}return res;}//显示所有水果库存public void showFruitList(){List
2.2.4 view
package com.zylai.fruit01.view;import com.zylai.fruit01.controller.Menu;/*** @Author: Zhao YunLai* @Date: 2022/06/21/17:36* @Description:*/public class Client {public static void main(String[] args) {Menu menu = new Menu();boolean flag = false;while(!flag){//调用主菜单的方法int slt = menu.showMainMenu();switch(slt){case 1:menu.showFruitList();break;case 2:menu.addFruit();break;case 3:menu.showFruitInfo();break;case 4:menu.deleteFruit();break;case 5:flag = menu.exit();break;}}System.out.println("谢谢使用");}}
2.2.5 最初版总结
代码的冗余量很大 ， 主要是dao层的实现类 ， 每个方法都要重复建立驱动、获取连接、关闭资源等操作 。
文章插图
2.3 改进：对于中获取连接操作以及释放资源操作做了提取
这次的改进就是对于中获取连接操作以及释放资源操作做了提取
如下：将加载驱动获取连接封装在方法中，将关闭资源封装在close方法中
private Connection getConnection(){try {//1.加载驱动Class.forName(DRIVER);//2.通过驱动获取连接对象return DriverManager.getConnection(URL, USER, PWD);} catch (ClassNotFoundException | SQLException e) {e.printStackTrace();}return null;}private void close(Connection connection,PreparedStatement psmt, ResultSet rs){try {if(rs!=null){rs.close();}if(psmt!=null){psmt.close();}if(connection!=null){connection.close();}} catch (SQLException e) {e.printStackTrace();}}//实际中使用//通过水果名称查询记录@Overridepublic Fruit getFruitByName(String fname) {Connection connection = null;PreparedStatement psmt = null;ResultSet rs = null;try {connection = getConnection();String sql = "select * from t_fruit where fname=?";psmt = connection.prepareStatement(sql);psmt.setString(1,fname);rs= psmt.executeQuery();if(rs.next()){int fid = rs.getInt("fid");int price = rs.getInt("price");int fcount = rs.getInt("fcount");String remark = rs.getString("remark");return new Fruit(fid,fname,price,fcount,remark);}} catch ( SQLException e) {e.printStackTrace();}finally {close(connection,psmt,rs);}return null;}2.4 改进：设置抽象类 ， 并抽取增删改操作
可以看到下面这个三个操作的步骤完全一样，不一样的地方只是SQL语句和psmt设置的参数
因此可以将这些相同的操作抽取出来
此外，这里只是涉及到一个表的操作，当有多个表时 ， 就涉及到多个dao类，而这多个dao类都需要这共同的驱动地址，数据库url ， 用户名，密码 ， 获取驱动方法，关闭资源的方法 ， 抽取增删改操作方法 。
因此，加入一个抽象类 ， 里面提供公共的常量和方法，并且把抽取的增删改方法加入
package com.zylai.fruit.dao.base;import java.sql.*;/*** @Author: Zhao YunLai* @Date: 2022/06/21/21:45* @Description:*/public abstract class BaseDAO {protected final String DRIVER = "com.mysql.jdbc.Driver";protected final String URL = "jdbc:mysql://localhost:3306/fruitdb?useUnicode=true&characterEncoding=utf-8&useSSL=false";protected final String USER = "root";protected final String PWD = "root";protected Connection getConnection(){try {//1.加载驱动Class.forName(DRIVER);//2.通过驱动获取连接对象return DriverManager.getConnection(URL, USER, PWD);} catch (ClassNotFoundException | SQLException e) {e.printStackTrace();}return null;}//关闭资源protectedvoid close(Connection connection, PreparedStatement psmt, ResultSet rs){try {if(rs!=null){rs.close();}if(psmt!=null){psmt.close();}if(connection!=null){connection.close();}} catch (SQLException e) {e.printStackTrace();}}//执行更新，返回影响行数protected int executeUpdate(String sql,Object... params){Connection connection = null;PreparedStatement psmt = null;try {connection = getConnection();psmt = connection.prepareStatement(sql);if(params!=null && params.length>0){for (int i = 0; i < params.length; i++) {psmt.setObject(i+1,params[i]);}}return psmt.executeUpdate();} catch ( SQLException e) {e.printStackTrace();}finally {close(connection,psmt,null);}return 0;}}然后让继承该抽象类
由于没有涉及到查询的改进 ， 这里省去查询的方法 。可以看到对于增删改方法，只需要调用父类的更新执行方法 ， 传入sql语句和参数即可完成业务 。
package com.zylai.fruit.dao.impl;import com.zylai.fruit.dao.FruitDAO;import com.zylai.fruit.dao.base.BaseDAO;import com.zylai.fruit.pojo.Fruit;import java.sql.*;import java.util.ArrayList;import java.util.List;/*** @Author: Zhao YunLai* @Date: 2022/06/21/18:05* @Description:*/public class FruitDAOImpl extends BaseDAO implements FruitDAO {//添加水果@Overridepublic boolean addFruit(Fruit fruit) {String sql = "insert into t_fruit values(0,?,?,?,?)";return super.executeUpdate(sql,fruit.getFname(),fruit.getPrice(),fruit.getFcount(),fruit.getRemark())>0;}//更新水果库存信息@Overridepublic boolean updateFruit(Fruit fruit) {String sql = "update t_fruit set fname=?,price=?,fcount=?,remark=? where fid=?";return super.executeUpdate(sql,fruit.getFname(),fruit.getPrice(),fruit.getFcount(),fruit.getRemark(),fruit.getFid())>0;}//删除水果@Overridepublic boolean deleteFruitByName(String fname) {String sql = "delete from t_fruit where fname=?";return super.executeUpdate(sql,fname)>0;}}2.5 改进：抽取查询操作 2.5.1 使用泛型
通过执行查询操作返回查询的结果集 ， 然后通过get方法得到指定列的值赋值给实体类比如Fruit，而对于会有多个继承它，因此不能把实体类写死，所以采用泛型 。
public abstract class BaseDAO {}public class FruitDAOImpl extends BaseDAO implements FruitDAO {} 2.5.2 通过反射得到真正的类
因为泛型只是一个符号，我们不能直接通过泛型创建实例 ， 所以用到反射技术来确定真正的实体类 。
首先在类中定义Class 属性
//T的Class对象private Class entityClass;在的无参构造器中，确定真正的实体类
public BaseDAO(){//getClass获取Class对象 ， 当前我们执行的是new FruitDAOImpl（），创建的是FruitDAOImpl实例//那么构造方法首先会调用父类（BaseDAO）的无参构造方法//因此此处的getClass方法执行，获取的是FruitDAOImpl的Class//所以使用getGenericSuperclass//getGenericSuperclass是获取父类的泛型 ， 即获取BaseDAO的泛型Type genericSuperclass = getClass().getGenericSuperclass();//ParameterizedType:参数化类型//获取（注意，泛型可以传递多个如 ， 所以返回值是一个数组）中的T的真是类型Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass).getActualTypeArguments();Type actualType = actualTypeArguments[0];try {entityClass = Class.forName(actualType.getTypeName());} catch (ClassNotFoundException e) {e.printStackTrace();}}2.5.3 查询方法
在处理结果集时我们不知道T到底有几个参数，是什么类型 。因此，我们需要获取结果集的元数据，所谓元数据就是描述结果集数据的数据，简单来讲，就是这个结果集有哪些列，什么类型等等 。
之后通过Class对象创建一个T的实例进行操作即可
【jdbc学习笔记以及DAO层设计】先定义一个工具函数：
//通过反射，给obj对象的property属性赋propertyValue值private void setValue(Object obj,String property,Object propertyValue){Class clazz = obj.getClass();//获取property这个字符串对应的属性名，比如“fid”去找obj中的fid属性try {Field field= clazz.getDeclaredField(property);if(field!=null){//强制访问field.setAccessible(true);//为obj对象设置filed属性的值field.set(obj,propertyValue);}} catch (NoSuchFieldException | IllegalAccessException e) {e.printStackTrace();}}执行查询的函数：
//执行查询protected List executeQuery(String sql,Object... params){List list = new ArrayList<>();try {//获取连接connection = getConnection();//设置预处理对象psmt = connection.prepareStatement(sql);//设置参数setParams(psmt,params);//执行查询rs= psmt.executeQuery();//处理结果集//难点在于如何处理T，我们不知道T是什么类型并且不知道T有多少个参数//通过rs可以获取结果集的元数据//元数据：描述结果集数据的数据，简单讲，就是这个结果接有哪些列，什么类型等等ResultSetMetaData metaData = http://www.kingceram.com/post/rs.getMetaData();int columnCount = metaData.getColumnCount();while(rs.next()){T entity = (T)entityClass.newInstance();for (int i = 0; i < columnCount; i++) {//获取列名String columnName = metaData.getColumnName(i + 1);//获取列对应的值Object columnValue = rs.getObject(i + 1);//这里获取了列名，就需要根据列名把值填充给entity对象setValue(entity,columnName,columnValue);}list.add(entity);}} catch (SQLException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} finally {close(connection,psmt,rs);}return list;}2.5.4 改进后的整个类为：
package com.zylai.fruit.dao.base;import java.lang.reflect.Field;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.sql.*;import java.util.ArrayList;import java.util.List;/*** @Author: Zhao YunLai* @Date: 2022/06/21/21:45* @Description:*/public abstract class BaseDAO {protected final String DRIVER = "com.mysql.jdbc.Driver";protected final String URL = "jdbc:mysql://localhost:3306/fruitdb?useUnicode=true&characterEncoding=utf-8&useSSL=false";protected final String USER = "root";protected final String PWD = "root";//老师是吧这几个放到这里的，我觉得可能会出现并发问题 ， 不过目前不考虑这个protected Connection connection = null;protected PreparedStatement psmt = null;protected ResultSet rs = null;//T的Class对象private Class entityClass;public BaseDAO(){//getClass获取Class对象，当前我们执行的是new FruitDAOImpl（），创建的是FruitDAOImpl实例//那么构造方法首先会调用父类（BaseDAO）的无参构造方法//因此此处的getClass方法执行，获取的是FruitDAOImpl的Class//所以使用getGenericSuperclass//getGenericSuperclass是获取父类的泛型，即获取BaseDAO的泛型Type genericSuperclass = getClass().getGenericSuperclass();//ParameterizedType:参数化类型//获取（注意，泛型可以传递多个如 ， 所以返回值是一个数组）中的T的真是类型Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass).getActualTypeArguments();Type actualType = actualTypeArguments[0];try {entityClass = Class.forName(actualType.getTypeName());} catch (ClassNotFoundException e) {e.printStackTrace();}}protected Connection getConnection(){try {//1.加载驱动Class.forName(DRIVER);//2.通过驱动获取连接对象return DriverManager.getConnection(URL, USER, PWD);} catch (ClassNotFoundException | SQLException e) {e.printStackTrace();}return null;}//关闭资源protectedvoid close(Connection connection, PreparedStatement psmt, ResultSet rs){try {if(rs!=null){rs.close();}if(psmt!=null){psmt.close();}if(connection!=null){connection.close();}} catch (SQLException e) {e.printStackTrace();}}//给预处理对象设置参数private void setParams(PreparedStatement psmt,Object... params) throws SQLException {if(params!=null && params.length>0){for (int i = 0; i < params.length; i++) {psmt.setObject(i+1,params[i]);}}}//通过反射，给obj对象的property属性赋propertyValue值private void setValue(Object obj,String property,Object propertyValue){Class clazz = obj.getClass();//获取property这个字符串对应的属性名，比如“fid”去找obj中的fid属性try {Field field= clazz.getDeclaredField(property);if(field!=null){//强制访问field.setAccessible(true);//为obj对象设置filed属性的值field.set(obj,propertyValue);}} catch (NoSuchFieldException | IllegalAccessException e) {e.printStackTrace();}}//执行查询protected List executeQuery(String sql,Object... params){List list = new ArrayList<>();try {//获取连接connection = getConnection();//设置预处理对象psmt = connection.prepareStatement(sql);//设置参数setParams(psmt,params);//执行查询rs= psmt.executeQuery();//处理结果集//难点在于如何处理T，我们不知道T是什么类型并且不知道T有多少个参数//通过rs可以获取结果集的元数据//元数据：描述结果集数据的数据 ， 简单讲 ， 就是这个结果接有哪些列，什么类型等等ResultSetMetaData metaData = http://www.kingceram.com/post/rs.getMetaData();int columnCount = metaData.getColumnCount();while(rs.next()){T entity = (T)entityClass.newInstance();for (int i = 0; i < columnCount; i++) {//获取列名String columnName = metaData.getColumnName(i + 1);//获取列对应的值Object columnValue = rs.getObject(i + 1);//这里获取了列名，就需要根据列名把值填充给entity对象setValue(entity,columnName,columnValue);}list.add(entity);}} catch (SQLException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} finally {close(connection,psmt,rs);}return list;}//通过查询返回一条记录protected T load(String sql,Object... params){try {//获取连接connection = getConnection();//设置预处理对象psmt = connection.prepareStatement(sql);//设置参数setParams(psmt,params);//执行查询rs= psmt.executeQuery();//处理结果集//难点在于如何处理T，我们不知道T是什么类型并且不知道T有多少个参数//通过rs可以获取结果集的元数据//元数据：描述结果集数据的数据，简单讲，就是这个结果接有哪些列，什么类型等等ResultSetMetaData metaData = rs.getMetaData();int columnCount = metaData.getColumnCount();if (rs.next()){T entity = (T)entityClass.newInstance();for (int i = 0; i < columnCount; i++) {//获取列名String columnName = metaData.getColumnName(i + 1);//获取列对应的值Object columnValue = rs.getObject(i + 1);//这里获取了列名，就需要根据列名把值填充给entity对象setValue(entity,columnName,columnValue);}return entity;}} catch (SQLException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} finally {close(connection,psmt,rs);}return null;}//执行复杂的查询，返回统计结果，这个方法暂时没有用到protected Object[] executeComplexQuery(String sql,Object... params){try {//获取连接connection = getConnection();//设置预处理对象psmt = connection.prepareStatement(sql);//设置参数setParams(psmt,params);//执行查询rs= psmt.executeQuery();//处理结果集//难点在于如何处理T ， 我们不知道T是什么类型并且不知道T有多少个参数//通过rs可以获取结果集的元数据//元数据：描述结果集数据的数据，简单讲，就是这个结果接有哪些列，什么类型等等ResultSetMetaData metaData = rs.getMetaData();int columnCount = metaData.getColumnCount();if (rs.next()){Object[] columnValueArr = new Object[columnCount];for (int i = 0; i < columnCount; i++) {//获取列对应的值Object columnValue = rs.getObject(i + 1);columnValueArr[i]=columnValue;}return columnValueArr;}} catch (SQLException e) {e.printStackTrace();} finally {close(connection,psmt,rs);}return null;}}3 数据库连接池 3.1 概述和优势
之前的的连接都是用的时候才创建连接，当使用完成之后就销毁，这样效率很低，浪费资源 。
使用数据库连接池就可以先创建多个连接对象放到连接池中，等到使用的时候直接从连接池中取出来，用完之后归还 。
3.1.1 好处： 响应时间更快连接对象的利用率更高 3.1.2详细配置参数：
不需要背，只是参考，记住主要用的几个就可以了
配置缺省说明
name
配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来 。如果没有配置，将会生成一个名字，格式是：”-” + .(this)
url
连接数据库的url，不同数据库不一样 。例如：mysql : jdbc:mysql://10.20.153.104:3306/: jdbc::thin:@10.20.149.85:1521:
连接数据库的用户名
连接数据库的密码 。如果你不希望密码直接写在配置文件中 ， 可以使用 。详细看这里：使用
根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别 ， 然后选择相应的(建议配置下)
初始化时建立物理连接的个数 。初始化发生在显示调用init方法 ， 或者第一次时
最大连接池数量
已经不再使用 ， 配置了也没效果
文章插图
最小连接池数量
获取连接时最大等待时间，单位毫秒 。配置了之后 ， 缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置属性为true使用非公平锁 。
ts
false
是否缓存，也就是 。对支持游标的数据库性能提升巨大，比如说 。在mysql下建议关闭 。
ments
-1
要启用，必须配置大于0，当大于0时 ， ts自动触发修改为true 。在Druid中，不会存在下占用内存过多的问题，可以把这个数值配置大一些，比如说100
用来检测连接是否有效的sql，要求是一个查询语句 。如果为null ， 、、都不会其作用 。
true
申请连接时执行检测连接是否有效，做了这个配置会降低性能 。
false
归还连接时执行检测连接是否有效，做了这个配置会降低性能
false
建议配置为true ， 不影响性能，并且保证安全性 。申请连接的时候检测，如果空闲时间大于，执行检测连接是否有效 。
有两个含义： 1)线程会检测连接的间隔时间2)的判断依据 ， 详细看属性的说明
un
不再使用，一个只支持一个
物理连接初始化的时候执行的sql
根据自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接
属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的:stat日志用的:log4j防御sql注入的:wall
类型是List ， 如果同时配置了和，是组合关系，并非替换关系
3.2 使用 3.2.1 基础使用
将对应的jar引入到项目中之后，创建对象，进行连接即可 。
注意:
被close的连接对象并没有真正关闭，而是将状态重新设置为空闲状态放回池子没有被close的连接对象会被一直占用 ， 那么下次继续获取连接对象，是不会获取到这个对象的对于conn1对象指向别的东西，原始情况下jvm会回收conn1之前指向的对象，但是连接池中的连接默认有一个变量指着，所以不会被回收
package com.zylai.jdbc;import com.alibaba.druid.pool.DruidDataSource;import com.alibaba.druid.pool.DruidPooledConnection;import java.sql.Connection;import java.sql.SQLException;/*** @Author: Zhao YunLai* @Date: 2022/06/22/14:13* @Description:*/public class Demo02Druid {public static void main(String[] args) throws SQLException {DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/fruitdb?&useSSL=false&useUnicode=true&characterEncoding=utf-8");dataSource.setUsername("root");dataSource.setPassword("root");//证明两点：//1.被close的连接对象并没有真正关闭，而是将状态重新设置为空闲状态放回池子//2.没有被close的连接对象会被一直占用，那么下次继续获取连接对象，是不会获取到这个对象的//对于conn1对象指向别的东西 ， 原始情况下jvm会回收conn1之前指向的对象，但是连接池中的连接默认有一个变量指着，所以不会被回收for (int i = 0; i < 5; i++) {Connection conn1 = dataSource.getConnection();Connection conn2 = dataSource.getConnection();System.out.println(conn1);System.out.println(conn2);if(i%3==0){conn1.close();conn2.close();}}}}3.2.2 验证连接池的部分参数
这里以最大连接数和最长等待时间为例，当获取完所有的连接之后，再去获取连接超过指定的等待时间会抛出异常
package com.zylai.jdbc;import com.alibaba.druid.pool.DruidDataSource;import java.sql.Connection;import java.sql.SQLException;/*** @Author: Zhao YunLai* @Date: 2022/06/22/14:13* @Description: 验证连接池的部分参数*/public class Demo03Druid {public static void main(String[] args) throws SQLException {DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/fruitdb?&useSSL=false&useUnicode=true&characterEncoding=utf-8");dataSource.setUsername("root");dataSource.setPassword("root");dataSource.setInitialSize(2);dataSource.setMaxActive(5);dataSource.setMaxWait(5000);for (int i = 0; i < 10; i++) {Connection conn1 = dataSource.getConnection();System.out.println(i+" "+conn1);}}}3.2.3 读取配置文件信息创建连接池
在实际开发中，比如数据库url，密码用户等信息都是写在配置文件中 ， 不会直接写在代码中进行硬编码
package com.zylai.jdbc;import com.alibaba.druid.pool.DruidDataSource;import java.io.File;import java.io.IOException;import java.io.InputStream;import java.sql.Connection;import java.sql.SQLException;import java.util.Properties;/*** @Author: Zhao YunLai* @Date: 2022/06/22/14:13* @Description: 从配置文件中读取信息*/public class Demo04Druid {public static void main(String[] args) throws SQLException, IOException {Properties properties = new Properties();InputStream is = Demo04Druid.class.getClassLoader().getResourceAsStream("jdbc.properties");properties.load(is);DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName(properties.getProperty("jdbc.driverClassName"));dataSource.setUrl(properties.getProperty("jdbc.url"));dataSource.setUsername(properties.getProperty("jdbc.username"));dataSource.setPassword(properties.getProperty("jdbc.pwd"));dataSource.setInitialSize(Integer.parseInt(properties.getProperty("druid.initialSize")));dataSource.setMaxActive(Integer.parseInt(properties.getProperty("druid.maxActive")));dataSource.setMaxWait(Long.parseLong(properties.getProperty("druid.maxWait")));for (int i = 0; i < 10; i++) {Connection conn1 = dataSource.getConnection();System.out.println(i+" "+conn1);}}}配置文件jdbc.:
jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/fruitdb?&useSSL=false&useUnicode=true&characterEncoding=utf-8jdbc.username=rootjdbc.pwd=rootdruid.initialSize=2druid.maxActive=5druid.maxWait=50003.2.4 直接通过配置文件建立连接池
通过ry.();返回**接口**，直接通过配置文件建立好了连接池 。不过这里对于配置文件的格式有要求 。
package com.zylai.jdbc;import com.alibaba.druid.pool.DruidDataSource;import com.alibaba.druid.pool.DruidDataSourceFactory;import javax.sql.DataSource;import java.io.IOException;import java.io.InputStream;import java.sql.Connection;import java.sql.SQLException;import java.util.Properties;/*** @Author: Zhao YunLai* @Date: 2022/06/22/14:13* @Description: 直接通过配置文件创建连接池*/public class Demo05Druid {public static void main(String[] args) throws Exception {Properties properties = new Properties();InputStream is = Demo05Druid.class.getClassLoader().getResourceAsStream("jdbc2.properties");properties.load(is);DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);for (int i = 0; i < 10; i++) {Connection conn1 = dataSource.getConnection();System.out.println(i+" "+conn1);}}}配置文件的格式应该一致
driverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/fruitdb?&useSSL=false&useUnicode=true&characterEncoding=utf-8username=rootpassword=rootinitialSize=2maxActive=5maxWait=5000- ab驾驶证有记分不参加学习后果是什么? 是否会被吊销驾驶证？
- 2023呼和浩特市专业技术人员继续教育网络学习通知
- 一 GitGitHub学习笔记之GitHub简单操作
- 如何最好保养笔记本电池 如何最好保养笔记本电池呢
- 联想笔记本电脑输入密码后一直转圈 联想笔记本电脑输入密码后一直转圈怎么回事
- 国画如何入门 国画的基本技法
- 大学生怎么学习英语 大学生怎么学好英语
- 联想笔记本键盘失灵自动不停输入 笔记本键盘失灵自动不停输入
- 青年大学习答案
- Sysmon笔记