24、ODP.NET 安全与性能优化指南

ODP.NET 安全与性能优化指南

1. ODP.NET 安全特性

1.1 实施最佳实践

在编写访问数据库的代码时，遵循最佳实践往往能避免应用程序中大部分的安全漏洞。例如，SQL 注入攻击是常见的数据库攻击形式，使用参数化查询而非动态生成的 SQL 语句，就能轻松避免此类攻击。

1.2 防止 SQL 注入攻击

SQL 注入攻击是通过输入文本框将恶意 SQL 代码直接注入应用程序的一种手段。以登录页面为例，若代码直接将用户输入融入 SQL 语句构建，恶意用户就可能通过输入特定格式的数据来操控该语句。

_cmdObj.CommandText = "SELECT * FROM Useraccounts WHERE UserID='" +  
txtUsername.Text + "' AND Password='" + txtPassword.Text + "'"; 
OracleDataReader _rdrObj = _cmdObj.ExecuteReader(); 
if (_rdrObj.HasRows) 
{  
    MessageBox.Show("Access Granted!");  
} 

若用户在用户名文本框输入 ' OR UserID<> ' ，密码文本框输入 ' OR Password<> ' ，最终生成的 SQL 语句为：

SELECT * FROM Useraccounts WHERE UserID='' OR UserID<>'' AND Password='' OR Password<>'' 

该语句会返回系统中的所有用户账户，恶意用户就能随意访问应用程序。此问题主要源于未对输入数据进行恰当格式化。为避免这种情况，可让应用程序检查输入数据中的单引号并去除或替换，更安全的做法是将输入作为参数传递给 SQL 语句，而非直接作为字符串追加。

_cmdObj.CommandText = "SELECT * FROM Useraccounts WHERE UserID=:UserID AND  Password=:Password"; 
_cmdObj.Parameters.Add(new OracleParameter("UserID", txtUsername.Text)); 
_cmdObj.Parameters.Add(new OracleParameter("Password", txtPassword.Text)); 

建议使用参数化查询或 PL/SQL 存储过程，将用户输入安全地传递给 SQL。若无法避免使用动态生成的 SQL，在将输入追加到 SQL 语句之前，需解析并检查所有输入的特殊字符，进行适当转义。

1.3 防止非持久跨站脚本攻击

非持久跨站脚本（XSS）攻击主要针对通过表单 POST 或 URL 查询字符串段在网页间传输数据的 Web 应用程序。例如，一个显示产品列表的网页，每个产品由看似无害的链接表示：

http://localhost/myapp/viewproduct.aspx?ProductID=333888 

假设 viewproduct.aspx.vb 页面包含如下代码：

_cmdObj.CommandText = "SELECT * FROM Products WHERE ProductID='"  
+ Request.QueryString["ProductID"] + "'"; 

恶意用户可将 URL 中的 ProductID 替换为：

http://localhost/myapp/viewproduct.aspx?ProductID=' UNION SELECT * FROM ProhibitedProducts WHERE ProhibitedProductID=100 AND ProhibitedProductID<> '

当该 ProductID 值被插入 SQL 语句时，SQL 变为：

SELECT * FROM Products WHERE ProductID='' UNION SELECT * FROM ProhibitedProducts WHERE ProhibitedProductID=100 AND ProhibitedProductID<>'' 

恶意用户就能访问原本无法访问的禁止表中的数据。为防止非持久 XSS 攻击，可采取以下预防措施：
- 始终对 URL 的查询字符串部分进行加密或混淆处理。
- 对输入数据进行双重检查。例如，若产品 ID 应为数字，需检查传入的产品 ID 是否为数值。
- 尽可能在网页上设置检查，确保当前登录用户有权查看所需页面及其数据。
- 最终输入 SQL 语句的数据应始终作为参数传递。

1.4 安全总结

创建安全的 ODP.NET 应用程序可通过以下三种方法实现：
1. 身份验证
2. 代码访问安全
3. 访问数据库时采用最佳实践

具体而言，需了解以下内容：
- Oracle 提供的三种不同身份验证模式及其适用场景。
- 如何使用 OraclePermission 和 OraclePermissionAttribute 类在代码中声明性和命令性地请求和拒绝访问 Oracle 数据库的权限。
- 如何通过更改 Web 应用程序的信任级别来保护 ASP.NET 应用程序。
- 如何防止 ODP.NET 代码遭受 SQL 注入和非持久跨站脚本攻击。

2. ODP.NET 性能优化

2.1 性能优化的重要性

在 ODP.NET 开发中，许多开发团队常将性能优化视为开发后期的可选任务，而非从编写第一行代码就养成的习惯。缺乏对 Oracle 数据库内部工作原理和最佳性能实践的了解，会使开发团队编写的代码难以在项目后期进行修改，可能需要重写整个数据层。因此，在开始 ODP.NET 项目前，掌握相关知识至关重要。

2.2 性能测量

测量应用程序性能通常有两种方法：一是检查 ODP.NET 发布的性能计数器，二是使用高分辨率计时器对代码进行编程计时。

2.2.1 启用性能计数器

ODP.NET 性能计数器能实时显示活动连接、关闭连接等数量，可用于检测代码中无意未关闭数据库连接的情况。例如，运行应用程序的某个函数，检查新连接总数，并与关闭的连接数进行对比，若多次实验后两者不匹配，就可判定存在连接泄漏问题。还可将这些性能计数器连接到 Windows 可靠性和性能监视器，以时间图表的形式直观展示数据库性能的各个方面，分析 CPU 和数据库利用率峰值之间的相关性。

以下是启用性能计数器的具体步骤：
1. 安装性能计数器 ：默认情况下，Oracle 性能计数器未安装。可在 Oracle 安装程序中选择自定义安装选项，并勾选“Oracle for Windows Performance”选项进行安装。
2. 注册数据库实例 ：Oracle 性能计数器仅能监控一个数据库实例，需使用命令行工具 Operfcfg.exe （位于 ORACLE_HOME\BIN 文件夹）进行注册，语法如下：

operfcfg U <system> P <password> D <instancename> 

例如，注册 NEWDB 数据库实例的命令为：

operfcfg U SYSTEM P admin D localhost\NEWDB 

3. 启用所有性能计数器 ：使用 Windows 注册表编辑器（ regedit.exe ），导航至以下键值：

HKEY_LOCAL_MACHINE\Software\ORACLE\ODP.NET\2.111.7.20\PerformanceCounters  

将该键值从 0（禁用）改为 4095（启用），然后重启 Oracle 数据库实例。
4. 在性能监视器中查看 ：打开 Windows 可靠性和性能监视器，点击“性能监视器”节点，选择“添加计数器”菜单项，在弹出窗口中找到“Oracle Data Provider for .NET”计数器，将所有计数器添加到“已添加的计数器”列表中，点击“确定”，即可在时间图表区域看到 ODP.NET 计数器。

Oracle 提供的性能计数器及其描述如下表所示：
| 性能计数器 | 描述 |
| — | — |
| HardConnectsPerSecond | 每秒建立的新数据库会话总数 |
| HardDisconnectsPerSecond | 每秒关闭的数据库会话总数 |
| SoftConnectsPerSecond | 从连接池中检索的缓存连接总数 |
| SoftDisconnectsPerSecond | 释放到连接池中的缓存连接总数 |
| NumberOfActiveConnectionPools | 活动连接池的总数 |
| NumberOfInactiveConnectionPools | 非活动连接池的总数 |
| NumberOfActiveConnections | 当前正在使用的连接总数 |
| NumberOfFreeConnections | 所有连接池中可用的连接总数 |
| NumberOfPooledConnections | 池化的活动（打开）连接总数 |
| NumberOfNonPooledConnections | 非池化的活动（打开）连接总数 |
| NumberOfReclaimedConnections | 被垃圾回收器内部处理的连接总数 |
| NumberOfStasisConnections | 用户已关闭但处于停滞状态，等待释放回连接池的连接总数 |

2.2.2 编程方式测量性能

测量代码性能的基本方法是记录事件前后的时间并计算差值，这需要一个能精确到毫秒的高分辨率计时器。.NET Framework 2.0 及以上版本提供的 StopWatch 类就非常适合此任务。

Stopwatch _stopwatch = new Stopwatch(); 
_stopwatch.Start(); 
// Do the task... 
_stopwatch.Stop(); 
MessageBox.Show(_stopwatch.Elapsed.TotalSeconds.ToString () + " seconds"); 

若要再次使用同一个 StopWatch 实例，需调用 StopWatch.Reset 方法重置内部存储的总经过时间。

Stopwatch _stopwatch = new Stopwatch(); 
_stopwatch.Start(); 
// Do first task ... 
_stopwatch.Stop(); 
_stopwatch.Reset(); 
_stopwatch.Start(); 
//Do second task ... 
_stopwatch.Stop(); 

需要注意的是，首次运行测试代码时进行性能测量通常不是个好主意，因为首次运行可能会有大量的后台加载、缓存和初始化操作，这些都会导致时间差值增大，单次偏离目标的测量可能会严重影响测量平均值，产生不准确的结果。

2.3 使用连接池加速连接

在应用程序的生命周期内，尤其是基于 Web 的应用程序，会频繁打开和关闭大量数据库连接。例如，一个网页平均每次打开两个数据库连接，若该网页每分钟接收 100 次访问，那么每分钟就会在数据库上打开约 200 个连接，这对任何数据库来说都是一个相当大的数量。

连接池是 Oracle 处理大量连接请求的方式。打开新的数据库连接通常是一个缓慢且资源密集的任务，而连接池在关闭连接对象后并不销毁它，而是将其置于“非活动”状态，等待新的连接请求到来时再次使用，从而避免了打开全新连接的昂贵操作。

可在连接字符串中指定是否启用连接池（默认启用）。以下代码展示了如何测量使用和不使用连接池时打开和关闭十个连接所需的时间：

private void btnConnectionPooling_Click(object sender, EventArgs e) 
{ 
    Stopwatch _stopwatch = new Stopwatch(); 
    String _Results; 
    String _connstring = "Data Source=localhost/NEWDB;User  Id=EDZEHOO;Password=PASS123;Pooling=false"; 
    try 
    { 
        //Open and close connections 10 times without connection pooling enabled 
        OracleConnection _connObj = new OracleConnection(_connstring); 
        _stopwatch.Start(); 
        for (int i = 1; i <= 10; i++) 
        { 
            _connObj.Open(); 
            _connObj.Close(); 
        } 
        _stopwatch.Stop(); 
        _Results = "Without connection pooling:\t" +  _stopwatch.Elapsed.TotalSeconds.ToString() + " seconds\n"; 
        //Open and close connections 10 times with connection pooling enabled 
        _connstring = "Data Source=localhost/NEWDB;User  Id=EDZEHOO;Password=PASS123;Pooling=true"; 
        _connObj = new OracleConnection(_connstring); 
        _stopwatch.Reset(); 
        _stopwatch.Start(); 
        for (int i = 1; i <= 10; i++) 
        { 
            _connObj.Open(); 
            _connObj.Close(); 
        } 
        _stopwatch.Stop(); 
        _Results = _Results + "With connection pooling:\t" +  _stopwatch.Elapsed.TotalSeconds.ToString() + " seconds\n"; 
        MessageBox.Show(_Results); 
        _connObj.Close(); 
    } 
    catch (Exception ex) 
    { 
        MessageBox.Show(ex.ToString()); 
    } 
} 

运行该代码并记录不同迭代次数（10、50、100、500、1000）下使用和不使用连接池的耗时，计算性能提升倍数（不使用连接池的耗时除以使用连接池的耗时），结果如下表所示：
| 迭代次数 | 不使用连接池 | 使用连接池 | 性能提升 |
| — | — | — | — |
| 10 | 0.4485831 | 0.2239234 | x 2.00 |
| 50 | 1.5553226 | 0.0757786 | x 20.52 |
| 100 | 3.0455792 | 0.0816510 | x 37.30 |
| 500 | 13.8253361 | 0.1356212 | x 101.94 |
| 1000 | 25.8209253 | 0.2001342 | x 129.02 |

从结果可以看出，启用连接池能显著提高性能，且随着打开和关闭连接次数的增加，性能提升效果更明显。因此，即使不需要频繁打开大量数据库连接，也建议始终启用连接池。以下是适合使用连接池的场景：
- 需要频繁打开和关闭连接的情况，如基于 Web 的应用程序，连接池可大大减少建立后续数据库连接所需的时间。
- 除非是始终连接的应用程序且需要对数据库连接进行完全控制，否则建议始终启用连接池。

2.4 执行更快的浮点运算

Oracle 10g 的一项改进是引入了 BINARY_FLOAT 和 BINARY_DOUBLE 数据类型，这些数据类型使用机器算术，将计算工作交给操作系统处理，因此在处理浮点数时非常高效。

以下代码展示了如何测量使用 BINARY_FLOAT 、 BINARY_DOUBLE 和 NUMBER 数据类型进行一百万次加法运算所需的时间：

private void btnMeasureNumbers(object sender, EventArgs e) 
{ 
    Stopwatch _stopwatch = new Stopwatch(); 
    String _Results; 
    String _connstring = "Data Source=localhost/NEWDB;User  Id=EDZEHOO;Password=PASS123;"; 
    try 
    { 
        OracleConnection _connObj = new OracleConnection(_connstring); 
        _connObj.Open(); 
        OracleCommand _cmdObj = _connObj.CreateCommand(); 
        //Adding NUMBERs 
        _cmdObj.CommandText = "DECLARE" + 
                              "    Number1 NUMBER:=1;" + 
                              "    Number2 NUMBER:=1;" + 
                              "BEGIN" + 
                              "    FOR i IN 1 .. 1000000 LOOP" + 
                              "         Number1:=Number1 + Number2;" + 
                              "    END LOOP;" + 
                              "END;"; 
        _stopwatch.Start(); 
        _cmdObj.ExecuteNonQuery(); 
        _stopwatch.Stop(); 
        _Results = "Adding NUMBERs:\t" + _stopwatch.Elapsed.TotalSeconds.ToString()  + " seconds\n"; 
        //Adding BINARY_FLOAT numbers 
        _cmdObj.CommandText = "DECLARE" + 
                              "    BinaryFloat1 BINARY_FLOAT:=1;" + 
                              "    BinaryFloat2 BINARY_FLOAT:=1;" + 
                              "BEGIN" + 
                              "    FOR i IN 1 .. 1000000 LOOP" + 
                              "        BinaryFloat1:=BinaryFloat1 + BinaryFloat2;" +  
                              "    END LOOP;" + 
                              "END;"; 
        _stopwatch.Reset(); 
        _stopwatch.Start(); 
        _cmdObj.ExecuteNonQuery(); 
        _stopwatch.Stop(); 
        _Results = _Results + "Adding BINARY_FLOATs:\t" +  _stopwatch.Elapsed.TotalSeconds.ToString() + " seconds\n"; 
        //Adding BINARY_DOUBLE numbers 
        _cmdObj.CommandText = "DECLARE" + 
                              "    BinaryDouble1 BINARY_DOUBLE:=1;" + 
                              "    BinaryDouble2 BINARY_DOUBLE:=1;" + 
                              "BEGIN" + 
                              "    FOR i IN 1 .. 1000000 LOOP" + 
                              "         BinaryDouble1:=BinaryDouble1 + " +  "BinaryDouble2;" + 
                              "    END LOOP;" + 
                              "END;"; 
        _stopwatch.Reset(); 
        _stopwatch.Start(); 
        _cmdObj.ExecuteNonQuery(); 
        _stopwatch.Stop(); 
        _Results = _Results + "Adding BINARY_DOUBLEs:\t" +  _stopwatch.Elapsed.TotalSeconds.ToString() + " seconds\n"; 
        MessageBox.Show(_Results); 
        _connObj.Close(); 
    } 
    catch (Exception ex) 
    { 
        MessageBox.Show(ex.ToString()); 
    } 
} 

记录不同数据类型进行运算的耗时，能直观地比较它们的性能差异，在处理浮点数运算时，可优先考虑使用 BINARY_FLOAT 和 BINARY_DOUBLE 数据类型以提高性能。

2.5 更高效地执行 SQL 语句

为了更高效地执行 SQL 语句，可采用以下几种策略：
- 使用预编译语句 ：预编译语句可以避免每次执行 SQL 时都进行语法解析和查询计划生成，从而提高执行效率。在 ODP.NET 中，可以通过 OracleCommand 对象的 Prepare 方法来预编译 SQL 语句。

OracleConnection _connObj = new OracleConnection(_connstring);
_connObj.Open();
OracleCommand _cmdObj = _connObj.CreateCommand();
_cmdObj.CommandText = "SELECT * FROM Products WHERE ProductID = :ProductID";
_cmdObj.Prepare();
_cmdObj.Parameters.Add(new OracleParameter("ProductID", 1));
OracleDataReader _rdrObj = _cmdObj.ExecuteReader();
while (_rdrObj.Read())
{
    // 处理数据
}
_rdrObj.Close();
_connObj.Close();

• 批量执行 SQL 语句 ：将多个 SQL 语句组合成一个批次进行执行，可以减少与数据库的交互次数，提高性能。在 ODP.NET 中，可以使用 OracleCommand 对象的 ExecuteNonQuery 方法批量执行 SQL 语句。

OracleConnection _connObj = new OracleConnection(_connstring);
_connObj.Open();
OracleCommand _cmdObj = _connObj.CreateCommand();
_cmdObj.CommandText = "INSERT INTO Products (ProductName, Price) VALUES ('Product1', 10); " +
                      "INSERT INTO Products (ProductName, Price) VALUES ('Product2', 20); " +
                      "INSERT INTO Products (ProductName, Price) VALUES ('Product3', 30);";
_cmdObj.ExecuteNonQuery();
_connObj.Close();

2.6 更高效地传递参数

在 ODP.NET 中，传递参数时可以采用以下方法提高效率：
- 使用参数化查询 ：参数化查询可以防止 SQL 注入攻击，同时也能提高性能。在前面防止 SQL 注入攻击的部分已经介绍过参数化查询的使用方法，这里再次强调其重要性。

_cmdObj.CommandText = "SELECT * FROM Useraccounts WHERE UserID=:UserID AND Password=:Password";
_cmdObj.Parameters.Add(new OracleParameter("UserID", txtUsername.Text));
_cmdObj.Parameters.Add(new OracleParameter("Password", txtPassword.Text));

• 设置参数的数据类型 ：明确指定参数的数据类型可以避免类型转换带来的性能开销。在创建 OracleParameter 对象时，可以指定其 OracleDbType 属性。

OracleParameter param = new OracleParameter("ProductID", OracleDbType.Int32);
param.Value = 1;
_cmdObj.Parameters.Add(param);

2.7 更高效地管理大对象（LOBs）

在处理大对象（LOBs）时，可采取以下措施提高效率：
- 使用流式处理 ：对于大的 LOB 数据，使用流式处理可以避免将整个 LOB 数据加载到内存中，减少内存占用。在 ODP.NET 中，可以使用 OracleDataReader 的 GetOracleLob 方法获取 LOB 对象，并使用其 BeginRead 和 EndRead 方法进行流式读取。

OracleConnection _connObj = new OracleConnection(_connstring);
_connObj.Open();
OracleCommand _cmdObj = _connObj.CreateCommand();
_cmdObj.CommandText = "SELECT LargeObjectColumn FROM LargeObjectTable WHERE ID = 1";
OracleDataReader _rdrObj = _cmdObj.ExecuteReader();
if (_rdrObj.Read())
{
    OracleLob lob = _rdrObj.GetOracleLob(0);
    byte[] buffer = new byte[4096];
    int bytesRead;
    while ((bytesRead = lob.BeginRead(buffer, 0, buffer.Length)) > 0)
    {
        // 处理读取的数据
    }
    lob.Close();
}
_rdrObj.Close();
_connObj.Close();

• 使用临时 LOBs ：在需要对 LOB 数据进行修改时，使用临时 LOBs 可以避免直接修改原始 LOB 数据，减少数据库的锁定时间。在 ODP.NET 中，可以使用 OracleLob 的 CreateTemporary 方法创建临时 LOB 对象。

OracleConnection _connObj = new OracleConnection(_connstring);
_connObj.Open();
OracleCommand _cmdObj = _connObj.CreateCommand();
_cmdObj.CommandText = "SELECT LargeObjectColumn FROM LargeObjectTable WHERE ID = 1 FOR UPDATE";
OracleDataReader _rdrObj = _cmdObj.ExecuteReader();
if (_rdrObj.Read())
{
    OracleLob originalLob = _rdrObj.GetOracleLob(0);
    OracleLob tempLob = originalLob.CreateTemporary(true, false);
    // 对临时 LOB 进行修改
    tempLob.BeginWrite(0);
    tempLob.Write(buffer, 0, buffer.Length);
    tempLob.EndWrite();
    // 将临时 LOB 数据更新到原始 LOB
    originalLob.CopyTo(tempLob, tempLob.Length);
    tempLob.Close();
}
_rdrObj.Close();
_connObj.Close();

2.8 更高效地检索数据

为了更高效地检索数据，可参考以下方法：
- 仅检索所需列 ：避免检索不必要的列，减少数据传输量和内存占用。在编写 SQL 查询时，明确指定需要检索的列。

SELECT ProductName, Price FROM Products WHERE Category = 'Electronics';

• 使用分页查询 ：对于大量数据的检索，使用分页查询可以减少一次性检索的数据量，提高响应速度。在 Oracle 中，可以使用 ROWNUM 或 OFFSET FETCH 子句实现分页查询。

-- 使用 ROWNUM 实现分页查询
SELECT * FROM (
    SELECT ProductName, Price, ROWNUM AS rn
    FROM Products
    WHERE Category = 'Electronics'
) WHERE rn BETWEEN 1 AND 10;

-- 使用 OFFSET FETCH 子句实现分页查询
SELECT ProductName, Price
FROM Products
WHERE Category = 'Electronics'
ORDER BY ProductName
OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY;

2.9 更高效地将批量数据加载到 Oracle

将批量数据加载到 Oracle 时，可采用以下方法提高效率：
- 使用 OracleBulkCopy 类 ： OracleBulkCopy 类可以将大量数据快速插入到 Oracle 表中。以下是一个使用 OracleBulkCopy 类的示例：

DataTable dataTable = new DataTable();
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));

// 填充数据
dataTable.Rows.Add("Product1", 10);
dataTable.Rows.Add("Product2", 20);
dataTable.Rows.Add("Product3", 30);

OracleConnection _connObj = new OracleConnection(_connstring);
_connObj.Open();
using (OracleBulkCopy bulkCopy = new OracleBulkCopy(_connObj))
{
    bulkCopy.DestinationTableName = "Products";
    bulkCopy.WriteToServer(dataTable);
}
_connObj.Close();

• 使用 SQL*Loader ：对于大规模的数据加载，SQL Loader 是一个更高效的工具。SQL Loader 是 Oracle 提供的一个命令行工具，可以从文本文件中快速加载数据到 Oracle 表中。使用 SQL*Loader 需要编写控制文件，指定数据文件的格式和目标表的结构。

2.10 获取详细的性能统计信息

为了进一步优化 ODP.NET 应用程序的性能，需要获取详细的性能统计信息。可以通过以下方式实现：
- 使用性能计数器 ：前面已经介绍过如何启用和使用 ODP.NET 的性能计数器，通过分析性能计数器的数据，可以了解数据库连接、查询执行等方面的性能情况。
- 使用数据库的性能视图 ：Oracle 提供了许多性能视图，如 V$SQL 、 V$SESSION 等，可以查询这些视图获取详细的 SQL 执行计划、会话信息等。

-- 查询 SQL 执行计划
SELECT * FROM V$SQL WHERE SQL_TEXT LIKE '%SELECT * FROM Products%';

-- 查询会话信息
SELECT * FROM V$SESSION WHERE SID = 123;

3. 总结

通过本文介绍的方法，可以创建安全且高性能的 ODP.NET 应用程序。在安全方面，要注意防止 SQL 注入和非持久跨站脚本攻击，采用身份验证、代码访问安全和最佳实践等方法保护应用程序。在性能优化方面，要从多个方面入手，包括启用性能计数器、加速连接、优化浮点运算、高效执行 SQL 语句、传递参数、管理大对象、检索数据和加载批量数据等。在实际开发中，要根据具体情况选择合适的方法进行优化，不断提升应用程序的性能和安全性。

综上所述，掌握 ODP.NET 的安全特性和性能优化技巧，对于开发高质量的 Oracle 数据库应用程序至关重要。希望本文介绍的内容能帮助开发者更好地应对 ODP.NET 开发中的安全和性能挑战。