JDBC相关知识

最新推荐文章于 2024-08-24 17:09:16 发布
最新推荐文章于 2024-08-24 17:09:16 发布
阅读量125 收藏
点赞数
分类专栏： 全栈 文章标签： 数据库 java mysql

JDBC是一组规范：接口。用于java程序与数据库之间的通信（中间商算是）。

 加载与注册 JDBC 驱动

java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。
在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理
器类 (java.sql.DriverManager) 去调用这些 Driver 实现
Oracle 的驱动： oracle.jdbc.driver.OracleDriver
mySql 的驱动： com.mysql.jdbc.Driver
以下我们都使用Mysql的驱动进行连接。

基础版：

进行数据库的连接 ： 
  public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.添加jar
        //2.加载驱动
        Class.forName("com.mysql.jdbc.Driver");//初始化给定的类
        //3.通过驱动管理器获取连接对象
        //url是为了防止数据库和代码不在同一台机器    jdbc:mysql:// 是固定的  localhost 本地  ip地址  不同  java:你的数据库名称
        String url = "jdbc:mysql://localhost:3306/java";
        String user = "root";
        String pwd = "123456";
        Connection connection = DriverManager.getConnection(url, user, pwd);
        System.out.println("connection = " + connection);
    }

进行插入数据：编写的sql语句？作为占位符 ，建立预处理命令对象后进行参数的填空，最后执行executeUpdate()操作（参数已填充完毕），最后释放资源。

 public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.通过驱动管理器获取连接对象  Url表示和数据库通信的地址 如果url中需要带参数，则需要使用？进行连接  如果需要使用多个参数，从第二个参数开始使用&
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8", "root", "123456");
        //3.编写sql语句   ?作为占位符
        String sql = "insert into fruitdb values(0,?,?,?,?)";
        //4.创建预处理命令对象  PreparedStatement(是接口) 把 sql语句装进去然后给DB
        PreparedStatement psmt = connection.prepareStatement(sql);
        //5.填充参数  1234 为第几个问号
        psmt.setString(1,"banana");
        psmt.setInt(2,15);
        psmt.setInt(3,100);
        psmt.setString(4,"very delicious");
        //6.执行更新（增删改），返回影响行数
        int count = psmt.executeUpdate();
        System.out.println(count>0?"添加成功":"添加失败！");
        //7.释放资源（关闭连接,先关闭psmt,后关闭con）
        psmt.close();
        connection.close();

    }

修与改：除了sql语句不同外，其他的和插入步骤全部一致，返回值也一致

  public static void main(String[] args) throws ClassNotFoundException, SQLException {
        Fruit fruit = new Fruit(4,"grapy",15,30);
        Class.forName("com.mysql.jdbc.Driver");
        //2.通过驱动管理器获取连接对象  Url表示和数据库通信的地址 如果url中需要带参数，则需要使用？进行连接  如果需要使用多个参数，从第二个参数开始使用&
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8", "root", "123xwt");
        //3.编写sql语句   ?作为占位符
        String sql = "update fruitdb set fname = ?,price=?,fcount = ? where fid = ?";
        //String sql = "delete from  fruitdb where fid = ?";
        PreparedStatement psmt = connection.prepareStatement(sql);
        psmt.setString(1,fruit.getFname());
        psmt.setInt(2,fruit.getPrice());
        psmt.setInt(3,fruit.getFcount());
        psmt.setInt(4,fruit.getFid());
        int count = psmt.executeUpdate();
        System.out.println(count>0?"添加成功":"添加失败！");
        psmt.close();
        connection.close();
    }

查询操作：返回的是结果集ResultSet，同时需要遍历使用get，数字代表列号（从1开始），字符串代表结果集的列名（SQL语句中是别名用别名），执行的是.executeQuery()，释放资源时，结果集也要释放。

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.通过驱动管理器获取连接对象  Url表示和数据库通信的地址 如果url中需要带参数，则需要使用？进行连接  如果需要使用多个参数，从第二个参数开始使用&
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8", "root", "123xwt");
        //3.编写sql语句   ?作为占位符
        String sql = "select * from fruitdb ";
        //4.创建预处理命令对象  PreparedStatement(是接口) 把 sql语句装进去然后给DB
        PreparedStatement psmt = connection.prepareStatement(sql);
        //5.执行查询，返回结果集
        ResultSet rs = psmt.executeQuery();

        ArrayList<Fruit> fruitArrayList = new ArrayList<>();
        //6，解析结果集
        while (rs.next()){
            int fid = rs.getInt(1);//1表示当前行的第一列
            String fname = rs.getString("fname");//getString/getInt 可以接结果集的列名（SQL语句中是别名用别名）
            int price = rs.getInt(3);
            int fcount = rs.getInt(4);
            String fremark = rs.getString("remark");
            Fruit fruit = new Fruit(fid, fname, price, fcount, fremark);
            fruitArrayList.add(fruit);
        }

        //7.释放资源（关闭连接,先关闭psmt,后关闭con）
        rs.close();//结果集也需要关闭
        psmt.close();
        connection.close();
        fruitArrayList.forEach(System.out::println );
    }

直接上DAO：
先写一个Dao相关的接口 
public interface FruitDao {
    //查询库存列表
    List<Fruit> getFruitList();

    //新增库存
    boolean addFruit(Fruit fruit);
    //修改库存
    boolean updateFruit(Fruit fruit);

    //根据名称查询特定库存
    Fruit getFruitByFname(String fname);
    //删除特定库存记录
    boolean delFruit(String fname);
}

 实现类实现接口：

public class FruitDaoImpl extends BaseDao<Fruit> implements FruitDao {

    @Override
    public List<Fruit> getFruitList() {
        String sql = "select * from fruitdb ";
        return super.executeQuery(sql);
    }

    @Override
    public boolean addFruit(Fruit fruit) {
        String sql = "insert into fruitdb values(0,?,?,?,?)";
        return super.executeUpdate(sql,fruit.getFname(),fruit.getPrice(),fruit.getFcount(),fruit.getRemark())>0;
    }

    @Override
    public boolean updateFruit(Fruit fruit) {
        String sql = "update fruitdb set fcount = ? where fid = ?";

        return super.executeUpdate(sql,fruit.getFcount(),fruit.getFid())>0;
    }
    @Override
    public Fruit getFruitByFname(String fname) {
        String sql = "select * from fruitdb where fname= ?";
        return super.load(sql,fname);
    }

    @Override
    public boolean delFruit(String fname) {
        String sql = "delete from fruitdb where fname like ?";
        return super.executeUpdate(sql,fname)>0;
    }
}

将所有的操作写在父类方法里，实现类继承，然后传入相关sql语句，调用相关方法：

public abstract class BaseDao<T> {
    protected ResultSet rs;
    protected PreparedStatement psmt;
    protected Connection connection;
    protected String URL= "jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8";
    protected String DRIVER= "com.mysql.jdbc.Driver";
    protected String USER = "root";
    protected String PWD = "123xwt";
    //T的class对象
    private Class entityClass;
    public BaseDao(){
        //获得父类的泛型类(com...父类名<泛型类型>
        Type genericSuperclass = getClass().getGenericSuperclass();
        //ParameterizedType 参数化类型，即泛型   getActualTypeArguments()过的参数化类型的数组，泛型可能有多个
        Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass).getActualTypeArguments();
        //获取到的<T>的真实的类型
        Type actualType = actualTypeArguments[0];
        try {
            entityClass = Class.forName(actualType.getTypeName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    protected Connection getCon(){
        try {
            Class.forName(DRIVER);
            connection = DriverManager.getConnection(URL, USER, PWD);
            return connection;

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
    //执行更新，返回影响行数   Object... params    不定长参数，可传入多个参数
    protected int executeUpdate(String sql,Object... params){
        boolean insertFlag = false;//为了获取自增列
        //trim() 去除首尾空格  toUpperCase() 全部转换为大写  startsWith() 以什么开头
        insertFlag = sql.trim().toUpperCase().startsWith("INSERT");
        try {
            connection = getCon();
            if (insertFlag){
                psmt = connection.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);
            } else {
                psmt = connection.prepareStatement(sql);
            }
            setParams(psmt,params);
            int count = psmt.executeUpdate();

            rs = psmt.getGeneratedKeys();//insert 语句才会这样执行
            if (rs.next()){
                return ((Long)rs.getLong(1)).intValue();  //返回自增列值
            }
            return count;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                if (psmt!=null){
                    psmt.close();
                }
                if (connection!=null&&!connection.isClosed()){
                    connection.close();
                }}
            catch(SQLException e){
                e.printStackTrace();
            }
        }
    return 0;}
    //给预处理命令对象设置参数
    private void setParams(PreparedStatement psmt,Object... params) throws SQLException {
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                psmt.setObject(i + 1, params[i]);
            }
        }
    }
    //通过反射技术给obj对象的property属性赋propertyvalue值
    private void setValue(Object obj,String property,Object propertyValue){
        Class clazz = obj.getClass();
        try {
            //获取property这个字符串对应的属性名﹐比如"fid"去找 obj对象中的 fid属性
            Field field = clazz.getDeclaredField(property);
            if (field!=null){
                field.setAccessible(true);//强制访问，防止是private
                field.set(obj,propertyValue);
            }
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
    //执行查询，返回查询结果集
    protected ArrayList<T> executeQuery(String sql,Object... params){
        ArrayList<T> arrayList = new ArrayList<>();
        try {
            connection = getCon();
            psmt = connection.prepareStatement(sql);
            setParams(psmt,params);
            rs = psmt.executeQuery();
            //通过rs可以获取结果集的元数据
            //元数据︰描迹结果集数据的数据，简单讲，就是这个结果集有哪些列，什么类型等等
            ResultSetMetaData rsmd = rs.getMetaData();
            int columnCount = rsmd.getColumnCount();
            while (rs.next()){
                T entity = (T) entityClass.newInstance();
                for (int i = 0; i < columnCount; i++) {
                    String columnName = rsmd.getColumnName(i + 1);//获取列名
                    Object columnValue = rs.getObject(i + 1); //获取值
                    setValue(entity,columnName,columnValue);
                };
                //Fruit fruit = new Fruit(fid, fname, price, fcount, fremark);
                arrayList.add(entity);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            try {
                if (psmt!=null){
                    psmt.close();
                }
                if (connection!=null&&!connection.isClosed()){
                    connection.close();
                }}
            catch(SQLException e){
                e.printStackTrace();
            }
        }
        return arrayList;

    }
    //执行查询，返回单个实体对象
    protected T load(String sql,Object... params){
        try {
            connection = getCon();
            psmt = connection.prepareStatement(sql);
            setParams(psmt,params);
            rs = psmt.executeQuery();
            //通过rs可以获取结果集的元数据
            //元数据︰描迹结果集数据的数据，简单讲，就是这个结果集有哪些列，什么类型等等
            ResultSetMetaData rsmd = rs.getMetaData();
            int columnCount = rsmd.getColumnCount();
            if (rs.next()){
                T entity = (T) entityClass.newInstance();//新建一个实例
                for (int i = 0; i < columnCount; i++) {
                    String columnName = rsmd.getColumnName(i + 1);//获取列名
                    Object columnValue = rs.getObject(i + 1); //获取值
                    setValue(entity,columnName,columnValue);
                }
                return entity;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            try {
                if (psmt!=null){
                    psmt.close();
                }
                if (connection!=null&&!connection.isClosed()){
                    connection.close();
                }}
            catch(SQLException e){
                e.printStackTrace();
            }
        }
        return null;
    }
    //执行复杂查询（聚合函数等） 返回统计结果
    protected Object[] executeComplexQuer(String sql,Object... params){
        try {
            connection = getCon();
            psmt = connection.prepareStatement(sql);
            setParams(psmt,params);
            rs = psmt.executeQuery();
            //通过rs可以获取结果集的元数据
            //元数据︰描迹结果集数据的数据，简单讲，就是这个结果集有哪些列，什么类型等等
            ResultSetMetaData rsmd = rs.getMetaData();
            int columnCount = rsmd.getColumnCount();
            Object[] columnValueArr = new Object[columnCount];
            if (rs.next()){
                for (int i = 0; i < columnCount; i++) {
                    Object columnValue = rs.getObject(i + 1); //获取值
                    columnValueArr[i] = columnValue;
                }
                return columnValueArr;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (psmt!=null){
                    psmt.close();
                }
                if (connection!=null&&!connection.isClosed()){
                    connection.close();
                }}
            catch(SQLException e){
                e.printStackTrace();
            }
        }
        return null;
    }
}

        我们把连接和释放写入一个方法里：

    protected Connection getCon(){
        try {
            Class.forName(DRIVER);
            connection = DriverManager.getConnection(URL, USER, PWD);
            return connection;

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

        当使用泛型时（可能时多个泛型），我们获取具体的类名  actualTypeArguments[0]获取第一个泛型的类名

public BaseDao(){
        //获得父类的泛型类(com...父类名<泛型类型>
        Type genericSuperclass = getClass().getGenericSuperclass();
        //ParameterizedType 参数化类型，即泛型   getActualTypeArguments()过的参数化类型的数组，泛型可能有多个
        Type[] actualTypeArguments = ((ParameterizedType) genericSuperclass).getActualTypeArguments();
        //获取到的<T>的真实的类型
        Type actualType = actualTypeArguments[0];
        try {
            entityClass = Class.forName(actualType.getTypeName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

        同时将预处理命令对象设置参数抽成一个方法：这里就是setObject

 //给预处理命令对象设置参数
    private void setParams(PreparedStatement psmt,Object... params) throws SQLException {
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                psmt.setObject(i + 1, params[i]);
            }
        }
    }

        进行自增列查询时：预处理命令对象的创建需要使用额外的参数        Statement.RETURN_GENERATED_KEYS

psmt = connection.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);

        同时获取时：

rs = psmt.getGeneratedKeys();//insert 语句才会这样执行
if (rs.next()){
    return ((Long)rs.getLong(1)).intValue();  //返回自增列值
}

进行批处理：要执行批处理任务，需要添加一个参数：rewriteBatchedStatements=true

同时使用.addBatch(); 和executeBatch();   当任务太多时，我们可以分批执行 用if

 

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        //2.通过驱动管理器获取连接对象   如果要执行批处理任务，需要添加一个参数：rewriteBatchedStatements=true
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8&rewriteBatchedStatements=true", "root", "123xwt");
        //3.编写sql语句   ?作为占位符
        String sql = "insert into fruitdb values(0,?,?,?,?)";
        //4.创建预处理命令对象  PreparedStatement(是接口) 把 sql语句装进去然后给DB
        PreparedStatement psmt = connection.prepareStatement(sql);
        for (int i = 0; i <10 ; i++) {
            psmt.setString(1,"banana"+i);
            psmt.setInt(2,15);
            psmt.setInt(3,100);
            psmt.setString(4,"very delicious");
            //添加到批中
            psmt.addBatch();
            if (i%1000==0){//如果任务较多，可以分批次执行，每次执行完，清空任务队列
                psmt.executeBatch();
                psmt.clearBatch();
            }
        }
        int[] count = psmt.executeBatch();
        for (int i = 0; i < count.length; i++) {
            System.out.println(count[i]);
        }
        //7.释放资源（关闭连接,先关闭psmt,后关闭con）
        psmt.close();
        connection.close();

    }

使用德鲁伊Druid连接池：

//1.连接池中被close的对象并没有被真正关闭，而是将状态设置为空闲状态，然后放回池子，下次获取连接对象，这个对象会被重复利用
//2.没有被close的连接对象会被一直占用，那么下次继续获取连接对象，是不会获取到这个对象的
//读取外部的配置文件
public class Demo05Druid {
    public static void main(String[] args) throws Exception {

        Properties properties = new Properties();
        InputStream is = Demo05Druid.class.getClassLoader().getResourceAsStream("jdbc2.properties");
        properties.load(is);//加载属性文件

        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

        //1.连接池中被close的对象并没有被真正关闭，而是将状态设置为空闲状态，然后放回池子，下次获取连接对象，这个对象会被重复利用
        //2.没有被close的连接对象会被一直占用，那么下次继续获取连接对象，是不会获取到这个对象的
        Connection connection = dataSource.getConnection();//建立连接对象，可以建立多个连接对象
        System.out.println(connection);
    }
}

创建属性配置文件，写入参数：

driverClassName = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/java?userSSL=false&useUnicode=true&characterEncoding=utf-8
username = root
password = 123456
initialSize = 2
maxActive = 5
maxWait = 5000

 

 

粥ou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jdbc相关知识点归档.rar
03-21
本归档文件"Jdbc相关知识点归档.pdf"将深入探讨JDBC的核心概念和应用。 1. JDBC驱动类型： - Type 1：纯Java API，通过ODBC桥连接数据库，性能较低。 - Type 2：部分Java，部分本地代码，如NetJDBC，适用于Oracle...
Jdbc相关知识点归档
11-03
以下将从JDBC概述、数据持久化、Java中的数据存储技术、JDBC介绍、JDBC体系结构、JDBC程序编写步骤以及获取数据库连接等方面详细阐述JDBC的相关知识点。 ### JDBC概述 JDBC作为Java语言中操作数据库的基石，为...
jdbc相关知识点的MindMap
08-04
### JDBC相关知识点详解 #### 一、JDBC简介 JDBC（Java Database Connectivity）是Java中用来对关系型数据库进行统一访问的标准API，它提供了一组接口与规范，允许Java程序连接多种数据库，并执行SQL语句，从而...
JDBC相关知识点
03-05
JDBC（Java Database Connectivity）是Java编程语言中用于与各种关系型数据库进行交互的一种标准接口。它由一组Java API组成，允许开发人员编写能够与多种数据库进行通信的应用程序，而无需考虑具体的数据库实现细节...
JDBC知识点总结
05-05
### JDBC知识点总结 #### 一、JDBC概述 **简介** JDBC (Java Database Connectivity) 是由 SUN 公司提供的一套标准规范，用于在 Java 应用程序中访问关系型数据库。它允许 Java 程序通过统一的 API 与不同的...
【达梦数据库】导入导出过程中get DDL复现过程
weixin_47686079的博客
08-20 333
在处理问题的过程中，客户反馈在达梦数据库中导入导出分区表，get 表的DDL，不会出现表的所有分区信息，ORACLE数据库却会出现所有分区表，事实真的如此吗？
redis常用操作命令
diffiii
08-21 203
显示服务器时间 , 时间戳(秒), 微秒数。模糊查询以fine为前缀的key值。模糊查询以ha为后缀的key值。删除指定key，多个用空格隔开。当前数据库key的数量。登录redis客户端。退出redis客户端。
分布式事务：基本概念
玉汝于成
08-20 300
事务可以看做事一次大的活动，它由不同的小的活动组成，这些活动要么全部成功，要么全部失败。
【MySQL】表的增删查改
muyuteacher的博客
08-21 846
在数据库管理中，CRUD（Create, Read, Update, Delete）是一组基本的操作，用于管理表中的数据。Create：创建新的记录或表。Read：检索表中的数据。Update：修改表中现有记录的数据。Delete：从表中移除记录。本文将对这四种操作进行详细介绍。
Android架构组件：MVVM模式的实战应用
m0_66995023的博客
08-22 371
在 Android 开发中，MVVM（Model-View-ViewModel）模式是一种非常流行的架构模式，它可以帮助开发者更好地组织代码，使得应用程序更加模块化、易于维护。用途：在 ViewModel 中使用，当数据发生变化时通知 View 更新。职责：作为 Model 和 View 之间的桥梁，处理 UI 相关的逻辑。实例：持有数据和 UI 相关的状态，处理用户输入，更新 UI 等。用途：实现 View 和 ViewModel 之间的双向绑定。特点：简化 UI 更新逻辑，减少手动更新 UI 的代码。
笔记redis
风止的博客
08-22 1046
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
ABAP 程序间传递数据
weixin_45879627的博客
08-21 956
ABAP 程序间传递数据
2019 下午 CLI举例：通过ISAKMP方式建立GRE over IPsec隧道
qq_25467441的博客
08-23 217
http://127.0.0.1:51299/icslite/hdx.do?docid=HDXAZN01177_03_zh#topicid=ZH-CN_TASK_0000001555595308
linux上datax 安装以及使用
最新发布
寂夜了无痕的博客
08-24 875
linux上datax 安装以及使用
谷粒商城实战笔记-236~238-商城业务-购物车-环境搭建
epitomizelu的专栏
08-22 890
这一节的内容主要分析购物的业务逻辑和设计存储购物车的选型及数据结构。①把整个购物车封装为一个对象CartVo。
【mysql】大规模企业常用的MySQL性能优化方案分享
景天科技苑
08-21 908
MySQL作为广泛使用的关系型数据库管理系统，其性能优化对于提升应用程序的响应速度、保障系统稳定运行以及提高用户体验至关重要。本文将结合实际案例，详细阐述MySQL性能优化的多种策略和方法，涵盖查询优化、索引优化、表结构优化、服务器配置调整、定期维护、缓存技术、数据分区与分表、负载均衡技术、数据库设计优化以及性能监控与调优等多个方面。
Linux软件编程---数据库
m0_65301172的博客
08-22 751
数据库中最难的操作还是，查询操作，查询按照很多不同条件查询，情况比较多，必须扎实掌握。
06--kubernetes.pod管理与投射数据卷
qq_43387908的博客
08-22 2080
整理一下k8s资源对象的配置和管理命令卷映射的使用方法。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 736
@Transactional中使用线程锁导致了锁失效与解决方案
JDBC基础知识详解：数据库连接与驱动类型
"这是一份关于JDBC基础的浙江大学课程课件，主要介绍了JDBC的基本概念、不同类型及其工作原理。" 在Java世界中，JDBC（Java Database Connectivity）扮演着至关重要的角色，它是一个用于连接Java应用程序和各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值