【MySQL】JDBC使用入门

JDBC

1、JDBC概述

概念：Java DataBase ConnectivityJava 数据库连接，Java语言操作数据库

JDBC本质：一套操作所有关系型数据库的规则(接口)，各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）进行编程，真正执行的代码是驱动jar包中的实现类。

2、JDBC的使用

1）使用方法

1. 导入驱动jar包
   1. 复制到项目libs目录下
   2. 右键 --> Add As Library
2. 注册驱动
3. 获取数据库连接对象 Connection
4. 定义sql
5. 获取执行sql语句的对象 Statement
6. 执行sql，接收返回结果
7. 处理结果
8. 释放资源

//1.导包
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
//4.定义sql
String sql = "update stu set age = 18 where id = 1";
//5.获取执行sql的对象
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.printIn(count);
//8.释放资源
stmt.close();
conn.close();

2）详解各个对象

1. DriverManager：驱动管理对象

注册驱动：告诉程序该使用哪一个数据库驱动jar

Class.forName("com.mysql.jdbc.Driver");
//溯源：在com.mysql.jdbc.Driver类中存在静态代码块
static {
  try {			      
      java.sql.DriverManager.registerDriver(new Driver());
  } catch (SQLException E) {
      throw new RuntimeException("Can't register driver!");
  }
}

mysql5之后的驱动jar包可以省略注册驱动的步骤

获取数据库连接

//方法
static Connection getConnection(String url, String user, String password)；

  1. url：连接的路径
1. 语法：`jdbc:mysql://ip地址(域名):端口号/数据库名称`
2. 本机mysql且端口，可简写：`jdbc:mysql:///数据库名称`
  2. user：用户名
  3. password：密码 

2. Connection：数据库连接对象

1. 获取执行sql的对象
   1. Statement createStatement()
   2. PreparedStatement prepareStatement(String sql)
2. 管理事务
3. 开启事务：setAutoCommit(boolean autoCommit) 调用该方法设置参数为false，即开启事务
4. 提交事务：commit()
5. 回滚事务：rollback()

3. Statement：执行sql的对象

boolean execute(String sql) ：可以执行任意的sql (了解)

int executeUpdate(String sql) ：执行DML(insert、update、delete)语句、DDL(create，alter、drop)语句（返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。）

ResultSet executeQuery(String sql) ：执行DQL(select)语句

4. ResultSet：结果集对象,封装查询结果

boolean next()：游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true

getXxx(参数)：获取数据

1. Xxx：代表数据类型 如： int getInt() , String getString()
2. 参数：
   1. int：代表列的编号,从1开始 如： getString(1)
   2. String：代表列名称。 如： getDouble(“balance”)
3. 使用步骤：
   1. 游标向下移动一行
   2. 判断是否有数据
   3. 获取数据

5. PreparedStatement：执行sql的预编译对象

SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题

参数使用?作为占位符

使用：

1. 定义sql：select * from user where username = ? and password = ?;
2. 获取sql预编译对象：PreparedStatement Connection.prepareStatement(String sql);
3. 给?赋值：setXxx(参数1,参数2)
   1. Xxx：代表数据类型 如： int getInt() , String getString()
   2. 参数1：?的位置编号 从1开始
   3. 参数2：?的值
4. 执行sql，接受返回结果，不需要传递sql语句

后期都会使用PreparedStatement来完成增删改查的所有操作

1. 可以防止SQL注入
2. 效率更高

3、JDBC工具类

#jdbc.properties
url=
user=
password=

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    /**
     * 文件的读取，只需要读取一次即可拿到这些值-->使用静态代码块
     */
    static{
        //读取资源文件，获取值。
        try {
            //1. 创建Properties集合类。
            Properties pro = new Properties();

            //获取src路径下的文件的方式--->ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res  = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
            System.out.println(path);
            
            //2. 加载文件
            pro.load(new FileReader(path));

            //3. 获取数据，赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            
            //4. 注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     */
    public static void close(Statement stmt,Connection conn){
        JDBCUtils.close(null,stmt,conn);
    }
    
    /**
     * 释放资源
     */
    public static void close(ResultSet rs,Statement stmt, Connection conn){
        if( rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

4、数据库连接池

概念：一个存放数据库连接的容器，可以节约资源且高效地访问数据库

标准接口(经典白学)

1. 获取连接：getConnection()
2. 归还连接：Connection.close()

数据库厂商接口 => 数据库连接池技术

1. C3P0
2. Druid:阿里提供的

1）C3P0

1. 步骤

1. 导入jar包 (两个)： c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar 不要忘记导入数据库驱动jar包
2. 定义配置文件：
3. 名称：c3p0.properties 或者 c3p0-config.xml
4. 路径：直接将文件放在src目录下即可
5. 创建核心对象 数据库连接池对象 ：ComboPooledDataSource
6. 获取连接：getConnection

2. 代码实现

//1.创建数据库连接池对象
DataSource ds  = new ComboPooledDataSource();
//2. 获取连接对象
Connection conn = ds.getConnection();

2）Druid

1. 导入jar包 druid-1.0.9.jar
2. 定义配置文件：properties形式、可以叫任意名称，可以放在任意目录下
3. 加载配置文件：Properties
4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
5. 获取连接：getConnection

//3.加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//4.获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5.获取连接
Connection conn = ds.getConnection();

3）Druid工具类

public class JDBCUtils {

    //1.定义成员变量 DataSource
    private static DataSource ds ;

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            
            //2.获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

  /**
	* 获取连接
	*/
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

  /**
	* 释放资源
	*/
    public static void close(Statement stmt,Connection conn){
        /* if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }

		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		*/
        close(null,stmt,conn);
    }
    public static void close(ResultSet rs , Statement stmt, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

  /**
	* 获取连接池方法
	*/

    public static DataSource getDataSource(){
        return  ds;
    }
}

5、Spring JDBC

1）概述

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

2）步骤

1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource：JdbcTemplate template = new JdbcTemplate(ds);
3. 调用JdbcTemplate的方法来完成CRUD的操作

2）方法

update()：执行DML语句。增、删、改语句

queryForMap()：查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合 --> 这个方法查询的结果集长度只能是1

queryForList()：查询结果将结果集封装为list集合 --> 将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

query()：查询结果，将结果封装为JavaBean对象

query的参数：RowMapper

一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装

new BeanPropertyRowMapper<类型>(类型.class)

@Test
public void test(){
    String sql = "select * from emp";
    List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
    for (Emp emp : list) {
        System.out.println(emp);
    }
}

queryForObject：查询结果，将结果封装为对象 => 一般用于聚合函数的查询

@Test
public void test(){
  String sql = "select count(id) from emp";
  Long total = template.queryForObject(sql, Long.class);
  System.out.println(total);
}