• 如何在 Java 中编写命名参数化查询

    How To Write Named Parameterized Query In Java

    在java中，对于大查询，创建参数化查询并不容易，因为JAVA JDBC API接口PreparedStatement只支持通过索引传递参数。 

    为了克服这个限制，我们将创建自定义类，使我们能够按名称将参数传递给查询。让我们看看手头的问题是什么，然后我们将讨论解决方案。

    为什么我们需要参数化查询？

    在 Java 中，要执行 sql 查询，我们必须创建语句，然后我们可以执行该语句以从数据库中选择、插入、更新或删除数据。但是，不推荐这种方法，因为 java 语句不带任何参数，因此无法防止 SQL 注入。

    1. /*
    2.  * Here, we inserted static values in query. In your case these values might come from user input.
    3.  * Here, we are directly concatinating the values in the query. Hence, It's not SQL injection safe.  
    4.  */ 
    5. String sqlQuery = " INSERT INTO employee (id, name, designation, salary)"
    6.                 + " VALUES('1', 'Dwayne Johnson', 'Project Manager', '250000')";
    7. Statement stmt = conn.createStatement();
    8. stmt.executeUpdate(sqlQuery);
    9. stmt.close();

    为了防止 SQL 注入，我们必须编写参数化查询。要在 java 中创建参数化查询，我们有 PreparedStatement。它可以通过在查询中传递问号 (?) 来获取参数，然后将每个问号索引替换为所需的值。

    1. /*
    2.  * Here, we assigned static values in parameter. In your case these values might come from user input.
    3.  * Here, we are not directly concatinating the values in the query. Hence, It's SQL injection safe. 
    4.  */ 
    5. String sqlQuery = " INSERT INTO employee (id, name, designation, salary)"
    6.                 + " VALUES(?, ?, ?, ?)";
    7. PreparedStatement prepStmt = conn.prepareStatement(sqlQuery);
    8. prepStmt.setLong(1, 1); 
    9. prepStmt.setString(2, "Dwayne Jhonson");
    10. prepStmt.setString(3, "Team Leader");
    11. prepStmt.setDouble(4, 10000);
    12. prepStmt.executeUpdate();
    13. prepStmt.close();

    为什么我们需要命名参数化查询？

    正如您在上面的示例中看到的，PreparedStatement 使用问号的索引将参数传递给查询。需要时间，因为您必须计算索引以传递值，如果您的查询中有太多列来计算查询中每列的索引，情况会变得更糟。如果我们可以做这样的事情—— 

    1. /*
    2.  * This code is just to show requirement. PreparedStatement in java JDBC API does not support this syntax to set parameters
    3.  */ 
    4. String sqlQuery = " INSERT INTO employee (id, name, designation, salary)"
    5.                 + " VALUES(:id, :name, :designation, :salary)";
    6. PreparedStatement prepStmt = conn.prepareStatement(sqlQuery);
    7. prepStmt.setLong("id", 1);
    8. prepStmt.setString("name", "Dwayne Jhonson");
    9. prepStmt.setString("designation", "Team Leader");
    10. prepStmt.setDouble("salary", 10000);
    11. prepStmt.executeUpdate();
    12. prepStmt.close();

    但是，PreparedStatement 不支持按名称设置参数。因此，我们必须创建自定义的 PreparedStatement 类，该类将为我们提供按名称设置参数的功能。

    在一分钟内创建您的第一个命名参数化查询

    下面，我展示了我为编写参数化查询而创建的两个自定义类 - 

    只需在您的项目中创建这两个类，您就可以像这样在一分钟内创建参数化查询 - 

    1. String sqlQuery = " INSERT INTO employee (id, name, designation, salary)"
    2.                 + " VALUES(:id, :name, :designation, :salary)";
    3. PreparedStatement prepStmt = NamedPreparedStatement.prepareStatement(connection, sqlQuery);
    4. prepStmt.setLong("id", 1);
    5. prepStmt.setString("name", "Dwayne Jhonson");
    6. prepStmt.setString("designation", "Team Leader");
    7. prepStmt.setDouble("salary", 10000);
    8. prepStmt.executeUpdate();
    9. prepStmt.close();

    你不需要知道这些类是如何工作的。您可以创建这些类并开始使用它们，如上例所示。但是，作为一名程序员，您应该尝试了解它是如何工作的。这种方法很简单，因为您不必计算列的索引，并且您可以随时更改列的顺序。

    NamedPreparedStatement.java

    1. package com.codemeright.namedPerameterizedQuery;
    2.  
    3. import java.math.BigDecimal;
    4. import java.sql.Connection;
    5. import java.sql.Date;
    6. import java.sql.PreparedStatement;
    7. import java.sql.SQLException;
    8. import java.sql.Time;
    9. import java.sql.Timestamp;
    10. import java.text.SimpleDateFormat;
    11. import java.util.ArrayList;
    12. import java.util.Collection;
    13. import java.util.List;
    14. import java.util.regex.Matcher;
    15.  
    16. public class NamedPreparedStatement extends PreparedStatementImpl {
    17.  
    18.     private enum FormatType {
    19.  
    20.         NULL, BOOLEAN, BYTE, SHORT, INTEGER, LONG, FLOAT, DOUBLE, BIGDECIMAL, STRING, STRINGLIST, DATE, TIME, TIMESTAMP
    21.     }
    22.  
    23.     private String originalSQL;
    24.     private final List lstParameters;
    25.  
    26.     public static NamedPreparedStatement prepareStatement(Connection conn, String sql) throws SQLException {
    27.         List orderedParameters = new ArrayList();
    28.         int length = sql.length();
    29.         StringBuffer parsedQuery = new StringBuffer(length);
    30.         boolean inSingleQuote = false;
    31.         boolean inDoubleQuote = false;
    32.         boolean inSingleLineComment = false;
    33.         boolean inMultiLineComment = false;
    34.  
    35.         for (int i = 0; i < length; i++) {
    36.             char c = sql.charAt(i);
    37.             if (inSingleQuote) {
    38.                 if (c == '\'') {
    39.                     inSingleQuote = false;
    40.                 }
    41.             } else if (inDoubleQuote) {
    42.                 if (c == '"') {
    43.                     inDoubleQuote = false;
    44.                 }
    45.             } else if (inMultiLineComment) {
    46.                 if (c == '*' && sql.charAt(i + 1) == '/') {
    47.                     inMultiLineComment = false;
    48.                 }
    49.             } else if (inSingleLineComment) {
    50.                 if (c == '\n') {
    51.                     inSingleLineComment = false;
    52.                 }
    53.             } else if (c == '\'') {
    54.                 inSingleQuote = true;
    55.             } else if (c == '"') {
    56.                 inDoubleQuote = true;
    57.             } else if (c == '/' && sql.charAt(i + 1) == '*') {
    58.                 inMultiLineComment = true;
    59.             } else if (c == '-' && sql.charAt(i + 1) == '-') {
    60.                 inSingleLineComment = true;
    61.             } else if (c == ':' && i + 1 < length && Character.isJavaIdentifierStart(sql.charAt(i + 1))) {
    62.                 int j = i + 2;
    63.                 while (j < length && Character.isJavaIdentifierPart(sql.charAt(j))) {
    64.                     j++;
    65.                 }
    66.                 String name = sql.substring(i + 1, j);
    67.                 orderedParameters.add(name);
    68.                 c = '?';
    69.                 i += name.length();
    70.             }
    71.             parsedQuery.append(c);
    72.         }
    73.  
    74.         return new NamedPreparedStatement(conn.prepareStatement(parsedQuery.toString()), sql, orderedParameters);
    75.     }
    76.  
    77.     private NamedPreparedStatement(PreparedStatement preparedStatement, String originalSQL, List orderedParameters) {
    78.         super(preparedStatement);
    79.         this.originalSQL = originalSQL.trim();
    80.         this.lstParameters = orderedParameters;
    81.     }
    82.  
    83.     private Collection getParameterIndexes(String parameter) {
    84.         Collection indexes = new ArrayList();
    85.         for (int i = 0; i < lstParameters.size(); i++) {
    86.             if (lstParameters.get(i).equalsIgnoreCase(parameter)) {
    87.                 indexes.add(i + 1);
    88.             }
    89.         }
    90.         if (indexes.isEmpty()) {
    91.             throw new IllegalArgumentException(String.format("SQL statement doesn't contain the parameter '%s'",
    92.                     parameter));
    93.         }
    94.         return indexes;
    95.     }
    96.  
    97.     public void setNull(String parameter, int sqlType) throws SQLException {
    98.         for (Integer i : getParameterIndexes(parameter)) {
    99.             getPreparedStatement().setNull(i, sqlType);
    100.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((String) null, FormatType.NULL)));
    101.         }
    102.     }
    103.  
    104.     public void setBoolean(String parameter, boolean x) throws SQLException {
    105.         for (Integer i : getParameterIndexes(parameter)) {
    106.             getPreparedStatement().setBoolean(i, x);
    107.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Boolean) x, FormatType.BOOLEAN)));
    108.         }
    109.     }
    110.  
    111.     public void setByte(String parameter, byte x) throws SQLException {
    112.         for (Integer i : getParameterIndexes(parameter)) {
    113.             getPreparedStatement().setByte(i, x);
    114.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Byte) x, FormatType.BYTE)));
    115.         }
    116.     }
    117.  
    118.     public void setShort(String parameter, short x) throws SQLException {
    119.         for (Integer i : getParameterIndexes(parameter)) {
    120.             getPreparedStatement().setShort(i, x);
    121.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Short) x, FormatType.SHORT)));
    122.         }
    123.     }
    124.  
    125.     public void setInt(String parameter, int x) throws SQLException {
    126.         for (Integer i : getParameterIndexes(parameter)) {
    127.             getPreparedStatement().setInt(i, x);
    128.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Integer) x, FormatType.INTEGER)));
    129.         }
    130.     }
    131.  
    132.     public void setLong(String parameter, long x) throws SQLException {
    133.         for (Integer i : getParameterIndexes(parameter)) {
    134.             getPreparedStatement().setLong(i, x);
    135.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Long) x, FormatType.LONG)));
    136.         }
    137.     }
    138.  
    139.     public void setFloat(String parameter, float x) throws SQLException {
    140.         for (Integer i : getParameterIndexes(parameter)) {
    141.             getPreparedStatement().setFloat(i, x);
    142.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Float) x, FormatType.FLOAT)));
    143.         }
    144.     }
    145.  
    146.     public void setDouble(String parameter, double x) throws SQLException {
    147.         for (Integer i : getParameterIndexes(parameter)) {
    148.             getPreparedStatement().setDouble(i, x);
    149.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Double) x, FormatType.DOUBLE)));
    150.         }
    151.     }
    152.  
    153.     public void setBigDecimal(String parameter, BigDecimal x) throws SQLException {
    154.         for (Integer i : getParameterIndexes(parameter)) {
    155.             getPreparedStatement().setBigDecimal(i, x);
    156.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((BigDecimal) x, FormatType.BIGDECIMAL)));
    157.         }
    158.     }
    159.  
    160.     public void setString(String parameter, String x) throws SQLException {
    161.         for (Integer i : getParameterIndexes(parameter)) {
    162.             getPreparedStatement().setString(i, x);
    163.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((String) x, FormatType.STRING)));
    164.         }
    165.     }
    166.  
    167.     public void setBytes(String parameter, byte[] x) throws SQLException {
    168.         for (Integer i : getParameterIndexes(parameter)) {
    169.             getPreparedStatement().setBytes(i, x);
    170.             String fval = "";
    171.             for (int j = 0; j < x.length; j++) {
    172.                 fval += (char) x[j] + ",";
    173.             }
    174.             if (fval.endsWith(",")) {
    175.                 fval = fval.substring(0, fval.length() - 1);
    176.             }
    177.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((String) fval, FormatType.STRING)));
    178.         }
    179.     }
    180.  
    181.     public void setDate(String parameter, Date x) throws SQLException {
    182.         for (Integer i : getParameterIndexes(parameter)) {
    183.             getPreparedStatement().setDate(i, x);
    184.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Date) x, FormatType.DATE)));
    185.         }
    186.     }
    187.  
    188.     public void setTime(String parameter, Time x) throws SQLException {
    189.         for (Integer i : getParameterIndexes(parameter)) {
    190.             getPreparedStatement().setTime(i, x);
    191.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Time) x, FormatType.TIME)));
    192.         }
    193.     }
    194.  
    195.     public void setTimestamp(String parameter, Timestamp x) throws SQLException {
    196.         for (Integer i : getParameterIndexes(parameter)) {
    197.             getPreparedStatement().setTimestamp(i, x);
    198.             this.originalSQL = this.originalSQL.replaceFirst("(?i):" + parameter, Matcher.quoteReplacement(format((Timestamp) x, FormatType.TIMESTAMP)));
    199.         }
    200.     }
    201.  
    202.     public String getQuery() {
    203.         return this.originalSQL.trim();
    204.     }
    205.  
    206.     private String format(Object o, FormatType type) {
    207.         String returnParam = "";
    208.         try {
    209.             switch (type) {
    210.                 case NULL:
    211.                     returnParam = "NULL";
    212.                     break;
    213.                 case BIGDECIMAL:
    214.                     returnParam = ((o == null) ? "NULL" : "'" + ((BigDecimal) o).toString() + "'");
    215.                     break;
    216.                 case BOOLEAN:
    217.                     returnParam = ((o == null) ? "NULL" : "'" + (((Boolean) o == Boolean.TRUE) ? "1" : "0") + "'");
    218.                     break;
    219.                 case BYTE:
    220.                     returnParam = ((o == null) ? "NULL" : "'" + ((Byte) o).intValue() + "'");
    221.                     break;
    222.                 case DATE:
    223.                     returnParam = ((o == null) ? "NULL" : "'" + new SimpleDateFormat("yyyy-MM-dd").format((Date) o) + "'");
    224.                     break;
    225.                 case DOUBLE:
    226.                     returnParam = ((o == null) ? "NULL" : "'" + ((Double) o).toString() + "'");
    227.                     break;
    228.                 case FLOAT:
    229.                     returnParam = ((o == null) ? "NULL" : "'" + ((Float) o).toString() + "'");
    230.                     break;
    231.                 case INTEGER:
    232.                     returnParam = ((o == null) ? "NULL" : "'" + ((Integer) o).toString() + "'");
    233.                     break;
    234.                 case LONG:
    235.                     returnParam = ((o == null) ? "NULL" : "'" + ((Long) o).toString() + "'");
    236.                     break;
    237.                 case SHORT:
    238.                     returnParam = ((o == null) ? "NULL" : "'" + ((Short) o).toString() + "'");
    239.                     break;
    240.                 case STRING:
    241.                     returnParam = ((o == null) ? "NULL" : "'" + o.toString() + "'");
    242.                     break;
    243.                 case STRINGLIST:
    244.                     returnParam = ((o == null) ? "NULL" : "'" + o.toString() + "'");
    245.                     break;
    246.                 case TIME:
    247.                     returnParam = ((o == null) ? "NULL" : "'" + new SimpleDateFormat("hh:mm:ss a").format(o) + "'");
    248.                     break;
    249.                 case TIMESTAMP:
    250.                     returnParam = ((o == null) ? "NULL" : "'" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss a").format(o) + "'");
    251.                     break;
    252.                 default:
    253.                     break;
    254.             }
    255.         } catch (Exception ex) {
    256.             ex.printStackTrace();
    257.         }
    258.         return returnParam.trim();
    259.     }
    260. }

    PreparedStatementImpl.java

    1. package com.codemeright.namedPerameterizedQuery;
    2.  
    3. import java.io.InputStream;
    4. import java.io.Reader;
    5. import java.math.BigDecimal;
    6. import java.net.URL;
    7. import java.sql.Array;
    8. import java.sql.Blob;
    9. import java.sql.Clob;
    10. import java.sql.Connection;
    11. import java.sql.Date;
    12. import java.sql.NClob;
    13. import java.sql.ParameterMetaData;
    14. import java.sql.PreparedStatement;
    15. import java.sql.Ref;
    16. import java.sql.ResultSet;
    17. import java.sql.ResultSetMetaData;
    18. import java.sql.RowId;
    19. import java.sql.SQLException;
    20. import java.sql.SQLWarning;
    21. import java.sql.SQLXML;
    22. import java.sql.Time;
    23. import java.sql.Timestamp;
    24. import java.util.Calendar;
    25.  
    26. class PreparedStatementImpl implements PreparedStatement {
    27.  
    28.     private final PreparedStatement preparedStatement;
    29.  
    30.     protected PreparedStatement getPreparedStatement() {
    31.         return preparedStatement;
    32.     }
    33.  
    34.     public PreparedStatementImpl(PreparedStatement preparedStatement) {
    35.         this.preparedStatement = preparedStatement;
    36.     }
    37.  
    38.     @Override
    39.     public  T unwrap(Class iface) throws SQLException {
    40.         return preparedStatement.unwrap(iface);
    41.     }
    42.  
    43.     @Override
    44.     public ResultSet executeQuery(String sql) throws SQLException {
    45.         return preparedStatement.executeQuery(sql);
    46.     }
    47.  
    48.     @Override
    49.     public ResultSet executeQuery() throws SQLException {
    50.         return preparedStatement.executeQuery();
    51.     }
    52.  
    53.     @Override
    54.     public boolean isWrapperFor(Class iface) throws SQLException {
    55.         return preparedStatement.isWrapperFor(iface);
    56.     }
    57.  
    58.     @Override
    59.     public int executeUpdate(String sql) throws SQLException {
    60.         return preparedStatement.executeUpdate(sql);
    61.     }
    62.  
    63.     @Override
    64.     public int executeUpdate() throws SQLException {
    65.         return preparedStatement.executeUpdate();
    66.     }
    67.  
    68.     @Override
    69.     public void setNull(int parameterIndex, int sqlType) throws SQLException {
    70.         preparedStatement.setNull(parameterIndex, sqlType);
    71.     }
    72.  
    73.     @Override
    74.     public void close() throws SQLException {
    75.         preparedStatement.close();
    76.     }
    77.  
    78.     @Override
    79.     public int getMaxFieldSize() throws SQLException {
    80.         return preparedStatement.getMaxFieldSize();
    81.     }
    82.  
    83.     @Override
    84.     public void setBoolean(int parameterIndex, boolean x) throws SQLException {
    85.         preparedStatement.setBoolean(parameterIndex, x);
    86.     }
    87.  
    88.     @Override
    89.     public void setByte(int parameterIndex, byte x) throws SQLException {
    90.         preparedStatement.setByte(parameterIndex, x);
    91.     }
    92.  
    93.     @Override
    94.     public void setMaxFieldSize(int max) throws SQLException {
    95.         preparedStatement.setMaxFieldSize(max);
    96.     }
    97.  
    98.     @Override
    99.     public void setShort(int parameterIndex, short x) throws SQLException {
    100.         preparedStatement.setShort(parameterIndex, x);
    101.     }
    102.  
    103.     @Override
    104.     public int getMaxRows() throws SQLException {
    105.         return preparedStatement.getMaxRows();
    106.     }
    107.  
    108.     @Override
    109.     public void setInt(int parameterIndex, int x) throws SQLException {
    110.         preparedStatement.setInt(parameterIndex, x);
    111.     }
    112.  
    113.     @Override
    114.     public void setMaxRows(int max) throws SQLException {
    115.         preparedStatement.setMaxRows(max);
    116.     }
    117.  
    118.     @Override
    119.     public void setLong(int parameterIndex, long x) throws SQLException {
    120.         preparedStatement.setLong(parameterIndex, x);
    121.     }
    122.  
    123.     @Override
    124.     public void setEscapeProcessing(boolean enable) throws SQLException {
    125.         preparedStatement.setEscapeProcessing(enable);
    126.     }
    127.  
    128.     @Override
    129.     public void setFloat(int parameterIndex, float x) throws SQLException {
    130.         preparedStatement.setFloat(parameterIndex, x);
    131.     }
    132.  
    133.     @Override
    134.     public void setDouble(int parameterIndex, double x) throws SQLException {
    135.         preparedStatement.setDouble(parameterIndex, x);
    136.     }
    137.  
    138.     @Override
    139.     public int getQueryTimeout() throws SQLException {
    140.         return preparedStatement.getQueryTimeout();
    141.     }
    142.  
    143.     @Override
    144.     public void setQueryTimeout(int seconds) throws SQLException {
    145.         preparedStatement.setQueryTimeout(seconds);
    146.     }
    147.  
    148.     @Override
    149.     public void setBigDecimal(int parameterIndex, BigDecimal x)
    150.             throws SQLException {
    151.         preparedStatement.setBigDecimal(parameterIndex, x);
    152.     }
    153.  
    154.     @Override
    155.     public void setString(int parameterIndex, String x) throws SQLException {
    156.         preparedStatement.setString(parameterIndex, x);
    157.     }
    158.  
    159.     @Override
    160.     public void setBytes(int parameterIndex, byte[] x) throws SQLException {
    161.         preparedStatement.setBytes(parameterIndex, x);
    162.     }
    163.  
    164.     @Override
    165.     public void cancel() throws SQLException {
    166.         preparedStatement.cancel();
    167.     }
    168.  
    169.     @Override
    170.     public SQLWarning getWarnings() throws SQLException {
    171.         return preparedStatement.getWarnings();
    172.     }
    173.  
    174.     @Override
    175.     public void setDate(int parameterIndex, Date x) throws SQLException {
    176.         preparedStatement.setDate(parameterIndex, x);
    177.     }
    178.  
    179.     @Override
    180.     public void setTime(int parameterIndex, Time x) throws SQLException {
    181.         preparedStatement.setTime(parameterIndex, x);
    182.     }
    183.  
    184.     @Override
    185.     public void clearWarnings() throws SQLException {
    186.         preparedStatement.clearWarnings();
    187.     }
    188.  
    189.     @Override
    190.     public void setCursorName(String name) throws SQLException {
    191.         preparedStatement.setCursorName(name);
    192.     }
    193.  
    194.     @Override
    195.     public void setTimestamp(int parameterIndex, Timestamp x)
    196.             throws SQLException {
    197.         preparedStatement.setTimestamp(parameterIndex, x);
    198.     }
    199.  
    200.     @Override
    201.     public void setAsciiStream(int parameterIndex, InputStream x, int length)
    202.             throws SQLException {
    203.         preparedStatement.setAsciiStream(parameterIndex, x, length);
    204.     }
    205.  
    206.     @Override
    207.     public boolean execute(String sql) throws SQLException {
    208.         return preparedStatement.execute(sql);
    209.     }
    210.  
    211.     @Deprecated
    212.     @Override
    213.     public void setUnicodeStream(int parameterIndex, InputStream x, int length)
    214.             throws SQLException {
    215.         preparedStatement.setUnicodeStream(parameterIndex, x, length);
    216.     }
    217.  
    218.     @Override
    219.     public ResultSet getResultSet() throws SQLException {
    220.         return preparedStatement.getResultSet();
    221.     }
    222.  
    223.     @Override
    224.     public void setBinaryStream(int parameterIndex, InputStream x, int length)
    225.             throws SQLException {
    226.         preparedStatement.setBinaryStream(parameterIndex, x, length);
    227.     }
    228.  
    229.     @Override
    230.     public int getUpdateCount() throws SQLException {
    231.         return preparedStatement.getUpdateCount();
    232.     }
    233.  
    234.     @Override
    235.     public boolean getMoreResults() throws SQLException {
    236.         return preparedStatement.getMoreResults();
    237.     }
    238.  
    239.     @Override
    240.     public void clearParameters() throws SQLException {
    241.         preparedStatement.clearParameters();
    242.     }
    243.  
    244.     @Override
    245.     public void setObject(int parameterIndex, Object x, int targetSqlType)
    246.             throws SQLException {
    247.         preparedStatement.setObject(parameterIndex, x, targetSqlType);
    248.     }
    249.  
    250.     @Override
    251.     public void setFetchDirection(int direction) throws SQLException {
    252.         preparedStatement.setFetchDirection(direction);
    253.     }
    254.  
    255.     @Override
    256.     public int getFetchDirection() throws SQLException {
    257.         return preparedStatement.getFetchDirection();
    258.     }
    259.  
    260.     @Override
    261.     public void setObject(int parameterIndex, Object x) throws SQLException {
    262.         preparedStatement.setObject(parameterIndex, x);
    263.     }
    264.  
    265.     @Override
    266.     public void setFetchSize(int rows) throws SQLException {
    267.         preparedStatement.setFetchSize(rows);
    268.     }
    269.  
    270.     @Override
    271.     public int getFetchSize() throws SQLException {
    272.         return preparedStatement.getFetchSize();
    273.     }
    274.  
    275.     @Override
    276.     public int getResultSetConcurrency() throws SQLException {
    277.         return preparedStatement.getResultSetConcurrency();
    278.     }
    279.  
    280.     @Override
    281.     public boolean execute() throws SQLException {
    282.         return preparedStatement.execute();
    283.     }
    284.  
    285.     @Override
    286.     public int getResultSetType() throws SQLException {
    287.         return preparedStatement.getResultSetType();
    288.     }
    289.  
    290.     @Override
    291.     public void addBatch(String sql) throws SQLException {
    292.         preparedStatement.addBatch(sql);
    293.     }
    294.  
    295.     @Override
    296.     public void clearBatch() throws SQLException {
    297.         preparedStatement.clearBatch();
    298.     }
    299.  
    300.     @Override
    301.     public void addBatch() throws SQLException {
    302.         preparedStatement.addBatch();
    303.     }
    304.  
    305.     @Override
    306.     public int[] executeBatch() throws SQLException {
    307.         return preparedStatement.executeBatch();
    308.     }
    309.  
    310.     @Override
    311.     public void setCharacterStream(int parameterIndex, Reader reader, int length)
    312.             throws SQLException {
    313.         preparedStatement.setCharacterStream(parameterIndex, reader, length);
    314.     }
    315.  
    316.     @Override
    317.     public void setRef(int parameterIndex, Ref x) throws SQLException {
    318.         preparedStatement.setRef(parameterIndex, x);
    319.     }
    320.  
    321.     @Override
    322.     public void setBlob(int parameterIndex, Blob x) throws SQLException {
    323.         preparedStatement.setBlob(parameterIndex, x);
    324.     }
    325.  
    326.     @Override
    327.     public void setClob(int parameterIndex, Clob x) throws SQLException {
    328.         preparedStatement.setClob(parameterIndex, x);
    329.     }
    330.  
    331.     @Override
    332.     public Connection getConnection() throws SQLException {
    333.         return preparedStatement.getConnection();
    334.     }
    335.  
    336.     @Override
    337.     public void setArray(int parameterIndex, Array x) throws SQLException {
    338.         preparedStatement.setArray(parameterIndex, x);
    339.     }
    340.  
    341.     @Override
    342.     public ResultSetMetaData getMetaData() throws SQLException {
    343.         return preparedStatement.getMetaData();
    344.     }
    345.  
    346.     @Override
    347.     public boolean getMoreResults(int current) throws SQLException {
    348.         return preparedStatement.getMoreResults(current);
    349.     }
    350.  
    351.     @Override
    352.     public void setDate(int parameterIndex, Date x, Calendar cal)
    353.             throws SQLException {
    354.         preparedStatement.setDate(parameterIndex, x, cal);
    355.     }
    356.  
    357.     @Override
    358.     public ResultSet getGeneratedKeys() throws SQLException {
    359.         return preparedStatement.getGeneratedKeys();
    360.     }
    361.  
    362.     @Override
    363.     public void setTime(int parameterIndex, Time x, Calendar cal)
    364.             throws SQLException {
    365.         preparedStatement.setTime(parameterIndex, x, cal);
    366.     }
    367.  
    368.     @Override
    369.     public int executeUpdate(String sql, int autoGeneratedKeys)
    370.             throws SQLException {
    371.         return preparedStatement.executeUpdate(sql, autoGeneratedKeys);
    372.     }
    373.  
    374.     @Override
    375.     public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
    376.             throws SQLException {
    377.         preparedStatement.setTimestamp(parameterIndex, x, cal);
    378.     }
    379.  
    380.     @Override
    381.     public void setNull(int parameterIndex, int sqlType, String typeName)
    382.             throws SQLException {
    383.         preparedStatement.setNull(parameterIndex, sqlType, typeName);
    384.     }
    385.  
    386.     @Override
    387.     public int executeUpdate(String sql, int[] columnIndexes)
    388.             throws SQLException {
    389.         return preparedStatement.executeUpdate(sql, columnIndexes);
    390.     }
    391.  
    392.     @Override
    393.     public void setURL(int parameterIndex, URL x) throws SQLException {
    394.         preparedStatement.setURL(parameterIndex, x);
    395.     }
    396.  
    397.     @Override
    398.     public int executeUpdate(String sql, String[] columnNames)
    399.             throws SQLException {
    400.         return preparedStatement.executeUpdate(sql, columnNames);
    401.     }
    402.  
    403.     @Override
    404.     public ParameterMetaData getParameterMetaData() throws SQLException {
    405.         return preparedStatement.getParameterMetaData();
    406.     }
    407.  
    408.     @Override
    409.     public void setRowId(int parameterIndex, RowId x) throws SQLException {
    410.         preparedStatement.setRowId(parameterIndex, x);
    411.     }
    412.  
    413.     @Override
    414.     public void setNString(int parameterIndex, String value)
    415.             throws SQLException {
    416.         preparedStatement.setNString(parameterIndex, value);
    417.     }
    418.  
    419.     @Override
    420.     public boolean execute(String sql, int autoGeneratedKeys)
    421.             throws SQLException {
    422.         return preparedStatement.execute(sql, autoGeneratedKeys);
    423.     }
    424.  
    425.     @Override
    426.     public void setNCharacterStream(int parameterIndex, Reader value,
    427.             long length) throws SQLException {
    428.         preparedStatement.setNCharacterStream(parameterIndex, value, length);
    429.     }
    430.  
    431.     @Override
    432.     public void setNClob(int parameterIndex, NClob value) throws SQLException {
    433.         preparedStatement.setNClob(parameterIndex, value);
    434.     }
    435.  
    436.     @Override
    437.     public void setClob(int parameterIndex, Reader reader, long length)
    438.             throws SQLException {
    439.         preparedStatement.setClob(parameterIndex, reader, length);
    440.     }
    441.  
    442.     @Override
    443.     public boolean execute(String sql, int[] columnIndexes) throws SQLException {
    444.         return preparedStatement.execute(sql, columnIndexes);
    445.     }
    446.  
    447.     @Override
    448.     public void setBlob(int parameterIndex, InputStream inputStream, long length)
    449.             throws SQLException {
    450.         preparedStatement.setBlob(parameterIndex, inputStream, length);
    451.     }
    452.  
    453.     @Override
    454.     public void setNClob(int parameterIndex, Reader reader, long length)
    455.             throws SQLException {
    456.         preparedStatement.setNClob(parameterIndex, reader, length);
    457.     }
    458.  
    459.     @Override
    460.     public boolean execute(String sql, String[] columnNames)
    461.             throws SQLException {
    462.         return preparedStatement.execute(sql, columnNames);
    463.     }
    464.  
    465.     @Override
    466.     public void setSQLXML(int parameterIndex, SQLXML xmlObject)
    467.             throws SQLException {
    468.         preparedStatement.setSQLXML(parameterIndex, xmlObject);
    469.     }
    470.  
    471.     @Override
    472.     public void setObject(int parameterIndex, Object x, int targetSqlType,
    473.             int scaleOrLength) throws SQLException {
    474.         preparedStatement.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
    475.     }
    476.  
    477.     @Override
    478.     public int getResultSetHoldability() throws SQLException {
    479.         return preparedStatement.getResultSetHoldability();
    480.     }
    481.  
    482.     @Override
    483.     public boolean isClosed() throws SQLException {
    484.         return preparedStatement.isClosed();
    485.     }
    486.  
    487.     @Override
    488.     public void setPoolable(boolean poolable) throws SQLException {
    489.         preparedStatement.setPoolable(poolable);
    490.     }
    491.  
    492.     @Override
    493.     public boolean isPoolable() throws SQLException {
    494.         return preparedStatement.isPoolable();
    495.     }
    496.  
    497.     @Override
    498.     public void closeOnCompletion() throws SQLException {
    499.         preparedStatement.closeOnCompletion();
    500.     }
    501.  
    502.     @Override
    503.     public void setAsciiStream(int parameterIndex, InputStream x, long length)
    504.             throws SQLException {
    505.         preparedStatement.setAsciiStream(parameterIndex, x, length);
    506.     }
    507.  
    508.     @Override
    509.     public boolean isCloseOnCompletion() throws SQLException {
    510.         return preparedStatement.isCloseOnCompletion();
    511.     }
    512.  
    513.     @Override
    514.     public void setBinaryStream(int parameterIndex, InputStream x, long length)
    515.             throws SQLException {
    516.         preparedStatement.setBinaryStream(parameterIndex, x, length);
    517.     }
    518.  
    519.     @Override
    520.     public void setCharacterStream(int parameterIndex, Reader reader,
    521.             long length) throws SQLException {
    522.         preparedStatement.setCharacterStream(parameterIndex, reader, length);
    523.     }
    524.  
    525.     @Override
    526.     public void setAsciiStream(int parameterIndex, InputStream x)
    527.             throws SQLException {
    528.         preparedStatement.setAsciiStream(parameterIndex, x);
    529.     }
    530.  
    531.     @Override
    532.     public void setBinaryStream(int parameterIndex, InputStream x)
    533.             throws SQLException {
    534.         preparedStatement.setBinaryStream(parameterIndex, x);
    535.     }
    536.  
    537.     @Override
    538.     public void setCharacterStream(int parameterIndex, Reader reader)
    539.             throws SQLException {
    540.         preparedStatement.setCharacterStream(parameterIndex, reader);
    541.     }
    542.  
    543.     @Override
    544.     public void setNCharacterStream(int parameterIndex, Reader value)
    545.             throws SQLException {
    546.         preparedStatement.setNCharacterStream(parameterIndex, value);
    547.     }
    548.  
    549.     @Override
    550.     public void setClob(int parameterIndex, Reader reader) throws SQLException {
    551.         preparedStatement.setClob(parameterIndex, reader);
    552.     }
    553.  
    554.     @Override
    555.     public void setBlob(int parameterIndex, InputStream inputStream)
    556.             throws SQLException {
    557.         preparedStatement.setBlob(parameterIndex, inputStream);
    558.     }
    559.  
    560.     @Override
    561.     public void setNClob(int parameterIndex, Reader reader) throws SQLException {
    562.         preparedStatement.setNClob(parameterIndex, reader);
    563.     }
    564.  
    565. }

    所以，现在您已经看到了自定义类NamedParameterizedQuery.java 和 ParameterizedQueryImpl.java。 此外，您还知道如何使用上述示例中的这些类创建命名参数化查询。如果你好奇这些类是如何工作的，你可以在 debud 模式下测试它们以了解它的功能。

  • 相关阅读:
    机器学习之广义增量规则（Generalized Delta Rule）
    揭秘神秘的种子：Adobe联合宾夕法尼亚大学发布文本到图像扩散模型大规模种子分析
    HDC2022的无障碍参会体验，手语服务是如何做到的？
    SpringBoot关闭Tomcat容器，SpringBoot使用Jetty容器
    《实现领域驱动设计》- 领域服务
    element 表单自定义效验规则
    小程序员 scroll滚动与页面滚动冲突造成快速滑到底部卡顿失败问题
    nodejs+vue健身房课程预约评分系统
    【C语言】关键字
    C++静态成员&友元&命名空间介绍
  • 原文地址：https://blog.csdn.net/allway2/article/details/126110147