JDBC的使用

最新推荐文章于 2023-08-25 18:56:13 发布
最新推荐文章于 2023-08-25 18:56:13 发布
阅读量216 收藏 1
点赞数
文章标签： jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51973131/article/details/118947093
版权
JDBCJDBC的入门JDBC API 允许用户访问任何形式的表格数据，尤其是存储在关系数据库中的数据。执行流程：连接数据源，如：数据库。为数据库传递查询和更新指令。处理数据库响应并返回的结果。什么是JDBCJDBC 规范定义接⼝，具体的实现由各⼤数据库⼚商来实现。JDBC 是 Java 访问数据库的标准规范，真正怎么操作数据库还需要具体的实现类，也就是数据库驱动。每个数据库⼚商根据⾃家数据库的通信格式编写好⾃⼰数据库的驱动。所以我们只需要会调⽤ JDBC 接⼝中的⽅法即可，数据库驱动
摘要由CSDN通过智能技术生成

JDBC

JDBC的入门

JDBC API 允许用户访问任何形式的表格数据，尤其是存储在关系数据库中的数据。
执行流程：
连接数据源，如：数据库。
为数据库传递查询和更新指令。
处理数据库响应并返回的结果。

什么是JDBC

JDBC 规范定义接⼝，具体的实现由各⼤数据库⼚商来实现。
JDBC 是 Java 访问数据库的标准规范，真正怎么操作数据库还需要具体的实现类，也就是数
据库驱动。每个数据库⼚商根据⾃家数据库的通信格式编写好⾃⼰数据库的驱动。所以我们只需
要会调⽤ JDBC 接⼝中的⽅法即可，数据库驱动由数据库⼚商提供。

使⽤JDBC的好处：

  1. 程序员如果要开发访问数据库的程序，只需要会调⽤ JDBC 接⼝中的⽅法即可，不⽤关
    注类是如何实现的。
  2. 使⽤同⼀套 Java 代码，进⾏少量的修改就可以访问其他 JDBC ⽀持的数据库。
JDBC的架构

分为双层架构和三层架构。

双层

Two-tier-Architecture-for-Data-Access

作用：此架构中，Java Applet 或应用直接访问数据源。
条件：要求 Driver 能与访问的数据库交互。
机制：用户命令传给数据库或其他数据源，随之结果被返回。
部署：数据源可以在另一台机器上，用户通过网络连接，称为 C/S配置（可以是内联网或互联网）。

三层

在这里插入图片描述

侧架构特殊之处在于，引入中间层服务。
流程：命令和结构都会经过该层。
吸引：可以增加企业数据的访问控制，以及多种类型的更新；另外，也可简化应用的部署，并在多数情况下有性能优势。
历史趋势： 以往，因性能问题，中间层都用 C 或 C++ 编写，随着优化编译器（将 Java 字节码 转为 高效的 特定机器码）和技术的发展，如EJB，Java 开始用于中间层的开发这也让 Java 的优势突显出现出来，使用 Java 作为服务器代码语言，JDBC随之被重视。

使⽤JDBC开发使⽤到的包
会使⽤到的包说明
java.sql所有与 JDBC 访问数据库相关的接⼝和类
javax.sql数据库扩展包，提供数据库额外的功能。如:连接池
数据库的驱动由各⼤数据库⼚商提供，需要额外去下载，是对 JDBC 接⼝实现的类
JDBC的核⼼API
接⼝或类作⽤
DriverManager 类1. 管理和注册数据库驱动2. 得到数据库连接对象
Connection 接⼝⼀个连接对象，可⽤于创建 Statement 和 PreparedStatement对象
Statement 接⼝⼀个 SQL 语句对象，⽤于将 SQL 语句发送给数据库服务器。
PreparedStatement 接⼝⼀个 SQL 语句对象，是 Statement 的⼦接⼝
ResultSet 接⼝⽤于封装数据库查询的结果集，返回给客户端 Java 程序
加载和注册驱动
加载和注册驱动的⽅法描述
Class.forName(数据驱动实现类)加载和注册数据库驱动，数据库驱动由 MySQL ⼚商"com.mysql.jdbc.Driver"

DriverManager类

DriverManager 作⽤
  1. 管理和注册驱动
  2. 创建数据库的连接
类中的⽅法
DriverManager 类中的静态⽅法描述
Connection getConnection (String url, String user,String password)通过连接字符串，⽤户名，密码来得到数据库的连接对象
Connection getConnection (String url, Propertiesinfo)通过连接字符串，属性对象来得到连接对象
使⽤JDBC连接数据库的四个参数
JDBC连接数据库的四个参数说明
⽤户名登录的⽤户名
密码登录的密码
连接字符串 URL不同的数据库 URL 是不同的，mysql 的写法jdbc:mysql://localhost:3306/数据库[?参数名=参数值]
驱动类的字符串名com.mysql.jdbc.Driver
连接数据库
  1. 使用用户名、密码、URL得到连接对象
public class Demo2 {
	public static void main(String[] args) throws SQLException {
		String url = "jdbc:mysql://localhost:3306/java2106";
		Connection connection = DriverManager.getConnection(url, "root","123wang456");
		System.out.println(connection);
	}
}
  1. 使用属性文件和URL得到连接对象
public class Demo3 {
	public static void main(String[] args) throws SQLException {
		String url = "jdbc:mysql://localhost:3306/java2106";
		Properties prop = new Properties();
		prop.setProperty("user", "root");
		prop.setProperty("password", "123wang456");
		Connection connection = DriverManager.getConnection(url, prop);
		System.out.println(connection);
	}
}

数据库工具类JDBCUtils

public class JDBCUtils {
    private static String url;
    private static String driver;
    private static String username;
    private static String password;
    static {
        Properties pro = new Properties();
        try {
            pro.load(JDBCUtils.class.getResourceAsStream("JDBCmsg.properties"));
            driver = pro.getProperty("jdbc.driver");
            url = pro.getProperty("jdbc.url");
            username = pro.getProperty("jdbc.userName");
            password = pro.getProperty("jdbc.password");
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection(){
        try {
            return DriverManager.getConnection(url,username,password);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            return null;
        }
    }
}

PreparedStatement接口

Connection 创建 PreparedStatement对象
Connection 接⼝中的⽅法描述
PreparedStatementprepareStatement(String sql)指定预编译的 SQL 语句，SQL 语句中使⽤占位符? 创建⼀个语句对象
PreparedStatement接口中的对象
PreparedStatement 接⼝中的⽅法描述
int executeUpdate()执⾏ DML，增删改的操作，返回影响的⾏数。
ResultSet executeQuery()执⾏ DQL，查询的操作，返回结果集
PreparedSatement 的好处
  1. prepareStatement()会先将 SQL 语句发送给数据库预编译。PreparedStatement 会引⽤着
    预编译后的结果。可以多次传⼊不同的参数给 PreparedStatement 对象并执⾏。减少 SQL
    编译次数，提⾼效率。
  2. 安全性更⾼，没有 SQL 注⼊的隐患。
  3. 提⾼了程序的可读性。
PreparedSatement的使用
public class Demo03 {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        String username = sc.nextLine();
        String password = sc.nextLine();

        Connection conn = JDBCUtils.getConnection();
        String sql = "select * from user2 where username = ? and password = ?";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setString(1,username);
        stmt.setString(2,password);
        ResultSet rs = stmt.executeQuery();
        if(rs.next()){
                System.out.println("登陆成功");
        }else {
            System.out.println("登录失败");
        }
        rs.close();
        stmt.close();
        conn.close();
    }
}
案例

使⽤ PreparedStatement 查询⼀条数据，封装成⼀个Emp 对象

public class Demo04Emp {
    // 新增
    public void addEmp(Emp emp) {
        Connection conn = JDBCUtils.getConnection();
        String sql = "insert into emp values (?,?,?,?,?,?,?,?)";
        PreparedStatement stmt = null;
        try {
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,emp.getEmpno());
            stmt.setString(2,emp.getEname());
            stmt.setString(3,emp.getJob());
            stmt.setInt(4,emp.getMgr());
            stmt.setDate(5, (Date) emp.getHiredate());
            stmt.setDouble(6,emp.getSal());
            stmt.setDouble(7,emp.getComm());
            stmt.setInt(8,emp.getDeptno());
            stmt.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
    // 根据id删除
    public void deleteById(int empno) {
        Connection conn = JDBCUtils.getConnection();
        String sql = "delete from emp where empno = ?";
        PreparedStatement stmt = null;
        try {
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,empno);
            stmt.executeUpdate();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
    // 根据id查询
    public Emp findById(int empno) {
        Connection conn = JDBCUtils.getConnection();
        String sql = "select * from emp where empno = ?";
        PreparedStatement stmt = null;
        ResultSet rs = null;
        Emp emp = new Emp();
        try {
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,empno);
            rs = stmt.executeQuery();
            while (rs.next()){
                emp.setEmpno(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHiredate(rs.getDate(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptno(rs.getInt(8));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        return emp;
    }
    // 查询全部（分页）
    public List<Emp> findList(int page, int pageSize){
        Connection conn = JDBCUtils.getConnection();
        String sql = "select * from emp limit ?,?";
        PreparedStatement stmt = null;
        ResultSet rs = null;
        List<Emp> list = new ArrayList<>();
        try {
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,(page-1)*pageSize);
            stmt.setInt(2,pageSize);
            rs = stmt.executeQuery();
            while (rs.next()){
                Emp emp = new Emp();
                emp.setEmpno(rs.getInt(1));
                emp.setEname(rs.getString(2));
                emp.setJob(rs.getString(3));
                emp.setMgr(rs.getInt(4));
                emp.setHiredate(rs.getDate(5));
                emp.setSal(rs.getDouble(6));
                emp.setComm(rs.getDouble(7));
                emp.setDeptno(rs.getInt(8));
                list.add(emp);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        return list;
    }
    // 修改
    public void update(Emp emp) {
        Connection conn = JDBCUtils.getConnection();
        PreparedStatement stmt = null;
        String sql = "update emp set empno = ?,ename = ?,job = ?," +
                "mgr = ?,hiredate = ?,sal = ?,comm = ?,deptno = ? where empno = ?";
        try {
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,emp.getEmpno());
            stmt.setString(2,emp.getEname());
            stmt.setString(3,emp.getJob());
            stmt.setInt(4,emp.getMgr());
            stmt.setDate(5,(Date)emp.getHiredate());
            stmt.setDouble(6,emp.getSal());
            stmt.setDouble(7,emp.getComm());
            stmt.setInt(8,emp.getDeptno());
            stmt.setInt(9,emp.getEmpno());
            stmt.executeUpdate();
            stmt.close();
            conn.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
    //查询总记录条数
    public int getCount(){
        Connection conn = JDBCUtils.getConnection();
        PreparedStatement stmt = null;
        ResultSet rs = null;
        String sql = "select count(*) from emp";
        int count = 0;
        try {
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            if(rs.next()){
                count = rs.getInt(1);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
        return count;
    }
}
public class Demo06Main {
    Demo04Emp demo04Emp;
    @Before
    public void testBefore(){
        demo04Emp = new Demo04Emp();
    }
    @Test
    public void testAdd(){
        Emp emp = new Emp(7451,"MIKE","SALESMAN",
                7698,null,1600,200,20);
        demo04Emp.addEmp(emp);
    }
    @Test
    public void testDeleteById(){
        demo04Emp.deleteById(7451);
    }
    @Test
    public void testFindById(){
        demo04Emp.findById(7369);
    }
    @Test
    public void testFindList(){
        demo04Emp.findList(1,1);
    }
    @Test
    public void testUpdate(){
//        demo04Emp.update();
    }
    @Test
    public void testGetCount(){
        demo04Emp.getCount();
    }
}

public class Emp {
    private Integer empno;
    private String ename;
    private String job;
    private Integer mgr;
    private Date hiredate;
    private Double sal;
    private Double comm;
    private Integer deptno;

    public Emp() {
    }


    public Integer getEmpno() {
        return empno;
    }

    public void setEmpno(Integer empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public String getJob() {
        return job;
    }

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

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }

    public Double getComm() {
        return comm;
    }

    public void setComm(Double comm) {
        this.comm = comm;
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empno=" + empno +
                ", ename='" + ename + '\'' +
                ", job='" + job + '\'' +
                ", mgr=" + mgr +
                ", hiredate=" + hiredate +
                ", sal=" + sal +
                ", comm=" + comm +
                ", deptno=" + deptno +
                '}';
    }
}

JDBC事务的处理

之前我们是使⽤ MySQL 的命令来操作事务。接下来我们使⽤ JDBC 来操作银⾏转账的事务。

public class Demo07 {
    public static void main(String[] args) {
        Connection conn = JDBCUtils.getConnection();
        String sql1 = "update Account set money = money - ? where id = ? ";
        String sql2 = "update Account set money = money + ? where id = ? ";

        try {
            conn.setAutoCommit(false);
            PreparedStatement stmt1 = conn.prepareStatement(sql1);
            PreparedStatement stmt2 = conn.prepareStatement(sql2);
            stmt1.setInt(1,100);
            stmt1.setInt(2,1);
            stmt1.executeUpdate();

            //出现异常 - 手动制造
//            int i = 1/0;
            stmt2.setInt(1,100);
            stmt2.setInt(2,2);
            stmt2.executeUpdate();

            conn.commit();
            stmt2.close();
            stmt1.close();
            conn.close();
        } catch (SQLException throwables) {

        }
    }
}
鸣蜩一
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
jdbc使用参考手册
03-01
** JDBC使用参考手册详解 ** Java Database Connectivity (JDBC) 是Java编程语言中用于与数据库交互的一组标准API。这个英文版的JDBC使用参考手册是开发者的重要资源，提供了全面的指南来帮助理解和掌握JDBC的各个...
JDBC使用
weixin_50769390的博客
08-12 1563
jdbc详解，案例 sql注入问题
MySQL之limit的简单使用和优化
罗罗的1024
11-10 330
select * from table limit m,n 其中m是指记录开始的index，从0开始，表示第一条记录 n是指从第m+1条开始，取n条。 select * from tablename limit 2,4 即取出第3条至第6条，4条记录 select * from emp limit 5;
LAGOU任务二 MySql单表&约束&事务
hwinte的博客
06-25 242
1 DQL操作单表 1.1 创建数据表，复制表 （1）创建一个新的数据库 db2 CREATE DATABASE db2 CHARACTER SET utf8; （2）将db1数据库中的emp表复制到当前db2数据库 DQL_排序查询： /* 排序 使用order by字句 语法结构：select 字段名 from 表名 [where 字段名 = 值] order by 字段名称 [ASC/DESC] ASC 升序排序（默认升序） DESC 降序排序 */ -- 单列排序 按照某一个字段
大数据||Hive中常用的查询
热门推荐
大数据学习成长之路
03-07 1万+
Hive中的查询 Select查询语法SELECT [ALL | DISTINCT] select_expr, select_expr, ...  FROM table_reference  [WHERE where_condition]  [GROUP BY col_list]  [ORDER BY col_list]  [CLUSTER BY col_list    | [DISTRIBUTE...
Sharding-JDBC使用案例-分库分表
03-23
**Sharding-JDBC的使用步骤** 1. **配置分片规则**：在应用的配置文件中定义分库分表的策略，包括分片键、分片算法等。 2. **引入依赖**：在项目中添加Sharding-JDBC的依赖，通常是一个JAR包或者Maven/Gradle的...
JDBC使用方法
01-22
JDBC是 Java DataBase Connective 的缩写 JDBC的使用方法 获得connection对象
java连接数据库jdbc使用
03-07
了解数据库联接、了解JDBC 掌握JDBC在项目开发中的使用方法 使用JDBC连接数据库 使用JDBC操作数据库 实现单表的增加删除修改
JDBC基本用法
Allure泽宇的博客
12-15 2029
JDBC的基本操作
JDBC使用详解
KKK
05-25 971
JDBC详解
JDBC基本使用
太白_猿的博客
01-02 1578
JDBC基本使用（oracle、mysql连接数据库、Statement与PreparedStatement区别）
Java之Jdbc使用详解（ 最新！）
架构师小吴的博客
07-10 1417
JDBC（数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
JDBC（使用详解）
最新发布
weixin_65376296的博客
08-25 362
/ int update = loginDao.update(new User(6, "qinyuzhao", "123456", "秦昱照", "12315", "zhouyajun@qq.com"),"root");// int num = loginDao.register(new User(6, "qinyuzhao", "123456", "老韩", "13111223344", "qinyuzhao@qq.com"));# 查询使用executeQuery();
jdbc 简介
Darklovy
04-14 318
JDBC 指 Java 数据库连接，是一种标准Java应用编程接口（ JAVA API），用来连接 Java 编程语言和广泛的数据库。 JDBC API 库包含下面提到的每个任务，都是与数据库相关的常用用法。 制作到数据库的连接。 创建 SQL 或 MySQL 语句。 执行 SQL 或 MySQL 查询数据库。 查看和修改所产生的记录。 从根本上来说，JDBC 是一种规范，它提供了一套完...
【Java】学JDBC看这篇文章就够了—JDBC保姆级教程
任同学的博客
09-26 5852
基本介绍1. JDBC为访问不同的数据库提供了统一的接口，为使用者屏蔽了细节问题。2. Java程序员使用JDBC，可以连接任何提供了JDBC驱动程序的数据库系统，从而完成对数据库的各种操作。3. JDBC基本原理示意图4. JDBC是Java提供一套用于数据库操作的接口API，Java程序员只需要面向这套接口编程即可。不同的数据库厂商，需要针对这套接口，提供不同实现。JDBC相关API✨原创不易，还希望各位大佬支持一下👍✏️ 评论，你的意见是我进步的财富！
关于spring通过外部引入文件配置数据源，jdbc数据库配置文件中关于username的问题
qq_32448811的博客
06-23 2039
大多数数据库配置文件都会按这个格式编写： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=root jdbc.password=root 其中的jdbc.username为什么要标下划线呢？因为有时会有人将配置文件写成下面这个格式： driver=com.mysq...
JDBC使用SQLCA
03-30
JDBC不直接使用SQLCA。SQLCA是一个结构体，用于存储SQL语句的执行结果。在JDBC中，可以通过ResultSet对象获取SQL语句的执行结果。ResultSet对象提供了多个方法，可以访问查询结果的每一行数据。在执行更新操作时，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值