JDBC核心技术学习笔记

JDBC核心技术

  • 1、JDBC概述
    • 1.1 数据的持久化
    • 1.2Java中的数据存储技术
    • 1.3JDBC介绍
    • 1.4 JDBC体系结构
    • 1.5JDBC程序编写步骤
  • 2、快速入门
  • 3、详解各个对象
    • 抽取JDBC工具类:JDBCUtils
  • 4、JDBC控制事务
  • 5、数据库连接池
    • 1、概念:
    • 2、好处:
    • 3、实现:
    • 4、C3P0:数据库连接池技术
    • 5、Druid:数据库连接池技术,阿里巴巴提供
  • 6、Spring JDBC: JDBC Template

1、JDBC概述

  • 技术体系:
    JDBC核心技术学习笔记_第1张图片

1.1 数据的持久化

  • 持久化:把数据保存到可掉电式存储设备中以供之后使用。
  • 持久化的实现过程大多通过各种关系数据库来完成
  • 持久化的主要应用是将内存中的数据存储在关系型数据库中,当然也可以存储在磁盘文件,XML数据文件中。

1.2Java中的数据存储技术

  • Java数据库存储技术:
    • JDBC直接访问数据库。
    • JDO(Java Data Object)技术
    • 第三方工具,Mybatis

1.3JDBC介绍

JDBC是一个独立于特定数据库管理系统,通用的sql数据库存储和操作的公共接口(API)。

JDBC核心技术学习笔记_第2张图片
有了JDBC:
JDBC核心技术学习笔记_第3张图片

1.4 JDBC体系结构

JDBC核心技术学习笔记_第4张图片

1.5JDBC程序编写步骤

  • 开始
  • 导入java.sql包
    1、复制jar包到libs目录下
    2、右键,Add As Library
  • 建立数据源,附加驱动
  • 加载并注册驱动程序
  • 创建connection对象
  • 创建Statement对象
  • 执行SQL语句
  • 使用ResultSet对象
  • 关闭ResultSet对象
  • 关闭Statement对象
  • 关闭connection对象
  • 结束

2、快速入门

package com.atguigu.connection;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

/*
* Jdbc快速入门
* */
public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
        //1、导入驱动jar包
        //2、注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //3、湖区数据库连接对象
        Connection conn =  DriverManager.getConnection("jdbc:mysql://localhost:3306/db3?serverTimezone=GMT%2B8","root","123456");
        //4、定义sql语句
        String sql = "update account set balance = 500 where id = 1";
        //5、获取数据库对象Statement
        Statement stmt = conn.createStatement();
        //6、执行sql
        int count = stmt.executeUpdate(sql);
        //7、处理结果
        System.out.println(count);
        //8、释放资源
        stmt.close();
        conn.close();
    }
}

3、详解各个对象

  • 1、DriverManager:驱动管理对象

    • 功能:
      • 1、注册驱动:告诉程序使用哪个数据库驱动jar
        static void registerDriver(Driver driver) :注册与给定的驱动程序 DriveManager
        写代码使用: Class.forName(“com.mysql.cj.jdbc.Driver”);
        查看源码发现:com.mysql.cj.jdbc.Driver类中存在静态代码块
        注意:mysql5之后的驱动jar包可以省略注册驱动的步骤
      • 2、获取数据库连接:
        • 方法: static Connection getConnection(String url, String user, String password)
        • 参数:
          • url:指定连接的路径
            • 语法:jdbc:mysql://ip地址(域名):端口号/数据库名称
            • 例子:jdbc:mysql://localhost:3306/db3
            • 细节:如果连接的是本机的mysql服务器,并且mysql服务器默认端口号为3306.则url可以简写为:jdbc:mysql://数据库名称
          • user:用户名
          • password :密码
  • 2、Connection:数据库连接对象

    • 1、功能:
      • 1、获取数据库对象:
        • Statement createStatement()
        • PreparedStatement prepareStatement(String sql)
      • 2、管理事务:
        • 开启事务:setAutoCommit(boolean autoCommit)
        • 提交事务:commit()
        • 回滚事务:rollback()
  • 3、Statement: 执行sql的对象

    • 1、执行sql
      • 1、boolean execute(String sql):可以执行任意的sql
      • 2、int executeUpdate(Stirng) : 执行DML(insert、update、delete)语句、DDL(create、alter、drop)语句
        • 返回值:影响的行数,可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功,反之,则失败。
      • 3、ResultSet execute(String sql) : 执行DQL(select)语句
  • 4、ResultSet: 结果集对象,封装查询结果

    • next(): 游标向下移动一行,判断当前行是否是最后一行(是否有数据),如果是,则返回false,如果不是则返回true。
    • getXxx(): 获取数据
      • Xxx表示数据类型 如: int getInt(), String getString()
      • 参数:
        • int: 代表列的编号,从1开始 如:getString(1)
        • String:代表列名称。如:getDouble(“balance”)
      • 注意:
        • 使用步骤:
          • 1、游标向下移动一行
          • 2、判断是否有数据
          • 3、获取数据
            while (rs.next()){
                            //循环判断结果是否有下一行
                            //循环数据
                            int id = rs.getInt(1);
                            String name = rs.getString("ac_name");
                            double balance = rs.getDouble(3);
            
                            System.out.println(id + "---" + name + "---" + balance);
                        }
            
      • 练习:
        • 定义一个方法,查询表中的数据并将其封装为对象,然后装载集合,返回。
          • 1、定义类
          • 2、定义方法:public list findAll(){ }
          • 3、实现方法:select * from xxxl;
        package com.atguigu.connection;
        
        import com.atguigu.exe.Account;
        
        import java.sql.*;
        import java.util.ArrayList;
        import java.util.List;
        
        /*
         * 定义一个方法,查询Account表的数据并将其封装为对象,然后装载集合,返回
         * */
        public class JDBCDemo8 {
        
            public static void main(String[] args) {
                List<Account> list = new JDBCDemo8().findAll();
                System.out.println(list);
                System.out.println(list.size());
            }
        
            /*
             * 查询所有Account对象
             * */
            public List<Account> findAll() {
                Connection conn = null;
                Statement stmt = null;
                ResultSet rs = null;
                List<Account> list = null;
                try {
                    //1、注册驱动
                    Class.forName("com.mysql.cj.jdbc.Driver");
                    //2、获取连接
                    conn = DriverManager.getConnection("jdbc:mysql:///db3?serverTimezone=GMT%2B8", "root", "123456");
                    //3、定义sql
                    String sql = "select * from account";
                    //4、获取执行sql的对象
                    stmt = conn.createStatement();
                    //5、执行sql
                    rs = stmt.executeQuery(sql);
                    //6、遍历结果集,封装对象,装载集合
                    Account account = null;
                    list = new ArrayList<Account>();
                    while (rs.next()) {
                        //获取数据
                        int id = rs.getInt("id");
                        String ac_name = rs.getString("ac_name");
                        int balance = rs.getInt("balance");
                        //创建account对象,并赋值
                        account = new Account();
                        account.setId(id);
                        account.setAc_name(ac_name);
                        account.setBalance(balance);
                        //装载集合
                        list.add(account);
        
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally {
                    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();
                        }
                    }
                }
        
                return list;
            }
        }
        
        
  • 5、PreparedStatement:执行sql的对象

    • 1、SQL注入问题:在拼接sql时,有一些sql的特殊关键字与字符串的拼接。会造成安全性问题
      • 1、输入用户随便,输入密码:a’ or ‘a’ = ’ a
      • 2、sql: select * from user where username = ‘fhiasdh’ and password =a’ or ‘a’ = ’ a
    • 2、 解决sql注入问题:使用PreparedStatement对象来解决
    • 3、预编译的SQL:参数使用?作为占位符
    • 4、步骤:
      • 1、 导入驱动jar包
      • 2、注册驱动
      • 3、获取数据库连接对象 Connection
      • 4、定义sql
        • 注意: sql的参数使用?作为占位符。如:select * from user where username = ? and password = ?;
      • 5、获取执行sql语句的对象 PreoareStatement Connection.prepareStatement(String sql)
      • 6、给?赋值:
        • 方法:setXxx(参数1,参数2)
          • 参数1:?的位置编号(从1开始)
          • 参数2:?的值
      • 6、执行sql,接收返回结果,不需要传递sql 语句
      • 7、处理结果
      • 8、释放资源
    • 5、注意:后期都会使用PreparedStatement来完成增删改查的所有操作
      • 1、可以防止sql注入
      • 2、效率更高

抽取JDBC工具类:JDBCUtils

  • 目的:简化书写

  • 分析:

    • 1、注册驱动也抽取
    • 2、抽取一个方法获取连接对象
      • 需求:不想传递参数(麻烦),还得保证工具类的通用性。
      • 解决:配置文件
        • jdbc.properties
          url =
          user =
          password =
    • 3、 抽取一个方法释放对象
  • 代码实现1:

package com.atguigu.util;

import javax.annotation.processing.Filer;
import java.awt.*;
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();
            System.out.println(path);
            //2、加载文件
            //pro.load(new FileReader("src/jdbc.properties"));
            pro.load(new FileReader(path));
            //3、获取数据,赋值
            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 Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }


    /**
     * 释放资源
     *
     * @param stmt
     * @param conn
     */
    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();
            }
        }
    }

    /**
     * 释放资源
     *
     * @param stmt
     * @param 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();
            }
        }
    }

}

  • 练习:
    • 需求:

      • 1、键盘录入用户名密码
      • 2、判断用户是否登录成功
    • 步骤:

      • 1、创建数据库表 user
CREATE TABLE USER(
	id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
	username VARCHAR(32),
	PASSWORD VARCHAR(32)

);



INSERT INTO USER VALUES(NULL,'zhangsan','123');
INSERT INTO USER VALUES(NULL,'lisi','234');

SELECT * from USER;
  • 代码实现2:
package com.atguigu.connection;

/*
 * * 练习:
 * 需求:
 * 1、键盘录入用户名密码
 * 2、判断用户是否登录成功
 * */

import com.atguigu.util.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;

public class JDBCDemo9 {


    public static void main(String[] args) {
        //1、键盘录入,接收用户名密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();
        //2、调用方法
        boolean flag = new JDBCDemo9().login(username, password);
        //3、判断结果,输出不同语句
        if (flag) {
            //登陆成功
            System.out.println("success!");
            //登录失败
        } else {
            System.out.println("fail!");
        }

    }


    /**
     * 登录方法
     */
    public boolean login(String username, String password) {
        if (username == null || password == null) {
            return false;
        }
        //连接数据库判断是否登录成功
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        //1、获取连接
        try {
            conn = JDBCUtils.getConnection();
            //2、定义sql
            String sql = "select * from user where username = '" + username + "' and password = '" + password + "' ";
            //3、获取执行sql的对象
            stmt = conn.createStatement();
            //4、执行查询
            rs = stmt.executeQuery(sql);
            //5、判断
            return rs.next();//如果有下一行,返回true

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(rs, stmt, conn);
        }

        return false;
    }
}

4、JDBC控制事务

  • 1、事务:一个包含多个步骤的业务操作。如果这个业务操作被事务管理,则这多个步骤要么同时成功,要么同时失败。
  • 2、操作:
    • 1、开启事务
    • 2、提交事务
    • 3、回滚事务
  • 3、使用Connection对象来管理事务
    • 开启事务:setAutoCommit(boolean autoCommit):调用该方法设置参数为false,即开启事务
      • 在执行sql之前开启事务
    • 提交事务:commit()
      • 当所有sql都执行完提交事务
    • 回滚事务:rollback()
      • 在catch中回滚事务

5、数据库连接池

1、概念:

是一个集合,存放数据库连接的容器。当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完后,会将连接对象归还给容器

2、好处:

  • 节约资源
  • 用户访问高效

3、实现:

  • 1、标准接口:DataSource javax.sql包下的
    • 1、方法:
      • 获取连接:getConnection()
      • 归还连接:如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接
    • 2、一般我们不去实现它,有数据库厂商来实现
      • 1、C3P0:数据库连接池技术
      • 2、Druid:数据库连接池实现技术,由阿里巴巴提供

4、C3P0:数据库连接池技术

  • 步骤:
    1、导入jar包两个,还要导入数据库驱动包
    2、定义xml配置文件:
    • 名称:c3p0.properties 或者 c3p0-config.xml
    • 路径:直接将文件放在src目录下即可
      3、创建核心对象 数据库连接池对象 ComboPooledDataSource
      4、获取连接:getConnection

5、Druid:数据库连接池技术,阿里巴巴提供

  • 步骤:
    1、导入jar包
    2、定义properties配置文件:

    • 1、是properties形式的
    • 2、可以叫做任何名称,可放在任意目录下,手动加载
      3、加载配置文件:properties
      4、获取数据库连接池对象:通过工厂来获取:DruidDataSourceFactory
      5、获取连接:getConnection
  • 定义工具类:
    1、定义一个类 JDBCUtils
    2、提供静态代码块加载配置文件,初始化连接池对象
    3、提供方法

    • 1、 获取连接方法:通过数据库连接池获取连接
    • 2、释放资源
    • 3、获取连接池的方法

6、Spring JDBC: JDBC Template

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

  • 步骤:

    • 1、导入jar包
    • 2、 创建JDBCTemplate对象。依赖于数据源DataSource
    • 3、调用JDBCTemplate方法来完成crud操作:
      • update():执行DML语句。增删改
      • queryForMap():查询结果,将结果封装成Map集合
        • 注意:这个方法查询的结果集长度只能是1
      • queryForList():查询结果,将结果封装成list集合
        • 注意:将每一个结果封装成Map集合,再讲Map集合装载到list对象中
      • query():查询结果,将结果封装成JavaBean对象
        • query的参数:RowMapper
          • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
          • new BeanPropertyRowMapper<类型>(类型.class)
        • queryforObject:查询结果,将结果封装为对象
          • 一般用于聚合函数的查询
  • 基本入门程序:

package cn.itcust.datasource.jdbctemplate;

import cn.itcust.datasource.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;

/*
 * JdbcTemplate入门
 */
public class JdbcTemplateDemo1 {
    public static void main(String[] args) {
        //1、导入jar包
        //2、创建template对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3、调用方法
        String sql = "update account set balance = 5000 where id = ?";
        int count = template.update(sql,3);
        System.out.println(count);

    }
}

  • 练习:

    • 需求:
      • 修改1号数据的balance为10000;
      • 添加一条记录
      • 删除刚刚添加的记录
      • 查询id为1的记录,将其封装为map集合
      • 查询所有记录,将其封装为list
      • 查询所有记录,将其封装为Emp对象的list集合
      • 查询总记录数。
  • 演示代码:

package cn.itcust.datasource.jdbctemplate;

import cn.itcust.datasource.domain.Emp;
import cn.itcust.datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo2 {
    //1、获取JdbcTemplate对象
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 修改一号数据的balance为10000
     */
    @Test
    public void test1() {
        //2、定义sql
        String sql = "update account set balance = 10000 where id = 1";
        //3、执行sql
        int count = template.update(sql);
        System.out.println(count);
    }

    /**
     * 添加已一条记录
     */
    @Test
    public void test2() {
        String sql = "insert into account(id,ac_name,balance) value(?,?,?)";
        int count = template.update(sql, 8, "老八", 5000);
        System.out.println(count);
    }

    /**
     * 删除刚刚添加的记录
     */
    @Test
    public void test3() {
        String sql = "delete from account where id = ?";
        int count = template.update(sql, 8);
        System.out.println(count);
    }

    /**
     * 查询id为1的记录,将其封装成集合map
     * 注意:这个方法查询的结果集长度只能是1
     */
    @Test
    public void test4() {
        String sql = "select * from account where id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1);
        System.out.println(map);
        //结果:{id=1, ac_name=zhangsan, balance=10000}

    }

    /**
     * 查询所有记录,将其封装为Emp对象的list集合
     */
    @Test
    public void test5() {
        String sql = "select * from account";
        List<Map<String, Object>> list = template.queryForList(sql);
        for (Map<String, Object> stringObjectMap : list) {
            System.out.println(stringObjectMap);
        }
    }

    /**
     * 查询所有记录,将其封装为Emp对象的list集合
     */
    @Test
    public void test6() {
        String sql = "select * from account";
        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException {
                Emp emp = new Emp();
                int id = rs.getInt("id");
                String ac_name = rs.getString("ac_name");
                int balance = rs.getInt("balance");

                emp.setId(id);
                emp.setAc_name(ac_name);
                emp.setBalance(balance);
                return emp;
            }
        });

        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 查询所有记录,将其封装为Emp对象的list集合
     */
    @Test
    public void test6_2() {
        String sql = "select * from account";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

    /**
     * 查询所有记录数
     */
    @Test
    public void test7(){
        String sql = "select count(id) from account";
        Long total = template.queryForObject(sql,long.class);
        System.out.println(total);
    }
}

你可能感兴趣的:(Java)