导学

JDBC的全称为：Java DataBase Connectivity（java数据库连接），这是一门Java连接数据库的技术，可对多种数据库进行统一操作，不需要对单个数据库的驱动进行详细了解。
5.JDBC入门 - 图1
【仅需要了解 JDBC 的规范即可】 - 具体驱动会具体实现相应功能
image.png

开发步骤

  1. 选择数据库：加载数据库驱动
  2. 连接数据库
  3. 创建数据库查询
  4. 获取查询结果
  5. 关闭查询和连接

在使用 JDBC 的时候，需要关注的几个问题

  • 查询分为操作类（增加、删除、修改）和查询类。
  • 要避免重复的创建连接，增加数据库的连接数。
  • 注意异常的处理逻辑，保证没有未关闭的无效连接存在。

示例：

  1. import java.sql.Connection;
  2. import java.sql.DriverManager;
  3. import java.sql.PreparedStatement;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. public class Demo {
  7.     public static void main(String[] args) {
  8.         getDataFromDataBase();
  9.     }
  11.     public static void getDataFromDataBase() {
  12.         Connection conn = null;//Connection是与特定数据库连接回话的接口
  13.         PreparedStatement ps = null;
  14.         ResultSet rs = null;
  15.         try {
  16.             //Driver driver = new Driver();通过构建对象的方法去注册驱动，会使驱动注册两次
  17.             //DriverManager.registerDriver(driver);
  18.             //所以只能通过反射机制去加载该类，使静态代码块中的代码自动执行，可以保证之注册一次
  19.             //选择数据库，加载数据库驱动
  21.             //1.注册驱动(静态方法)(包名+类名），告知JVM使用的是哪一个数据库的驱动
  22.             Class.forName("com.mysql.cj.jdbc.Driver");
  23.             //设置连接地址，时间格式和编码格式（因为版本升级，所以需要加上时间格式）
  24.             String url = "jdbc:mysql://localhost:3306/j121study?serverTimezone=UTC&characterEncoding=UTF-8";
  25.             String user = "root";
  26.             String password = "123456";
  27.             //2.连接数据库
  28.             conn = DriverManager.getConnection(url,user,password);
  29.             /**
  30.              * DriverManager类用来管理数据库中的所有驱动程序。
  31.              * 是JDBC的管理层，作用于用户和驱动程序之间，跟踪可用的驱动程序，并在数据库的驱动程序之间建立连接。
  32.              * 此外，DriverManager类中的方法都是静态方法，所以在程序中无须对它进行实例化，直接通过类名就可以调用。
  33.              * DriverManager类的常用方法有getConnection(String url,String user,String password)方法
  34.              */
  35.             //3.获取语句执行平台，并创建数据库查询
  36.             //Statement s = conn.createStatement();
  37.             //该语句使用字符串拼接参数存在较大的漏洞，极易被SQL注入攻击
  38.             //Statement接口创建之后，可以执行SQL语句，完成对数据库的增删改查。然而查询略显复杂。
  39.             //与 Statement一样，PreparedStatement也是用来执行sql语句的，
  40.             //与创建Statement不同的是，需要根据sql语句创建PreparedStatement。
  41.             //除此之外，还能够通过设置参数，指定相应的值，而不是Statement那样使用字符串拼接。
  42.             ps = conn.prepareStatement("select * from school where school_name=?");
  43.             //该语句为参数保留一个问号作为占位符
  44.             //传递参数，参数什么Xxx类型，就使用setXxx()方法
  45.             ps.setString(1, "渡课教育跃龙路主校区");//1表示第1个占位符
  47.             //4.执行查询语句，并获取查询结果
  48.             rs = ps.executeQuery();
  49.             //当要执行查询时，需要调用executeQuery()方法
  50.             //如果要执行增删改操作时，调用的是executeUpdate()方法
  51.             while(rs.next()) {
  52.                 System.out.println(rs.getInt("id"));
  53.                 System.out.println(rs.getString("address"));
  54.             }//结果集同样可以释放，以便于下次更方便的填充数据
  55.         } catch (ClassNotFoundException e) {
  56.             e.printStackTrace();
  57.         } catch (SQLException e) {
  58.             e.printStackTrace();
  59.         } finally {
  60.             //关闭查询与连接和结果集
  61.             if(null != conn) {
  62.                 try {
  63.                     conn.close();
  64.                     conn = null;
  65.                     //数据库连接资源非常宝贵，要让连接资源及时回收。
  66.                     //因为哪怕将连接关闭，数据库连接回收机制也不会主动回收连接资源
  67.                     //将连接资源设置为null，可以使Java的垃圾回收机制更早回收连接资源。
  68.                     //这样可以影响数据库回收机制，使连接资源更早回收
  69.                 } catch (SQLException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.             }
  73.             if(null != ps) {
  74.                 try {
  75.                     ps.close(); 
  76.                     ps = null;
  77.                 } catch (SQLException e) {
  78.                     e.printStackTrace();
  79.                 }
  80.             }r
  81.             if(null != rs) {
  82.                 try {
  83.                     rs.close(); 
  84.                     rs = null;
  85.                 } catch (SQLException e) {
  86.                     e.printStackTrace();
  87.                 }
  88.             }
  89.         }
  90.     }
  91. }

PrepareStatement中方法

  1. ResultSet executeQuery(String sql)  执行sql中select语句
  2. int executeUpdate(String sql)  执行sql中的update，insert，delete语句，返回影响条数

把资源关闭放到finally语句中，最后要把每个关闭了的资源对象设置一个null值。因为这些资源是很宝贵的就算被关闭了也不会马上被回收，设置为null可以让垃圾回收机制更早的回收

JDBC工具类的抽取

在使用JDBC时，我们发现会有很多代码是重复的，那么其实我们可以将这些代码抽取到工具类中。而且也可以和属性文件搭配使用！避免修改源代码。
jdbc.properties：

  1. driverClass=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/j123study?serverTimezone=UTC&characterEncoding=UTF-8
  3. username=root
  4. password=abc

JDBC工具类：

  1. public class JDBCUtils {
  2.     private static final String driverClass;
  3.     private static final String url;
  4.     private static final String username;
  5.     private static final String password;
  7.     static{
  8.         // 加载属性文件解析对象：
  9.         Properties props = new Properties();
  10.         // 如何获得属性文件的输入流？
  11.         // 通常情况下使用类的加载器的方式进行获取：类加载器加载JDBCUtils类，并去使用文件资源作为输入流
  12.         //在JVM运行JDBCUtils时，通过class属性，得到该类的字节码，并通过字节码得到类加载器，
  13.         //指明类加载器在加载JDBCUtils类时，将某一个文件作为输入流并到该类的字节码中
  14.         InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("com/dodoke/jdbc_test/jdbc.properties");
  15.         try {
  16.             props.load(is);
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  21.         driverClass = props.getProperty("driverClass");
  22.         url = props.getProperty("url");
  23.         username = props.getProperty("username");
  24.         password = props.getProperty("password");
  25.     }
  26.     /**
  27.      * 注册驱动的方法
  28.      * @throws ClassNotFoundException 
  29.      */
  30.     public static void loadDriver() throws ClassNotFoundException{
  31.         Class.forName(driverClass);
  32.     }
  34.     /**
  35.      * 获得连接的方法:
  36.      * @throws SQLException 
  37.      */
  38.     public static Connection getConnection() throws Exception{
  39.         loadDriver();
  40.         Connection conn = DriverManager.getConnection(url, username, password);
  41.         return conn;
  42.     }
  44.     /**
  45.      * 资源释放
  46.      */
  47.     public static void release(Statement stmt,Connection conn){
  48.         if(stmt != null){
  49.             try {
  50.                 stmt.close();
  51.             } catch (SQLException e) {
  52.                 e.printStackTrace();
  53.             }
  54.             stmt = null;
  55.         }
  56.         if(conn != null){
  57.             try {
  58.                 conn.close();
  59.             } catch (SQLException e) {
  60.                 e.printStackTrace();
  61.             }
  62.             conn = null;
  63.         }
  64.     }
  66.     public static void release(ResultSet rs,Statement stmt,Connection conn){
  67.         if(rs!= null){
  68.             try {
  69.                 rs.close();
  70.             } catch (SQLException e) {
  71.                 e.printStackTrace();
  72.             }
  73.             rs = null;
  74.         }
  75.         if(stmt != null){
  76.             try {
  77.                 stmt.close();
  78.             } catch (SQLException e) {
  79.                 e.printStackTrace();
  80.             }
  81.             stmt = null;
  82.         }
  83.         if(conn != null){
  84.             try {
  85.                 conn.close();
  86.             } catch (SQLException e) {
  87.                 e.printStackTrace();
  88.             }
  89.             conn = null;
  90.         }
  91.     }
  92. }

SQL注入的漏洞

注入漏洞产生的原因：
在输入的时候输入了sql语句的关键字

  1. public class JDBCDemo4 {
  2.     /**
  3.      * 测试SQL注入漏洞的方法
  4.      */
  5.     public void demo1(){
  6.         boolean flag = JDBCDemo4.login2("aaa' or '1=1", "1fsdsdfsdf");
  7.         if(flag == true){
  8.             System.out.println("登录成功！");
  9.         }else{
  10.             System.out.println("登录失败！");
  11.         }
  12.     }
  14.     /**
  15.      * 避免SQL注入漏洞的方法
  16.      */
  17.     public static boolean login2(String username,String password){
  18.         Connection conn = null;
  19.         PreparedStatement pstmt = null;
  20.         ResultSet rs = null;
  21.         boolean flag = false;
  22.         try{
  23.             // 获得连接:
  24.             conn = JDBCUtils.getConnection();
  25.             // 编写SQL:
  26.             String sql = "select * from user where username = ? and password = ?";
  27.             // 预处理SQL:
  28.             pstmt = conn.prepareStatement(sql);
  29.             // 设置参数:
  30.             pstmt.setString(1, username);
  31.             pstmt.setString(2, password);
  32.             // 执行SQL：
  33.             rs = pstmt.executeQuery();
  34.             // 判断结果街
  35.             if(rs.next()){
  36.                 flag = true;
  37.             }else{
  38.                 flag = false;
  39.             }
  40.         }catch(Exception e){
  41.             e.printStackTrace();
  42.         }finally{
  43.             JDBCUtils.release(rs, pstmt, conn);
  44.         }
  45.         return flag;
  46.     }
  48.     /**
  49.      * 产生SQL注入漏洞的方法
  50.      * @param username
  51.      * @param password
  52.      * @return
  53.      */
  54.     public static boolean login(String username,String password){
  55.         Connection conn = null;
  56.         Statement stmt  = null;
  57.         ResultSet rs = null;
  58.         boolean flag = false;
  59.         try{
  60.             conn = JDBCUtils.getConnection();
  61.             // 创建执行SQL语句的对象:
  62.             stmt = conn.createStatement();
  63.             // 编写SQL:
  64.             String sql = "select * from user where username = '"+username+"' and password = '"+password+"'";
  65.             // 执行SQL:
  66.             rs = stmt.executeQuery(sql);
  67.             // 判断结果集中是否有数据。
  68.             if(rs.next()){
  69.                 flag = true;
  70.             }else{
  71.                 flag = false;
  72.             }
  73.         }catch(Exception e){
  74.             e.printStackTrace();
  75.         }finally{
  76.             JDBCUtils.release(rs, stmt, conn);
  77.         }
  78.         return flag;
  79.     }
  80. }

数据库连接池

连接池：
连接池是创建和管理一个连接的缓冲池的技术，这些连接准备好被任何需要它们的线程使用。
在实际应用开发中，特别是在WEB应用系统中，如果JSP、Servlet或EJB使用JDBC直接访问数据库中的数据，每一次数据访问请求都必须经历建立数据库连接、打开数据库、存取数据和关闭数据库连接等步骤，而连接并打开数据库是一件既消耗资源又费时的工作，如果频繁发生这种数据库操作，系统的性能必然会急剧下降，甚至会导致系统崩溃。数据库连接池技术是解决这个问题最常用的方法，在许多应用程序服务器中，基本都提供了这项技术，无需自己编程，但是，深入了解这项技术是非常必要的。
数据库连接池技术的思想非常简单，将数据库连接作为对象存储在一个对象中，一旦数据库连接建立后，不同的数据库访问请求就可以共享这些连接，这样，通过复用这些已经建立的数据库连接，可以克服上述缺点，极大地节省系统资源和时间。
5.JDBC入门 - 图3
5.JDBC入门 - 图4
用数据库连接池时，不要再临时创建到数据库的连接，而是直接去使用某个容器或者地址中创建好的connection

常用的有 ： DPCP、C3P0

C3P0 jar包下载地址：https://sourceforge.net/projects/c3p0/?source=navbar
示例：
c3p0配置文件-放在src目录下面

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <c3p0-config>
  3.   <default-config>
  4.   <property name="driverClass">com.mysql.jdbc.Driver</property>
  5.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/j123study?serverTimezone=UTC&amp;characterEncoding=UTF-8</property>
  6.     <property name="user">root</property>
  7.     <property name="password">123456</property>
  8.     <property name="initialPoolSize">5</property>
  9.     <property name="maxPoolSize">20</property>
  10.   </default-config>
  11. </c3p0-config>
  1. public class JDBCUtils2 {
  2.     private static final ComboPooledDataSource dataSource = new ComboPooledDataSource();
  4.     /**
  5.      * 获得连接的方法:
  6.      * @throws SQLException 
  7.      */
  8.     public static Connection getConnection() throws Exception{
  9.         Connection conn = dataSource.getConnection();
  10.         return conn;
  11.     }
  13.     /**
  14.      * 资源释放
  15.      */
  16.     public static void release(Statement stmt,Connection conn){
  17.         if(stmt != null){
  18.             try {
  19.                 stmt.close();
  20.             } catch (SQLException e) {
  21.                 e.printStackTrace();
  22.             }
  23.             stmt = null;
  24.         }
  25.         if(conn != null){
  26.             try {
  27.                 conn.close();
  28.             } catch (SQLException e) {
  29.                 e.printStackTrace();
  30.             }
  31.             conn = null;
  32.         }
  33.     }
  35.     public static void release(ResultSet rs,Statement stmt,Connection conn){
  36.         if(rs!= null){
  37.             try {
  38.                 rs.close();
  39.             } catch (SQLException e) {
  40.                 e.printStackTrace();
  41.             }
  42.             rs = null;
  43.         }
  44.         if(stmt != null){
  45.             try {
  46.                 stmt.close();
  47.             } catch (SQLException e) {
  48.                 e.printStackTrace();
  49.             }
  50.             stmt = null;
  51.         }
  52.         if(conn != null){
  53.             try {
  54.                 conn.close();
  55.             } catch (SQLException e) {
  56.                 e.printStackTrace();
  57.             }
  58.             conn = null;
  59.         }
  60.     }
  61. }
  1. public class DataSourceDemo1 {
  2.     /**
  3.      * 使用配置文件的方式
  4.      */
  5.     public void demo2(){
  6.         Connection conn = null;
  7.         PreparedStatement pstmt = null;
  8.         ResultSet rs = null;
  9.         try{
  10.             /*// 获得连接:
  11.             ComboPooledDataSource dataSource = new ComboPooledDataSource();*/
  12.             // 获得连接:
  13.             // conn = dataSource.getConnection();
  14.             conn = JDBCUtils2.getConnection();
  15.             // 编写Sql:
  16.             String sql = "select * from user";
  17.             // 预编译SQL:
  18.             pstmt = conn.prepareStatement(sql);
  19.             // 设置参数
  20.             // 执行SQL:
  21.             rs = pstmt.executeQuery();
  22.             while(rs.next()){
  23.                 System.out.println(rs.getInt("uid")+"   "+rs.getString("username")+"   "+rs.getString("password")+"   "+rs.getString("name"));
  24.             }
  25.         }catch(Exception e){
  26.             e.printStackTrace();
  27.         }finally{
  28.             JDBCUtils2.release(rs, pstmt, conn);
  29.         }
  30.     }
  31.     @Test
  32.     /**
  33.      * 手动设置连接池
  34.      */
  35.     public void demo1(){
  36.         // 获得连接:
  37.         Connection conn = null;
  38.         PreparedStatement pstmt = null;
  39.         ResultSet rs = null;
  40.         try{
  41.             // 创建连接池:
  42.             ComboPooledDataSource dataSource = new ComboPooledDataSource();
  43.             // 设置连接池的参数:
  44.             dataSource.setDriverClass("com.mysql.jdbc.Driver");
  45.             dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/j123study?serverTimezone=UTC&characterEncoding=UTF-8");
  46.             dataSource.setUser("root");
  47.             dataSource.setPassword("abc");
  48.             dataSource.setMaxPoolSize(20);//设置最大连接数
  49.             dataSource.setInitialPoolSize(3);//设置初始化时连接池中有多少连接，数字越大，启动越慢
  51.             // 获得连接:从连接池获得连接
  52.             conn = dataSource.getConnection();//返回数据库连接池中空闲的连接
  53.             // 编写Sql:
  54.             String sql = "select * from user";
  55.             // 预编译SQL:
  56.             pstmt = conn.prepareStatement(sql);
  57.             // 设置参数
  58.             // 执行SQL:
  59.             rs = pstmt.executeQuery();
  60.             while(rs.next()){
  61.                 System.out.println(
  62.                     rs.getInt("uid")+"   "+
  63.                     rs.getString("username")+"   "+
  64.                     rs.getString("password")+"   "+
  65.                     rs.getString("name"));
  66.             }
  67.         }catch(Exception e){
  68.             e.printStackTrace();
  69.         }finally{
  70.             JDBCUtils.release(rs, pstmt, conn);
  71.         }
  72.     }
  73. }