特色栏目： python 批处理 net编程 Javascript Php Asp Css Html5 Android seo centos

JavaWEB-03-JDBC

来源：互联网收集：自由互联发布时间：2022-06-16

内容 JDBC `JDBC`简介 JDBC `JDBC`快速入门 JDBC API `JDBC API` 详解数据库连接池 JDBC `JDBC`案例 1. JDBC 入门 1.1 概述概念 JDBC：Java DataBase Connectivity ， Java 数据库连接 JDBC 就是使用 Java 语言操作关

内容 1. JDBC入门 1.1 概述

概念

JDBC：Java DataBase Connectivity，Java数据库连接

JDBC就是使用Java语言操作关系型数据库的一套API。

Sun公司和数据库厂商共同制定的一套连接并操作数据库的统一规范（接口），由数据库厂商负责实现（驱动Jar包）；我们使用的时候只需要导入数据库厂商已经实现好的jar包即可。
好处

因为各个数据库厂商都实现了同一套JDBC接口规范。
1. 我们可以使用同一套Java代码操作不同的关系型数据库
2. 访问数据库的Java代码不改变的前提下，替换不同的驱动Jar包可以轻松更换数据库
我们要怎么做

整体思路：基于JDBC定义的规则编码，不用考虑不同数据库之间的差异
1. 导数对应据库驱动包。
2. 基于JDBC定义的规则轻松编程。

1.2 quick start

实现步骤
1. 导入Jar包
2. 注册驱动
3. 获取连接
4. 获取执行者对象
5. 执行SQL语句，并且接收结果
6. 处理结果
7. 释放资源

演示代码

package com.cy.jdbc;

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

/**
 * JDBC快速入门
 */
public class JDBCDemo {

    public static void main(String[] args) throws Exception {
        //1. 注册驱动  建议写上去
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接
        //url  jdbc:mysql:///maven   == jdbc:mysql://127.0.0.1:3306/maven
        //jdbc:mysql://ip:数据库端口号/数据库名称?添加自定义参数
        String url = "jdbc:mysql://127.0.0.1:3306/maven";
        String username = "root";
        String password = "root";
        //Connection 数据库的连接对象
        Connection conn = DriverManager.getConnection(url, username, password);
        //3. 定义sql
        String sql = "update account set money = ? where id = ?";
        //4. 获取执行sql的对象 Statement
        //Statement stmt = conn.createStatement();
        PreparedStatement pps = conn.prepareStatement(sql);

        pps.setDouble(1,3000);
        pps.setInt(2,1);

        //5. 执行sql
        //int count = stmt.executeUpdate(sql);//受影响的行数  执行增删改
        int count = pps.executeUpdate();

        //6. 处理结果  受影响的行数
        System.out.println(count);
        //7. 释放资源
        pps.close();
        conn.close();
    }
}

2. jdbc常用API 2.1 DriverManager

功能1：注册驱动

不需要手动调用DriverManager的API注册，而是保证com.mysql.jdbc.Driver被加载进内存即可。

查看com.mysql.jdbc.Driver类的源码

package com.mysql.jdbc;

import java.sql.DriverManager;
import java.sql.SQLException;

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            // 在静态代码块中完成了注册驱动的代码
            // 我们只要保证Driver被加载进内存，下面的注册驱动的步骤就会自动完成。
            /*
            	Class.forName("com.mysql.jdbc.Driver");
            	Driver.class //Driver的字节码对象
            	new Driver(); // 多一个driver对象
            */
            /*
            	在MySQL5以上的版本，注册驱动不需要我们自己做了。
            	在mysql-connector-java-5.1.47.jar中META-INF下面services下面的
            	java.sql.Driver文件中，填写了com.mysql.jdbc.Driver全类名
            	该类的便会自动被加载进内存
            */
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

功能2：获取连接对象

static Connection getConnection(url, username, password)

//3.获取连接
// 相当于之前使用mysql工具连接数据库
// 完整格式：jdbc:mysql://ip:数据库端口号/数据库名称?添加自定义参数
// jdbc:mysql://就是协议 相当于 http://
// url连本机  jdbc:mysql://localhost:3306/db2 简化写法jdbc:mysql:///db2 
// 可选自定义参数：useSSL=false 不是用SSL加密并取消提示

Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1","root","root");

2.2 Connection

就像打电话，一个Connection对象，就是一通电话。

所以连接又称会话，Session。

功能1：获取执行者对象

该对象会执行SQL语句

获取普通执行者对象：Statement createStatement();
获取预编译执行者对象：PreparedStatement prepareStatement(String sql);

功能2：控制事务

Connection中定义了三个方法，用来控制事务。对应MySQL中的三种操作。

开启：setAutoCommit(boolean autoCommit); 参数为false，则开启事务。
提交：commit();
回滚：rollback();

功能3：释放资源

close();

演示代码

package com.cy.jdbc;

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

/**
 * JDBC API 详解：Connection
 */
public class JDBCDemo3_Connection {

    public static void main(String[] args) throws Exception {
        //1. 注册驱动  建议写上去
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接，配置连接四要素
        //jdbc:mysql://ip:数据库端口号/数据库名称?添加自定义参数
        String url = "jdbc:mysql://127.0.0.1:3306/web22_day03_jdbc";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);
        //3. 定义sql
        String sql1 = "update account set money = money - 500 where id = 1";
        String sql2 = "update account set money = money + 500 where id = 2";
        //4. 获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        try {
            // 开启事务
            conn.setAutoCommit(false);
            //5. 执行sql
            int count1 = stmt.executeUpdate(sql1);//受影响的行数
            //6. 处理结果
            System.out.println(count1);
            int i = 3/0;
            //5. 执行sql
            int count2 = stmt.executeUpdate(sql2);//受影响的行数
            //6. 处理结果
            System.out.println(count2);

            // 提交事务
            conn.commit();
        } catch (Exception throwables) {
            // 回滚事务，手动开启事务之后，该操作可以省略。
            // 没有没有提交，他也不会自动提交，就相当于回滚了。
            // conn.rollback();
            throwables.printStackTrace();
        }

        //7. 释放资源
        stmt.close();
        conn.close();
    }
}

2.3 Statement

执行者对象，执行SQL语句并返回SQL语句执行的结果/结果集。

执行DML/DDL语句：修改（增删改）

int executeUpdate(String sql);

返回值int：返回影响的行数。

参数sql：insert、update、delete语句。

一般不会在Java代码中执行DDL语句，Java中主要完成对数据库中表记录的操作。
执行DQL语句：查询

ResultSet executeQuery(String sql);

返回值ResultSet：封装查询的结果集。

参数sql：select语句。
释放资源

立即将执行者对象释放：void close();

演示代码：演示增删改

/**
 * statement执行dql，并获取结果集
 * JDBC API 详解：Statement
 */
public class JDBCDemo4_Statement {

    /**
     * 执行DML语句
     * @throws Exception
     */
    @Test
    public void testDML() throws  Exception {
       //1. 注册驱动
       //Class.forName("com.mysql.jdbc.Driver");
       //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
       String url = "jdbc:mysql:///maven?useSSL=false";
       String username = "root";
       String password = "root";
       Connection conn = DriverManager.getConnection(url, username, password);
       //3. 定义sql
       String sql = "update account set money = 4000 where id = 1";
       //4. 获取执行sql的对象 Statement
       Statement stmt = conn.createStatement();
       //5. 执行sql
       int count = stmt.executeUpdate(sql);//执行完DML语句，受影响的行数

       //6. 处理结果
        if(count > 0){
            System.out.println("修改成功~");
        }else{
            System.out.println("修改失败~");
        }
       //7. 释放资源
       stmt.close();
       conn.close();

   }


    /**
     * 执行DDL语句
     * @throws Exception
     */
    @Test
    public void testDDL() throws  Exception {
        //1. 注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        String url = "jdbc:mysql:///db1?useSSL=false";
        String username = "root";
        String password = "1234";
        Connection conn = DriverManager.getConnection(url, username, password);
        //3. 定义sql
        String sql = "drop database db2";
        //4. 获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //5. 执行sql
        int count = stmt.executeUpdate(sql);//执行完DDL语句，可能是0
        //6. 处理结果
        //System.out.println(count);
       /* if(count > 0){
            System.out.println("修改成功~");
        }else{

            System.out.println("修改失败~");
        }*/
        System.out.println(count);

        //7. 释放资源
        stmt.close();
        conn.close();

    }
}

演示代码：查询及结果集处理

public class JDBCDemo5_ResultSet {

    /**
     * 执行DQL
     *
     * @throws Exception
     */
    @Test
    public void testResultSet() throws Exception {
        //1. 注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        String url = "jdbc:mysql:///maven?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3. 定义sql
        String sql = "select * from account";

        //4. 获取statement对象
        Statement stmt = conn.createStatement();

        //5. 执行sql  executeQuery
        ResultSet rs = stmt.executeQuery(sql);


        // 6.1 光标向下移动一行，并且判断当前行是否有数据
        while (rs.next()) { //移动到下一行
            //6.2 获取数据  getXxx()
            
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money");

            System.out.println("id = " + id);
            System.out.println("name = " + name);
            System.out.println("money = " + money);
        }

        //7. 释放资源
        rs.close();
        stmt.close();
        conn.close();
    }
}

2.4 查询并封装POJO对象案例 2.4.1 需求

查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中

2.4.2 核心步骤

使用上述操作完成查询，查询出结果集。
定义实体类Account
查询数据，封装到Account对象中
将Account对象存入ArrayList集合中

2.4.3 演示代码

package com.cy.pojo;

public class Account {

    private int id;
    private String name;
    private double money;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

/**
 * 实现需求：查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中
 */
public class JDBCDemo5_ResultSet {
  
    /**
     * 查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中
     * 1. 定义实体类Account
     * 2. 查询数据，封装到Account对象中
     * 3. 将Account对象存入ArrayList集合中
     *
     *
     * @throws Exception
     */
    @Test
    public void testResultSet2() throws  Exception {
        //1. 注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        String url = "jdbc:mysql:///maven?useSSL=false";
        String username = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, username, password);

        //3. 定义sql
        String sql = "select * from account";

        //4. 获取statement对象   不能用（Statement）
        //Statement stmt = conn.createStatement();
        PreparedStatement pps = conn.prepareStatement(sql);
        //5. 执行sql
        //ResultSet rs = stmt.executeQuery(sql);
        ResultSet rs = pps.executeQuery();
        // 创建集合
        List<Account> list = new ArrayList<>();

        // 6.1 光标向下移动一行，并且判断当前行是否有数据
        while (rs.next()){
            Account account = new Account();
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double money = rs.getDouble("money1");
            account.setId(id);
            account.setName(name);
            account.setMoney(money);
            // 存入集合
            list.add(account);
        }
        System.out.println(list);

        //7. 释放资源
        rs.close();
        pps.close();
        conn.close();
    }
}

2.5 PreparedStatement 2.5.1概述

预编译的执行者对象，执行SQL语句并返回SQL语句执行的结果集。

相对于Statement来说，PreparedStatement有额外两个作用：

通过转义字符避免SQL注入问题。
开启预编译后，通过预编译可以提高SQL语句的执行效率。

2.5.2 使用及API

获取该对象

// 这里的SQL语句，不需要指定参数，而是通过？作为占位符，后面再通过setString方法把参数设置进来
PreparedStatement  connection.prepareStatement(sql)

设置参数

// index 从1 开始
pst.setString(int index, String paramter)

执行DML语句：修改（增删改）

int executeUpdate();

返回值int：返回影响的行数。

执行DQL语句：查询

ResultSet executeQuery();

返回值ResultSet：封装查询的结果集。
释放资源

立即将执行者对象释放：void close();

演示代码

/**
  *
  * @throws Exception
  */
@Test
public void testPreparedStatement() throws  Exception {
    //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
    String url = "jdbc:mysql:///db1?useSSL=false";
    String username = "root";
    String password = "1234";
    Connection conn = DriverManager.getConnection(url, username, password);

    // 接收用户输入 用户名和密码
    String name = "zhangsan";
    String pwd = "' or '1' = '1";

    // 定义sql   预编译sql   ? 占位符
    String sql = "select * from tb_user where username = ? and password = ?";

    // 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    // 设置？的值
    pstmt.setString(1,name);
    pstmt.setString(2,pwd);

    // 执行sql
    ResultSet rs = pstmt.executeQuery();

    // 判断登录是否成功
    if(rs.next()){
        System.out.println("登录成功~");
    }else{
        System.out.println("登录失败~");
    }

    //7. 释放资源
    rs.close();
    pstmt.close();
    conn.close();
}

2.5.3 原理

可以通过日志看到其运行原理及效果。

准备工作1：开启预编译

想要看小预编译执行者对象的执行效果，需要先在url中开启预编译，添加如下自定义参数即可
```
useServerPrepStmts=true
```
添加该参数后，完整的URL链接如下：
```
jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
```

准备工作2：打开日志，查看预编译等相关效果

在my.ini文件末尾，添加如下内容，并重启MySQL服务。

log-output=FILE
general-log=1
general_log_file="D:\mysql.log"
slow-query-log=1
slow_query_log_file="D:\mysql_slow.log"
long_query_time=2

重启MySQL，

方式1：可以打开服务窗口，手动重启MySQL服务。

方式2：在以管理员身份打开的命令行中，键入以下命令
```
net stop mysql  # 关闭mysql服务
net start mysql  # 开启mysql服务
```
结论

通过修改查询相关代码，并查看日志，可以得出如下结论：
1. 在URL中开启预编译后，相同模板的SQL语句在创建预编译执行者对象的时候，就已经发送到SQL，并完成了语法检查和编译。
2. 预编译执行者对象，在往SQL模板中设置参数的时候，会对参数中的特殊符号添加转义字符\，避免SQL注入
3. 使用相同模板的多条不同参数的SQL语句，只会在第一次创建预编译执行者对象的时候编译一次，从而提高执行效率。

演示代码

/**
 * PreparedStatement原理
 * @throws Exception
 */
@Test
public void testPreparedStatement2() throws  Exception {



    //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
    // useServerPrepStmts=true 参数开启预编译功能
    String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
    String username = "root";
    String password = "root";
    Connection conn = DriverManager.getConnection(url, username, password);

    // 接收用户输入 用户名和密码
    String name = "zhangsan";
    String pwd = "' or '1' = '1";

    // 定义sql
    String sql = "select * from tb_user where username = ? and password = ?";

    // 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);


    Thread.sleep(10000);
    // 设置？的值
    pstmt.setString(1,name);
    pstmt.setString(2,pwd);
    ResultSet rs = null;
            // 执行sql
    rs = pstmt.executeQuery();


    // 设置？的值
    pstmt.setString(1,"aaa");
    pstmt.setString(2,"bbb");

    // 执行sql
    rs = pstmt.executeQuery();


    // 判断登录是否成功
    if(rs.next()){
        System.out.println("登录成功~");
    }else{
        System.out.println("登录失败~");
    }

    //7. 释放资源
    rs.close();
    pstmt.close();
    conn.close();
}

3. SQL注入及解决方案 3.1. 产生的原因

使用任意用户名并配合下面的密码，登录

' or '1' = '1

普通执行者对象拼接后的SQL 语句，变成了：

select * from tb_user where username = 'xxxx' and password = '' or '1' = '1'

普通的statement只是把用户输入的用户名和密码进行了简单的拼接，拼接到了SQL语句中。

这样，用户名或密码中特殊的单子或符号就被识别成了SQL语句中的关键字或者是特殊符号。

思路：仅把' or 1=1 -- 当做普通的字符串来处理，使用转义符号\，然后面的符号表示其本来的意思（现原形）。

PreparedStatement就是使用这个思路解决的。

PreparedStatement中的方法public void setString(int parameterIndex, String x) throws SQLException

// 提前准备好长度变量，不用每次调用length()方法，效率高
int stringLength = x.length();

for(int i = 0; i < stringLength; ++i) {
    // 获取参数的每一个字符
    char c = x.charAt(i);
    
    // 判断是否是特殊符号，如果是就在前面拼一个 \  转义，让这个特殊符号表示自己原来的意思。
    switch(c) {
        case '\u0000':
            buf.append('\\');
            buf.append('0');
            break;
        case '\n':
            buf.append('\\');
            buf.append('n');
            break;
        case '\r':
            buf.append('\\');
            buf.append('r');
            break;
        case '\u001a':
            buf.append('\\');
            buf.append('Z');
            break;
        case '"':
            if (this.usingAnsiMode) {
                buf.append('\\');
            }

            buf.append('"');
            break;
        case '\'':
            buf.append('\\');
            buf.append('\'');
            break;
        case '\\':
            buf.append('\\');
            buf.append('\\');
            break;
        case '¥':
        case '₩':
            if (this.charsetEncoder != null) {
                CharBuffer cbuf = CharBuffer.allocate(1);
                ByteBuffer bbuf = ByteBuffer.allocate(1);
                cbuf.put(c);
                cbuf.position(0);
                this.charsetEncoder.encode(cbuf, bbuf, true);
                if (bbuf.get(0) == 92) {
                    buf.append('\\');
                }
            }

            buf.append(c);
            break;
        default:
            buf.append(c);
    }
}

4. 连接池 4.1 概念

初始化并维护多个连接对象，当其他地方需要数据库连接时，从连接池获取；用完之后，归还到连接池。

以此实现连接的复用，提高效率。

数据源：DataSource，内部维护了一个连接池，还提供了操作连接池的一些功能。

一般情况下，会把数据源和连接池混为一谈，把数据源喊做连接池。

常见的数据源有：C3P0、Druid。我们学习Druid。

4.2 池化思想（重要）

以空间换时间的做法。

游戏背包、新闻客户端。

提供更好的使用体验
对资源的消耗会更少。不会频繁的创建和销毁对象。

4.3 Druid使用 4.3.1 导包

// 导包并添加到添加了模块类库
druid-1.1.12.jar

4.3.2 配置文件

properties配置文件(名字任意)，但是配置文件中key的值固定。常见参数如下：

# 连接四要素
# 数据库驱动全类名
driverClassName=com.mysql.jdbc.Driver
# URL
url=jdbc:mysql:///maven?useSSL=false&useServerPrepStmts=true
#用户名
username=root
#密码
password=root

# 其他参数
# 初始化连接数
initialSize=5
# 最大连接数
maxActive=10
# 超时时间
maxWait=3000

完整参数介绍：

属性说明建议值 url 数据库的jdbc连接地址。一般为连接oracle/mysql。示例如下： mysql : jdbc:mysql://ip:port/dbname?option1&option2&… oracle : jdbc:oracle:thin:@ip:port:oracle_sid username 登录数据库的用户名 password 登录数据库的用户密码 initialSize 启动程序时，在连接池中初始化多少个连接 10-50已足够 maxActive 连接池中最多支持多少个活动会话 maxWait 程序向连接池中请求连接时,超过maxWait的值后，认为本次请求失败，即连接池 100 没有可用连接，单位毫秒，设置-1时表示无限等待 minEvictableIdleTimeMillis 池中某个连接的空闲时长达到 N 毫秒后, 连接池在下次检查空闲连接时，将见说明部分回收该连接,要小于防火墙超时设置 net.netfilter.nf_conntrack_tcp_timeout_established的设置 timeBetweenEvictionRunsMillis 检查空闲连接的频率，单位毫秒, 非正整数时表示不进行检查 keepAlive 程序没有close连接且空闲时长超过 minEvictableIdleTimeMillis,则会执 true 行validationQuery指定的SQL,以保证该程序连接不会池kill掉,其范围不超过minIdle指定的连接个数。 minIdle 回收空闲连接时，将保证至少有minIdle个连接. 与initialSize相同 removeAbandoned 要求程序从池中get到连接后, N 秒后必须close,否则druid 会强制回收该 false,当发现程序有未连接,不管该连接中是活动还是空闲, 以防止进程不会进行close而霸占连接。正常close连接时设置为true removeAbandonedTimeout 设置druid 强制回收连接的时限，当程序从池中get到连接开始算起，超过此应大于业务运行最长时间值后，druid将强制回收该连接，单位秒。 logAbandoned 当druid强制回收连接后，是否将stack trace 记录到日志中 true testWhileIdle 当程序请求连接，池在分配连接时，是否先检查该连接是否有效。(高效) true validationQuery 检查池中的连接是否仍可用的 SQL 语句,drui会连接到数据库执行该SQL, 如果正常返回，则表示连接可用，否则表示连接不可用 testOnBorrow 程序申请连接时,进行连接有效性检查（低效，影响性能） false testOnReturn 程序返还连接时,进行连接有效性检查（低效，影响性能） false poolPreparedStatements 缓存通过以下两个方法发起的SQL: true public PreparedStatement prepareStatement(String sql) public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) maxPoolPrepareStatement
PerConnectionSize 每个连接最多缓存多少个SQL 20 filters 这里配置的是插件,常用的插件有: stat,wall,slf4j 监控统计: filter:stat 日志监控: filter:log4j 或者 slf4j 防御SQL注入: filter:wall connectProperties 连接属性。比如设置一些连接池统计方面的配置。 druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 比如设置一些数据库连接属性: 4.3.3 代码

public class DruidDemo {

    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件

        //3. 加载配置文件  map集合  key-value
        Properties prop = new Properties();
        prop.load(new FileInputStream("web_day03_jdbc-demo/src/druid.properties"));
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //5. 获取数据库连接 Connection
        Connection connection = dataSource.getConnection();

        System.out.println(connection);

        // 这里可以调用connection的close方法
        // Druid充了connection的close方法，实现逻辑变成了回收连接，而非关闭连接
        connection.close();


        // 获取当前代码的运行路径，可以运行下面一行代码
        //System.out.println(System.getProperty("user.dir"));
    }
}

上一篇：李呈祥：bilibili在湖仓一体查询加速上的实践与探索
下一篇：没有了

JavaWEB-03-JDBC

相关文章