JDBC基础知识点

JDBC:定义了操作所有关系型数据库的规则（接口）
不同数据库写了不同的实现类
执行步骤
1.导入jar包
2.注册驱动
3.获取数据库的连接对象 Connection
4.定义sql
5.或取执行sql语句的对象 statement
6.执行sql，接受返回结果
7.处理结果
8.释放资源

JDBC中的各个对象
1.DriverManager：驱动管理对象
功能：
1.注册驱动：告诉程序该使用哪一个数据库驱动jar
2.获取数据库连接：
方法：static Connection getConnection(String url, String user, String password)
试图建立到给定数据库 URL 的连接。
url：指定的连接路劲
语法：jdbc:mysql://ip地址（域名）:端口号/数据库名称（如果是本机的ip地址和默认端口，可以不写）
user：用户名 password：用户密码
2.Connection:数据库连接对象
功能：
（1）.获取执行sql的对象
Statement createStatement()
PreparedStatement perparedStatement(String sql)
(2).管理事务
开启事务：setAutoCommit(boolean autoCommit):调用该方法设置参数为false 开启事务
提交事务：commit
回滚事务：rollback
3.Statement：执行sql的对象
执行sql:
(1).boolean execute（String sql）：可以执行任意sql
(2).int executeUpdate（String sql）执行DML（insert，update，delete）DDL(create,alter,drop)
返回值影响行数，可以通过执行的行数>0判断执行成功
(3).ResultSet executeQuery（String sql）:执行DQL（select）语句
实例：

public class JDBCNote {
    public static void main(String[] args) {
        //1.导入驱动jar包
        //2.注册驱动
        Connection con=null;
        Statement sta=null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            //定义sql语句
            String sql="insert into stu values(null,'番茄',18,95.0,'2024-06-03',null)";
            //获取数据库连接对象
            con = DriverManager.getConnection("jdbc:mysql:///db2", "root", "0903");
            //获取执行sql的对象 Statement
            sta = con.createStatement();
            //执行sql
            int i = sta.executeUpdate(sql);
            System.out.println(i);
            if (i>0){
                System.out.println("添加成功");
            }else{
                System.out.println("添加失败");
            }
            con.close();
            sta.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            if(sta!=null){
                try {
                    sta.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(con!=null){
                try {
                    con.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

4.ResultSet：结果集对象,就是封装查询结果的
Boolean next（）：游标向下移动一行，判断当前行是否是最后一行末尾
getXxx（参数）：获取数据
Xxx:代表数据类型 如 int getInt（1）
参数：int 代表列的编号
String 代表列的名称

实例：

/**
 ResultSet结果遍历
 */
public class Demo01_ResultSet {
    public static void main(String[] args) {
        Connection con=null;
        Statement sta=null;
        ResultSet rs=null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String sql="select * from stu";
            con = DriverManager.getConnection("jdbc:mysql:///db2", "root", "0903");
            sta = con.createStatement();
            rs = sta.executeQuery(sql);
            while(rs.next()){
                int id = rs.getInt(1);
                System.out.print(id);
                String name = rs.getString(2);
                System.out.print(name);
                int age = rs.getInt(3);
                System.out.print(age);
                double score = rs.getDouble(4);
                System.out.print(score);
                String brithday = rs.getString(5);
                System.out.print(brithday);
                String time = rs.getString(6);
                System.out.println(time);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(sta!=null){
                try {
                    sta.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(con!=null){
                try {
                    con.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

5.preparedStatement extneds Statement：执行sql的对象
sql注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。造成安全性问题
解决sql注入问题：使用preparedStatement对象解决
预编译的sql：参数使用？作为占位符
步骤
1.导入jar包
2.注册驱动
3.获取数据库的连接对象 Connection
4.定义sql:sql参数的使用使用？作为占位符。比如select * from user where username =？and password=？;
5.或取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
6.给问号赋值：方法：setXxx（参数1，参数2） 参数1：？的位置编号 参数2：？的值
7.执行sql，接受返回结果，不需要传递参数
8.处理结果
9.释放资源
后期都使用PreparedStatement，效率更高，可以防止sql注入

抽取JDBC工具类：JDBCUtils
目的：简化书写
分析：
1.注册驱动也抽取
2.抽取一个方法获取连接对象
需求：不传递参数，还得保证工具类的通用性
解决：配置文件
静态代码块（文件的读取只需要读取一次即可拿到这些值）
3.抽取一个方法释放资源

代码：

import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

/**
 JDBC工具类
 */
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();
            pro.load(new FileReader(path));
            //获取属性，赋值
            url= pro.getProperty("url");
            user=pro.getProperty("user");
            password=pro.getProperty("password");
            driver= pro.getProperty("driver");
            Class.forName(driver);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /*

    获取连接
    return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,password);
    }

    /**
     释放资源
     * @param stat
     * @param con
     */
    public static void close(Statement stat,Connection con){
        if(stat!=null){
            try {
                stat.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(con!=null){
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close(ResultSet rs,Statement stat, Connection con){
        if(stat!=null){
            try {
                stat.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(con!=null){
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

类加载器
获取src路径下文件的方式–>ClassLoader 类加载器

ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
            pro.load(new FileReader(path));

JDBC事务：
1.事务：一个包含多个步骤的业务，如果这个业务操作都被事务管理，要么步骤同时成功，要么同时失败
2.操作：用Connection对象
在执行sql之前开启事务：setAutoCommit(boolean autoCommit):调用该方法设置参数为false 开启事务
在sql执行完之后提交事务：commit
在catch中回滚事务：rollback
Druid:数据库连接池 实现技术由阿里提供

Druid:数据库连接池 实现技术由阿里提供
步骤：
1.导入druid-1.0.9.jar包
2.定义配置文件：是properties形式，可以叫任意名称，可以放在任意目录下
3.加载配置文件
4.获取数据库名称连接池对象：通过工厂来获取 DruidDataSourceFactory
5.获取连接：getConnection
定义一个工具类
1.定义一个类 DruidUtils
2.提供静态代码块加载配置文件
3.提供方法
（1）获取连接方法
（2）获取连接池的方法
（3）释放资源

public class DruidUtils {
    private static DataSource ds;
    static {
        try {
            //加载配置文件
            Properties pro = new Properties();
            InputStream is = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);
            //获取连接池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 sta,Connection con){
        if (sta!=null){
            try {
                sta.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (con!=null){
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close(ResultSet rs,Statement sta, Connection con){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (sta!=null){
            try {
                sta.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (con!=null){
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    //获取连接池的方法
    public static DataSource getDataSource(){
        return ds;
    }
}

Spring框架对JDBC的简单封装，提供一个JDBCTemplate对象简化JDBC的开发
步骤：
1.导入jar包
2.创建jdbcTemplate对象，依赖于数据源DataSource
3.调用jdbcTemplate的方法完成CRUD操作
常用方法：
update（）：执行DML语句。增删改查
queryForMap（）：查询结果将结果集封装为map集合
注意：此方法查询的结果集只能是1
queryList（）：查询结果将结果集封装为list集合
注意：将每一条记录装载到map集合中，再将多个map集合装载到list里面
query（）：查询结果，将结果封装为javaBean对象
query一般使用BeanPropertyRowMapper实现类可以完成javaBean(JavaBean 是一种JAVA语言写成的可重用组件,它是一个类)的自动封装
new BeanPropertyRowMapper<类型>(类型.class));

private JdbcTemplate te=new JdbcTemplate(DruidUtils.getDataSource());
    @Test
    public void test(){
        String sql="select*from stu";
        List<Stu> list = te.query(sql, new BeanPropertyRowMapper<Stu>(Stu.class));
        for (Stu stu : list) {
            System.out.println(stu);
        }

queryForObject：查询结果，将结果封装为对象
注意：一般用于查询一些聚合函数

public class Demo06_SpringJDBC {
    public static void main(String[] args) {
        //创建jdbcTemplate对象，依赖于数据源DataSource
        JdbcTemplate template = new JdbcTemplate(DruidUtils.getDataSource());
        //调用jdbcTemplate的方法完成CRUD操作
        String sql="update stu set score=77.7 where id=?";
        template.update(sql,1);
    }
}