第02篇_Java进阶

第01章_数据库编程(JDBC)

第一节 JDBC的基本使用

1. JDBC简介

JDBC(Java DataBase Connectivity)是官方定义的一套操作关系数据库的接口，各数据库厂商实现了这套接口，提供相应的驱动包。

​x
1
<!-- Mysql 8.x 驱动-->
2
<dependency>
3
    <groupId>mysql</groupId>
4
    <artifactId>mysql-connector-java</artifactId>
5
    <version>8.0.32</version>
6
</dependency>
7

8
<!-- Mysql 5.x 驱动-->
9
<dependency>
10
    <groupId>mysql</groupId>
11
    <artifactId>mysql-connector-java</artifactId>
12
    <version>5.1.49</version>
13
</dependency>
14

注意：

1. Oracle和SqlServer等数据库由于版权原因，无法从Maven中央仓库下载驱动包，需手动安装。

   • 常见的Oracle驱动包版本有：ojdbc14-10.2.0.5.0.jar、ojdbc6-11.2.0.4.jar、ojdbc8-12.2.0.1.jar、ojdbc8-21.1.0.0.jar。

   • 常见的SqlServer驱动包版本有：sqljdbc4-4.0.jar、mssql-jdbc-9.2.1.jre8.jar。

2. 基本增删改查

1) 直接执行SQL

74
1
public class JdbcTest {
2

3
    private static final String MYSQL_URL = "jdbc:mysql://106.53.120.230:3306/test01";
4
    private static final String MYSQL_USER = "root";
5
    private static final String MYSQL_PASSWORD = "Hyx147741";
6

7
    private static final String ORACLE_URL = "jdbc:oracle:thin:@127.0.0.1:1521:ORCL01";
8
    private static final String ORACLE_USER = "kbssfms";
9
    private static final String ORACLE_PASSWORD = "kbssfms";
10

11
    private static final String MSSQL_URL = "jdbc:sqlserver://localhost:1433; DatabaseName=test";
12

13
    private Connection mysql_connection;
14
    private Connection oracle_connection;
15
    private Statement statement;
16
    private PreparedStatement preparedStatement;
17
    private CallableStatement callableStatement;
18
    private ResultSet resultSet;
19

20
    @Before
21
    public void init() throws SQLException {
22
        // 1. 注册驱动
23
        try {
24
            Class.forName("com.mysql.jdbc.Driver");
25
            Class.forName("oracle.jdbc.driver.OracleDriver");
26
            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
27
        } catch (ClassNotFoundException e) {
28
            e.printStackTrace();
29
        }
30

31
        // 2. 获取连接
32
        mysql_connection = DriverManager.getConnection(MYSQL_URL, MYSQL_USER, MYSQL_PASSWORD);
33
        oracle_connection = DriverManager.getConnection(ORACLE_URL, ORACLE_USER, ORACLE_PASSWORD);
34
    }
35

36
    @Test
37
    public void testStatement() throws SQLException {
38
        // 3.1 创建Statement
39
        statement = mysql_connection.createStatement();
40

41
        // 3.2 执行查询语句
42
        resultSet = statement.executeQuery("select * from user");
43

44
        // 3.3 处理结果
45
        int columnCount = resultSet.getMetaData().getColumnCount();
46
        while (resultSet.next()) {
47
            for (int i = 1; i <= columnCount; i++) {
48
                System.out.print(resultSet.getMetaData().getColumnLabel(i) + "=" + resultSet.getObject(i) + "\t");
49
            }
50
            System.out.println();
51
        }
52
    }
53

54
    @After
55
    public void destroy() {
56
        // 4. 释放资源
57
        doClose(resultSet);
58
        doClose(statement);
59
        doClose(preparedStatement);
60
        doClose(callableStatement);
61
        doClose(mysql_connection);
62
    }
63
    
64
    private void doClose(AutoCloseable autoCloseable) {
65
        if (autoCloseable != null) {
66
            try {
67
                autoCloseable.close();
68
            } catch (Exception exception) {
69
                exception.printStackTrace();
70
            }
71
        }
72
    }
73
}
74

SQL脚本如下：

13
1
-- MYSQL：user
2
CREATE TABLE `user` (
3
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户编号',
4
  `username` varchar(32) NOT NULL COMMENT '用户名称',
5
  `birthday` datetime NOT NULL COMMENT '用户生日',
6
  `sex` char(2) NOT NULL COMMENT '性别，0男1女',
7
  `address` varchar(255) DEFAULT NULL COMMENT '用户地址',
8
  PRIMARY KEY (`id`)
9
) ENGINE=InnoDB AUTO_INCREMENT=44 DEFAULT CHARSET=utf8 COMMENT='用户表'
10
INSERT INTO user (id, username, birthday, sex, address) VALUES (1, 'hyx01', '1999-09-13 00:00:00', '0', 'shenzheng');
11
INSERT INTO user (id, username, birthday, sex, address) VALUES (2, 'hyx2', '1998-09-13 00:00:00', '1', 'shenzheng');
12
commit;
13

2) 预编译执行SQL

15
1
@Test
2
public void testPrepareStatement() throws SQLException {
3
    // 3.1 创建prepareStatement
4
    preparedStatement = mysql_connection.prepareStatement("update user set username = ? where id = ?");
5

6
    // 3.2 设置参数并执行
7
    preparedStatement.setString(1, "hyx01");
8
    preparedStatement.setInt(2, 1);
9
    int update = preparedStatement.executeUpdate();
10

11
    // 3.3 处理结果
12
    if (update > 0) {
13
        System.out.println("更新成功...");
14
    }
15
}

3) 调用存储过程

13
1
@Test
2
public void javaCallProcedure() throws Exception {
3
    // 3.1 创建CallableStatement
4
    CallableStatement callableStatement = oracle_connection.prepareCall("{call p_yearsal(?, ?)}");
5

6
    // 3.2 设置参数并执行
7
    callableStatement.setObject(1, 7788);
8
    callableStatement.registerOutParameter(2, OracleTypes.NUMBER);
9
    callableStatement.execute();
10

11
    // 3.3 输出结果(第二个参数)
12
    System.out.println(callableStatement.getObject(2)); // 36000
13
}

SQL脚本如下：

33
1
-- Oracle：EMP
2
create table EMP
3
(
4
    empno    NUMBER(4),
5
    ename    VARCHAR2(10),
6
    job      VARCHAR2(9),
7
    mgr      NUMBER(4),
8
    hiredate DATE,
9
    sal      NUMBER(7, 2),
10
    comm     NUMBER(7, 2),
11
    deptno   NUMBER(2)
12
);
13
insert into EMP (empno, ename, job, mgr, hiredate, sal, comm, deptno)
14
values (7876, 'ADAMS', 'CLERK', 7788, to_date('23-05-1987', 'dd-mm-yyyy'), 1100, null, 20);
15
commit;
16

17
-- 创建存储过程
18
create or replace procedure p_yearsal(eno emp.empno%type, yearsal out number)
19
    is
20
    s number(10);
21
    c emp.comm%type;
22
begin
23
    select sal * 12, nvl(comm, 0) into s, c from emp where empno = eno;
24
    yearsal := s + c;
25
end;
26

27
-- 调用存储过程
28
declare
29
    yearsal number(10);
30
begin
31
    p_yearsal(7788, yearsal);
32
    dbms_output.put_line(yearsal);
33
end;

4) 调用存储函数

13
1
@Test
2
public void javaCallFunction() throws Exception {
3
    // 3.1 创建CallableStatement
4
    CallableStatement pstm = oracle_connection.prepareCall("{?= call f_yearsal(?)}");
5

6
    // 3.2 设置参数并执行
7
    pstm.setObject(2, 7788);
8
    pstm.registerOutParameter(1, OracleTypes.NUMBER);
9
    pstm.execute();
10

11
    // 3.3 输出结果(第一个参数)
12
    System.out.println(pstm.getObject(1)); // 36000
13
}

SQL脚本如下：

16
1
-- 创建存储函数
2
create or replace function f_yearsal(eno emp.empno%type) return number
3
    is
4
    s number(10);
5
begin
6
    select sal * 12 + nvl(comm, 0) into s from emp where empno = eno;
7
    return s;
8
end;
9

10
-- 调用存储函数
11
declare
12
    s number(10);
13
begin
14
    s := f_yearsal(7788);
15
    dbms_output.put_line(s);
16
end;

5) JDBC批处理

60
1
@Test
2
public void jdbcBatch() throws SQLException {
3
    ArrayList<List<Integer>> batchResults = new ArrayList<>();
4
    int[] results = null;
5
    boolean isAutoCommit = mysql_connection.getAutoCommit();
6

7
    int TOTAL_NUM = 100;
8
    int PER_NUM = 30;
9

10
    try {
11
        // 3.1 设置为非自动提交
12
        mysql_connection.setAutoCommit(false);
13

14
        // 3.2 创建PrepareStatement
15
        preparedStatement = mysql_connection.prepareStatement("INSERT INTO user (id, username, birthday, sex, address) VALUES (null, ?, ?, ?, ?)");
16

17
        // 3.3 设置参数并执行
18
        for (int i = 1; i <= TOTAL_NUM; i++) {
19

20
            // 3.3.1 设置参数并添加到缓冲区
21
            preparedStatement.setString(1, "hyx_" + i);
22
            preparedStatement.setDate(2, new Date(System.currentTimeMillis()));
23
            preparedStatement.setString(3, "男");
24
            preparedStatement.setString(4, "深圳市");
25
            preparedStatement.addBatch();
26

27
            // 3.3.2 每N个作为一批次执行
28
            if (i % PER_NUM == 0) {
29
                results = preparedStatement.executeBatch();
30
                mysql_connection.commit();
31
                batchResults.add(Arrays.stream(results).boxed().collect(Collectors.toList()));
32
                preparedStatement.clearBatch();
33
            }
34
        }
35

36
        // 3.3.3 最后一个批次执行
37
        if (TOTAL_NUM % PER_NUM != 0) {
38
            results = preparedStatement.executeBatch();
39
            mysql_connection.commit();
40
            batchResults.add(Arrays.stream(results).boxed().collect(Collectors.toList()));
41
            preparedStatement.clearBatch();
42
        }
43

44
    } finally {
45
        // 3.4 回退自动提交标记
46
        mysql_connection.setAutoCommit(isAutoCommit);
47
    }
48

49
    // 3.5 处理结果
50
    for (int i = 0; i < batchResults.size(); i++) {
51
        System.out.println("第" + (i + 1) + "批次结果: " + batchResults.get(i));
52
    }
53
}
54

55
/*
56
第1批次结果: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
57
第2批次结果: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
58
第3批次结果: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
59
第4批次结果: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
60
*/

3. JDBCUtils

60
1
public class JDBCUtils {
2
    private static String driver;
3
    private static String url;
4
    private static String user;
5
    private static String password;
6

7
    static {
8
        try {
9
            // 1. 加载JDBC配置
10
            Properties properties = new Properties();
11
            properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
12

13
            // 2. 设置属性值
14
            url = properties.getProperty("url");
15
            user = properties.getProperty("user");
16
            password = properties.getProperty("password");
17
            driver = properties.getProperty("driver");
18

19
            // 3. 注册驱动
20
            Class.forName(driver);
21

22
        } catch (Exception e) {
23
            e.printStackTrace();
24
        }
25
    }
26

27
    /**
28
     * 获取连接
29
     *
30
     * @return
31
     * @throws SQLException
32
     */
33
    public static Connection getConnection() throws SQLException {
34
        return DriverManager.getConnection(url, user, password);
35
    }
36

37
    /**
38
     * 释放资源
39
     *
40
     * @param resultSet
41
     * @param statement
42
     * @param connection
43
     */
44
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
45
        doClose(resultSet);
46
        doClose(statement);
47
        doClose(connection);
48
    }
49

50
    private static void doClose(AutoCloseable autoCloseable) {
51
        if (autoCloseable != null) {
52
            try {
53
                autoCloseable.close();
54
            } catch (Exception exception) {
55
                exception.printStackTrace();
56
            }
57
        }
58
    }
59
}
60

第二节 相关接口详解

1. DriverManager

DriverManager为JDBC客户端管理一组可用的驱动(Driver)实现，主要功能有两个：

10
1
// 1. 注册驱动
2
public static synchronized void registerDriver(java.sql.Driver driver) throws SQLException
3
public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException
4
public static Driver getDriver(String url) throws SQLException
5
public static java.util.Enumeration<Driver> getDrivers()
6

7
// 2. 获取连接
8
public static Connection getConnection(String url) throws SQLException // 无需用户名时使用
9
public static Connection getConnection(String url, java.util.Properties info) // 需提供其它连接参数时使用
10
public static Connection getConnection(String url, String user, String password) throws SQLException

2. DataSource

DataSource是另一种获取连接的方式，主要如下三类：

• 普通数据源(DataSource )：

  4
  1
  Connection getConnection() throws SQLException
  2
  Connection getConnection(String username, String password)
  3
  boolean isWrapperFor(java.lang.Class<?> iface) throws java.sql.SQLException; // 是否为某类的包装类
  4
  <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException; // 拆包
  

• 连接池数据源(ConnectionPoolDataSource)：

  2
  1
  PooledConnection getPooledConnection() throws SQLException;
  2
  PooledConnection getPooledConnection(String user, String password) throws SQLException;
  

• 分布式数据源(XADataSource)：

2
1
XAConnection getXAConnection() throws SQLException;
2
XAConnection getXAConnection(String user, String password) throws SQLException;

注意：

1. DataSource相关接口并未定义close()方法，但具体连接池一般会扩展类似接口。

3. Connection

Connection表示通过JDBC驱动与数据源建立的连接，数据源可以是关系型数据库、文件系统或者其他通过JDBC驱动访问的数据。

40
1
// 1. 创建Statement
2
Statement createStatement() throws SQLException
3
Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException;
4
Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException;
5

6
PreparedStatement prepareStatement(String sql) throws SQLException;
7
PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException; // autoGeneratedKeys-是否回写自动生成的列值，Statement.RETURN_GENERATED_KEYS表示回写
8
PreparedStatement prepareStatement(String sql, int columnIndexes[]) throws SQLException; // 回写哪些自动生成的列值
9
PreparedStatement prepareStatement(String sql, String columnNames[]) throws SQLException; // 回写哪些自动生成的列值
10
PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException;
11
PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException;
12

13
CallableStatement prepareCall(String sql) throws SQLException;
14
CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException;
15
CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException;
16

17

18
// 2. 管理事务
19
void commit() throws SQLException;
20
void rollback() throws SQLException;
21
void rollback(Savepoint savepoint) throws SQLException; // 回滚到指定保存点
22

23
boolean getAutoCommit() throws SQLException;
24
void setAutoCommit(boolean autoCommit) throws SQLException; // 设置是否自动提交，默认为true
25

26
Savepoint setSavepoint() throws SQLException;
27
Savepoint setSavepoint(String name) throws SQLException;
28
void releaseSavepoint(Savepoint savepoint) throws SQLException;
29

30

31
// 3. 管理连接状态
32
void setReadOnly(boolean readOnly) throws SQLException; // 设置连接只读
33
boolean isReadOnly() throws SQLException; // 判断连接是否只读
34
boolean isClosed() throws SQLException; // 判断连接是否被关闭
35
boolean isValid(int timeout) throws SQLException; // 判断连接是否有效
36

37

38
// 4. 获取其它信息
39
DatabaseMetaData getMetaData() throws SQLException; // 获取数据库元信息
40

4. Statement

Statement接口中定义了直接执行SQL语句的方法，其子类PreparedStatement扩展了设置SQL参数的方法，其孙类CallableStatement 又扩展了调用存储过程/函数的相关方法。

53
1
// 1. 执行DQL语句
2
ResultSet executeQuery(String sql) throws SQLException; // 如果是预编译形式，则无sql参数，下同
3

4
// 2. 执行DML/DDL语句
5
// 默认返回匹配的行数，在mysql中，可通过useAffectedRows=true连接参数修改为受影响的行数
6
int executeUpdate(String sql) throws SQLException; 
7
int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException;
8
int executeUpdate(String sql, int columnIndexes[]) throws SQLException;
9
int executeUpdate(String sql, String columnNames[]) throws SQLException;
10

11
// 3. 执行未知SQL语句
12
// 返回值为true表示为ResultSet结果集，可以通过getResultSet()获取，否则可以尝试通过getUpdateCount()获取更新计数
13
boolean execute(String sql) throws SQLException; 
14
boolean execute(String sql, int autoGeneratedKeys) throws SQLException; 
15
boolean execute(String sql, int columnIndexes[]) throws SQLException;
16
boolean execute(String sql, String columnNames[]) throws SQLException; 
17

18
// 4. 批量执行SQL
19
void addBatch( String sql ) throws SQLException; // 添加SQL到缓冲区
20
void clearBatch() throws SQLException; // 清空缓冲区
21
int[] executeBatch() throws SQLException; // 批量执行
22

23
// 5. 结果处理
24
ResultSet getResultSet() throws SQLException; // 获取查询语句的结果集
25
int getUpdateCount() throws SQLException; // 获取更新语句的更新计数(注意：DDL语句该值始终为0)
26
ResultSet getGeneratedKeys() throws SQLException; // 获取数据库自动生成的值
27
SQLWarning getWarnings() throws SQLException; // 获取SQL警告
28
boolean getMoreResults() throws SQLException; // 多结果集支持
29

30
// 6. 相关参数设置
31
void setFetchSize(int rows) throws SQLException; // 每次提取的行数，可用于进行流式查询
32
int getFetchSize() throws SQLException;
33
void setQueryTimeout(int seconds) throws SQLException; // Statement级别的查询超时时间
34
int getQueryTimeout() throws SQLException;
35

36
// 7. 关闭Statement
37
boolean isClosed() throws SQLException;
38
void close() throws SQLException;
39

40
// 8. PreparedStatement设置参数
41
void setInt(int parameterIndex, int x) throws SQLException;
42
void setString(int parameterIndex, String x) throws SQLException;
43
void setObject(int parameterIndex, Object x) throws SQLException;
44
void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException;
45
void setDate(int parameterIndex, java.sql.Date x) throws SQLException;
46
void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws SQLException;
47
void setNull(int parameterIndex, int sqlType) throws SQLException; // 将占位符参数设置为 JDBC 的NULL
48
void setNull (int parameterIndex, int sqlType, String typeName) throws SQLException;
49

50
// 9. CallableStatement注册输出参数
51
void registerOutParameter(int parameterIndex, int sqlType) throws SQLException;
52
default void registerOutParameter(int parameterIndex, SQLType sqlType) throws SQLException
53

5. ResultSet

ResultSet提供了检索和操作SQL执行结果相关的方法，有3种不同的类型：

• TYPE FORWARD_ONLY：默认类型，仅支持向前滚动。

• TYPE_SCROLL_INSENSITIVE：可任意滚动，即可相对于当前位置向前或向后移动，也可以移动到绝对位置。

• TYPE SCROLL SENSITIVE：可任意滚动，并且当ResultSet 没有关闭时，对ResultSet对象的修改会直接影响数据库中的记录。

18
1
// 1. 游标滚动
2
boolean next() throws SQLException; // 游标向前移动一行，如果游标定位到下一行，则返回true;如果游标位于最后一行之后，则返回false
3
boolean absolute( int row ) throws SQLException; // 游标定位到ResultSet对象中的第row行，允许负数表示倒数。
4

5
// 2. 根据索引获取当前行列值，索引从1开始
6
int getInt(int columnIndex) throws SQLException;
7
String getString(int columnIndex) throws SQLException;
8
java.sql.Date getDate(int columnIndex) throws SQLException;
9
java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException;
10
Object getObject(int columnIndex) throws SQLException;
11

12
// 3. 根据查询列名获取当前列值
13
int getInt(String columnLabel) throws SQLException;
14
String getString(String columnLabel) throws SQLException;
15
java.sql.Date getDate(String columnLabel) throws SQLException;
16
java.sql.Timestamp getTimestamp(String columnLabel) throws SQLException; 
17
Object getObject(String columnLabel) throws SQLException;
18

6. DatabaseMetaData

DatabaseMetaData接口用于获取数据源的相关元信息。

31
1
// 1. 获取数据源基本信息
2
String getURL() throws SQLException; // 获取连接URL
3
String getUserName() throws SQLException; // 获取数据库已知的用户
4
String getDatabaseProductName() throws SQLException;// 获取数据库厂商名
5
String getDatabaseProductVersion() throws SQLException; // 获取数据库产品的版本
6
int getDriverMajorVersion(); // 获取驱动主版本
7
int getDriverMinorVersion(); // 获取驱动副版本
8
String getSQLKeywords() throws SQLException; // 获取数据库SQL关键字
9

10
// 2. 获取数据源支持项和限制项
11
int getMaxConnections() throws SQLException; // 获取此数据库支持的最大连接数
12
int getMaxStatementLength() throws SQLException; // 获取此数据库在SQL语句中允许的最大字符数
13
int getMaxTablesInSelect() throws SQLException; // 获取此数据库在SELECT语句中允许的最大表数
14

15
// 3. 获取事务支持
16
boolean supportsTransactions() throws SQLException; // 是否支持事务
17
boolean supportsMultipleTransactions() throws SQLException; // 是否支持同时开启多个事务
18
boolean supportsTransactionIsolationLevel(int level) throws SQLException; // 是否支持某一事务隔离级别
19
int getDefaultTransactionIsolation() throws SQLException; // 获取默认的事务隔离级别
20

21

22
// 4. 获取SQL对象及属性
23
ResultSet getSchemas() throws SQLException; // 获取Schema信息
24
ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException; // 获取表信息
25
ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException; // 获取主键信息
26
ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException; // 获取存储过程信息
27
ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException; // 获取给定类别的存储过程参数和结果列的信息
28
ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException; // 获取函数信息。
29
ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException; // 获取给定类别的函数参数和结果列的信息。
30
ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException; // 获取用户自定义数据类型
31

7. ResultSetMetaData

ResultSetMetaData用于获取结果集的相关元信息。

6
1
int getColumnCount() throws SQLException; // 结果集列数
2
String getColumnLabel(int column) throws SQLException; // 查询列名(as后的部分)
3
String getColumnName(int column) throws SQLException; // 列名所对应的表列名
4
String getTableName(int column)           // 列所定义的表名
5
int getColumnType(int column) throws SQLException; // 列类型(java.sql.Type)
6

第三节 数据库连接池

数据库连接池是一个存储数据库连接的资源池，使用它可以更高效的使用数据库连接。

1. C3P0连接池

C3P0是一个开源的数据库连接池，使用方式如下：

• 首先需要导入相关依赖：

  10
  1
  <dependency>
  2
      <groupId>c3p0</groupId>
  3
      <artifactId>c3p0</artifactId>
  4
      <version>0.9.1.2</version>
  5
  </dependency>
  6
  <dependency>
  7
      <groupId>com.mchange</groupId>
  8
      <artifactId>mchange-commons-java</artifactId>
  9
      <version>0.2.15</version>
  10
  </dependency>
  

• 然后在src目录下配置c3p0.properties或c3p0-config.xml文件：

  22
  1
  <c3p0-config>
  2
      <!-- 命名的配置 -->
  3
      <named-config name="test">
  4
          <!-- 连接数据库的4项基本参数 -->
  5
          <property name="driverClass">com.mysql.jdbc.Driver</property>
  6
          <property name="jdbcUrl">jdbc:mysql://localhost:3306/mytest01</property>
  7
          <property name="user">root</property>
  8
          <property name="password">123</property>
  9
          <!-- 如果池中数据连接不够时一次增长多少个 -->
  10
          <property name="acquireIncrement">5</property>
  11
          <!-- 初始化连接数 -->
  12
          <property name="initialPoolSize">5</property>
  13
          <!-- 最小连接数 -->
  14
          <property name="minPoolSize">10</property>
  15
          <!-- 最大连接数 -->
  16
          <property name="maxPoolSize">40</property>
  17
          <!-- JDBC的标准参数，用以控制数据源内加载的PrepareStatements数量 -->
  18
          <property name="maxStatements">200</property>
  19
          <!-- 连接池内单个连接所拥有的最大缓存statements数 -->
  20
          <property name="maxStatementsPerConnection">5</property>
  21
      </named-config>
  22
  </c3p0-config>
  

• 最后就可以在代码中通过如下一些方法使用连接池了：

  9
  1
  // 1. 创建连接池
  2
  DataSource ds  = new ComboPooledDataSource(); // 使用默认配置
  3
  DataSource ds  = new ComboPooledDataSource("otherc3p0"); // 使用指定名称的配置
  4
  
  5
  // 2. 获取连接
  6
  Connection conn = ds.getConnection();
  7
  
  8
  // 3. 释放连接
  9
  conn.close(); // 归还连接到连接池中
  

2. Druid连接池

Druid是阿里巴巴开源的一个数据库连接池实现，不仅效率高，而且可以很好的监控DB池连接和SQL的执行情况，使用方式如下：

• 首先导入相关依赖：

  5
  1
  <dependency>
  2
      <groupId>com.alibaba</groupId>
  3
      <artifactId>druid</artifactId>
  4
      <version>1.2.8</version>
  5
  </dependency>
  

• 然后在类路径下定义配置文件druid.properties如下：

  9
  1
  driverClassName=com.mysql.cj.jdbc.Driver
  2
  url=jdbc:mysql://106.53.120.230:3306/test01?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone =Asia/Shanghai
  3
  username=root
  4
  password=Hyx147741
  5
  
  6
  initialSize=10
  7
  maxActive=100
  8
  maxWait=3000
  9
  
  

下面是一个基于Duird连接池的JDBC工具类：

60
1
public class DruidJdbcUtils {
2
    private static DataSource dataSource;
3

4
    static {
5
        try {
6
            // 1. 加载配置文件
7
            Properties properties = new Properties();
8
            properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
9

10
            // 2. 获取DataSource
11
            dataSource = DruidDataSourceFactory.createDataSource(properties);
12

13
        } catch (IOException e) {
14
            e.printStackTrace();
15
        } catch (Exception e) {
16
            e.printStackTrace();
17
        }
18
    }
19

20
    public static void main(String[] args) throws SQLException {
21
        Connection connection = DruidJdbcUtils.getConnection();
22
        Statement statement = connection.createStatement();
23
        ResultSet resultSet = statement.executeQuery("select 1");
24
        resultSet.next();
25
        System.out.println(resultSet.getInt(1));
26
    }
27

28
    /**
29
     * 获取连接池
30
     */
31
    public static DataSource getDataSource() {
32
        return dataSource;
33
    }
34

35
    /**
36
     * 获取连接
37
     */
38
    public static Connection getConnection() throws SQLException {
39
        return dataSource.getConnection();
40
    }
41

42
    /**
43
     * 释放连接
44
     */
45
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
46
        doClose(resultSet);
47
        doClose(statement);
48
        doClose(connection);
49
    }
50

51
    private static void doClose(AutoCloseable autoCloseable) {
52
        if (autoCloseable != null) {
53
            try {
54
                autoCloseable.close();
55
            } catch (Exception exception) {
56
                exception.printStackTrace();
57
            }
58
        }
59
    }
60
}

第02章_网络编程(TCP&UDP)

第一节 网络基础知识

1. 网络通信三要素

网络程序之间通信必须明确三要素：通信协议、IP地址、端口号。

• 通信协议：对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。

• IP地址：表示网络设备的唯一编号，主要有IPv4和IPv6两种协议。

• 端口号：标识网络设备中的进程，取值范围为0~65535。

上述“通信协议+IP地址+端口号”的组合，唯一标识了网络中的某个进程以及与其的通信方式，基于此就可以实现进程间网络通信了。

2. 网络分层

网络根据不同的规范可分为OSI七层模型或TCP/IP四层模型：

3. TCP协议

TCP全名为传输控制协议 (Transmission Control Protocol)，是一种面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过三次握手，以保证连接的可靠：

• 1. 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。

• 2. 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。

• 3. 第三次握手，客户端再次向服务器端发送确认信息，确认连接。

4. UDP协议

UDP全称为用户数据报协议(User Datagram Protocol)。它是面向无连接的通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

5. HTTP协议

HTTP全名为超文本传输协议（HyperText Transfer Protocol），是一种用于分布式、协作式和超媒体信息系统的应用层协议。

• 请求头示例

  

• 响应头示例

  

第二节 简单的TCP程序

1. Socket简介

Socket简称套接字，是进程间通信的一种方式，在TCP程序中分为客户端Socket和服务端Socket：

• 客户端Socket：主要用来创建客户端套接字对象，实现与服务端的通信，用java.net.Socket类表示。

  12
  1
  // 1. 创建客户端Socket，并尝试与指定IP+端口建立TCP连接
  2
  public Socket(String host, int port) // host可为null，表示本地回环地址，不进行网络传输
  3
      
  4
  // 2. Socket通信
  5
  public InputStream getInputStream()  // 返回此套接字的输入流
  6
  public OutputStream getOutputStream()  // 返回此套接字的输出流
  7
      
  8
  // 3. 关闭客户端Socket
  9
  public void close() // Socket被关闭后不可再使用，并且也将关闭相关的InputStream和OutputStream
  10
      
  11
  // 4. 禁用Socket的输出流(写结束标记)
  12
  public void shutdownOutput() // 之后，任何先前写出的数据将被发送，随后终止输出流
  

• 服务端Socket：相当于一个网络服务，阻塞等待客户端的连接，用java.net.ServerSocket类表示。

  5
  1
  // 1. 创建服务端Socket
  2
  public ServerSocket(int port)  // port-监听端口
  3
      
  4
  // 2. 阻塞等待客户端Socket发起连接
  5
  public Socket accept() // 每次连接成功后返回一个新的Socket对象，用于和客户端实现通信
  

注意：

1. 客户端Socket返回的输入流、输出流与Socket所关联的通道为同一个，关闭任何一个，其它对象所关联的通道也将关闭。

2. 一个简单的TCP程序示例

58
1
// 服务端
2
public class ServerTCP {
3
    public static void main(String[] args) throws IOException {
4
        // 1.创建服务端Socket，监听指定端口，开始等待连接
5
        ServerSocket ss = new ServerSocket(6666);
6
        System.out.println("服务端启动, 等待连接 .... ");
7

8
        // 2.接收客户端连接, 返回一个用于与客户端通信的Socket对象
9
        Socket server = ss.accept();
10

11
        // 3.通过该Socket获取输入流
12
        InputStream is = server.getInputStream();
13

14
        // 4.一次性读取数据
15
        byte[] b = new byte[1024];
16
        int len = is.read(b);
17
        String msg = new String(b, 0, len);
18
        System.out.println("client: " + msg);
19

20
        // 5. 通过Socket获取输出流
21
        OutputStream out = server.getOutputStream();
22

23
        // 6. 回写数据
24
        out.write("hello, client001".getBytes());
25

26
        // 7.关闭资源
27
        out.close();
28
        is.close();
29
        server.close();
30
    }
31
}
32

33
// 客户端
34
public class ClientTCP {
35
    public static void main(String[] args) throws Exception {
36
        // 1.创建客户端Socket，连接到指定IP+端口
37
        Socket client = new Socket("localhost", 6666);
38

39
        // 2.通过Scoket获取输出流对象
40
        OutputStream os = client.getOutputStream();
41

42
        // 3.写数据
43
        os.write("hello, tcp server".getBytes());
44

45
        // 4. 通过Scoket获取输入流对象
46
        InputStream in = client.getInputStream();
47

48
        // 5. 读取响应数据
49
        byte[] b = new byte[100];
50
        int len = in.read(b);
51
        System.out.println("server: " + new String(b, 0, len));
52

53
        // 6. 关闭资源
54
        in.close();
55
        os.close();
56
        client.close();
57
    }
58
}