梵高的猪v
梵高的猪v

JAVA高级核心-JDBC-与数据库交互的一套标准规范

文章目录

    • 推荐后学
    • 第一章：概述
      • 1.1 JavaWeb技术
      • 1.2 JDBC概述
      • 1.3 JDBC程序编写步骤
    • 第二章：获取数据库连接
      • 2.1 Driver（驱动）接口实现
    • 第三章：PreparedStatement 实现CRUD
      • 3.1 Statement
      • 3.2 PreparedStatement
      • 3.3 实现 增
      • 3.4 *封装 增删改
      • 3.5 查
      • 3.6 *封装 查
      • 3.7 *思考
      • 3.8 *任意表查询
      • 3.9 利用集合处理多行的结果集
      • 3.10 好处
      • 3.11 Blob类型
      • 3.12 批量操作
      • 3.13 Statement vs preparedStatement
    • 第四章：数据库事务
      • 4.1 引入
      • 4.2 *事务 1.0
      • 4.3 事务的ACID属性
      • 4.4 数据库的并发问题
      • 4.5 *数据库的隔离级别
    • 第五章：DAO
    • 第六章：数据库连接池
      • 6.1 连接池
      • 6.2 c3p0
      • 6.3 dbcp
      • 6.4 *Druid
    • 第七章：Apache-DBUtils 实现CRUD
      • DbUtils类
      • ResultSetHandler接口
      • QueryRunner实现类
      • 代码示例

推荐后学

  1. 九万字的JavaWeb学习记录,从入门到入坟,更近一步
  2. 五万字的Spring5学习笔记,带你熟悉运用Spring5

第一章：概述

1.1 JavaWeb技术

  • B/S Brower/Server

  • C/s Client/Server

  • 目前前端三大技术。html，css，js，框架：Vue，react。

1.2 JDBC概述

  • JDBC 直接访问数据库

  • JDO 技术（Java Data Object）

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

  • JDBC 是 java 访问数据库的基石，JDO, Hibernate 等只是更好的封装了 JDBC。

  • JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统（DBMS）、通用的 SQL 数据库存取和操作的 公共接口（一组 API），定义了用来访问数据库的标准 Java 类库，使用这个类库可以以一种标准的方法、方便地访 问数据库资源 JDBC 为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。 JDBC 的目标是使 Java 程序员使用 JDBC 可以连接任何提供了 JDBC 驱动程序的数据库系统，这样就使得程序员无需 对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。

    有 JDBC，那么 Java 程序访问数据库时是这样的：

    JAVA高级核心-JDBC-与数据库交互的一套标准规范_第1张图片

    https://i.loli.net/2021/06/21/hwHcgGe3IkQWLyZ.png

    如果没有JDBC，每种数据库都有一种规范，都给开发者造成很大麻烦，JDBC便定义了这种规范接口，让各自厂商实现自己的驱动，而开发者只是面向该接口去编程就可以了。

1.3 JDBC程序编写步骤

JAVA高级核心-JDBC-与数据库交互的一套标准规范_第2张图片

​ https://i.loli.net/2021/06/21/tqGvP2DzWUZyabL.png

第二章：获取数据库连接

2.1 Driver（驱动）接口实现

  • 五种方式获取驱动，即与数据库连接，请详细看代码注释
package com.hyb.JDBC;

import com.mysql.cj.jdbc.Driver;
import org.junit.Test;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @program: ConectionTest
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-21 19:48
 **/

public class ConnectionTest {
//    方式一,用Driver接口
    @Test
    public void testConnection1() throws SQLException {
//        获取jar包下的驱动类，要是没有jar包，请上网查找如何导入，应用
        Driver driver = new Driver();
//        获取你数据库的URL，jdbc:mysql:协议，localhost ip地址，3306 端口号,你的想要操作数据库的名称
        String url="jdbc:mysql://localhost:3306/mysqldata";
//        获取一个Properties，来获取用户和密码
        Properties info=new Properties();
        info.setProperty("user","root");
        info.setProperty("password","15717747056HYB");
//        进行连接
        Connection connect = driver.connect(url, info);
        System.out.println(connect);
//        获得数据库的toString
//        com.mysql.cj.jdbc.ConnectionImpl@38364841
    }


//    方式二，对方式一的迭代
//    为什么要迭代？
//    Java具有可移植性，我们可以看到在本类的开头
//    import com.mysql.cj.jdbc.Driver;
//    这说明我们在用方式一连接数据库的时候需要导包，这也就限制了我们的移植性，
//    所以我们要解决这一矛盾，可以需要用到反射去获取import com.mysql.cj.jdbc.Driver;
    @Test
    public void testConnection2() throws Exception{
//        利用反射获取import com.mysql.cj.jdbc.Driver;
        Class classConnection = Class.forName("com.mysql.cj.jdbc.Driver");
//        利用反射获取运行时类的对象
        Driver driver= (Driver) classConnection.newInstance();
//        然后其他步骤都一样
        String url="jdbc:mysql://localhost:3306/mysqldata";
//        获取一个Properties，来获取用户和密码
        Properties info=new Properties();
        info.setProperty("user","root");
        info.setProperty("password","15717747056HYB");
//        进行连接
        Connection connect = driver.connect(url, info);
        System.out.println(connect);
//        com.mysql.cj.jdbc.ConnectionImpl@63a65a25
    }

//      加入 DriverManager
    @Test
    public void testConnection3() throws Exception {
//        利用反射获取import com.mysql.cj.jdbc.Driver;
        Class classConnection = Class.forName("com.mysql.cj.jdbc.Driver");

//        获取对象
        Driver driver = (Driver) classConnection.newInstance();


//        注册驱动
        DriverManager.registerDriver(driver);

        String url="jdbc:mysql://localhost:3306/mysqldata";
        String u="root";
        String p="15717747056HYB";
        Connection connection = DriverManager.getConnection(url, u, p);
        System.out.println(connection);
//        com.mysql.cj.jdbc.ConnectionImpl@54c562f7

    }

//    方式四：对方式三的优化
    @Test
    public void testConnection4() throws Exception {
    //        利用反射获取import com.mysql.cj.jdbc.Driver;
//        删除Class classConnection =
        Class.forName("com.mysql.cj.jdbc.Driver");
//        如下操作可以被注释掉：
//           获取对象
//        Driver driver = (Driver) classConnection.newInstance();
//           注册驱动
//        DriverManager.registerDriver(driver);
//        为什么可以？
//        在mysql的实现类的众，声明了如下操作
//        static {
//            try {
//                DriverManager.registerDriver(new Driver());
//            } catch (SQLException var1) {
//                throw new RuntimeException("Can't register driver!");
//            }
//        }
//      它会自动帮你创建
        String url="jdbc:mysql://localhost:3306/mysqldata";
        String u="root";
        String p="15717747056HYB";
        Connection connection = DriverManager.getConnection(url, u, p);
        System.out.println(connection);
    //        com.mysql.cj.jdbc.ConnectionImpl@54c562f7

    }


//    最终版，我们都知道，程序一般都不要暴露我们的信息，所以我们要将自己的数据库信息放到一个配置文件里再读取
    @Test
    public void finalConnection() throws Exception{
//        我们要用类的加载器来获取配置文件，所以要在src下建立Properties格式的文件
//          user=root
//          password=15717747056HYB
//          url=jdbc:mysql://localhost:3306/mysqldata
//          driverClass=com.mysql.cj.jdbc.Driver
//        尽量不要有空格，除非你的数据本身就有空格

        InputStream o = ConnectionTest.class.getClassLoader().getResourceAsStream("myTest.properties");
        Properties p = new Properties();
        p.load(o);

        String user = p.getProperty("user");
        String password = p.getProperty("password");
        String url = p.getProperty("url");
        String driverClass = p.getProperty("driverClass");

        Class.forName(driverClass);

        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
//        com.mysql.cj.jdbc.ConnectionImpl@54c562f7

    }

}

第三章：PreparedStatement 实现CRUD

  • CRUD增删改查

3.1 Statement

  • 弊端：会出现SQL语句注入问题，在用户输出非法的用户名和密码，可能会产生恶意的SQL语句，造成也登录成功的后果。

3.2 PreparedStatement

  • 是Statement的子接口，用其可解决Statement的问题
  • 预编译的SQL语句

3.3 实现 增

package com.hyb.JDBC;

import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @program: QueryTest
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-22 09:43
 **/

public class SQLTest {
    @Test
    public void InsertTest() {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            InputStream o = SQLTest.class.getClassLoader().getResourceAsStream("myTest.properties");
            Properties p = new Properties();
            p.load(o);

            String user = p.getProperty("user");
            String password = p.getProperty("password");
            String url = p.getProperty("url");
            String driverClass = p.getProperty("driverClass");

            Class.forName(driverClass);

            connection = DriverManager.getConnection(url, user, password);

//        连接成功后，我们对自己的数据库表进行操作，下面给出我的数据库表
//        name_b    age     work        salary
//        hyb      21     student        0
//        hfy      13     father     1000
//        zyl      21     student        0
//        lzm      12     student        0
//        cjk      13     film       10000

//        写入SQL语句
            String sql="insert into firstme(name_b,age,work,salary) values(?,?,?,?)";
            ps = connection.prepareStatement(sql);

//        填充占位符
            ps.setString(1,"newHyb");
            ps.setInt(2,21);
            ps.setString(3,"student");
            ps.setString(4,"0");
//            执行
            ps.execute();
        } catch (IOException | SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                assert ps != null;
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
//         插入成功后，会出现以下内容
//        name_b    age     work        salary
//        hyb      21     student        0
//        hfy      13     father     1000
//        zyl      21     student        0
//        lzm      12     student        0
//        cjk      13     film       10000
//        newHyb   21      student       0
    }
}

3.4 *封装 增删改

  • 以上，当我们进行增删改查数据库时都要进行连接和关闭资源的操作，所以可以对他们进行封装。

    package com.hyb.JDBC;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @program: SQLConnection
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-22 10:31
 **/

public class SQLConnection {
    public static Connection connect() throws Exception {
        Connection connection = null;
        InputStream o = SQLTest.class.getClassLoader().getResourceAsStream("myTest.properties");
        Properties p = new Properties();
        p.load(o);
        String user = p.getProperty("user");
        String password = p.getProperty("password");
        String url = p.getProperty("url");
        String driverClass = p.getProperty("driverClass");
        Class.forName(driverClass);
        connection = DriverManager.getConnection(url, user, password);
        return connection;
    }

    public static void Close(Connection cnt,PreparedStatement ps){
        try {
            assert ps != null;
            ps.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            cnt.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

  • 进行封装后，我们测试，执行修改数据库某条指定的操作

        @Test
    public void upDatedSQl(){
        Connection connect = null;
        PreparedStatement ps = null;
        try {
//        1.获取数据库连接
            connect = SQLConnection.connect();
//        2.进行SQl语句的预编译
            ps = connect.prepareStatement("update firstme set name_b=? where name_b=? ");
//       3. 填充占位符
            ps.setObject(1,"oldHyb");
            ps.setObject(2,"newHyb");
            ps.execute();
            System.out.println("修改成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            assert ps != null;
            SQLConnection.Close(connect,ps);
        }
//        修改成功！
//        oldHyb   student    21 0
    }

  • 封装一次后，是否可以再封装，答案是可以的！

    数据库连接和资源关闭我们已经封装了，所以我们下一步进行增删改的操作，这里没有查，查询不一样。

    package com.hyb.JDBC;

import java.sql.Connection;
import java.sql.PreparedStatement;

/**
 * @program: SQLUpdate
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-22 11:10
 **/

public class SQLUpdate {
//        Connection connect = null;
//        PreparedStatement ps = null;
//        try {
        1.获取数据库连接
//            connect = SQLConnection.connect();
        2.进行SQl语句的预编译
//            ps = connect.prepareStatement("update firstme set name_b=? where name_b=? ");
       3. 填充占位符
//            ps.setObject(1,"oldHyb");
//            ps.setObject(2,"newHyb");
//            ps.execute();
//            System.out.println("修改成功！");
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            assert ps != null;
//            SQLConnection.Close(connect,ps);
//        }

//    要包装，我们要解决几个问题：
//    1.每次传入的sql语句都不一样
//    2.更新语句不一样
//    1.我们可以传入一个String类型的字符串
//    2.这个更新语句，我们可以用可变形参，类型不一样，直接定义为Object类型便可以了
    public static void updateSQL(String sql,Object ...arg){
        Connection connect = null;
        PreparedStatement ps = null;
        try {
//        1.获取数据库连接
            connect = SQLConnection.connect();
//        2.进行SQl语句的预编译
            ps = connect.prepareStatement(sql);
//        3. 填充占位符
            for (int i = 0; i < arg.length; i++) {
//              这里填充占位符，记住在我们sql语句里，索引是从1开始的，而数组是从0开始的
                ps.setObject(i+1,arg[i]);
            }
            ps.execute();
            System.out.println("修改成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            assert ps != null;
            SQLConnection.Close(connect,ps);
        }
    }
    
}

    接下来，我们调用

        @Test
    public void testSQLUpdate(){
        SQLUpdate.updateSQL("update firstme set name_b=? where name_b=?","reNewHyb","oldHyb");
        //这里对于每个表都是有用的，不过有时候会报错，因为表名有可能是SQL语句里的关键字，所以要是报错，可以检查一下表名，两边加单引号就可以了
//        reNewHyb
    }

3.5 查

  • 查询数据表操作，类似，但又有些不同，要处理返回的结果，也就是结果集。

  • 但一张表可能有很多属性，而且每个属性都有很多数据，即使我们用数组来操作，依旧显得有些无力。

    所以，我们一般用类来操作整个表。

    那么就要引入ORM思想：

    1. 一个数据表对应一个类
    2. 表中的每条记录对应一个对象。
    3. 表中的字段对应类的各个属性。

  • 下面我们如同增删改的步骤一样，先引入我们一般的查询写法。

        @Test
    public void testQuery(){
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
//      1.我们封装了连接和关闭资源操作，直接调用就可以了
            Connection connect = SQLConnection.connect();

//      2.进行SQl的预编译
            ps = connect.prepareStatement("select name_b,age,work,salary from firstme where name_b=? ");

//      3.填充占位符,第一个占位符，为hyb
            ps.setObject(1,"hyb");

//      4.启动查询,方法有些不一样
            rs = ps.executeQuery();

//      5.对结果集进行处理,这里的处理思想和迭代器一样
            if (rs.next()){

    //          5.1 记住，rs表示整张表，而我们数据库的索引是从1开始的。
                String name = rs.getString(1);
                int age = rs.getInt(2);
                String work= rs.getString(3);
                String salary = rs.getString(4);

    //          5.2 之后，我们要处理这里数据，让他们输出，可以采用ORM思想，建立这个表的类
                firstmeTableClass ftc = new firstmeTableClass(name, age, work, salary);
                System.out.println(ftc);
//              firstmeTableClass{name_b='hyb', age=21, work='student', salary='0'}
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
 //      6.关闭资源，也可以直接调用我们之前封装好的
            try {
                assert rs != null;
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }

    查询方法写完后，我们为方法里的类补全

    package com.hyb.JDBC;

/**
 * @program: firstmeClass
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-22 12:42
 **/

public class firstmeTableClass {
    private String name_b;
    private int age;
    private String work;
    private String salary;

    public firstmeTableClass() {
    }

    public firstmeTableClass(String name_b, int age, String work, String salary) {
        this.name_b = name_b;
        this.age = age;
        this.work = work;
        this.salary = salary;
    }

    public String getName_b() {
        return name_b;
    }

    public void setName_b(String name_b) {
        this.name_b = name_b;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getWork() {
        return work;
    }

    public void setWork(String work) {
        this.work = work;
    }

    public String getSalary() {
        return salary;
    }

    public void setSalary(String salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "firstmeTableClass{" +
                "name_b='" + name_b + '\'' +
                ", age=" + age +
                ", work='" + work + '\'' +
                ", salary='" + salary + '\'' +
                '}';
    }
}

3.6 *封装 查

package com.hyb.JDBC;

import javax.management.Query;
import java.lang.reflect.Field;
import java.sql.*;

/**
 * @program: Query，通用查询
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-22 12:08
 **/


/*通用查询从操作，我们会遇到如下几个问题
 * 1.传入什么sql语句
 * 2.占位符有几个
 * 3.我们都知道，一个表里有多少个列，我们定义的类就有多少个属性；
 *   而这些属性个数正好也决定了这个类中的带参构造器的参数个数；
 *   我们查询的时候要用到ORM思想，就必须去new对象，并初始化，
 *   *但当我们要查询的列数和表的列数不相同（也就是和类的构造器参数的个数不同）时，我们该如何去初始化这个类的对象？
 * */


public class SQLQuery {
    public static Object Query(String sql,Object ...arg){
        Connection connect = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
//        1.数据库连接
            connect = SQLConnection.connect();
//        2.进行sql预编译
            ps = connect.prepareStatement("select name_b,age from firstme where name_b=? ");
//        3.填充占位符
            for (int i = 0; i < arg.length; i++) {
                ps.setObject(i+1,arg[i]);
            }
//        4.启动查询,返回一个结果集
            rs = ps.executeQuery();
//        5.迭代
//        5.1.1 获取结果集的元数据,因为还是结果，所以我们要在迭代之前获取元数据
            ResultSetMetaData mdt = rs.getMetaData();
//        5.1.2 获取这些元数据的列数
            int columnCount = mdt.getColumnCount();
            if (rs.next()){
    //            5.1 在没有封装之前，我们要将我们要查的列传入到一个类中
    //                  但是现在这里不是所有的列，就不能用构造器的方法去初始化一个对象
    //                  所以我们要解决这个问题，只能利用反射去初始化一个对象的属性
    //                  但是要初始化这些属性，也必须知道我们到底要查哪些列，而上面我们进行预编译的sql是String类型的，所以很难获取。
    //                  所以要引入*元数据*的概念，String name=“hyb”，hyb便是这个String name的元数据（5.1.1）。

    //            5.1.3 初始化一个对象，没有初始值
                firstmeTableClass ftc = new firstmeTableClass();
                for (int i = 0; i < columnCount; i++) {
    //                5.1.4 获取每个列的列值，待会我们要将它赋值给类里的属性
                    Object o = rs.getObject(i + 1);

    //                5.1.5 获取每列的列名，
                    String columnName = mdt.getColumnName(i+1);
    //                5.1.6 通过反射初始化columnName这个列的值
                    Field df = firstmeTableClass.class.getDeclaredField(columnName);
                    df.setAccessible(true);
                    df.set(ftc,o);//df是ftc对象里的属性，被赋值为o
                }
    //            5.1.7 每一行都是一个对象，每次有行都要返回
                return ftc;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//        6.资源关闭
            SQLConnection.Close(connect,ps);
            try {
                if (rs!=null) {
                    rs.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        return null;
    }

}

封装完毕后，我们执行

    @Test
    public void Query(){
        Object hybData = SQLQuery.Query("select name_b,age from firstme where name_b=? ", "hyb");
        System.out.println(hybData);
//        firstmeTableClass{name_b='hyb', age=21, work='null', salary='null'}
    }

3.7 *思考

  • 上面我们用自定义类代表数据表，下面引出一个问题：如果类中的属性名和数据表中的列名不一样会发生什么？

    无法找到列名异常！

    为什么会出现这种情况？请看下列代码：

    //                5.1.5 获取每列的列名，
                String columnName = mdt.getColumnName(i+1);
//                5.1.6 通过反射初始化columnName这个列的值
                Field df = firstmeTableClass.class.getDeclaredField(columnName);
                df.setAccessible(true);
                df.set(ftc,o);//df是ftc对象里的属性，被赋值为o

    我们可以看到，反射机制是根据你列名与类对应的属性名相等才可以赋值的，如果不相等，自然会报错。

    那我们该如何解决这各小矛盾呢？总不能每一次定义的类的属性名和数据表里的列名一样，那样不规范了。

    可以利用sql语句的一个小知识来解决，每次查询的sql语句，我们都可以为被查询列赋一个新的名字，不妨就利用这个细节去处理

    ps = connect.prepareStatement("select name_b 类对应的属性名,age  类对应的属性名 from firstme where name_b=? ");

    可是这样修改后，再去运行，我们会发现，又报错了，还是无法找到列名异常？

    答案在这里：

    //                5.1.5 获取每列的列名，
                String columnName = mdt.getColumnName(i+1);

    这里我们可以看到，这个函数获取的还是列名，并不是列的别名，所以在Java里，提供了一个方法，没有别名就获取列名，有列名就获取别名的方法。

    String columnName = mdt.getColumnLabel(i+1);

    这样就完美了！

3.8 *任意表查询

  • 前面我们对一种查询都进行了封装，但这些封装还是比较固定的，为了描述问题，请看（封装 查）里的一些代码：

    public static Object Query(String sql,Object ...arg)
....
firstmeTableClass ftc = new firstmeTableClass();
....
Object o = rs.getObject(i + 1);
....
Field df = firstmeTableClass.class.getDeclaredField(columnName);

    以上这些代码都是些在程序里的，把他们写死了，肯定限制了可移植性，我们目标要的肯定是什么类，什么表，只要用了这个方法，返回值就是想要的结果。

    上面有四条语句，我们可以一步一步解决上面的问题：

    1. 首先，在函数声名的时候，我们可以将这个语句声名为泛型。
    2. 在new一个类的对象时，我们可以利用反射获取运行时类的对象。
    3. 那么，其他问题就很容易解决了。

  • 改变后：

    //    第一个,决定了该方法为泛型方法，对任意表的查询，
//    T 代表返回值类型
//    第二个泛型类，决定了返回值类型
    public static  T Query(Class className,String sql,Object ...arg)

                T ftc = className.newInstance();
            for (int i = 0; i < columnCount; i++) {
//                5.1.4 获取每个列的列值，待会我们要将它赋值给类里的属性
                Object o = rs.getObject(i + 1);

//                5.1.5 获取每列的列名，
                String column = mdt.getColumnLable(i+1);
//                5.1.6 通过反射初始化columnName这个列的值
                Field df = ftc.getClass().getDeclaredField(column);
                df.setAccessible(true);
                df.set(ftc,o);//df是ftc对象里的属性，被赋值为o
            }

       /*对于封装查询后的方法查询*/
    @Test
    public void Query(){
        Object hybData = SQLQuery.Query(firstmeTableClass.class, "select name_b,age from firstme where name_b=? ", "hyb");
        System.out.println(hybData);
//        firstmeTableClass{name_b='hyb', age=21, work='null', salary='null'}
    }

3.9 利用集合处理多行的结果集

  • 前面我们可以观察到，好像我输出一般都是一行一行或者是全部的，但是我们想要其中几行呢？不难想象，我们拿集合就可以了。
public static  List ListQuery(Class className,String sql,Object ...arg ){
    Connection connect = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        connect = SQLConnection.connect();
        ps = connect.prepareStatement(sql);
        for (int i = 0; i < arg.length; i++) {
            ps.setObject(i+1,arg[i]);
        }
        rs = ps.executeQuery();
        ArrayList obj = new ArrayList<>();
        ResultSetMetaData mt = rs.getMetaData();
        int columnCount = mt.getColumnCount();
        while (rs.next()){
            T t = className.newInstance();
            for (int i = 0; i < columnCount; i++) {
                String cl = mt.getColumnLabel(i+1);
                Field dfd = className.getDeclaredField(cl);
                dfd.setAccessible(true);
                Object o = rs.getObject(i + 1);
                dfd.set(t,o);
            }
            obj.add(t);
        }
        return obj;
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        SQLConnection.Close(connect,ps);
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    return null;
}

    @Test
    public void ListQuery(){
        List hyb = SQLQuery.ListQuery(firstmeTableClass.class, "select name_b,age from firstme where age> ? ", "hyb");
        System.out.println(hyb);
//        [firstmeTableClass{name_b='hyb', age=21, work='null', salary='null'}, firstmeTableClass{name_b='hfy', age=13, work='null', salary='null'}, firstmeTableClass{name_b='zyl', age=21, work='null', salary='null'}, firstmeTableClass{name_b='lzm', age=12, work='null', salary='null'}, firstmeTableClass{name_b='cjk', age=13, work='null', salary='null'}, firstmeTableClass{name_b='reNewHyb', age=21, work='null', salary='null'}]
    }

3.10 好处

  • 上面说到Statement会产生SQl注入的问题，而为什么PreparedStatement为什么不会呢？多次练习可见，使用后者会进行预编译，这就使得我们后者的语句里，就是架构，执行的时候会被缓存，进行多次执行，大大减少了代码量，只有到后面我们要运行的时候才会执行，而前者，一开始就说要干什么，会将本来不是数据的东西，就看成了数据，会造成混乱，而每执行一次，就要重写代码。
  • 不仅如此，使用后者，我们可以处理Blob类型的数据，比如图片，视频等。

3.11 Blob类型

  • MySQL中，支持四种的Blob数据：

    1. tinyblob:仅255个字符

    2. blob:最大限制到65K字节

    3. mediumblob:限制到16M字节

      • 这里数据库默认是只能插入小于1m的图片，所以在编程之前我们要进行如下预先设置：

        我们要在mysql安装的目录下，找到my.ini文件夹，打开然后将此此语句（max_allowed_packet=16M）插入最后。

    4. longblob:可达4GB

  • 无论是查找还是插入图片和视频，处理结果都一样，只不过要将它们转换成流交换而已。

    /*向数据库插入图片，在插入图片之前，我们先在Sql添加一列，如下：
    *
    name_b  age     work        salary  photo
    hyb        21     student        0      null
    hfy        13     father     1000   null
    zyl        21     student        0      null
    lzm        12     student        0      null
    cjk        13     film       10000  null
    reNewHyb   21 student        0      null

* */

    /*插入方式都一样，就是要把图片打散成流
    * 在这之前，我们要在本工程目录下，放一张图片（myLove.jpg）,大小超过1m，演示插入数据库的操作*/
    @Test
    public void InsertPhoto(){
        Connection connect = null;
        PreparedStatement ps = null;
        try {
//        获取数据库连接
            connect = SQLConnection.connect();
//        进行预编译
            ps = connect.prepareStatement("update firstme set photo= ? where name_b=? ");
//        填充占位符,要使用到流
            FileInputStream fis = new FileInputStream(new File("myLove.jpg"));
            ps.setObject(1,fis);
            ps.setObject(2,"zyl");
//        执行
            boolean execute = ps.execute();
//            zyl      21     student        0      一张图片
//            System.out.println(execute);false
            if(!execute){ System.out.println("执行成功！");}

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ps != null) {
                    ps.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                if (connect != null) {
                    connect.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    /*下面展示如何将图片从数据库查询图片，并放入文件夹里，这里，我们将放入的图片查询*/
    @Test
    public void PhotoQuery(){
        Connection connect = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        InputStream bs = null;
        FileOutputStream fs = null;
        try {
//        获取数据库连接
            connect = SQLConnection.connect();
            ps = connect.prepareStatement("select photo from firstme where name_b=? ");
            ps.setObject(1,"zyl");
            rs = ps.executeQuery();
            if (rs.next()){
                Blob photo = rs.getBlob("photo");
//        获得二进制流
                bs = photo.getBinaryStream();
//        读入文件里，这步骤前面讲过
                fs = new FileOutputStream("forMyLove.jpg");
                byte[] bys = new byte[1024];
                int len;
                while ((len=bs.read(bys))!=-1){
                    fs.write(bys,0,len);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                assert fs != null;
                fs.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bs.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            try {
                connect.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }

3.12 批量操作

  • 有关批量操作，有两个点，一是批量缓存，二是手动提交。
  • 若是不进行这两步，效率非常慢。
    @Test
    public void BathOperation(){
        Connection connect = null;
        PreparedStatement ps = null;
        try {
//
            long stTime = System.currentTimeMillis();

//        1.获取数据库连接
            connect = SQLConnection.connect();

//            预编译,这里只是预编译，还没有执行，到了for循环里面，进行execute才可以执行，这个时候数据才被提交
            ps = connect.prepareStatement("insert into firstme(name_b) values(?)");

//        为了增加速度，不允许连接自动提交数据，先将所有数据“攒”起来，
            connect.setAutoCommit(false);

            for (int i=0;i<100;i++){
                ps.setObject(1,"name_"+i);
    //            分批缓存
                ps.addBatch();
                if (i%500==0){
                    ps.execute();
                    ps.clearBatch();
                }
            }
//        全部缓存后，统一提交数据
            connect.commit();
            long endTime = System.currentTimeMillis();
            System.out.println(endTime-stTime);//2442
            
            /*我们可以看到，用的毫秒数是很少的，所以，我们要加快速度，有两点：
            * 1.加大批量缓存数目。
            * 2.手动提供数据。*/
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            SQLConnection.Close(connect,ps);
        }
    }

3.13 Statement vs preparedStatement

  • 后者是前者的子接口
  • 在Java中，sql语句还是个字符串，这两个接口提供一个信使功能去与数据库对接。
  • Statement会产生SQL注入，造成混乱。
  • 后者通过预编译解决了SQL注入问题。
  • 后者更高效，快捷，因为预编译，可对SQL语句进行缓存，在进行大量批量删除的时候，可以手动提交数据，大大减少了编译时间。

第四章：数据库事务

4.1 引入

  • 很经典的转账问题：A->B，A执行转出SQL语句，B执行转入SQL语句，若中间出现网络挂断，A的SQL语句执行了，B的没有执行，就会现丢失问题。

4.2 *事务 1.0

  • 为了解决这些问题，数据库引入了事务概念，一组逻辑操作单元（增删改查），使得数据从一种状态变换为另一种状态，如果出现中断，可以进行回滚（rollback），否则提交，称为事务。

  • 数据一旦提交，无法回滚。

  • 哪些数据会自动提交？DDL操作一旦执行，都会自动提交（无法手动提交），DML默认情况下，一旦执行，也会自动提交（可以手动提交）。当然，关闭连接后，也会自动提交。

  • 所以，我们要解决上面的问题，就要回滚，而要回滚，就要防止它出问题的时候自动提交。

  • 但我们会想到，我们一般执行完一条不同的SQL语句后，都会关闭连接，这样不就是自动了提交了？

    所以，在整件事务中，我们执行到一半操作，要避免关闭连接，到最后关闭才可以。这是本章的一个重点。

    public static void rollbackTx(Connection cnt,String sql,Object ...arg){
        PreparedStatement ps = null;
        try {
//        2.进行SQl语句的预编译
            ps = cnt.prepareStatement(sql);
//        3. 填充占位符
            for (int i = 0; i < arg.length; i++) {
//                这里填充占位符，记住在我们sql语句里，索引是从1开始的，而数组是从0开始的
                ps.setObject(i+1,arg[i]);
            }
            ps.execute();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            assert ps != null;
            //这里一定不能关闭连接，因为一旦关闭，数据就自动提交了，要关闭的是ps，ps关闭不会自动连接
            SQLConnection.Close(null,ps);
        }

    }

    /*下面展示事务回滚的操作，如何在出现网络堵塞的情况，转账不成功*/
//    我们还是用下面这个表(firstme)进行查询：
//       name_b    age     work        salary
//        hyb      21     student        0
//        hfy      13     father     1000
//        zyl      21     student        0
//        lzm      12     student        0
//        cjk      13     film       10000
//        reNewHyb 21      student       0
//    模拟cjk朝hfy转账五千，出现网络堵塞，是否成功！
    @Test
    public void RollbackTx(){
        Connection connect = null;
        try {
//        为了代码简洁，我们用之前写过的万能方法，进行操作。
            connect = SQLConnection.connect();
            //数据先不提交
            connect.setAutoCommit(false);
            SQLUpdate.rollbackTx(connect ,"update firstme set salary=salary-? where name_b=?",5000,"cjk");
//      网络异常
//            System.out.println(10/0);

            SQLUpdate.rollbackTx(connect,"update firstme set salary=salary+? where name_b=?",5000,"hfy");
            //执行一系列操作后再提交
            connect.commit();
            System.out.println("修改成功！");
//            hfy  13 father 6000
//            cjk  13 film   5000
        } catch (Exception e) {
            e.printStackTrace();
            try {
                if (connect != null) {
                    //                    当出现异常，进行回滚数据
                    connect.rollback();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        } finally {
            //            设置会默认值
            assert connect != null;
            try {
                connect.setAutoCommit(true);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            SQLConnection.Close(connect,null);
        }
    }
  • 有一点值得注意的是，我们要是进行手动提交，建议执行过后要调回true状态，因为可能下一个连接继续用false。

4.3 事务的ACID属性

  • 原子性：原子性是指事务是一个不可分割的工作单位，要么可以执行，要么不执行。如经典的转账问题，要么转账，要么不转账，不可能出现一方转账，一方没收到账的问题。
  • 一致性：事务必须从一个一致性状态装换为另一个一致性状态，如经典的转账问题，不可能出现一方只转账，没收到钱的状态，对于数据库来讲，这样的问题是不可能出现数据不一致状态。
  • 隔离性：指一个事务不能被另一个事务干扰，如经典的转账问题，不能出现第三方进行干扰，只能是两个人之间的转账。
  • 持久性：指一个事务一旦被提交，就不能回滚，如经典的转账问题，转出去的钱，不可能再收回来，只能通过对方进行转账，那又是另一个事务了。

4.4 数据库的并发问题

对于两个事务a，b同时操作一张表。

  • 脏读：a已经更新了数据库，但还未提交，此时b进行了读取，之后a才提交，这样来说b读取的数据是无效的。
  • 不可重复读：a读取了字段，b进行了更新，a再读取，读取的不再是原来的数据。
  • 幻读：a读取了一个字段，b增加了行数，再次读取，发现多了几行数据。
  • 但实际上，对于我们每天的数据更新，都要进行数据库更新，而且我们要时刻获取立马更新的数据，无论它事务有没有提交，我们都需要获取最新的数据，也就是说，解决上面的不可重复读和幻读问题，没有多大的实际意义（但有时候也要进行解决）。解决脏读问题，才是有意义的，因为脏读得到的是无效的数据。

4.5 *数据库的隔离级别

  • 数据库默认隔离级别为4，可解决脏读问题，意义重大，不用重写设置级别。
  • 但是在一些特殊情况下，我们需要解决不可重复读和幻读问题，在Connection接口里，可以通过源代码查看隔离级别设置的变量。
/*A constant indicating that transactions are not supported.*/
int TRANSACTION_NONE             = 0;

/**
 * A constant indicating that
 * dirty reads, non-repeatable reads and phantom reads can occur.
 * This level allows a row changed by one transaction to be read
 * by another transaction before any changes in that row have been
 * committed (a "dirty read").  If any of the changes are rolled back,
 * the second transaction will have retrieved an invalid row.
 */
int TRANSACTION_READ_UNCOMMITTED = 1;

/**
 * A constant indicating that
 * dirty reads are prevented; non-repeatable reads and phantom
 * reads can occur.  This level only prohibits a transaction
 * from reading a row with uncommitted changes in it.
 */
int TRANSACTION_READ_COMMITTED   = 2;

/**
 * A constant indicating that
 * dirty reads and non-repeatable reads are prevented; phantom
 * reads can occur.  This level prohibits a transaction from
 * reading a row with uncommitted changes in it, and it also
 * prohibits the situation where one transaction reads a row,
 * a second transaction alters the row, and the first transaction
 * rereads the row, getting different values the second time
 * (a "non-repeatable read").
 */
int TRANSACTION_REPEATABLE_READ  = 4;

/**
 * A constant indicating that
 * dirty reads, non-repeatable reads and phantom reads are prevented.
 * This level includes the prohibitions in
 * TRANSACTION_REPEATABLE_READ and further prohibits the
 * situation where one transaction reads all rows that satisfy
 * a WHERE condition, a second transaction inserts a row that
 * satisfies that WHERE condition, and the first transaction
 * rereads for the same condition, retrieving the additional
 * "phantom" row in the second read.
 */
int TRANSACTION_SERIALIZABLE     = 8;
  • 不懂数值的意思，可以查看解释。
  • 下面给出代码演示。
package com.hyb.JDBC;

import org.junit.Test;

import java.sql.Connection;
import java.sql.Time;
import java.util.List;

/**
 * @program: TransactionTest
 * @description:进行隔离级别的测试，还是使用下面的数据表对hfy的工资进行操作
 * 为了方便掩饰，我们直接throws异常
 * hyb  21 student    0
 * hfy 13 father 1000
 * zyl 21 student    0
 * lzm 12 student    0
 * cjk 13 film   10000
 * @author: Huang Yubin
 * @create: 2021-06-23 22:19
 **/

public class TransactionTest {
//    事务一：读取数据操作
    @Test
    public void rideTx() throws Exception{
        Connection connect1 = SQLConnection.connect();
//        查看隔离级别
        System.out.println(connect1.getTransactionIsolation());
//        设置隔离级别,数据库默认为4（TRANSACTION_REPEATABLE_READ），代表解决脏读问题，这里可忽略，要想验证隔离级别，请设置其他级别。
//        ->设置了不能解决脏读问题的隔离级别之后，我们会发现，在事务二没有提交之前，事务一是不可能读取成功，即读取的还是原来的。
//        如果我们将隔离级别换成不能读取脏读的（可以设置成0），那么会发现当事务二更新还未提交，事务一这边还是可以查询成功的，即查询到事务二更新但还未提交的值
        connect1.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
//        因为执行insert语句还是会自动提交，所以我们得设置为不能自动提交
        connect1.setAutoCommit(false);
        List hfy = SQLQuery.ListTxQuery(connect1, firstmeTableClass.class, "select * from firstme where name_b=? ", "hfy");
        System.out.println(hfy);

//        因为要演示，不能进行提交操作
    }
//    事务二：写入数据操作
    @Test
    public void writeTx() throws Exception{
        Connection connect2 = SQLConnection.connect();

        connect2.setAutoCommit(false);
        SQLUpdate.rollbackTx(connect2,"update firstme set salary=salary+? where name_b=?",1000,"hfy");

        Thread.sleep(15000);
//        这里我们不进行提交，也即是说数据库里的表不会进行更新操作。
    }

}

第五章：DAO

  • 虽然开发当中我们可以这样操作数据库，但是仍然比较麻烦，所以，DAO是我们专门用来操作数据库的，是对以上方法的封装模式

  • DAO模式有几个关键点：

    1. 提供操作数据表的抽象类A，该类的方法只能被子类或本类使用，不能被外部使用。
    2. 提供一个类B存储要操作的数据库表的数据，具体对象为数据表的每一行。
    3. 提供一个接口C，规范抽象类A里的具体方法。
    4. 提供一个实现类D继承于抽象类A，并实现接口C。

  • 第一步：抽象类A里有操作数据表的一般方法。

    package com.hyb.JDBCDAO;

import com.hyb.JDBC.SQLConnection;
import com.hyb.JDBC.SQLTest;
import com.hyb.JDBC.SQLUpdate;
import org.junit.Test;

import java.io.*;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @program: OPTable
 * @description:提供操作数据库的基本方法，为了只能让其子类调用其方法，所以要将其类定义为抽象类，方法也不能是静态的。
 * @author: Huang Yubin
 * @create: 2021-06-24 13:07
 **/

public abstract class OPTable {
//    1.获取数据库连接
    public Connection Connect(){
        Connection connection = null;
        try {
            InputStream o = SQLTest.class.getClassLoader().getResourceAsStream("myTest.properties");
            Properties p = new Properties();
            p.load(o);
            String user = p.getProperty("user");
            String password = p.getProperty("password");
            String url = p.getProperty("url");
            String driverClass = p.getProperty("driverClass");
            Class.forName(driverClass);
            connection = DriverManager.getConnection(url, user, password);
        } catch (IOException | SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return connection;
    }

//    2.关闭操作，这里我们将原来的稍作更改,因为我们处理结果集和文件流还是要关闭资源的
    public void Close(Connection cnt, PreparedStatement ps, ResultSet ...arg) {
        try {
            if (ps!=null) {
                ps.close();
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        try {
            if (cnt!=null){
                cnt.close();
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        for (ResultSet resultSet : arg) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

//    3.更新操作，包括普通插入，和视频图片等插入，更新数据。
   public void Update(Connection cnt,String sql,Object ...arg){
       PreparedStatement ps = null;
       try {
//        1.获取数据库连接
           //        2.进行SQl语句的预编译
           ps = cnt.prepareStatement(sql);
//        3. 填充占位符
           for (int i = 0; i < arg.length; i++) {
//                这里填充占位符，记住在我们sql语句里，索引是从1开始的，而数组是从0开始的
               ps.setObject(i+1,arg[i]);
           }
           ps.execute();
           System.out.println("修改成功！");
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           assert ps != null;
           Close(null,ps);
       }
   }

//   多行查询
    public   List ListQuery(Connection cnt,Class className, String sql, Object ...arg ){
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = cnt.prepareStatement(sql);
            for (int i = 0; i < arg.length; i++) {
                ps.setObject(i+1,arg[i]);
            }
            rs = ps.executeQuery();
            ArrayList obj = new ArrayList<>();
            ResultSetMetaData mt = rs.getMetaData();
            int columnCount = mt.getColumnCount();
            while (rs.next()){
                T t = className.newInstance();
                for (int i = 0; i < columnCount; i++) {
                    String cl = mt.getColumnLabel(i+1);
                    Field dfd = className.getDeclaredField(cl);
                    dfd.setAccessible(true);
                    Object o = rs.getObject(i + 1);
                    dfd.set(t,o);
                }
                obj.add(t);
            }
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            SQLConnection.Close(null,ps);
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        return null;
    }
}

  • 第二步：当我们要查询数据表的数据时，需要将数据放入一个类中，提供这个类B。

    package com.hyb.JDBCDAO;

/**
 * @program: SQLTable
 * @description:这里以一个类去存储要操作的数据库表。
 * @author: Huang Yubin
 * @create: 2021-06-24 13:04
 **/

public class SQLTable {
    private String name;
    private int age;
    private String job;
    private String salary;

    public SQLTable() {
    }

    public SQLTable(String name, int age, String job, String salary) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getSalary() {
        return salary;
    }

    public void setSalary(String salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "SQLTable{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", salary='" + salary + '\'' +
                '}';
    }
}

  • 提供接口C，规范类A里的操作。

    package com.hyb.JDBCDAO;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.List;

/**
* @Description: 此接口用于规范类OPTable的操作
* @Param: 
* @return: 
* @Author: Huang Yubin
* @Date: 2021/6/24
*/
public interface OPInterface{

    Connection getConnect();

    void setClose(Connection cnt, PreparedStatement ps);

    void insert(Connection cnt);

    void update(Connection cnt,SQLTable table);

    List ListQuery(Connection cnt);


}

  • 提供类D，继承类A，实现接口C

    package com.hyb.JDBCDAO;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;

/**
 * @program: OPClass
 * @description:提供实现类，继承SQLTable，实现OPInterface接口，写入sql语句，表示要干什么
 * @author: Huang Yubin
 * @create: 2021-06-24 17:14
 **/

public class OPClass extends OPTable implements OPInterface{

    @Override
    public Connection getConnect() {
        return Connect();
    }

    @Override
    public void setClose(Connection cnt, PreparedStatement ps) {
        Close(cnt,ps);
    }

    @Override
    public void insert(Connection cnt) {
        Update(cnt,"insert into firstme(name_b,age,work,salary) values(?,?,?,?)","RenewHyb",21,"student",0);
    }

    @Override
    public void update(Connection cnt, SQLTable table) {
        Update(cnt,"update firstme set name_b=? where name_b=? ","newHyb","hyb");
    }

    @Override
    public List ListQuery(Connection cnt) {
        return ListQuery(cnt, SQLTable.class, "select name_b name,age,work job,salary from firstme where name_b=? ", "hyb");
    }
}

  • 第五步：进行测试

    以本章统一数据表测试。

    package com.hyb.JDBCDAO;

import org.junit.Test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @program: SQLTest
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-24 16:22
 **/

public class SQLTest {
    @Test
    public void testInsert(){
        OPClass op = new OPClass();
        Connection connect = op.getConnect();
        op.insert(connect);
        op.setClose(connect,null);
    }

    @Test
    public void testQuery(){
        OPClass op = new OPClass();
        Connection connect = op.getConnect();
        List sqlTables = op.ListQuery(connect);
        op.setClose(connect,null);
        System.out.println(sqlTables);
    }
}

  • 说明：在开发未使用框架的情况下，一般使用DAO模型建设操作数据库，以抽象类为主类，再建立要操作数据表类和规范接口，这就形成了操作数据库的DAO模式，在这种模式下，不容易混乱，思路清晰，是我们在未使用框架下的一种高效开发手段。

  • 当然，这DAO模式还有一个小的升级版，我们进行DAO模式，是确立了要操作哪一张表，并且为这张表建立一个保存其数据的类，所以我们在下面的代码中：

    @Override
public List ListQuery(Connection cnt) {
    return ListQuery(cnt, SQLTable.class, "select name_b name,age,work job,salary from firstme where name_b=? ", "hyb");
}

    可以看出，我们在查询的时候，传入了SQLTable.class，这是合理的，因为我们要操作的就是这个类。但就是因为我们明确了要操作这个类，是否可以不用传入SQLTable.class呢？答案是可以，但这是一个比较困难的思路，要用反射。

    • 第一：在抽象类中，指明为泛型，可以操作任何类。

      public abstract class OPTable<T>

    • 第二：在子类继承上，说明继承了SQLTable类型（SQLTable是保存要操作的数据表的数据的类）的父类。

      public class OPClass extends OPTable implements OPInterface

    • 第三：既然说明了继承了哪个类型的父类，在本类OPClass中，类形参要删除。

      ListQuery(cnt, SQLTable.class, "select name_b name,age,work job,salary from firstme where name_b=?

      删除SQLTable.class,。

      既然不用传入SQLTable.class了，在public List ListQuery(Connection cnt,Class className, String sql, Object ...arg )里，我们就不用传入Class了，但如果不传入Class className，这函数里的T t = className.newInstance();就不能使用了（我们必须用到这条语句，不能忽略，这是它后面反射代码的关键），所以我们要解决的第一个问题就是既要保证它能被使用，又能删除泛型类的传入。【在这里泛型方法已经没有用了，所以我们也要删除public后的】

    • 第四：

      我们再具体描述一下第三步最后的问题：

      T t = className.newInstance();这条语句是在抽象类OPTable中的，在没删除ListQuery(cnt, SQLTable.class, "select name_b name,age,work job,salary from firstme where name_b=? 中SQLTable.class,之前，t是被SQLTable.class

      赋值的，而现在删除了SQLTable.class，说明t没有被赋值了，但是我们也得让t拥有这个值。在此之前，我们说过，我们在OPClass类中，已经声明了我们要继承的就是SQLTable类型的父类，即抽象类的OPTable的泛型就是SQLTable，所以我们要t也拥有SQLTable.calss，只能通过反射获取子类中的声明好的泛型父类OPTable中的泛型SQLTable。

      在这之前，因为要用在泛型父类OPTable中用到className,所以我们得先声明为null。

      public abstract class OPTable {
    private Class className=null;
    ...

      那么我们可以在本类下通过反射获取泛型子类中声明好的父类泛型

      public class OPClass extends OPTable implements OPInterface//获取SQLTable

      public abstract class OPTable {
    private Class className=null;

//    public OPTable() {
//    }
    {
//        获取子类中父类的泛型
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType parameterizedType= (ParameterizedType) genericSuperclass;
//        得到泛型数组，因为只有一个类型，所以这里是0
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        className= (Class) actualTypeArguments[0];
    }

      注意：上面代码里的this指的是子类的this，因为只有在子类中才能获取父类的泛型，如果这个this指代的父类的this，不合理，首先，这个父类是抽象的，不可能被实例化，其次，当要执行这个代码块的时候，只有子类调用ListQuery才会执行，也就是说每次要用到静态代码块，只是子类被实例化了一次，所以这个this只能指代子类。

      但有人会问，既然指代子类，为什么不在子类写这个静态代码块呢？如果在子类写入静态代码块，那么假如有很多子类的时候，都要写一次，造成代码冗杂。

      又有会问，不考虑冗杂问题，如果真放在子类中，能运行吗？毕竟父类声名的className是个null，而父类的方法里就有用className这个变量了。当然能运行，前面说过，通过子类才能调用父类需要变量className的方法，所以当子类一执行，静态代码块执行，产生className，这个时候调用父类方法，className自然有值啦！

第六章：数据库连接池

在使用开发基于数据库的 web 程序时，传统的模式基本是按以下步骤：

  • 在主程序（如 servlet、beans、DAO）中建立数据库连接。

  • 进行 sql 操作

  • 断开数据库连接。

这种模式开发，存在的问题:

  • 普通的 JDBC 数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection 加载到

    内存中，再验证 IP 地址，用户名和密码(得花费 0.05s～1s 的时间)。需要数据库连接的时候，就向数据库要求

    一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的

    重复利用.若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会

    造成服务器的崩溃。

  • 对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的 内存泄漏，最终将导致重启数据库。

  • 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄 漏，服务器崩溃。

数据库连接池的基本思想：

  • 为解决传统开发中的数据库连接问题，可以采用数据库连接池技术（connection pool）。

    数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需

    要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。数据库连接池负责分配、管理和释

    放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。

    数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库

    连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最

    大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量

    时，这些请求将被加入到等待队列中。

数据库连接池技术的优点：

  • 资源重用：

    ​ 由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，

    另一方面也增加了系统运行环境的平稳性。

  • 更快的系统反应速度

    ​ 数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工

    作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时

    间开销，从而减少了系统的响应时间

  • 新的资源分配手段

    ​ 对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数

    据库连接数的限制，避免某一应用独占所有的数据库资源

  • 统一的连接管理，避免数据库连接泄露

    ​ 在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规

    数据库连接操作中可能出现的资源泄露

两种开源的数据库连接池

  • JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic,

    WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：

    • DBCP 数据库连接池

    • C3P0 数据库连接池

  • DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池

DBCP 数据源

  • DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Common-pool. 如

    需使用该连接池实现，应在系统中增加如下两个 jar 文件：

    • Commons-dbcp.jar：连接池的实现

    • Commons-pool.jar：连接池实现的依赖库

  • Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独

    立使用。

  • 注意：

    • 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据

      源即可。

    • 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但 conn.close()并没有关闭数据库的

      物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

6.1 连接池

功能 *dbcp *druid *c3p0 tomcat-jdbc HikariCP
是否支持PSCache 是 是 是 否 否
监控 jmx jmx/log/http jmx,log jmx jmx
扩展性 弱 好 弱 弱 弱
代码 简单 中等 复杂 简单 简单
sql拦截及解析 无 支持 无 无 无
更新时间 2015.8.6 2015.10.10 2015.12.09 2015.12.3
特点 依赖于common-pool 阿里开源，功能全面 历史久远，代码逻辑复杂，且不易维护 底层 优化力度大，功能简单，起源于boneCP
连接池管理 LinkedBlockingDeque 数组 FairBlockingQueue threadlocal+CopyOnWriteArrayLis

6.2 c3p0

  • 下面演示c3p0连接池获取连接的步骤。

  • 第一步：下载第三方jar包，c3p0-0.9.5.5.jar，mchange-commons-java-0.2.20.jar，下载网址：

    http://mvnrepository.com/artifact/com.mchange/mchange-commons-java/0.2.15（进去，找到Jdbcpool,然后下载上面两个，可以下载不同版本）

  • 第二步：两个jar都要导入EXternal Libraries下，上网查阅以前的视频，好像只要第一个jar就可以了，但是本人尝试过不行，可能是新版的原因，两个都导入后方可成功，导包过程若不懂请上网查阅。

  • 第三步：请看代码。

    //    方式一，获取数据库连接池，不建议这么写代码
    @Test
    public void testConnection() throws Exception {
        ComboPooledDataSource cpld = new ComboPooledDataSource();
//        对比
//        获取jar包下的驱动类，要是没有jar包，请上网查找如何导入，应用
//        import com.mysql.cj.jdbc.Driver;
//        Driver driver = new Driver();
        cpld.setDriverClass("com.mysql.cj.jdbc.Driver");
        获取你数据库的URL，jdbc:mysql:协议，localhost ip地址，3306 端口号,你的想要操作数据库的名称
//        String url="jdbc:mysql://localhost:3306/mysqldata";
        cpld.setJdbcUrl("jdbc:mysql://localhost:3306/mysqldata");
        cpld.setUser("root");
        cpld.setPassword("15717747056HYB");
//        获取初始时连接池中的连接个数
        cpld.setInitialPoolSize(10);
//        获取连接
        Connection connection = cpld.getConnection();
        System.out.println(connection);
//        com.mchange.v2.c3p0.impl.NewProxyConnection@548e7350 [wrapping: com.mysql.cj.jdbc.ConnectionImpl@1a968a59]
//        销毁池子，不建议这么做
        DataSources.destroy(cpld);
    }

    //    方式二：编辑为一个xml文件
 	private static ComboPooledDataSource connect = new ComboPooledDataSource("myConnection");
//	上面的创建池子语句最好放在外面，因为加入我们每次都调用下面获取连接的方法，就会出现造了很多池子。
//	而且这个池子建议是私有的和静态的，因为这会封装在一个类里，如同上面我们讲DAO一样
    @Test
    public void testXmlConnection() throws SQLException {
        Connection connection = connect.getConnection();
        System.out.println(connection);
//        com.mchange.v2.c3p0.impl.NewProxyConnection@589838eb [wrapping: com.mysql.cj.jdbc.ConnectionImpl@5cc484b9]

    }

    
<c3p0-config>

    <named-config name="myConnection">





        <property name="driverClass">
                com.mysql.cj.jdbc.Driver
        property>
        <property name="jdbcUrl">
                jdbc:mysql://localhost:3306/mysqldata
        property>
        <property name="user">
                root
        property>
        <property name="password">
                15717747056HYB
        property>



        <property name="acquireIncrement">
                5
        property>

        <property name="initialPoolSize">
                10
        property>

        <property name="minPoolSize">
                10
        property>

        <property name="maxPoolSize">
                100
        property>

        <property name="maxStatements">
                50
        property>
            
            <property name="minStatementsPerConnection">
                    2
            property>
    named-config>
c3p0-config>

    注意：

    • IDEA中，若不可以直接创建XML文件，上网查阅方式便可。

6.3 dbcp

  • 如c3p0一样也必须导入两个jar包，commons-dbcp-1.4.jar，commons-pool-1.6.jar。

  • 导入成功后，这里要创建的是properties文件

    driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mysqldata
username=root
password=15717747056HYB

    信息前面的名字必须要和我一致，因为它提供的方法便是这个名字。

  •     @Test
    public void connection() throws Exception{
        Properties ps = new Properties();
        FileInputStream fis = new FileInputStream("dbcp.properties");
        ps.load(fis);
//        创建一个连接池
        DataSource ds = BasicDataSourceFactory.createDataSource(ps);
//        获取一个连接
        Connection connection = ds.getConnection();
        System.out.println(connection);
//        jdbc:mysql://localhost:3306/mysqldata, UserName=root@localhost, MySQL Connector/J

    }

  • 升级版和c3p0思想一样，只不过这里涉及到一些代码规范问题，所以要使用静态代码块

    //    方式一和c3p0的一个样,下面只讲方式二，如c3p0相似，只不过dbcp建立的是properties文件夹
    private static DataSource ds = null;
    static {
        try {
            Properties ps = new Properties();
            FileInputStream fis = new FileInputStream("dbcp.properties");
            ps.load(fis);
            ds=BasicDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Test
    public void connection() throws Exception{
//        获取一个连接
        Connection connection = ds.getConnection();
        System.out.println(connection);
//        jdbc:mysql://localhost:3306/mysqldata, UserName=root@localhost, MySQL Connector/J

    }

6.4 *Druid

  • 下面给出Durid常用

    配置 缺省值 说明
    name 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。 如果没有配置，将会生成一个名字，格式是：“DataSource-” + System.identityHashCode(this)
    url 连接数据库的url，不同数据库不一样。例如： jdbc:mysql://localhost:3306/mysqldata
    username 连接数据库的用户名
    password 连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
    driverClassName 根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
    initialSize 0 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
    maxActive 8 最大连接池数量
    maxIdle 8 已经不再使用，配置了也没效果
    minIdle 最小连接池数量
    maxWait 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
    poolPreparedStatements false 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
    maxOpenPreparedStatements -1 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
    validationQuery 用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
    testOnBorrow true 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
    testOnReturn false 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
    testWhileIdle false 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
    timeBetweenEvictionRunsMillis 有两个含义： 1) Destroy线程会检测连接的间隔时间2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明
    numTestsPerEvictionRun 不再使用，一个DruidDataSource只支持一个EvictionRun
    connectionInitSqls 物理连接初始化的时候执行的sql
    exceptionSorter 根据dbType自动识别 当数据库抛出一些不可恢复的异常时，抛弃连接
    filters 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
    proxyFilters 类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

  • 非常重要，阿里巴巴开源的数据库连接池，但是套路和其他都一样。

    package com.hyb.SQLPool;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @program: DruidTest
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-27 19:57
 **/

public class DruidTest {
    private static DataSource source=null;
    static {
        try {
            Properties ps = new Properties();
            FileInputStream fs=new FileInputStream("Druid.properties");
            ps.load(fs);
            source=  DruidDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Test
    public void Druid() throws SQLException {
        Connection connection = source.getConnection();
        System.out.println(connection);
//        com.mysql.cj.jdbc.ConnectionImpl@35fb3008
    }
}

        driverClassName=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mysqldata
    username=root
    password=15717747056HYB

第七章：Apache-DBUtils 实现CRUD

  • 这只是别人对增删改查的封装，源码基本和前面所写的一样，由于是第三方的，所以我们还是得导入第三方jar包：commons-dbutils-1.7.jar
  • DBUtils有三大核心。

DbUtils类

  • 提供如关闭连接、装载 JDBC 驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：

    • public static void close(…) throws java.sql.SQLException： DbUtils 类提供了三个重载的关闭方法。这些方法检查

    所提供的参数是不是 NULL，如果不是的话，它们就关闭 Connection、Statement 和 ResultSet。

    • public static void closeQuietly(…): 这一类方法不仅能在 Connection、Statement 和 ResultSet 为 NULL 情况下避免

    关闭，还能隐藏一些在程序中抛出的 SQLEeception。

    • public static void commitAndClose(Connection conn)throws SQLException 用来提交连接的事务，然后关闭连接

    • public static void commitAndCloseQuietly(Connection conn)： 用来提交连接的事务，然后关闭连接，并且在关闭

    连接时不抛出 SQL 异常。

    • public static void rollback(Connection conn)throws SQLException 允许 conn 为 null，因为方法内部做了判断

    • public static void rollbackAndClose(Connection conn)throws SQLException

    • rollbackAndCloseQuietly(Connection)

    • public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册 JDBC 驱动程序，如果成功就

    返回 true。使用该方法，你不需要捕捉这个异常 ClassNotFoundException。/2QueryRunner 类

    该类封装了 SQL 的执行，是线程安全的。

    （1）可以实现增、删、改、查、批处理、

    （2）考虑了事务处理需要共用 Connection。

    （3）该类最主要的就是简单化了 SQL 查询，它与 ResultSetHandler 组合在一起使用可以完成大部分的数据库操作，

    能够大大减少编码量。

ResultSetHandler接口

  • 用于处理结果集。
BeanHandler 把结果集的第一条记录转为创建 BeanHandler 对象时传入的 Class 参数对应的对象.
BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中，也传入一个Class类对象。
ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中
ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合
ScalarHandler 它是用于单数据。例如select count(*) from 表操作。

QueryRunner实现类

  • QueryRunner 类提供了两个构造方法：

  • QueryRunner()：默认的构造方法

  • QueryRunner(DataSource ds)：需要一个 javax.sql.DataSource 来作参数的构造方法。

  • 利用该类实现增删改查的操作

    • 更新：

      • public int update(Connection conn, String sql, Object… params) throws SQLException:用来执行一个更新（插入、更新或 删除）操作。

      • public int update(Connection conn, String sql) throws SQLException：用来执行一个不需要置换参数的更新操作。

    • 插入：

      • **public T insert(Connection conn,String sql,ResultSetHandler rsh)**throws SQLException：其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自 动生成的键值

      • public T insert(Connection conn,String sql,ResultSetHandler rsh, Object… params) throws SQLException：只支持 INSERT

      • public T **insert(String sql,ResultSetHandler rsh)**throws SQLException：只支持 INSERT

      • public **T insert(String sql,ResultSetHandler rsh,Object… params)**throws SQLException：只支持 INSERT

    • 批处理：

      • public int[] **batch(Connection conn,String sql,Object[][] params)**throws SQLException： INSERT, UPDATE, or DELETE 语句

      • public int[] **batch(String sql,Object[][] params)**throws SQLException： INSERT, UPDATE, or DELETE 语句

      • public T **insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[][] params)**throws SQLException：只 支持 INSERT

      • public T **insertBatch(String sql,ResultSetHandler rsh,Object[][] params)**throws SQLException：只支持 INSERT

    • 查询：

      • public Object query(Connection conn, String sql, ResultSetHandler rsh,Object… params) throws SQLException：执行一 个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理PreparedStatement 和 ResultSet 的创建和关闭。

      • public Object query(String sql, ResultSetHandler rsh, Object… params) throws SQLException: 几乎与第一种方法一 样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造方法的数据源(DataSource) 或使用 的 setDataSource 方法中重新获得 Connection。

      • public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换 参数的查询操作。

      • public Object query( String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。

代码示例

package com.hyb.JDBC;

import com.hyb.SQLPool.Druid;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.junit.Test;

import java.sql.Connection;
import java.sql.SQLException;

/**
 * @program: QueryRunnarTest
 * @description:
 * @author: Huang Yubin
 * @create: 2021-06-27 21:00
 **/

public class QueryRunnerTest {

//    更新
    @Test
    public void testInsert(){
        Connection connect = null;
        try {
//            QueryRunner 为查询类
            QueryRunner runner = new QueryRunner();
//        我们利用连接池来获取连接
            connect = Druid.getConnection();
            int update = runner.update(connect, "update firstme set name_b=? where name_b = ?", "newHyb", "hyb");
//            newHyb   21 student    0
//            获得更新次数
            System.out.println(update);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            try {
                assert connect!=null;
                connect.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

//    查询
    @Test
    public void queryTest(){
        Connection cn = null;
        try {
            QueryRunner qr = new QueryRunner();
            cn = Druid.getConnection();
//        1.返回一条记录 BeanHandler将结果集中第一条记录封装到一个指定的javaBean中。
//            BeanHandler fs = new BeanHandler(firstmeTableClass.class);
//
//            firstmeTableClass query = qr.query(cn, "select * from firstme where name_b=?", fs,"newHyb");
//
//        2.BeanListHandler将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中，也传入一个Class类对象。
//            BeanListHandler fs = new BeanListHandler<>(firstmeTableClass.class);
//
//            List query = qr.query(cn, "select * from firstme", fs);
//
//        3.**ColumnListHandler****将结果集中指定的列的字段值，封装到一个List集合中**
//            ColumnListHandler fs = new ColumnListHandler<>();
//            List query = qr.query(cn, "select name_b from firstme", fs);
//        4.**ArrayHandler****将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值**
//            ArrayHandler fs = new ArrayHandler();
//            Object[] query = qr.query(cn, "select name_b,age from firstme", fs);
//            for (Object o: query){
//                System.out.println(o);
//            }
//        5.**ArrayListHandler****将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。**
//            ArrayListHandler fs = new ArrayListHandler();
//            List query = qr.query(cn, "select * from firstme", fs);
//            for (Object[] o:query){//集合中的每个元素都是Object[]类型
//                for (Object p:o){//Object[]中的每个元素都是Object类型
//                    System.out.println(p);
//                }
//            }
//        6.**MapHandler****将结果集第一行封装到Map集合中,Key 列名, Value 该列数据**
//            MapHandler fs = new MapHandler();
//            Map query = qr.query(cn, "select * from firstme", fs);
//        7.**MapListHandler****将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合**
//            MapListHandler fs = new MapListHandler();
//            List> query = qr.query(cn, "select * from firstme", fs);
//            for (Map o:query){
//                System.out.println(o);
//            }
//        8.**ScalarHandler****它是用于单数据。例如select count(*) from 表操作。**
//            ScalarHandler fs = new ScalarHandler<>();
//            Long query = qr.query(cn, "select count(*) from firstme", fs);
//            System.out.println(query);
//        9.自定义实现类
            ResultSetHandler fs=(resultSet)-> {
                if (resultSet.next()){
                    String name_b = resultSet.getString("name_b");
                    int age = resultSet.getInt("age");
                    String work = resultSet.getString("work");
                    String salary = resultSet.getString("salary");
                    return new firstmeTableClass("name_b",age,"wrok","salary");
                }
                return null;
            };
            firstmeTableClass query = qr.query(cn, "select * from firstme", fs);
            System.out.println(query);

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            assert cn!=null;
            try {
                DbUtils.close(cn);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JDBC数据库交互,java,java学习,java,JDBC,数据库交互技术)

        

            

                
    
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 腾讯云技术深度探索：构建高效云原生微服务架构
                        我的运维人生
云原生架构腾讯云运维开发技术共享
                        
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 使用LLaVa和Ollama实现多模态RAG示例
                        llzwxh888
python人工智能开发语言
                        
    本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。
                        那一叶秋

                        
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
    
                    
    • 
                    
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
    
                    
    • 
                                
  • 对股票分析时要注意哪些主要因素？
                                    会飞的奇葩猪
股票 分析 云掌股吧
                                    
     
　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。 
 
    一、成交量 
 
　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
    
                                
    • 
                                
  • 【Scala十八】视图界定与上下文界定
                                    bit1129
scala
                                    
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。 
  
隐式参数 
首先引入一个泛型函数max，用于取a和b的最大值 
  def max[T](a: T, b: T) = {
    if (a > b) a else b
  } 
 因为T是未知类型，只有运行时才会代入真正的类型，因此调用a > 
    
                                
    • 
                                
  • C语言的分支——Object-C程序设计阅读有感
                                    darkblue086
applec框架cocoa
                                    
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 
Object-C程序设计这本书
    
                                
    • 
                                
  • 去除浏览器对表单值的记忆
                                    周凡杨
html记忆autocompleteform浏览
                                    
      
                                   &n
    
                                
    • 
                                
  • java的树形通讯录
                                    g21121
java
                                    
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 
	// 首先取出每个部门的联系人
			for (int i = 0; i < depList.size(); i++) {
				List<Contacts> list = getContactList(depList.get(i
    
                                
    • 
                                
  • Nginx安装部署
                                    510888780
nginxlinux
                                    
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
    
                                
    • 
                                
  • java servelet异步处理请求
                                    墙头上一根草
ｊａｖａ异步返回ｓｅｒｖｌｅｔ
                                    
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能， 
   
  
  final AsyncContext ac = request.startAsync(request, response); 
  ac.s
    
                                
    • 
                                
  • 我的spring学习笔记8-Spring中Bean的实例化
                                    aijuans
Spring 3
                                    
    在Spring中要实例化一个Bean有几种方法： 
 
1、最常用的（普通方法） 
 
 
<bean id="myBean" class="www.6e6.org.MyBean" /> 
 
使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 
 
（有构造方法的下个文细说） 
 
2、还
    
                                
    • 
                                
  • 为Mysql创建最优的索引
                                    annan211
mysql索引
                                    
    


	索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。
	索引经常会被误解甚至忽略，而且经常被糟糕的设计。
	索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比
	较好的索引性能要好2个数量级。
	
	1 索引的类型
	  (1) B-Tree
	    不出意外，这里提到的索引都是指 B-
    
                                
    • 
                                
  • 日期函数
                                    百合不是茶
oraclesql日期函数查询
                                    
      
ORACLE日期时间函数大全

   TO_DATE格式(以时间:2007-11-02   13:45:25为例)
   
        Year:      
        yy two digits 两位年                显示值:07
        yyy three digits 三位年                显示值:007
   
    
                                
    • 
                                
  • 线程优先级
                                    bijian1013
javathread多线程java多线程
                                    
    多线程运行时需要定义线程运行的先后顺序。 
线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 
实例： 
package com.bijian.study;

/**
 * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法
 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
    
                                
    • 
                                
  • 适配器模式和代理模式的区别
                                    bijian1013
java设计模式
                                    
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
    
                                
    • 
                                
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件
                                    bit1129
Mybatis3
                                    
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 
这些元素包含三方面内容 
1. 要执行的SQL语句 
2. SQL语句的入参，比如查询条件 
3. SQL语句的返回结果
    
                                
    • 
                                
  • oracle大数据表复制备份个人经验
                                    bitcarter
oracle大表备份大表数据复制
                                    
    前提： 
   数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。 
    
    
                                
    • 
                                
  • HTTP加速器varnish安装小记
                                    ronin47
http varnish 加速
                                    
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 
苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ 
Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
    
                                
    • 
                                
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度
                                    bylijinnan
java
                                    
    

public class LongestSymmtricalLength {

	/*
	 * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。
	 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。
	 */
	
	public static void main(String[] args) {
		Str
    
                                
    • 
                                
  • 学习编程的一点感想
                                    Cb123456
编程感想Gis
                                    
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目. 
  
   本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
    
                                
    • 
                                
  • [能源与安全]美国与中国
                                    comsci
能源
                                    
     
 
     现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。 
 
 
      在这个大
    
                                
    • 
                                
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析
                                    cwqcwqmax9
oracle
                                    
    甲说： 
A B两个表总数据量都很大，在百万以上。 
idx1  idx2字段表示是索引字段 
A B 两表上都有 
col1字段表示普通字段 
 
select xxx from A 
where A.idx1 between mmm and nnn 
     and exists (select 1 from B where B.idx2 =
    
                                
    • 
                                
  • SpringMVC-ajax返回值乱码解决方案
                                    dashuaifu
AjaxspringMVCresponse中文乱码
                                    
      
SpringMVC-ajax返回值乱码解决方案 
  
一：（自己总结，测试过可行） 
ajax返回如果含有中文汉字，则使用：（如下例：） 
@RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
    
                                
    • 
                                
  • Linux系统中查看日志的常用命令
                                    dcj3sjt126com
OS
                                    
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 
cat 
tail -f 
日 志 文 件 说 明 
/var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 
/var/log/secure 与安全相关的日志信息 
/var/log/maillog 与邮件相关的日志信
    
                                
    • 
                                
  • [应用结构]应用
                                    dcj3sjt126com
PHPyii2
                                    
    应用主体 
应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 
 
 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
    
                                
    • 
                                
  • assertThat用法
                                    eksliang
JUnitassertThat
                                    
    junit4.0  assertThat用法 
一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 
注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 
2、assertThat( testedNumber, anyOf( g
    
                                
    • 
                                
  • android点滴2
                                    gundumw100
应用服务器android网络应用OSHTC
                                    
    如何让Drawable绕着中心旋转？ 
 

Animation a = new RotateAnimation(0.0f, 360.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f);
a.setRepeatCount(-1);
a.setDuration(1000);
 
 
如何控制Andro
    
                                
    • 
                                
  • 超简洁的CSS下拉菜单
                                    ini
htmlWeb工作html5css
                                    
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>简洁的HTML+CSS下拉菜单-HoverTree</title>
    
                                
    • 
                                
  • kafka consumer防止数据丢失
                                    kane_xie
kafkaoffset commit
                                    
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。 
  
尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。 
  
考虑这样一个case，partiton_num=2
    
                                
    • 
                                
  • @Repository、@Service、@Controller 和 @Component
                                    mhtbbx
DAOspringbeanprototype
                                    
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean 
Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
    
                                
    • 
                                
  • java 多线程高并发读写控制 误区
                                    qifeifei
java thread
                                    
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ 
public class testTh7 {
	private String data;
	public String read(){
		System.out.println(Thread.currentThread().getName() + "read data " 
    
                                
    • 
                                
  • mongodb replica set(副本集)设置步骤
                                    tcrct
javamongodb
                                    
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 
 
首先先去下载一个mongodb最新版，目前最新版应该是2.6 
 

cd /usr/local/bin
wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz
tar -zxvf  mongodb-linux-x86_64-2.6.0.t
    
                                
    • 
                                
  • rust学习笔记
                                    wudixiaotie
学习笔记
                                    
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 
let x = 1; let mut y = 2; 
2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 
3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 
4.每个语句结尾都要加分
    
                                
    •