java jdbc 命名参数_支持命名参数的PreparedStatement

最新推荐文章于 2021-03-18 19:48:12 发布

weixin_39805924

最新推荐文章于 2021-03-18 19:48:12 发布

阅读量579

点赞数

文章标签： java jdbc 命名参数

本文链接：https://blog.csdn.net/weixin_39805924/article/details/114530587

版权

PreparedStatement语法存在的问题

PreparedStatement的问题来源于它的参数的语法，PreparedStatement语句的参数是匿名并被通过索引访问，如下代码所示：

PreparedStatement p = con.prepareStatement("select * from people where

(first_name = ? or last_name = ?) and address = ?");

p.setString(1, name);

p.setString(2, name);

p.setString(3, address);

对于一两个小的查询来说，这不是问题，但是对于大量参数的查询，跟踪索引就会变得困难。开发者必须小心翼翼的阅读SQL语句并查找出对应的参数索引，如果一个参数被插入或被删除，所有的索引就要被重新命名，很显然，当这个被插入或删除的参数在最开始，而后面还有更多的参数的时候，或者查询被重新组织了，这两种情况都会导致很多麻烦。

解决方法?(Workarounds)

有一个方法可以解决重新命名索引，那就是使用一个计数器来跟踪索引，如下代码所示：

PreparedStatement p = con.prepareStatement("select * from people where

(first_name = ? or last_name = ?) and address = ?");

int i = 1;

p.setString(i++, name);

p.setString(i++, address);

这种方法对于某个参数被插入或者删除的情况来说，有很好的效果，但是代码依然可读性差，而且程序员依然要注意确保参数的顺序。

NamedParameterStatement

现在我们来看看NamedParameterStatement这个类，这个类和PreparedStatement的基本相同，除了一点，那就是不是用问号？来顶替索引，而是用一个变量来顶替索引，如下面的代码所示：

String query = "select * from people where (first_name = :name or last_name

= :name) and address = :address");

NamedParameterStatement p = new NamedParameterStatement(con, query);

p.setString("name", name);

p.setString("address", address);

这个类的内幕就是，NamedParameterStatement类做了一个转换，它使用HashMap将SQL语句种对应的变量转换成问号，然后再创建一个对应的PreparedStatement语句，并且保持了对应变量和索引的映射关系，这两个类是兼容的，所以你可以分别加以利用。

论性能

两者的性能的差别在于NamedParameterStatement多了一个转换的过程，但这个过程所消耗的性能是非常之小，经过本机的测试，执行一条简单的查询表的记录的语句，PreparedStatement花了332毫秒，而NamedParameterStatement则花了352毫秒。在加入缓存之后，已经没有任何区别。

总结

NamedParameterStatement作为PreparedStatement的代替是高效而且无需配置的，同时它的简便的接口也提高了程序员的效率，或者更重要的是，由于代码的可读性增强，维护会变得更加轻松。

附上代码：

import java.io.InputStream;

import java.io.Reader;

import java.math.BigDecimal;

import java.net.URL;

import java.sql.*;

import java.sql.Date;

import java.util.*;

/**

* This class wraps around a {@link PreparedStatement} and allows the programmer to set parameters by name instead

* of by index. This eliminates any confusion as to which parameter index represents what. This also means that

* rearranging the SQL statement or adding a parameter doesn't involve renumbering your indices.

* Code such as this:

* Connection conn = getConnection();

* String sql = "select * from my_table where name=? or address=?";

* PreparedStatement p = conn.prepareStatement(sql);

* p.setString(1, "bob");

* p.setString(2, "123");

* ResultSet rs = p.executeQuery();

*

* Can be replaced with:

* Connection conn = getConnection();

* String sql = "select * from my_table where name=:name or address=:address";

* NamedParameterStatement p = new NamedParameterStatement(conn, sql);

* p.setString("name", "bob");

* p.setString("address", "123");

* ResultSet rs = p.executeQuery();

*

public class NamedParameterStatement extends PreparedStatementWrapper {

private static final HashMap>> nameIndexCache = new HashMap>>();

private static final HashMap parsedSqlCache = new HashMap();

private final String parsedSql;

private final Map> nameIndexMap;

/**

* Creates a NamedParameterStatement. Wraps a call to

* c.{@link Connection#prepareStatement(java.lang.String) prepareStatement}.

* @param conn the database connection

* @param sql the parameterized sql

* @throws SQLException if the statement could not be created

public NamedParameterStatement(Connection conn, String sql) throws SQLException {

if (nameIndexCache.containsKey(sql)) {

nameIndexMap = nameIndexCache.get(sql);

parsedSql = parsedSqlCache.get(sql);

} else {

nameIndexMap = new HashMap>();

parsedSql = parseNamedSql(sql, nameIndexMap);

nameIndexCache.put(sql, nameIndexMap);

parsedSqlCache.put(sql, parsedSql);

}

ps = conn.prepareStatement(parsedSql);

}

/**

* Returns the indexes for a parameter.

* @param name parameter name

* @return parameter indexes

* @throws IllegalArgumentException if the parameter does not exist

private List getIndexes(String name) {

List indexes = nameIndexMap.get(name);

if (indexes == null) {

throw new IllegalArgumentException("Parameter not found: " + name);

}

return indexes;

}

/**

* Parses a sql with named parameters. The parameter-index mappings

* are put into the map, and the parsed sql is returned.

* @param sql sql with named parameters

* @return the parsed sql

private static String parseNamedSql(String sql, Map> nameIndexMap) {

// I was originally using regular expressions, but they didn't work well for ignoring

// parameter-like strings inside quotes.

int length = sql.length();

StringBuffer parsedSql = new StringBuffer(length);

boolean inSingleQuote = false;

boolean inDoubleQuote = false;

int index = 1;

for (int i = 0; i < length; i++) {

char c = sql.charAt(i);

if (inSingleQuote) {

if (c == '\'') {

inSingleQuote = false;

}

} else if (inDoubleQuote) {

if (c == '"') {

inDoubleQuote = false;

}

} else {

if (c == '\'') {

inSingleQuote = true;

} else if (c == '"') {

inDoubleQuote = true;

} else if (c == ':' && i + 1 < length && Character.isJavaIdentifierStart(sql.charAt(i + 1))) {

int j = i + 2;

while (j < length && Character.isJavaIdentifierPart(sql.charAt(j))) {

j++;

}

String name = sql.substring(i + 1, j);

c = '?'; // replace the parameter with a question mark

i += name.length(); // skip past the end if the parameter

List indexList = nameIndexMap.get(name);

if (indexList == null) {

indexList = new LinkedList();

nameIndexMap.put(name, indexList);

}

indexList.add(index);

index++;

}

parsedSql.append(c);

}

return parsedSql.toString();

}

public void setArray(String name, Array value) throws SQLException {