java中的数据存储技术

• 在Java中，数据库存取技术可分为如下几类：

  • JDBC直接访问数据库

  • JDO (Java Data Object )技术

  • 第三方O/R工具，如Hibernate, Mybatis 等

• JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。jdbc识sun发布的一个java程序和数据库之间通信的规范（接口）

JDBC体系结构

JDBC接口（API）包括两个层次：

• 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。

• 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。zhu

1、JDBC的常规操作

1). JDBC连接MySQL数据库

要先导入mysql-jdbc(驱动)jar包（创建一个lib目录，里面存放该jar包，记得要添加为类库。（个大数据库厂商去实现JDBC规范（实现类），这些实现类打成压缩包，就是所谓的jar包。

 mysql驱动的下载MySQL :: Download Connector/J

 （注意：如果是Dynamic Web Project（动态的web项目）话，则是把驱动jar放到WebContent（有的开发工具叫 WebRoot）目录中的WEB-INF目录中的lib目录下即可

JDBC程序编写步骤：

1、注册驱动DriverManager

2、获取数据库连接

3、创建发送sql语句对象

4、发送sql语句，并获取返回结果

5、结果集解析

6、资源关闭

1. JDBC常规操作：

1). JDBC连接MySQL数据库

关于驱动：

/*
注册驱动：
依赖：驱动版本 8+ com.mysql.cj.jdbc.Driver驱动版本 5+ com.mysql.jdbc.Driver*/

加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名，Class.forName(“com.mysql.jdbc.Driver”);

注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序

//方案1// DriverManager.registerDriver(new Driver());//方案2:注册驱动 固定写法 mysql - mysql Driver || 不灵活，换成oracle 等别的数据库需要再改代码// new Driver();//方案3:反射//字符串的Driver全限定词，可以引导外部的配置文件-》xx.properties -> oracle -> 配置文件修改Class.forName("com.mysql.cj.jdbc.Driver");/*方案一问题：会注册两次驱动1、 DriverManager.registerDriver();方法本身会注册一次2、 Driver.static{ DriverManager.registerDriver()} 静态代码块也会注册一次解决：只触发静态代码块 Driver触发静态代码块：类加载时会触发加载【class文件--》java虚拟机和class对象连接【验证（检查文件类型）-》准备(静态变量默认值）-》解析（触发静态代码块）初始化（静态属性赋真实值）触发类加载：1、new2、调用类的静态方法3、调用静态属性4、接口  1.8 default默认实现5、反射116、子类触发父类 （子类实例化会触发父类）7、程序的入口main
*/

 （如图如果DriverManager.registerDriver(new Driver());来注册驱动，通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，则相当于DriverManager.registerDriver调用了两次自己，注册了两次驱动。所以采用方案三来注册驱动合适。

关于获取数据库连接

        //方式1Connection connection = DriverManager.getConnection("jdbc:mysql:///forget", "root", "1234567");//方式2Properties info = new Properties();info.put("user","root");info.put("password","1234567");Connection connection1 = DriverManager.getConnection("jdbc:mysql:///forget", info);//方式3DriverManager.getConnection("jdbc:mysql:///forget?user=root&password=1234567");/*getConnection(1,2,3)是一个重载方法，下面对其参数形式作解释，上面是示例核心属性：1、数据库软件所在的主机的ip地址： localhost | 127.0.0.12、数据库软件所在的主机的端口号：3306（默认的端口号是这个）3、连接的具体数据库：4、连接的账号、密码5、可选信息：三个参数：String url：数据库软件所在信息，连接的具体库，以及其他可选信息语法：jdbc；数据库管理软件名称【mysql，oracle]://ip地址|主机名：port端口号/数据库名？key=value&key=value 可选信息具体： jdbc:mysql://127.0.0.1:3306/forgetjdbc:mysql://localhost:3306/forget本机省略写法：如果你的数据库软件安装到本机，可以进行一些省略jdbc:mysql:///forget  （forget是我创建的数据库名字）String user：String password：user,password可以用“属性名=属性值”方式告诉数据库也可以调用 DriverManager 类的 getConnection() 方法建立到数据库的连接两个参数：String url:properties info:储存账号和密码：properties 类似于Map 只不过key = value 都是字符串形式key user ：账号信息key password ：密码信息一个参数：:数据库ip，端口号，具体数据库jdbc:数据库软件名://ip:port/forget?key=value&key=value&key=valuejdbc:数据库软件名://ip:port/forget?key=value&key=value&key=v*/

URL：JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。

JDBC URL的标准由三部分组成，各部分间用冒号分隔。

jdbc:子协议:子名称
协议：JDBC URL中的协议总是jdbc
子协议：子协议用于标识一个数据库驱动程序

子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库，提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名

几种常用数据库的 JDBC URL
MySQL的连接URL编写方式：
jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
jdbc:mysql://localhost:3306/atguigu
jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8（如果JDBC
程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
jdbc:mysql://localhost:3306/atguigu?user=root&password=123456
Oracle 9i的连接URL编写方式：
jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
jdbc:oracle:thin:@localhost:1521:atguigu
SQLServer的连接URL编写方式：
jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称
jdbc:sqlserver://localhost:1433:DatabaseName=atguigu

 综上只要注册驱动和获取连接只要使用如下就好

        //1、注册驱动Class.forName("com.mysql.cj.jdbc.Driver");//2、获取连接Connection connection = DriverManager.getConnection("jdbc:mysql:///forget", "root", "1234567");

（其它讲法，

数据库连接的连接方式一：

public void connectiontest1(){try {//1.提供java.sql.Driver接口实现类的对象Driver driver = new com.mysql.cj.jdbc.Driver();//2.提供url，指明具体操作的数据String url ="jdbc:mysql://localhost:3306/jdbc";//3.提供Properties的对象，指明用户名和密码Properties info = new Properties();info.setProperty("user","root");info.setProperty("password","1234567");//4.调用driver的connect()，获取连接Connection connection = driver.connect(url,info);System.out.println(connection);} catch (SQLException e) {throw new RuntimeException(e);}}

如果打印结果输出为null，可能是url打错了。打印结果如下形式
Driver driver = new com.mysql.jdbc.Driver();可根据如下图理解，
（上述代码中显式出现了第三方数据库的API）

这里可以改进实例化Driver方式，获取Driver实现类时使用反射，不在代码中体现第三方数据库的API。体现了面向接口编程思想。换成如下

Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");

方式二：

使用DriverManager实现数据库的连接。体会获取连接必要的4个基本要素

public void connectiontest2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {//1、实现Driver实现类对象Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");Driver driver = (Driver) clazz.newInstance();//2.数据库连接的3个基本信息：String url = "jdbc:mysql://localhost:3306/jdbc";String user = "root";String password = "1234567";//3、注册驱动DriverManager.registerDriver(driver);//4、获取连接Connection connection = DriverManager.getConnection(url, user, password);System.out.println(connection);}

上面方法 DriverManager.registerDriver(driver);，前面分析时讲到不太适合。在这个基础上可以删掉，变成

        String url = "jdbc:mysql://localhost:3306/jdbc";String user = "root";String password = "1234567";Connection connection = DriverManager.getConnection(url, user, password);System.out.println(connection);

（可以省略是因为mysql的Driver实现类中声明：

static {try {DriverManager.registerDriver(new Driver());} catch (SQLException var1) {throw new RuntimeException("Can't register driver!");}}

因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例。所以可以只是加载驱动，不必显式的注册驱动了。因为在DriverManager的源码中已经存在静态代码块，实现了驱动的注册。

方式三：使用配置文件的方式保存配置信息，在代码中加载配置文件

但是在mysql中可以省略，但是换成别的数据库可能就不行了，所以

Class.forName("com.mysql.cj.jdbc.Driver");还是不要省略了，

创建properties文件存储需要用到的内容（记住=左右不要空格），该文件放在src目录下

public void connectiontest3() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException, IOException {//1、加载配置文件InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");Properties properties = new Properties();properties.load(is);//加载这个文件//2.读取配置信息String user = properties.getProperty("user");String password = properties.getProperty("password");String url = properties.getProperty("url");String driverClass = properties.getProperty("driverClass");//3、加载驱动Class.forName(driverClass);//4、获取连接Connection connection = DriverManager.getConnection(url, user, password);System.out.println(connection);}

（①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码 ②如果修改了配置信息，省去重新编译的过程。

补充：

（在navicat中导入数据表成功却没有表，遇到这个问题，看到了这篇博客navicat导入sql文件成功但没有表_sql导入成功但是没有数据_czx鑫的博客-CSDN博客

使用PreparedStatement实现CRUD操作

操作和访问数据库：数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。

在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。CallableStatement：用于执行 SQL 存储过程

但是使用Statement操作数据表存在弊端：

    Scanner scanner = new Scanner(System.in);System.out.println("请输入账号：");String account = scanner.nextLine();System.out.println("请输入密码：");String password = scanner.nextLine();  Class.forName("com.mysql.cj.jdbc.Driver");  Connection connection=DriverManager.getConnection("jdbc:mysql:///forget?user=root&password=1234567");//创建发送sql语句的statement对象//statement 可以发送sql语句到数据库，并且获取返回结果Statement statement = connection.createStatement();//发送sql语句String sql ="select * from user where account = '"+account+"'and password ='"+password+"';";

statement在后面查询结果集会使用到，如下

ResultSet resultSet = statement.executeQuery(sql);

关于statement的使用

问题一：存在拼串操作，繁琐
问题二：存在SQL注入问题

SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令。如下

 一开始的sql语句：

"select * from user where user = '"+user+"'and password ='"+password+"';"

所以当如下输入时

user输入1'  or

密码输入 =1 or '1' = '1 时，会改变sql语句的原意，变成

SELECT user, password FROM user_table WHERE user='1' OR 1 = ' AND password = ' OR '1' ='1')

意味着用户名为1或者密码为1或1=1（恒成立）。从而利用系统的 SQL 引擎完成恶意行为的做法。

对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。

PreparedStatement的使用

可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取PreparedStatement 对象

        //1、注册驱动Class.forName("com.mysql.cj.jdbc.Driver");//2、获取连接Connection connection = DriverManager.getConnection("jdbc:mysql:///forget", "root", "1234567");//3、编写sql语句结果，动态值的部分使用？代替String sql = "insert into user(account,password,nickname)values(?,?,?);";//4、创建preparedStatement，并且传入sql语句结果PreparedStatement preparedStatement = connection.prepareStatement(sql);

PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1开始)，第二个是设置的 SQL 语句中的参数的值

        //5、占位符赋值preparedStatement.setObject(1, "test");preparedStatement.setObject(2, "test");preparedStatement.setObject(3, "lulu");

相当于：
insert into user(account,password,nickname)values("test","test","lulu");

PreparedStatement的增删改

如下为添加数据操作

 public void testInsert() {Connection connection = null;PreparedStatement preparedStatement = null;try {//1、获取配置信息InputStream resourceAsStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");Properties properties = new Properties();properties.load(resourceAsStream);String user = properties.getProperty("user");String password = properties.getProperty("password");String url = properties.getProperty("url");String driverClass = properties.getProperty("driverClass");//2、加载驱动Class.forName(driverClass);//3、获取连接connection = DriverManager.getConnection(url, user, password);//4、预编译sql语句，返回PreparedStatement的实例String sql="insert into customers(name,email,birth) values(?,?,?)";preparedStatement = connection.prepareStatement(sql);//5、填充占位符preparedStatement.setObject(1,"周日");preparedStatement.setObject(2,"326111111@qq.com");SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");Date date = simpleDateFormat.parse("1909-02-01");preparedStatement.setDate(3,  new java.sql.Date(date.getTime()));//util下的date不能转换为sql下的date，所以(java.sql.Date)new (date.getTime())不行//6、执行操作preparedStatement.execute();} catch (Exception e) {e.printStackTrace();} finally {//7、资源的关闭try {if(preparedStatement!=null){preparedStatement.close();}} catch (SQLException e) {e.printStackTrace();}try {if(connection!=null){connection.close();}} catch (SQLException e) {e.printStackTrace();}}}

遇到报错

https://www.cnblogs.com/We612/p/10849556.html，修改字符集即可，我是再navicat上利用图形化界面的操作实现的，但是可以俩姐下相关命令。

关于字符集，我当时没找到utf8，看到有utfmb3和utfmb4，我设置的是4。

mysql中没有utf8字符集_mysql之坑–UTF8字符集_帕腓尼基的博客-CSDN博客

接下来的删、改则通过对jdbc一些步骤封装成工具类后进行使用实现

public class JDBCUtils {public static Connection getConnection() throws Exception {//1、获取配置信息InputStream resourceAsStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");Properties properties = new Properties();properties.load(resourceAsStream);String user = properties.getProperty("user");String password = properties.getProperty("password");String url = properties.getProperty("url");String driverClass = properties.getProperty("driverClass");//2、加载驱动Class.forName(driverClass);//3、获取连接Connection connection = DriverManager.getConnection(url, user, password);return connection;}public static void closeResource(Connection con, PreparedStatement ps) {try {if (ps != null) {ps.close();}} catch (SQLException e) {e.printStackTrace();}try {if (con != null) {con.close();}} catch (SQLException e) {e.printStackTrace();}}
}

如上对加载驱动，创建连接，PreparedStatemen语句、关闭资源等的封装

改

public void testUpdate() throws Exception {Connection connection = null;PreparedStatement ps = null;try {//1、通过封装的JDBCUtils工具类获取数据库连接connection = JDBCUtils.getConnection();//2、预编译sql语句，返回PreparedStatement的实例String sql ="update customers set name = ? where id =?";ps = connection.prepareStatement(sql);//3、填充占位符ps.setObject(1,"tom");ps.setObject(2,18);//4、执行ps.execute();} catch (Exception e) {e.printStackTrace();} finally {//5、关闭资源JDBCUtils.closeResource(connection,ps);}}

在工具类的基础上我们再改进一下，实现通用的增删改（就是把占位符赋值部分的功能封装

 public static void CommonUse(String sql,Object...args){Connection connection = null;PreparedStatement preparedStatement = null;try {connection = JDBCUtils.getConnection();preparedStatement = connection.prepareStatement(sql);for (int i = 0; i < args.length; i++) {preparedStatement.setObject(i+1,args[i]);}preparedStatement.execute();} catch (Exception e) {e.printStackTrace();} finally {JDBCUtils.closeResource(connection,preparedStatement);}

测试

 @Testpublic void testDelete() throws Exception {//增String add="insert into customers(name,email) value(?,?) ";CommonUse(add,"lucy","488@qq.com");//删String dele="delete from customers where id = ? ";CommonUse(dele,20);//改String update ="update customers set email=? where name=?";CommonUse(update,"2442ew@qq.com","tom");}

查询（之前增删改，使用的时execute()方法进行执行操作，因为需要返回结果集的缘故，后面则是其它方法）

a、查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象

b、ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
c、ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
d、ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。

e、当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
例如: getInt(1), getString("name")
注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
ResultSet 接口的常用方法：
boolean next()
getString()

​​​​​​​

相关查询操作

（下图表示Java与SQL对应数据类型转换表）

一个数据表对应一个java类，表中的一条记录对应java类的一个对象，表中的一个字段对应java类的一个属性。我们创建一个Customer类来封装一条记录

Customer类中，成员变量如下（记得还要生成get和set方法，带参的构造方法）

public class Customer {private int id;private String name;private String email;private Date brith;

测试

public void CustomerForQuery() {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {connection = JDBCUtils.getConnection();String sql = "select * from customers";preparedStatement = connection.prepareStatement(sql);resultSet = preparedStatement.executeQuery();while (resultSet.next()) {Integer id = resultSet.getInt(1);String name = resultSet.getString(2);String eamil = resultSet.getString(3);Date brith = resultSet.getDate(4);Customer customer = new Customer(id, name, eamil, brith);System.out.println(customer);}} catch (Exception e) {throw new RuntimeException(e);} finally {try {if (resultSet != null) {resultSet.close();}} catch (Exception e) {e.printStackTrace();}try {if (preparedStatement != null) {preparedStatement.close();}} catch (Exception e) {e.printStackTrace();}try {if (connection != null) {connection.close();}} catch (Exception e) {e.printStackTrace();}}}

（但是这种是针对某一具体实体类型的数据封装

ResultSetMetaData

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
 

ResultSetMetaData meta = rs.getMetaData();
getColumnName(int column)：获取指定列的名称
getColumnLabel(int column)：获取指定列的别名
getColumnCount()：返回当前 ResultSet 对象中的列数。
getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
isNullable(int column)：指示指定列中的值是否可以为 null。
isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

如下代码中对它的使用

出现一个报错

原来是没有对应字段造成的（在表中字段名为birth，在实体类中为brith，没对应上），还有就是注意查询字段和属性名一一对应（查询的sql语句的编写），（造成如上报错的原因还可能是属性为私有时获取Field用的方法不是getDeclaredField。）

如下为查询结果：

Customer{id=1, name='张三', email='wf@126.com', birth=2010-02-02}
 

a

总结

 JDBC对数据库进行增、删、改、查

（补充：

关于反射

下图为从内存中看反射

Class对象是反射的根源。

在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()

获取 Class 类的实例 四种方法

方式1：要求编译期间已知类型 （Class clazz = String.class;）

方式2：获取对象的运行时类型

前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

Class clazz = "www.atguigu.com".getClass();

方式3：可以获取编译期间未知的类型

前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

方式4：其他方式
前提：可以用系统类加载对象或自定义加载器对象加载指定路径下的类型

实例：
ClassLoader cl = this.getClass().getClassLoader();

Class clazz4 = cl.loadClass("类的全类名");

  /*关于java.lang.Class类的理解1、类的加载过程程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）接着我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例2、换句话说，Class的实例就对应着一个运行时类3、加载到内存中的运行时类，会缓存一定时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。*///获取Class的实例的方式@Testpublic void test3() throws ClassNotFoundException {//方式一：调用运行时类的属性： .classClass clazz1 = Person.class;//Class<Person> clazz1 = Person.class;System.out.println(clazz1);//class SE.Reflection.Person//方式二：调用运行时类的对象Person p1 = new Person();Class clazz2 = p1.getClass();System.out.println(clazz2);//class SE.Reflection.Person//方式三：调用Class的静态方法: forName(String classPath)Class clazz3 = Class.forName("SE.Reflection.Person");//类的全类名，包含包名在内的完整路径System.out.println(clazz3);//class SE.Reflection.PersonSystem.out.println(clazz1 == clazz2);//trueSystem.out.println(clazz1 == clazz3);//true//方式四：使用类的加载器:ClassLoaderClassLoader classLoader = ReflectionTest.class.getClassLoader();Class clazz4 = classLoader.loadClass("SE.Reflection.Person");System.out.println(clazz4);//class SE.Reflection.PersonSystem.out.println(clazz1 == clazz4);//true}

类的加载器（以jdk8为例）

JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。在程序中我们最常见的类加载器结构主要是如下情况：

（启动类加载器（引导类加载器，Bootstrap ClassLoader）它用来加载 Java 的核心库（ JAVA_HOME/jre/lib/rt.jar 或 sun.boot.class.path 路径下的内容）。用于提供 JVM 自身需要的类。
• 并不继承自 java.lang.ClassLoader ，没有父加载器。

扩展类加载器（Extension ClassLoader）由 sun.misc.Launcher$Ex tClassLoader 实现。

应用程序类加载器（系统类加载器，AppClassLoader）它负责加载环境变量 classpath 或系统属性 java.class.path 指定路径下的类库
• 应用程序中的类加载器默认是系统类加载器。
• 它是用户自定义类加载器的默认父加载器
• 通过 ClassLoader 的 getSystemClassLoader() 方法可以获取到该类加载器

查看某个类的类加载器对象（1）获取默认的系统类加载器ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2（2）查看某个类是哪个类加载器加载的//如果是根加载器加载的类，则会得到nullClassLoader classloader1 = Class.forName("java.lang.Object").getClassLoader();System.out.println(classloader1);//null（3）获取某个类加载器的父加载器ClassLoader parentClassloader = systemClassLoader.getParent();System.out.println(parentClassloader);//sun.misc.Launcher$ExtClassLoader@372f7a8d

关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流。

public void test2() throws IOException {Properties pros = new Properties();//此时的文件默认在当前的module下//读取配置文件方式一：
//        FileInputStream fis = new FileInputStream("jdbc1.properties");// FileInputStream fis = new FileInputStream("src//jdbc2.properties");// pros.load(fis);//读取配置文件方式二：//配置文件默认识别为：当前module的src下
//        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
//        InputStream is = classLoader.getResourceAsStream("jdbc2.properties");
//        pros.load(is);//获取配置文件中的信息String user = pros.getProperty("user");String password = pros.getProperty("password");System.out.println("user="+user+","+"password="+password);//user=小小,password=123456}

反射的应用

应用 1 ：创建运行时类的对象

方式1：直接调用Class对象的newInstance()方法

newInstance():调用此方法，创建对应的运行时类的对象内部调用了运行时类的空参构造器用此方法正常创建运行时类的对象，要求满足：1、运行时类必须提供空参构造器2、空参的构造器的访问权限得够。通常，设置为public//        Class clazz = Person.class;
//        Person obj = (Person) clazz.newInstance();Class<Person> clazz = Person.class; //这样写后面就不用强转Person obj = clazz.newInstance();//Person{name='null', age=0} 

方式2：通过获取构造器对象来进行实例化

1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器 2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。 
3）通过Constructor实例化对象。
如果构造器的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)Class<Person> clazz = Person.class;Constructor<?>[] constructors = clazz.getDeclaredConstructors();constructors[2].setAccessible(true);Object obj = constructors[2].newInstance("today");System.out.println(obj);//Person{name='today', age=0}//如果构造器有多个，我们通常是根据形参【类型】列表来获取指定的一个构造器的Constructor<?> constructors1 = clazz.getDeclaredConstructor(String.class);constructors1.setAccessible(true);Object obj1 = constructors1.newInstance("today1");System.out.println(obj1);//Person{name='today1', age=0}

应用 2 ：获取运行时类的完整结构

可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）。

//1.实现的全部接口 
public Class<?>[] getInterfaces() 
//确定此对象所表示的类或接口实现的接口。
//2.所继承的父类 
public Class<? Super T> getSuperclass() 
//返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。
//3.全部的构造器 
public Constructor<T>[] getConstructors() 
//返回此 Class 对象所表示的类的所有public构造方法。 
public Constructor<T>[] getDeclaredConstructors() 
//返回此 Class 对象表示的类声明的所有构造方法。 
//Constructor类中： 
//取得修饰符: 
public int getModifiers(); 
//取得方法名称: 
public String getName(); 
//取得参数的类型： 
public Class<?>[] getParameterTypes(); 
//4.全部的方法 
public Method[] getDeclaredMethods() 
//返回此Class对象所表示的类或接口的全部方法 
public Method[] getMethods() 
//返回此Class对象所表示的类或接口的public的方法 //Method类中： 
public Class<?> getReturnType() 
//取得全部的返回值 
public Class<?>[] getParameterTypes() 
//取得全部的参数 
public int getModifiers() 
//取得修饰符 
public Class<?>[] getExceptionTypes() 
//取得异常信息 //5.全部的Field 
public Field[] getFields() 
//返回此Class对象所表示的类或接口的public的Field。 
public Field[] getDeclaredFields() 
//返回此Class对象所表示的类或接口的全部Field。 //Field方法中： 
public int getModifiers() 
//以整数形式返回此Field的修饰符 
public Class<?> getType() 
//得到Field的属性类型 
public String getName() 
//返回Field的名称。//6. Annotation相关 
get Annotation(Class<T> annotationClass) getDeclaredAnnotations() 
//7.泛型相关 
//获取父类泛型类型： 
Type getGenericSuperclass() 
//泛型类型：
ParameterizedType 
//获取实际的泛型类型参数数组： 
getActualTypeArguments() 
//8.类所在的包 
Package getPackage()

public class UseTest{/*获取当前运行时类的属性结构*/@Testpublic void test(){Class clazz = Person1.class;//获取属性结构//getFields():获取当前运行时类及其父类中声明为public访问权限的属性Field[] fields = clazz.getFields();for (Field f :fields) {System.out.println(f);//public int SE.Reflection.Person1.id//public double SE.Reflection.Creature.weight}System.out.println("----------------");//getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性Field[] declaredFields = clazz.getDeclaredFields();for (Field f :declaredFields) {System.out.println(f);//private java.lang.String SE.Reflection.Person1.name//int SE.Reflection.Person1.age//public int SE.Reflection.Person1.id}}//权限修饰符  数据类型  变量名@Testpublic void test2(){Class clazz = Person1.class;Field[] declaredFields = clazz.getDeclaredFields();for (Field f :declaredFields) {//1、获取权限修饰符int modifiers = f.getModifiers();System.out.print(Modifier.toString(modifiers)+"\t");//2、数据类型Class type = f.getType();System.out.print(type.getName()+"\t");//class java.lang.String	type//java.lang.String          type.getName()//3、变量名String fName = f.getName();System.out.println(fName);System.out.println();}}/*获取运行时类的方法结构*/@Testpublic void test3(){Class clazz= Person1.class;//getMethods():获取当前运行时类及其父类中声明为public权限的方法Method[] methods = clazz.getMethods();for (Method m :methods) {System.out.println(m);//public int SE.Reflection.Person1.compareTo(java.lang.Object)//public int SE.Reflection.Person1.compareTo(java.lang.String)//public void SE.Reflection.Person1.info()//public java.lang.String SE.Reflection.Person1.display(java.lang.String)//public void SE.Reflection.Creature.eat()//public final void java.lang.Object.wait() throws java.lang.InterruptedException//public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException//public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException//public boolean java.lang.Object.equals(java.lang.Object)//public java.lang.String java.lang.Object.toString()//public native int java.lang.Object.hashCode()//public final native java.lang.Class java.lang.Object.getClass()//public final native void java.lang.Object.notify()//public final native void java.lang.Object.notifyAll()}System.out.println("----------------");//getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法Method[] declaredMethods = clazz.getDeclaredMethods();for (Method m :declaredMethods) {System.out.println(m);//public int SE.Reflection.Person1.compareTo(java.lang.Object)//public int SE.Reflection.Person1.compareTo(java.lang.String)//public void SE.Reflection.Person1.info()//public java.lang.String SE.Reflection.Person1.display(java.lang.String)//private java.lang.String SE.Reflection.Person1.show(java.lang.String)}}/*@Xxx权限修饰符 返回值类型 方法名（参数类型1，形参名1...) throws XxxException{}*/@Testpublic void test4(){Class clazz = Person1.class;//1、获取方法声明的注解Method[] declaredMethods = clazz.getDeclaredMethods();for (Method method :declaredMethods) {Annotation[] annotations = method.getAnnotations();for (Annotation a :annotations) {System.out.print(a);//@SE.Reflection.MyAnnotation(value=hello)//@SE.Reflection.MyAnnotation(value=today is Monday)}//2、每个方法的权限修饰符System.out.print(Modifier.toString(method.getModifiers())+"\t");//3、返回值类型System.out.print(method.getReturnType().getName()+"\t");//4、方法名System.out.print(method.getName());System.out.print("(");//5、形参列表Class[] parameterTypes = method.getParameterTypes();if(!(parameterTypes==null&&parameterTypes.length==0)){for (int i=0;i<parameterTypes.length;i++){if(i==parameterTypes.length-1){System.out.print(parameterTypes[i].getName()+"args_"+i);break;}System.out.print(parameterTypes[i].getName()+"args_"+i+",");}}System.out.print(")");//6、抛出的异常Class[] exceptionTypes = method.getExceptionTypes();if(exceptionTypes.length>0){for (int i = 0; i < exceptionTypes.length; i++) {System.out.print("throws ");if(i==exceptionTypes.length-1){System.out.print(exceptionTypes[i].getName());break;}System.out.print(exceptionTypes[i].getName()+",");}}System.out.println();
// public volatile	int	compareTo(java.lang.Objectargs_0)
//public	int	compareTo(java.lang.Stringargs_0)
//public	void	info()throws java.lang.ExceptionInInitializerError,throws java.lang.NumberFormatException
//@SE.Reflection.MyAnnotation(value=today is Monday)private	java.lang.String	show(java.lang.Stringargs_0)
//@SE.Reflection.MyAnnotation(value=hello)public	java.lang.String	display(java.lang.Stringargs_0)throws java.lang.NullPointerException}}/*获取构造器结构*/@Testpublic void test5(){Class clazz = Person1.class;//getConstructors():当前运行时类中声明为public的构造器Constructor[] constructors = clazz.getConstructors();for (Constructor c :constructors) {System.out.println(c);//public SE.Reflection.Person1()}System.out.println();//getDeclaredConstructors():获取当前运行时类声明的所有的构造器Constructor[] declaredConstructors = clazz.getDeclaredConstructors();for (Constructor c:declaredConstructors) {System.out.println(c);//SE.Reflection.Person1(java.lang.String,int)//private SE.Reflection.Person1(java.lang.String)//public SE.Reflection.Person1()}}/*获取运行时类的带泛型的父类*/@Testpublic void test6(){Class clazz = Person1.class;Type genericSuperclass = clazz.getGenericSuperclass();System.out.println(genericSuperclass);//SE.Reflection.Creature<java.lang.String>//获取运行时类的带泛型的父类的泛型ParameterizedType paramType = (ParameterizedType) genericSuperclass;//1获取泛型类型Type[] actualTypeArguments = paramType.getActualTypeArguments();for (Type t :actualTypeArguments) {//System.out.println(t.getTypeName());// java.lang.StringSystem.out.println(((Class) t).getName());//java.lang.String}}/*获取运行时类实现的接口*/@Testpublic void test7(){Class clazz = Person1.class;Class[] interfaces = clazz.getInterfaces();for (Class c :interfaces) {System.out.println(c);//interface java.lang.Comparable//interface SE.Reflection.MyInterface}System.out.println();//获取运行时类的父类实现的接口Class[] interfaces1 = clazz.getSuperclass().getInterfaces();for (Class c :interfaces1) {System.out.println(c);//interface java.io.Serializable}}/*获取运行时类所在的包*/@Testpublic void test8(){Class clazz = Person1.class;Package pack = clazz.getPackage();System.out.println(pack);//package SE.Reflection}/*获取运行时类声明的注解*/@Testpublic void test9(){Class clazz = Person1.class;Annotation[] annotations = clazz.getAnnotations();for (Annotation a :annotations) {System.out.println(a);//@SE.Reflection.MyAnnotation(value=hi)}}
}

调用运行时类中指定的结构：属性、方法、构造器

public class UseTest1 {/*如何操作运行时类中指定的属性---掌握*/@Testpublic void testField() throws NoSuchFieldException, InstantiationException, IllegalAccessException {Class clazz = Person1.class;//创建运行时类的对象Person1 p = (Person1) clazz.newInstance();//获取指定属性:要求运行时类中属性声明为public//通常不采用Field id = clazz.getField("id");/*设置当前属性的值set():参数1：指明设置哪个对象的属性 参数2：将此属性值设置为多少*/id.set(p, 11001);/*获取当前属性的值get():参数1：获取哪个对象的当前属性值*/int pid = (int) id.get(p);System.out.println(pid);System.out.println("------------------");// 1\getDeclaredField(String fieldname):获取当前运行时类中指定变量名的属性Field name = clazz.getDeclaredField("name");//2\保证当前属性是可访问的name.setAccessible(true);//3\获取、设置指定对象的此属性值name.set(p, "forget");System.out.println(name.get(p));}/*如何操作运行时类中指定的方法*/@Testpublic void testMethod() throws Exception {Class clazz = Person1.class;//创建运行时类的对象Person1 p = (Person1) clazz.newInstance();/*1、获取指定的某个方法getDeclaredMethod():参数1：指明获取方法的名称 参数2：指明获取的方法的形参列表*/Method show = clazz.getDeclaredMethod("show", String.class);//保证当前方法是可访问的show.setAccessible(true);/*2、调用方法invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参invoke()的返回值即为对应类中调用的方法的返回值*/Object returnValue = show.invoke(p, "china"); //我的国籍是：china//String nation = show.invoke(p, "china");System.out.println(returnValue);//chinaSystem.out.println("-------如何调用静态方法------");// private static void showDesc()Method showDesc = clazz.getDeclaredMethod("showDesc");showDesc.setAccessible(true);//如果调用的运行时类中的方法没有返回值，则此invoke()返回nullObject returnValue1 = showDesc.invoke(null);//Object returnValue1 = showDesc.invoke(Person1.class);System.out.println(returnValue1);//null}/*如何调用运行时类中指定的构造器*/@Testpublic void testConstructor() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Class clazz = Person1.class;//private Person1(String name)/*1\获取指定的构造器getDeclaredConstructor():参数：指明构造器的参数列表*/Constructor constructor = clazz.getDeclaredConstructor(String.class);//2\保证此构造器是可访问的constructor.setAccessible(true);//3\调用此构造器创建运行时类的对象Person1 per = (Person1) constructor.newInstance("Tom");System.out.println(per);//Person1{name='Tom', age=0, id=0}}}

补充：

发现在navicat直接按f6可以进行输入命令行操作，如下

 添加操作时获取自增列主键值

 /*** user插入一条数据并且获取数据库自增长的主键* 1、创建preparedStatement时,告知带回数据库自增长的主键* PreparedStatement preparedStatement = connection.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);* 2、获取装主键值的结果集对象，一行一列，获取对应的数据即可* ResultSet resultSet = preparedStatement.getGeneratedKeys();* resultSet.next();* int id = resultSet.getInt(1);*/@Testpublic void resultPrinaryKey() throws SQLException, ClassNotFoundException {Class.forName("com.mysql.cj.jdbc.Driver");Connection connection = DriverManager.getConnection("jdbc:mysql:///web", "root", "1234567");String sql = "insert into tb_student(sname,gender,age) values(?,?,?);";PreparedStatement preparedStatement = connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);preparedStatement.setObject(1, "wang");preparedStatement.setObject(2, "女");preparedStatement.setObject(3, 21);int update = preparedStatement.executeUpdate();if (update > 0) {System.out.println("插入成功！");ResultSet resultSet = preparedStatement.getGeneratedKeys();resultSet.next();int id = resultSet.getInt(1);System.out.println("id=" + id);} else {System.out.println("插入失败！");}preparedStatement.close();connection.close();}

批量插入

批量执行SQL语句

JDBC的批量处理语句包括下面三个方法：
addBatch(String)：添加需要批量处理的SQL语句或是参数；
executeBatch()：执行批量处理语句；
clearBatch(): 清空缓存的数据
通常我们会遇到两种批量执行SQL语句的情况：
多条SQL语句的批量处理；
一个SQL语句的批量传参；

（mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
* ?rewriteBatchedStatements=true 写在配置文件的url后面）

 public void testInsert() throws SQLException, ClassNotFoundException {/*** 使用批量插入的方式插入10000条数据* 1、路径后添加rewriteBatchedStatements=true，允许批量插入* 2、insert into values 必须写，且语句不能添加;结束* 3、不是执行语句，是批量添加，addBatch()* 4、遍历添加 完毕以后，统一批量执行executeBatch()*/Class.forName("com.mysql.cj.jdbc.Driver");Connection connection = DriverManager.getConnection("jdbc:mysql:///web?rewriteBatchedStatements=true", "root", "1234567");String sql = "insert into user(account,password,nickname) values(?,?,?)";PreparedStatement preparedStatement = connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);long start = System.currentTimeMillis();for (int i = 0; i < 10000; i++) {preparedStatement.setObject(1, "w"+i);preparedStatement.setObject(2, "1s"+i);preparedStatement.setObject(3, "xs"+i);preparedStatement.addBatch();//不执行，接到values后面}preparedStatement.executeBatch();//执行批量操作long end = System.currentTimeMillis();System.out.println("执行10000次数据插入消耗时间："+(end-start));preparedStatement.close();connection.close();}

如果做出如下改进，即执行一部分一部分执行，则会提高速度。

            for (int i = 0; i < 10000; i++) {preparedStatement.setObject(1, "w"+i);preparedStatement.setObject(2, "女"+i);preparedStatement.setObject(3, i+10);//1.“攒”sqlpreparedStatement.addBatch();if(i % 500 == 0){//2.执行preparedStatement.executeBatch();//3.清空preparedStatement.clearBatch();}

 数据源连接池

工作原理

多种开源的数据库连接池

（特别注意：
数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。）

Druid（德鲁伊）数据库连接池
Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。

硬编码方式：如下把参数信息用代码表示（不易修改，灵活性差，不推荐）

public class DruidUsePart {/*** 直接使用代码设置连接池连接参数方式* 1、创建一个druid连接对象* 2、设置连接池参数【必须|非必须】* 3、获取连接【通用方法，所有连接池都一样】* 4、回收连接【通用方法*/public void testHard() throws SQLException {//连接池对象DruidDataSource druidDataSource = new DruidDataSource();//设置参数//必须 连接数据库驱动类的全限定符【注册驱动】 | url | user | passworddruidDataSource.setUrl("jdbc:mysql:///jdbc");druidDataSource.setUsername("root");druidDataSource.setPassword("1234567");druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");//非必须 初始化连接数量，最大的连接数量druidDataSource.setInitialSize(4);//初始化连接数量druidDataSource.setMaxActive(19);//最大数量//获取连接Connection connection = druidDataSource.getConnection();//数据库curd//回收连接connection.close();//连接池提供的连接，close，就是回收连接}}

软编码方式：如下将配置信息写入配置文件，通过读取配置文件获取参数

properties文件要自己创建，里面放入上面代码所表示的信息

getResourceAsStream("druid.properties");注意这里的写法，如果是在src下则直接写文件名

 /*** 通过读取外部配置文件的方法，实例化druid连接池的对象*/@Testpublic void testSoft() throws Exception {//1、读取外部的配置文件Properties properties = new Properties();//src下的文件，可以使用类加载器提供的方法InputStream resourceAsStream = DruidUsePart.class.getClassLoader().getResourceAsStream("druid.properties");properties.load(resourceAsStream);//2、使用连接池的工具类的工厂模式，创建连接池DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);Connection connection = dataSource.getConnection();//数据库curd操作在创建连接后的这里实现即可connection.close();}

（补充：配置文件里的相关信息

把创建连接池封装到一个类中。

public class DruidTest {private static DataSource dataSource=null;static {try {//1.加载配置文件Properties properties = new Properties();InputStream resourceAsStream = DruidTest.class.getClassLoader().getResourceAsStream("jdbc.properties");properties.load(resourceAsStream);//2.获取DataSourcedataSource = DruidDataSourceFactory.createDataSource(properties);} catch (Exception e) {e.printStackTrace();}}//获取连接public static Connection getConnection() throws Exception {return dataSource.getConnection();}//关闭资源public static void close(Connection connection, PreparedStatement preparedStatement){close(connection,preparedStatement,null);}public static void close(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet){try {if(resultSet!=null){resultSet.close();}} catch (Exception e) {e.printStackTrace();}try {if(preparedStatement!=null){preparedStatement.close();}} catch (Exception e) {e.printStackTrace();}try {if(connection!=null){connection.close();}} catch (Exception e) {e.printStackTrace();}}}

Apache-DBUtils实现CRUD操作

commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。

a

• Dbutils三个核心功能

  • QueryRunner中提供对sql语句操作的API.

  • ResultSetHandler接口，用于定义select操作后，怎样封装结果集.

  • DbUtils类是一个工具类，定义了关闭资源与事务处理的方法

• QueryRunner核心方法

  • QueryRunner(DataSource ds) ；传入参数为连接池

  • update(String sql, Object… params) ，执行insert update delete操作（增删改）

  • query(String sql, ResultSetHandler rsh, Object… params) ，执行 select操作

• ResultSetHandler结果集处理

例如测试添加

public void testInsert() {Connection connection=null;try {QueryRunner queryRunner = new QueryRunner();connection= DruidTest.getConnection();String sql = "insert into tb_student(sid,sname,gender,age)values(?,?,?,?)";int update = queryRunner.update(connection, sql, 2, "forget", "女", 19);System.out.println(update);} catch (Exception e) {throw new RuntimeException(e);}finally {DruidTest.close(connection,null);}}

删除（如下就是sql语句不同和改变参数即可）

public void testDetele() {Connection connection=null;try {QueryRunner queryRunner = new QueryRunner();connection= DruidTest.getConnection();String sql = "delete from tb_student where sid = ?";int update = queryRunner.update(connection, sql, 2);System.out.println(update);} catch (Exception e) {throw new RuntimeException(e);}finally {DruidTest.close(connection,null);}}
}

使用ResultSetHandler结果集处理

ResultSetHandler接口及实现类

该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。
ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。
接口的主要实现类：
 

ArrayHandler：把结果集中的第一行数据转成对象数组。
ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
ColumnListHandler：将结果集中某一列的数据存放到List中。
KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map
里，其key为指定的key。
MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
ScalarHandler：查询单个值对象

使用ResultSetHandler的实现类：BeanHandler：查询一条记录

 public void testSelect1() {Connection connection=null;try {QueryRunner queryRunner = new QueryRunner();connection= DruidTest.getConnection();String sql = "select * from tb_student where sid = ?";BeanHandler<Student> handler = new BeanHandler<>(Student.class);Student query = queryRunner.query(connection, sql, handler, 1);System.out.println(query);} catch (Exception e) {throw new RuntimeException(e);}finally {DruidTest.close(connection,null);}}

使用ResultSetHandler的实现类：BeanListHandler：查询多条记录构成的集合

public void testSelect2() {Connection connection=null;try {QueryRunner queryRunner = new QueryRunner();connection= DruidTest.getConnection();String sql = "select * from tb_student";BeanListHandler<Student> handler = new BeanListHandler<>(Student.class);List<Student> query = queryRunner.query(connection, sql, handler);System.out.println(query);} catch (Exception e) {throw new RuntimeException(e);}finally {DruidTest.close(connection,null);}}

使用ResultSetHandler的实现类：MapHandler：查询第一行数据

使用ResultSetHandler的实现类：MapListHandler：查询所有数据

使用ResultSetHandler的实现类：ScalarHandler：查询单个值的对象

如何查询类似于最大的，最小的，平均的，总和，个数相关的数据，
* 使用ScalarHandler

自定义ResultSetHandler的实现类

public void testSelect6() {Connection connection=null;try {QueryRunner queryRunner = new QueryRunner();connection= DruidTest.getConnection();String sql = "select * from tb_student";ResultSetHandler<List<Student>> handler = new ResultSetHandler<List<Student>>() {@Overridepublic List<Student> handle(ResultSet resultSet) throws SQLException {List<Student> list = new ArrayList<>();System.out.println("自定义");while(resultSet.next()){int sid = resultSet.getInt(1);String sname = resultSet.getString(2);String gender = resultSet.getString(3);int age = resultSet.getInt(4);list.add(new Student(sid,sname,gender,age));}return list;}};List<Student> query = queryRunner.query(connection, sql, handler);query.forEach(System.out::println);} catch (Exception e) {throw new RuntimeException(e);}finally {DruidTest.close(connection,null);}}

（ ResultSetHandler<List<Student>> handler = new ResultSetHandler<List<Student>>() {这里的泛型决定了下面重写方法的返回值，因为在方法中老是不能返回List集合，好像是因为一开始在泛型这里写的是Student

输出结果：

数据库事务

 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提(commit)，那么这些修改就永久地保存下来；
要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。

JDBC事务处理
a、数据一旦提交，就不可回滚。
b、数据什么时候意味着提交？
当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会
向数据库自动提交，而不能回滚。
关闭数据库连接，数据就会自动的提交。如果多个操作，每个操作使用的是自己单独的连接，则无法保证
事务。即同一个事务的多个操作必须在同一个连接下。
c、JDBC程序中为了让多个 SQL 语句作为一个事务执行：
调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
在出现异常时，调用 rollback(); 方法回滚事务

创建表

对字段进行设置让其值不能为负，才不会得到如下结果（

public class BankDao {/*** 加钱的数据库操作方法（jdbc）*     account 加钱的账号*     money 加钱的金额**/public void add(String account,int money,Connection connection) throws ClassNotFoundException, SQLException {String sql = "update bank set money = money+? where account =?; ";PreparedStatement preparedStatement = connection.prepareStatement(sql);preparedStatement.setObject(1,money);preparedStatement.setObject(2,account);preparedStatement.executeUpdate();System.out.println("加钱成功！");}/*** 减钱的数据库操作方法（jdbc）*     account 减钱的账号*     money 减钱的金额**/public void sub(String account,int money,Connection connection) throws ClassNotFoundException, SQLException {String sql = "update bank set money = money-? where account = ?; ";PreparedStatement preparedStatement = connection.prepareStatement(sql);preparedStatement.setObject(1,money);preparedStatement.setObject(2,account);preparedStatement.executeUpdate();System.out.println("减钱成功！");}
}

public class BankService {@Testpublic void start() throws SQLException, ClassNotFoundException {transfer("小熊", "大大", 500);}/*事务添加是在业务方法中：利用try catch代码块，开启事务和提交事务，事务回滚将connection传入dao层即可，dao只负责使用，不要close()*/public void transfer(String addAccount, String subAccount, int money) throws SQLException, ClassNotFoundException {BankDao bankDao = new BankDao();Class.forName("com.mysql.cj.jdbc.Driver");Connection connection = DriverManager.getConnection("jdbc:mysql:///jdbc", "root", "1234567");try {//开启事务connection.setAutoCommit(false);//执行数据库动作bankDao.add(addAccount, money, connection);System.out.println("----------------------");bankDao.sub(subAccount, money, connection);//事务提交connection.commit();} catch (Exception e) {// 5.若有异常，则回滚事务try {connection.rollback();} catch (SQLException e1) {e1.printStackTrace();}e.printStackTrace();} finally {try {//6.恢复每次DML操作的自动提交功能connection.setAutoCommit(true);} catch (SQLException e) {e.printStackTrace();}//7.关闭连接connection.close();}}
}

执行后得到

可以看到数据库中二者的钱数没有变化，可知进行了回滚

DAO及相关实现类

DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、
Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
作用：为了实现功能的模块化，更有利于代码的维护和升级。